authors.push(a.to_string());

        authors.push(a.to_string().into());

            authors.push(k.key)

            authors.push(k.key.into())

            authors.push(a.clone());

            authors.push(a.clone().into());

                authors.push(k.key)

                authors.push(k.key.into())
            } else {
                bail!("No identity configured yet. Please use `pijul key` to create one")

            write!(v, "{}", a).unwrap();

            write!(v, "{}", a.name).unwrap();

}
use serde_derive::*;
#[derive(Debug, Serialize, Deserialize)]
pub struct Identity {
    public_key: libpijul::key::PublicKey,
    name: String,
    #[serde(default, skip_serializing_if = "String::is_empty")]
    origin: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    email: Option<String>,

use std::collections::hash_map::Entry;
use std::collections::HashMap;

            let mut authors = HashMap::new();
            let mut id_path = if let Some(mut dir) = crate::config::global_config_dir() {
                dir.push("identities");
                Some(dir)
            } else {
                None
            };

                writeln!(stdout, "Author: {:?}", header.authors)?;

                write!(stdout, "Author: ")?;
                let mut is_first = true;
                for auth in header.authors.into_iter() {
                    let auth = match authors.entry(auth.name) {
                        Entry::Occupied(e) => e.into_mut(),
                        Entry::Vacant(e) => {
                            let mut id = None;
                            if let Some(ref mut p) = id_path {
                                p.push(e.key());
                                if let Ok(f) = std::fs::File::open(&p) {
                                    if let Ok(id_) =
                                        serde_json::from_reader::<_, super::Identity>(f)
                                    {
                                        id = Some(id_)
                                    }
                                }
                                p.pop();
                            }
                            if let Some(id) = id {
                                e.insert(id.name)
                            } else {
                                let k = e.key().to_string();
                                e.insert(k)
                            }
                        }
                    };
                    if is_first {
                        is_first = false;
                        write!(stdout, "{}", auth)?;
                    } else {
                        write!(stdout, ", {}", auth)?;
                    }
                }
                writeln!(stdout)?;

    Generate {},

    Generate {
        #[clap(long = "email")]
        email: Option<String>,
        name: String,
    },

            Some(SubCommand::Generate {}) => {

            Some(SubCommand::Generate { email, name }) => {

                    std::fs::create_dir_all(&dir)?;

                    serde_json::to_writer_pretty(&mut f, &k.public_key())?;

                    let pk = k.public_key();
                    serde_json::to_writer_pretty(&mut f, &pk)?;
                    f.write_all(b"\n")?;
                    dir.pop();
                    dir.push("identities");
                    std::fs::create_dir_all(&dir)?;
                    dir.push(&pk.key);
                    debug!("creating file {:?}", dir);
                    let mut f = std::fs::File::create(&dir)?;
                    serde_json::to_writer_pretty(
                        &mut f,
                        &super::Identity {
                            public_key: pk,
                            origin: String::new(),
                            name,
                            email,
                        },
                    )?;

pub const VERSION: u64 = 5;

pub const VERSION: u64 = 7;
pub const VERSION_NOENC: u64 = 5;

    #[serde(default, skip_serializing_if = "Option::is_none")]

        let secret = ed25519_dalek::SecretKey::from_bytes(&key).unwrap();

            key: ed25519_dalek::Keypair::from_bytes(&key).unwrap(),

            key: ed25519_dalek::Keypair {
                public: (&secret).into(),
                secret,
            },

}
#[derive(Clone, Copy)]
pub struct SerializedKey {
    pub(crate) t: u8,
    k: K,
}
impl From<ed25519_dalek::PublicKey> for SerializedKey {
    fn from(k: ed25519_dalek::PublicKey) -> Self {
        SerializedKey {
            t: 0,
            k: K {
                ed25519: k.as_bytes().clone(),
            },
        }
    }
}
impl From<SerializedKey> for ed25519_dalek::PublicKey {
    fn from(k: SerializedKey) -> Self {
        assert_eq!(k.t, 0);
        unsafe { ed25519_dalek::PublicKey::from_bytes(&k.k.ed25519).unwrap() }
    }

#[derive(Clone, Copy)]
pub(crate) union K {
    ed25519: [u8; 32],
}

        bincode::deserialize(buf).unwrap()

        if let Ok(m) = bincode::deserialize(buf) {
            m
        } else {
            let (a, b) = buf.split_at(2);
            use byteorder::ByteOrder;
            FileMetadata {
                metadata: InodeMetadata(byteorder::BigEndian::read_u16(a)),
                basename: std::str::from_utf8(b).unwrap(),
                encoding: None,
            }
        }

mod noenc;

    #[error("Version mismatch")]
    VersionMismatch,

    #[error("Version mismatch: got {}", got)]
    VersionMismatch { got: u64 },

    pub authors: Vec<String>,

    pub authors: Vec<Author>,
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
pub struct Author {
    pub name: String,
    #[serde(default)]
    pub full_name: Option<String>,
    #[serde(default)]
    pub email: Option<String>,
}
impl From<String> for Author {
    fn from(name: String) -> Author {
        Author {
            name,
            ..Author::default()
        }
    }

pub struct LocalChange<Local> {

pub struct LocalChange<Hunk> {

    pub hashed: Hashed<Local>,

    pub hashed: Hashed<Hunk>,

impl std::ops::Deref for LocalChange<Local> {
    type Target = Hashed<Local>;

impl std::ops::Deref for LocalChange<Hunk<Option<Hash>, Local>> {
    type Target = Hashed<Hunk<Option<Hash>, Local>>;

impl std::ops::DerefMut for LocalChange<Local> {

impl std::ops::DerefMut for LocalChange<Hunk<Option<Hash>, Local>> {

// Beware of change the version, tags also use that.
pub const VERSION: u64 = 5;

// Beware of changes in the version, tags also use that.
pub const VERSION: u64 = 6;
pub const VERSION_NOENC: u64 = 4;

pub struct Hashed<Local> {

pub struct Hashed<Hunk> {

    pub changes: Vec<Hunk<Option<Hash>, Local>>,

    pub changes: Vec<Hunk>,

pub type Change = LocalChange<Local>;

pub type Change = LocalChange<Hunk<Option<Hash>, Local>>;

impl<L> LocalChange<L> {

impl LocalChange<Hunk<Option<Hash>, Local>> {

        changes: Vec<Hunk<Option<Hash>, L>>,

        changes: Vec<Hunk<Option<Hash>, Local>>,

        if off.version != VERSION {
            return Err(ChangeError::VersionMismatch);

        if off.version != VERSION && off.version != VERSION_NOENC {
            return Err(ChangeError::VersionMismatch { got: off.version });

            return Err(ChangeError::VersionMismatch);

            return Err(ChangeError::VersionMismatch {
                got: offsets.version,
            });

        let hashed: Hashed<Local> = bincode::deserialize(&buf_)?;

        let hashed: Hashed<Hunk<Option<Hash>, Local>> = bincode::deserialize(&buf_)?;

        if offsets.version != VERSION {
            return Err(ChangeError::VersionMismatch);

        if offsets.version == VERSION_NOENC {
            return Self::deserialize_noenc(offsets, r, hash);
        } else if offsets.version != VERSION {
            return Err(ChangeError::VersionMismatch {
                got: offsets.version,
            });

        let hashed: Hashed<Local> = {

        let hashed: Hashed<Hunk<Option<Hash>, Local>> = {

            Some(serde_json::from_slice(&out)?)

            debug!("parsing unhashed: {:?}", std::str::from_utf8(&out));
            serde_json::from_slice(&out).ok()

impl LocalChange<Local> {

impl LocalChange<Hunk<Option<Hash>, Local>> {

use super::{Atom, Change, ChangeError, Hashed, Local, LocalChange, Offsets};
use crate::pristine::Hasher;
use crate::Hash;
#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
pub enum Hunk<Hash, Local> {
    FileMove {
        del: Atom<Hash>,
        add: Atom<Hash>,
        path: String,
    },
    FileDel {
        del: Atom<Hash>,
        contents: Option<Atom<Hash>>,
        path: String,
    },
    FileUndel {
        undel: Atom<Hash>,
        contents: Option<Atom<Hash>>,
        path: String,
    },
    FileAdd {
        add_name: Atom<Hash>,
        add_inode: Atom<Hash>,
        contents: Option<Atom<Hash>>,
        path: String,
    },
    SolveNameConflict {
        name: Atom<Hash>,
        path: String,
    },
    UnsolveNameConflict {
        name: Atom<Hash>,
        path: String,
    },
    Edit {
        change: Atom<Hash>,
        local: Local,
    },
    Replacement {
        change: Atom<Hash>,
        replacement: Atom<Hash>,
        local: Local,
    },
    SolveOrderConflict {
        change: Atom<Hash>,
        local: Local,
    },
    UnsolveOrderConflict {
        change: Atom<Hash>,
        local: Local,
    },
    ResurrectZombies {
        change: Atom<Hash>,
        local: Local,
    },
}
impl<H, L> From<Hunk<H, L>> for super::Hunk<H, L> {
    fn from(h: Hunk<H, L>) -> Self {
        match h {
            Hunk::FileMove { del, add, path } => super::Hunk::FileMove { del, add, path },
            Hunk::FileDel {
                del,
                contents,
                path,
            } => super::Hunk::FileDel {
                del,
                contents,
                path,
                encoding: None,
            },
            Hunk::FileUndel {
                undel,
                contents,
                path,
            } => super::Hunk::FileUndel {
                undel,
                contents,
                path,
                encoding: None,
            },
            Hunk::FileAdd {
                add_name,
                add_inode,
                contents,
                path,
            } => super::Hunk::FileAdd {
                add_name,
                add_inode,
                contents,
                path,
                encoding: None,
            },
            Hunk::SolveNameConflict { name, path } => super::Hunk::SolveNameConflict { name, path },
            Hunk::UnsolveNameConflict { name, path } => {
                super::Hunk::UnsolveNameConflict { name, path }
            }
            Hunk::Edit { change, local } => super::Hunk::Edit {
                change,
                local,
                encoding: None,
            },
            Hunk::Replacement {
                change,
                replacement,
                local,
            } => super::Hunk::Replacement {
                change,
                replacement,
                local,
                encoding: None,
            },
            Hunk::SolveOrderConflict { change, local } => {
                super::Hunk::SolveOrderConflict { change, local }
            }
            Hunk::UnsolveOrderConflict { change, local } => {
                super::Hunk::UnsolveOrderConflict { change, local }
            }
            Hunk::ResurrectZombies { change, local } => super::Hunk::ResurrectZombies {
                change,
                local,
                encoding: None,
            },
        }
    }
}
impl Change {
    /// Deserialise a change from the file given as input `file`.
    #[cfg(feature = "zstd")]
    pub(super) fn deserialize_noenc(
        offsets: Offsets,
        mut r: std::fs::File,
        hash: Option<&Hash>,
    ) -> Result<Self, ChangeError> {
        use std::io::Read;
        debug!("offsets = {:?}", offsets);
        let mut buf = vec![0u8; (offsets.unhashed_off - Self::OFFSETS_SIZE) as usize];
        r.read_exact(&mut buf)?;
        let hashed: Hashed<Hunk<Option<Hash>, Local>> = {
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut out = vec![0u8; offsets.hashed_len as usize];
            s.decompress(&mut out[..], 0)?;
            let mut hasher = Hasher::default();
            hasher.update(&out);
            let computed_hash = hasher.finish();
            if let Some(hash) = hash {
                if &computed_hash != hash {
                    return Err(super::ChangeError::ChangeHashMismatch {
                        claimed: *hash,
                        computed: computed_hash,
                    });
                }
            }
            bincode::deserialize_from(&out[..])?
        };
        buf.clear();
        buf.resize((offsets.contents_off - offsets.unhashed_off) as usize, 0);
        let unhashed = if buf.is_empty() {
            None
        } else {
            r.read_exact(&mut buf)?;
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut out = vec![0u8; offsets.unhashed_len as usize];
            s.decompress(&mut out[..], 0)?;
            serde_json::from_slice(&out).ok()
        };
        debug!("unhashed = {:?}", unhashed);
        buf.clear();
        buf.resize((offsets.total - offsets.contents_off) as usize, 0);
        let contents = if r.read_exact(&mut buf).is_ok() {
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut contents = vec![0u8; offsets.contents_len as usize];
            s.decompress(&mut contents[..], 0)?;
            contents
        } else {
            Vec::new()
        };
        debug!("contents = {:?}", contents);
        Ok(LocalChange {
            offsets,
            hashed: hashed.into(),
            unhashed,
            contents,
        })
    }
}
impl From<Hashed<Hunk<Option<Hash>, Local>>> for Hashed<super::Hunk<Option<Hash>, Local>> {
    fn from(hashed: Hashed<Hunk<Option<Hash>, Local>>) -> Self {
        Hashed {
            contents_hash: hashed.contents_hash,
            dependencies: hashed.dependencies,
            extra_known: hashed.extra_known,
            header: hashed.header,
            metadata: hashed.metadata,
            version: hashed.version,
            changes: hashed.changes.into_iter().map(|x| x.into()).collect(),
        }
    }
}

    hashed: Hashed<Local>,

    hashed: Hashed<Hunk<Option<Hash>, Local>>,

        if offsets.version != VERSION {
            return Err(ChangeError::VersionMismatch);

        if offsets.version != VERSION && offsets.version != VERSION_NOENC {
            return Err(ChangeError::VersionMismatch {
                got: offsets.version,
            });

        let hashed: Hashed<Local> = {

        let hashed: Hashed<Hunk<Option<Hash>, Local>> = if offsets.version == VERSION {

            debug!("deserialize current version {:?}", buf2.len());

        } else {
            assert_eq!(offsets.version, VERSION_NOENC);
            let mut s = zstd_seekable::Seekable::init_buf(&buf)?;
            s.decompress(&mut buf2, 0)?;
            debug!("deserialize noenc {:?}", buf2.len());
            let h: Hashed<noenc::Hunk<Option<Hash>, Local>> = bincode::deserialize(&buf2)?;
            h.into()

            Some(toml::de::from_slice(&buf2)?)

            debug!("parsing unhashed: {:?}", std::str::from_utf8(&buf2));
            serde_json::from_slice(&buf2).ok()

    pub fn hashed(&self) -> &Hashed<Local> {

    pub fn hashed(&self) -> &Hashed<Hunk<Option<Hash>, Local>> {