let (encoding, score) = detector.guess_assess(None, true);
        if score {
            Ok(Some(Encoding(encoding)))

        if let Some(e) = detector.get_valid(None, true, &buffer[init..]) {
            Ok(Some(Encoding(e)))

#[cfg(test)]
use quickcheck::{Arbitrary, Gen};

#[cfg(test)]
// TODO: more encodings. This is not critical, since it is not used ATM.
// But the instance is needed.
impl Arbitrary for Encoding {
    fn arbitrary(g: &mut Gen) -> Self {
        g.choose(&[
            Encoding(encoding_rs::UTF_8),
            Encoding(encoding_rs::SHIFT_JIS),
        ])
        .unwrap()
        .clone()
    }
}

use crate::change::*;
use crate::changestore::*;
use crate::pristine::*;
use crate::record::*;
use crate::working_copy::*;
use crate::*;
use std::io::Write;
use super::*;
fn hash_mismatch(change: &Change) -> Result<(), anyhow::Error> {
    env_logger::try_init().unwrap_or(());
    use crate::change::*;
    let mut buf = tempfile::NamedTempFile::new()?;
    let mut h = change.serialize(&mut buf)?;
    match h {
        crate::pristine::Hash::Blake3(ref mut h) => h[0] = h[0].wrapping_add(1),
        _ => unreachable!(),
    }
    match Change::deserialize(buf.path().to_str().unwrap(), Some(&h)) {
        Err(ChangeError::ChangeHashMismatch { .. }) => {}
        _ => unreachable!(),
    }
    let f = ChangeFile::open(h, buf.path().to_str().unwrap())?;
    assert_eq!(f.hashed(), &change.hashed);
    Ok(())
}
#[test]
fn hash_mism() -> Result<(), anyhow::Error> {
    env_logger::try_init().unwrap_or(());
    let contents = b"a\nb\nc\nd\ne\nf\n";
    let repo = working_copy::memory::Memory::new();
    let store = changestore::memory::Memory::new();
    repo.add_file("file", contents.to_vec());
    repo.add_file("file2", contents.to_vec());
    let env = pristine::sanakirja::Pristine::new_anon()?;
    let txn = env.arc_txn_begin().unwrap();
    let mut channel = txn.write().open_or_create_channel("main")?;
    txn.write().add_file("file", 0)?;
    txn.write().add_file("file2", 0)?;
    let mut state = Builder::new();
    state
        .record(
            txn.clone(),
            Algorithm::Myers,
            channel.clone(),
            &repo,
            &store,
            "",
            0,
        )
        .unwrap();
    let rec = state.finish();
    let changes: Vec<_> = rec
        .actions
        .into_iter()
        .map(|rec| rec.globalize(&*txn.read()).unwrap())
        .collect();
    info!("changes = {:?}", changes);
    let change0 = crate::change::Change::make_change(
        &*txn.read(),
        &channel,
        changes,
        std::mem::take(&mut *rec.contents.lock()),
        crate::change::ChangeHeader {
            message: "test".to_string(),
            authors: vec![],
            description: None,
            timestamp: chrono::Utc::now(),
        },
        Vec::new(),
    )
    .unwrap();
    let hash0 = store.save_change(&change0)?;
    apply::apply_local_change(
        &mut *txn.write(),
        &mut channel,
        &change0,
        &hash0,
        &rec.updatables,
    )?;
    hash_mismatch(&change0)?;
    Ok(())
}
#[cfg(feature = "text-changes")]
#[test]
fn text_changes() -> Result<(), anyhow::Error> {
    env_logger::try_init().unwrap_or(());
    let contents = b"a\nb\nc\nd\ne\nf\n";
    let repo = working_copy::memory::Memory::new();
    let store = changestore::memory::Memory::new();
    repo.add_file("file", contents.to_vec());
    repo.add_file("file2", contents.to_vec());
    let env = pristine::sanakirja::Pristine::new_anon()?;
    let txn = env.arc_txn_begin().unwrap();
    let channel = txn.write().open_or_create_channel("main")?;
    txn.write().add_file("file", 0)?;
    txn.write().add_file("file2", 0)?;
    let h0 = record_all(&repo, &store, &txn, &channel, "")?;
    let change0 = store.get_change(&h0).unwrap();
    text_test(&store, &change0, h0);
    write!(repo.write_file("file")?, "a\nx\nc\ne\ny\nf\n")?;
    let h1 = record_all(&repo, &store, &txn, &channel, "")?;
    let change1 = store.get_change(&h1).unwrap();
    text_test(&store, &change1, h1);
    repo.remove_path("file2", false)?;
    let h2 = record_all(&repo, &store, &txn, &channel, "")?;
    let change2 = store.get_change(&h2).unwrap();
    text_test(&store, &change2, h2);
    repo.rename("file", "file3")?;
    txn.write().move_file("file", "file3", 0)?;
    let h3 = record_all(&repo, &store, &txn, &channel, "")?;
    let change3 = store.get_change(&h3).unwrap();
    text_test(&store, &change3, h3);
    // name conflicts
    let env2 = pristine::sanakirja::Pristine::new_anon()?;
    let txn2 = env2.arc_txn_begin().unwrap();
    let channel2 = txn2.write().open_or_create_channel("main")?;
    let repo2 = working_copy::memory::Memory::new();
    apply::apply_change(&store, &mut *txn2.write(), &mut *channel2.write(), &h0)?;
    apply::apply_change(&store, &mut *txn2.write(), &mut *channel2.write(), &h1)?;
    apply::apply_change(&store, &mut *txn2.write(), &mut *channel2.write(), &h2)?;
    output::output_repository_no_pending(&repo2, &store, &txn2, &channel2, "", true, None, 1, 0)?;
    repo2.rename("file", "file4")?;
    txn2.write().move_file("file", "file4", 0)?;
    record_all(&repo2, &store, &txn2, &channel2, "")?;
    apply::apply_change(&store, &mut *txn2.write(), &mut *channel2.write(), &h3)?;
    output::output_repository_no_pending(&repo2, &store, &txn2, &channel2, "", true, None, 1, 0)?;
    let h = record_all(&repo2, &store, &txn2, &channel2, "")?;
    let solution = store.get_change(&h).unwrap();
    text_test(&store, &solution, h);
    Ok(())
}
fn text_test<C: ChangeStore>(c: &C, change0: &Change, h: Hash) {
    let mut v = Vec::new();
    // let channel = channel.borrow();
    change0.write(c, Some(h), true, &mut v).unwrap();
    println!("{}", String::from_utf8_lossy(&v));
    for i in std::str::from_utf8(&v).unwrap().lines() {
        debug!("{}", i);
    }
    let change1 = Change::read(std::io::Cursor::new(&v[..]), &mut HashMap::default()).unwrap();
    if change0.header != change1.header {
        error!("header: {:#?} != {:#?}", change0.header, change1.header);
    }
    if change0.dependencies != change1.dependencies {
        error!(
            "deps: {:#?} != {:#?}",
            change0.dependencies, change1.dependencies
        );
    }
    if change0.extra_known != change1.extra_known {
        error!(
            "extra: {:#?} != {:#?}",
            change0.extra_known, change1.extra_known
        );
    }
    if change0.metadata != change1.metadata {
        error!("meta: {:#?} != {:#?}", change0.metadata, change1.metadata);
    }
    if change0.changes != change1.changes {
        if change0.changes.len() != change1.changes.len() {
            trace!("change0.changes = {:#?}", change0.changes);
            trace!("change1.changes = {:#?}", change1.changes);
        } else {
            for (a, b) in change0.changes.iter().zip(change1.changes.iter()) {
                trace!("change0: {:#?}", a);
                trace!("change1: {:#?}", b);
                for (a, b) in a.iter().zip(b.iter()) {
                    if a != b {
                        error!("change0 -> {:#?}", a);
                        error!("change1 -> {:#?}", b);
                    }
                }
            }
        }
    }
    if change0.contents != change1.contents {
        error!("change0.contents = {:?}", change0.contents);
        error!("change1.contents = {:?}", change1.contents);
    }
    assert_eq!(change0, &change1);
}
quickcheck! {
  fn string_roundtrip(s1: String) -> () {
      let mut w = Vec::new();
      write!(&mut w, "{}", Escaped(&s1)).unwrap();
      let utf = std::str::from_utf8(&w).unwrap();
      let (_, s2) = parse_string(&utf).unwrap();
      assert_eq!(s1, s2);
  }
}
#[test]
#[cfg(feature = "text-changes")]
fn hunk_roundtrip_test() {
    fn go(hunk: PrintableHunk) {
        let mut w = Vec::new();
        hunk.write(&mut &mut w).unwrap();
        let s = std::str::from_utf8(&w).unwrap();
        match parse_hunk(&s) {
            Ok((_, hunk2)) => {
                if hunk != hunk2 {
                    eprintln!("## Hunk: \n\n{}", s);
                    eprintln!("In:  {:?}\n\nOut: {:?}\n", hunk, hunk2);
                    panic!("Hunks don't match.");
                }
            }
            Err(e) => {
                eprintln!("Hunk: \n\n{}", s);
                panic!("Can't parse hunk. Error: {:?}", e);
            }
        }
    }
    // Create a new thread with custom stack size
    std::thread::Builder::new()
        // frequently blown by shrinking :(
        // You can disable shrinking by commenting out the shrink function
        // for PrintableHunk
        .stack_size(20 * 1024 * 1024)
        .spawn(move || {
            quickcheck::QuickCheck::new()
                .tests(1000)
                .gen(quickcheck::Gen::new(3))
                .max_tests(100000000)
                .quickcheck(go as fn(PrintableHunk) -> ());
        })
        .unwrap()
        .join()
        .unwrap();
}

mod text_changes;

#[cfg(test)]
use quickcheck::{Arbitrary, Gen};

    }
}
#[cfg(test)]
impl Arbitrary for ChangePosition {
    fn arbitrary(g: &mut Gen) -> Self {
        ChangePosition(L64(u64::arbitrary(g)))

    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        Box::new(self.0 .0.shrink().map(|x| ChangePosition(L64(x))))
    }

#[cfg(test)]
#[macro_use]
extern crate quickcheck;

    }
    /// Get a valid encoding. This is checked by round-tripping the encoding on `buffer`.
    /// TODO: This is a hack. Make it better. Make it faster.
    pub fn get_valid(
        &self,
        tld: Option<&[u8]>,
        allow_utf8: bool,
        buffer: &[u8],
    ) -> Option<&'static Encoding> {
        if let (encoding, true) = self.guess_assess(tld, allow_utf8) {
            if let (s, e, false) = encoding.decode(buffer) {
                if encoding.encode(&s).0 == buffer {
                    return Some(e);
                }
            }
        }
        None

#[cfg(feature = "text-changes")]
mod parse;
#[cfg(feature = "text-changes")]
mod printable;

pub use parse::*; // for testing
pub use printable::*; // for testing

use regex::Captures;

use crate::change::parse::*;
use crate::change::printable::*;

    #[error(transparent)]
    Nom(#[from] nom::Err<nom::error::Error<String>>),

        let (mut change, extra_dependencies) = Self::read_(r, updatables)?;

        let (mut change, extra_dependencies) = Self::read_new(r, updatables)?;

        Ok(Self::read_(r, updatables)?.0)

        Ok(Self::read_new(r, updatables)?.0)

    fn read_<R: BufRead>(

    fn read_new<R: BufRead>(

        use self::text_changes::*;
        let mut section = Section::Header(String::new());

        // read the data
        // TODO: make this streaming
        let mut s = String::new();
        r.read_to_string(&mut s)?;
        let i = &s;
        // parse header
        let (i, m_header) = parse_header(i).map_err(|e| e.to_owned())?;
        let header = m_header?;
        dbg!(&header);
        // parse dependencies
        let (i, deps) = parse_dependencies(i).map_err(|e| e.to_owned())?;
        dbg!(&deps);
        // parse hunks
        let (_, hunks) = parse_hunks(i).map_err(|e| e.to_owned())?;
        dbg!(&hunks);
        Change::update(header, deps, hunks, updatables)
    }
    fn update(
        header: ChangeHeader,
        dependencies: Vec<PrintableDep>,
        hunks: Vec<(u64, PrintableHunk)>,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
    ) -> Result<(Self, HashSet<Hash>), TextDeError> {
        // TODO: get rid of this whole default change if possible

                header: ChangeHeader {
                    authors: Vec::new(),
                    message: String::new(),
                    description: None,
                    timestamp: chrono::Utc::now(),
                },

                header,

        };
        let conclude_section = |change: &mut Change,
                                section: Section,
                                contents: &mut Vec<u8>|
         -> Result<(), TextDeError> {
            match section {
                Section::Header(ref s) => {
                    debug!("header = {:?}", s);
                    change.header = toml::de::from_str(&s)?;
                    Ok(())
                }
                Section::Deps => Ok(()),
                Section::Changes {
                    mut changes,
                    current,
                    ..
                } => {
                    if has_newvertices(&current) {
                        contents.push(0)
                    }
                    if let Some(c) = current {
                        debug!("next action = {:?}", c);
                        changes.push(c)
                    }
                    change.changes = changes;
                    Ok(())
                }
            }

        let mut h = String::new();
        let mut contents = Vec::new();

        // process dependencies

        while r.read_line(&mut h)? > 0 {
            debug!("h = {:?}", h);
            if h == Self::DEPS_LINE {
                let section = std::mem::replace(&mut section, Section::Deps);
                conclude_section(&mut change, section, &mut contents)?;
            } else if h == Self::HUNKS_LINE {
                let section = std::mem::replace(
                    &mut section,
                    Section::Changes {
                        changes: Vec::new(),
                        current: None,
                        offsets: HashMap::default(),
                    },
                );
                conclude_section(&mut change, section, &mut contents)?;
            } else {
                use regex::Regex;
                lazy_static! {
                    static ref DEPS: Regex = Regex::new(r#"\[(\d*|\*)\](\+| ) *(\S*)"#).unwrap();
                    static ref KNOWN: Regex = Regex::new(r#"(\S*)"#).unwrap();

        for dep in dependencies {
            let hash = Hash::from_base32(dep.hash.as_bytes()).unwrap();
            match dep.type_ {
                DepType::Numbered(n, false) => {
                    change.hashed.dependencies.push(hash);
                    deps.insert(n, hash);

                match section {
                    Section::Header(ref mut s) => s.push_str(&h),
                    Section::Deps => {
                        if let Some(d) = DEPS.captures(&h) {
                            let hash = Hash::from_base32(d[3].as_bytes()).unwrap();
                            if let Ok(n) = d[1].parse() {
                                if &d[2] == " " {
                                    change.hashed.dependencies.push(hash);
                                }
                                deps.insert(n, hash);
                            } else if &d[1] == "*" {
                                change.hashed.extra_known.push(hash);
                            } else {
                                extra_dependencies.insert(hash);
                            }
                        }
                    }
                    Section::Changes {
                        ref mut current,
                        ref mut changes,
                        ref mut offsets,
                    } => {
                        if let Some(next) =
                            Hunk::read(updatables, current, &mut contents, &deps, offsets, &h)?
                        {
                            debug!("next action = {:?}", next);
                            changes.push(next)
                        }
                    }

                DepType::Numbered(n, true) => {
                    deps.insert(n, hash);
                }
                DepType::ExtraKnown => {
                    change.hashed.extra_known.push(hash);
                }
                DepType::ExtraUnknown => {
                    extra_dependencies.insert(hash);

            h.clear();

        }
        // process hunks
        let mut contents = Vec::new();
        let mut offsets = HashMap::default();
        for (n, hunk) in hunks {
            let res =
                Hunk::from_printable(updatables, &mut contents, &deps, &mut offsets, (n, hunk))?;
            change.hashed.changes.push(res);

        conclude_section(&mut change, section, &mut contents)?;

const BINARY_LABEL: &str = "binary";

pub fn to_printable_new_vertex(
    atom: &Atom<Option<Hash>>,
    hashes: &HashMap<Hash, usize>,
) -> PrintableNewVertex {
    if let PrintableAtom::NewVertex(v) = to_printable_atom(atom, hashes) {
        v
    } else {
        panic!("PrintableAtom::NewVertex expected here")
    }
}

struct Escaped<'a>(&'a str);

pub fn to_printable_edge_map(
    atom: &Atom<Option<Hash>>,
    hashes: &HashMap<Hash, usize>,
) -> Vec<PrintableEdge> {
    if let PrintableAtom::Edges(v) = to_printable_atom(atom, hashes) {
        v
    } else {
        panic!("PrintableAtom::Edges expected here")
    }
}

impl<'a> std::fmt::Display for Escaped<'a> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(fmt, "\"")?;
        for c in self.0.chars() {
            if c == '"' {
                write!(fmt, "\\{}", c)?
            } else if c == '\\' {
                write!(fmt, "\\\\")?
            } else {
                write!(fmt, "{}", c)?
            }
        }
        write!(fmt, "\"")?;
        Ok(())

/// Panics if the Atom is not an EdgeMap
fn to_printable_atom(atom: &Atom<Option<Hash>>, hashes: &HashMap<Hash, usize>) -> PrintableAtom {
    match atom {
        Atom::NewVertex(ref new_vertex) => PrintableAtom::NewVertex(PrintableNewVertex {
            up_context: new_vertex
                .up_context
                .iter()
                .map(|c| to_printable_pos(hashes, *c))
                .collect(),
            start: new_vertex.start.0 .0,
            end: new_vertex.end.0 .0,
            down_context: new_vertex
                .down_context
                .iter()
                .map(|c| to_printable_pos(hashes, *c))
                .collect(),
        }),
        Atom::EdgeMap(ref edge_map) => PrintableAtom::Edges(
            edge_map
                .edges
                .iter()
                .map(|c| PrintableEdge {
                    previous: PrintableEdgeFlags::from(c.previous),
                    flag: PrintableEdgeFlags::from(c.flag),
                    from: to_printable_pos(hashes, c.from),
                    to_start: to_printable_pos(hashes, c.to.start_pos()),
                    to_end: c.to.end.0 .0,
                    introduced_by: *hashes.get(&c.introduced_by.unwrap()).unwrap_or_else(|| {
                        panic!("introduced_by = {:?}, not found", c.introduced_by)
                    }),
                })
                .collect(),
        ),

fn unescape(s: &str) -> std::borrow::Cow<str> {
    let mut b = 0;
    let mut result = String::new();
    let mut ch = s.chars();
    while let Some(c) = ch.next() {
        if c == '\\' {
            if result.is_empty() {
                result = s.split_at(b).0.to_string();
            }
            if let Some(c) = ch.next() {
                result.push(c)
            }
        } else if !result.is_empty() {
            result.push(c)
        }
        b += c.len_utf8()
    }
    if result.is_empty() {
        s.into()
    } else {
        result.into()

fn from_printable_edge_map(
    edges: &[PrintableEdge],
    changes: &HashMap<usize, Hash>,
) -> Result<Vec<NewEdge<Option<Hash>>>, TextDeError> {
    let mut res = Vec::new();
    for edge in edges {
        let Position { change, pos } = from_printable_pos(changes, edge.to_start)?;
        res.push(NewEdge {
            previous: edge.previous.to(),
            flag: edge.flag.to(),
            from: from_printable_pos(changes, edge.from)?,
            to: Vertex {
                change,
                start: pos,
                end: ChangePosition(L64(edge.to_end)),
            },
            introduced_by: change_ref(changes, edge.introduced_by)?,
        })

    Ok(res)

        mut w: &mut W,

        w: &mut W,

        // let file_name = |local: &Local, _| -> String { format!("{}:{}", local.path, local.line) };

                        metadata: perms,

                        metadata,

                    write!(
                        w,
                        "Moved: {} {} {}",
                        Escaped(&path),
                        Escaped(&name),
                        if perms.0 & 0o1000 == 0o1000 {
                            "+dx "
                        } else if perms.0 & 0o100 == 0o100 {
                            "+x "
                        } else {
                            ""
                        }
                    )?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &del)?;
                    write!(w, "up")?;
                    for c in add.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    write!(w, ", down")?;
                    for c in add.down_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?

                    PrintableHunk::FileMoveV {
                        path: path.to_string(),
                        name: name.to_string(),
                        perms: PrintablePerms::from_metadata(metadata),
                        pos: to_printable_pos(hashes, del.inode()),
                        up_context: to_printable_pos_vec(hashes, &add.up_context),
                        down_context: to_printable_pos_vec(hashes, &add.down_context),
                        del: to_printable_edge_map(del, hashes),

                    w.write_all(b"\n")?;

                Atom::EdgeMap(_) => {
                    write!(w, "Moved: {:?} ", path)?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &add)?;
                    write_atom(&mut w, hashes, &del)?;
                }

                Atom::EdgeMap(_) => PrintableHunk::FileMoveE {
                    path: path.to_string(),
                    pos: to_printable_pos(hashes, del.inode()),
                    add: to_printable_edge_map(add, hashes),
                    del: to_printable_edge_map(del, hashes),
                },

                write!(w, "File deletion: {} ", Escaped(path))?;
                write_pos(&mut w, hashes, del.inode())?;
                writeln!(w, " {:?}", encoding_label(encoding))?;

                let (contents_data, content_edges) = if let Some(ref c) = contents {
                    (
                        get_change_contents(changes, c, change_contents)?,
                        to_printable_edge_map(c, hashes),
                    )
                } else {
                    (Vec::new(), Vec::new())
                };

                write_atom(&mut w, hashes, &del)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    writeln!(w)?;
                    print_change_contents(w, changes, contents, change_contents, encoding)?;
                } else {
                    writeln!(w)?;

                PrintableHunk::FileDel {
                    path: path.to_string(),
                    pos: to_printable_pos(hashes, del.inode()),
                    encoding: encoding.clone(),
                    del_edges: to_printable_edge_map(del, hashes),
                    content_edges: content_edges,
                    contents: contents_data,

                write!(w, "File un-deletion: {} ", Escaped(path))?;
                write_pos(&mut w, hashes, undel.inode())?;
                writeln!(w, " {:?}", encoding_label(encoding))?;
                write_atom(&mut w, hashes, &undel)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    print_change_contents(w, changes, contents, change_contents, encoding)?;

                let (contents_data, content_edges) = if let Some(ref c) = contents {
                    (
                        get_change_contents(changes, c, change_contents)?,
                        to_printable_edge_map(c, hashes),
                    )

                    writeln!(w)?;

                    (Vec::new(), Vec::new())
                };
                PrintableHunk::FileUndel {
                    path: path.to_string(),
                    pos: to_printable_pos(hashes, undel.inode()),
                    encoding: encoding.clone(),
                    undel_edges: to_printable_edge_map(undel, hashes),
                    content_edges: content_edges,
                    contents: contents_data,

                        metadata: perms,

                        metadata,

                    let parent = if let Some(p) = crate::path::parent(&path) {
                        if p.is_empty() {
                            "/"
                        } else {
                            p
                        }

                    let contents = if let Some(Atom::NewVertex(ref n)) = contents {
                        change_contents[n.start.us()..n.end.us()].to_vec()

                        "/"

                        Vec::new()

                    write!(
                        w,
                        "File addition: {} in {}{} \"{}\"\n  up",
                        Escaped(name),
                        Escaped(parent),
                        if perms.0 & 0o1000 == 0o1000 {
                            " +dx"
                        } else if perms.0 & 0o100 == 0o100 {
                            " +x"
                        } else {
                            ""
                        },
                        encoding_label(encoding)
                    )?;

                    for c in n.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?

                    PrintableHunk::FileAddition {
                        name: name.to_string(),
                        parent: crate::path::parent(&path).unwrap_or("").to_string(),
                        perms: PrintablePerms::from_metadata(metadata),
                        encoding: encoding.clone(),
                        up_context: to_printable_pos_vec(hashes, &n.up_context),
                        start: n.start.0 .0,
                        end: n.end.0 .0,
                        contents,

                    writeln!(w, ", new {}:{}", n.start.0, n.end.0)?;
                }
                if let Some(Atom::NewVertex(ref n)) = contents {
                    let c = &change_contents[n.start.us()..n.end.us()];
                    print_contents(w, "+", c, encoding)?;
                    if !c.ends_with(b"\n") {
                        writeln!(w, "\n\\")?
                    }

                } else {
                    // TODO: should this panic?
                    panic!("Invalid Hunk::FileAdd field add_name: {:?}", add_name);

                write!(w, "Edit in {}:{} ", Escaped(&local.path), local.line)?;
                write_pos(&mut w, hashes, change.inode())?;
                write!(w, " {:?}", encoding_label(encoding))?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(w, changes, change, change_contents, encoding)?;

                PrintableHunk::Edit {
                    path: local.path.clone(),
                    line: local.line,
                    pos: to_printable_pos(hashes, change.inode()),
                    encoding: encoding.clone(),
                    change: to_printable_atom(change, hashes),
                    contents: get_change_contents(changes, change, change_contents)?,
                }

                write!(w, "Replacement in {}:{} ", Escaped(&local.path), local.line)?;
                write_pos(&mut w, hashes, change.inode())?;
                write!(w, " {:?}", encoding_label(encoding))?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                write_atom(&mut w, hashes, &replacement)?;
                print_change_contents(w, changes, change, change_contents, encoding)?;
                print_change_contents(w, changes, replacement, change_contents, encoding)?;
            }
            Hunk::SolveNameConflict { name, path } => {
                write!(w, "Solving a name conflict in {} ", Escaped(path))?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;
            }
            Hunk::UnsolveNameConflict { name, path } => {
                write!(w, "Un-solving a name conflict in {} ", Escaped(path))?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;

                PrintableHunk::Replace {
                    path: local.path.clone(),
                    line: local.line,
                    pos: to_printable_pos(hashes, change.inode()),
                    encoding: encoding.clone(),
                    change: to_printable_edge_map(change, hashes),
                    replacement: to_printable_new_vertex(replacement, hashes),
                    change_contents: get_change_contents(changes, change, change_contents)?,
                    replacement_contents: get_change_contents(
                        changes,
                        replacement,
                        change_contents,
                    )?,
                }

            Hunk::SolveNameConflict { name, path } => PrintableHunk::SolveNameConflict {
                path: path.clone(),
                pos: to_printable_pos(hashes, name.inode()),
                names: get_deleted_names(changes, name)?,
                edges: to_printable_edge_map(name, hashes),
            },
            Hunk::UnsolveNameConflict { name, path } => PrintableHunk::UnsolveNameConflict {
                path: path.clone(),
                pos: to_printable_pos(hashes, name.inode()),
                names: get_deleted_names(changes, name)?,
                edges: to_printable_edge_map(name, hashes),
            },

                debug!("solve order conflict");
                write!(
                    w,
                    "Solving an order conflict in {}:{} ",
                    Escaped(&local.path),
                    local.line,
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(w, changes, change, change_contents, &None)?;

                // TODO: pass in the encoding
                let contents = get_change_contents(changes, change, change_contents)?;
                let encoding = get_encoding(&contents);
                PrintableHunk::SolveOrderConflict {
                    path: local.path.clone(),
                    line: local.line,
                    pos: to_printable_pos(hashes, change.inode()),
                    encoding: encoding.clone(),
                    change: to_printable_new_vertex(change, hashes),
                    contents: get_change_contents(changes, change, change_contents)?,
                }

                debug!("unsolve order conflict");
                write!(
                    w,
                    "Un-solving an order conflict in {}:{} ",
                    Escaped(&local.path),
                    local.line,
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(w, changes, change, change_contents, &None)?;

                // TODO: pass in the encoding
                let contents = get_change_contents(changes, change, change_contents)?;
                let encoding = get_encoding(&contents);
                PrintableHunk::UnsolveOrderConflict {
                    path: local.path.clone(),
                    line: local.line,
                    pos: to_printable_pos(hashes, change.inode()),
                    encoding: encoding.clone(),
                    change: to_printable_edge_map(change, hashes),
                    contents: get_change_contents(changes, change, change_contents)?,
                }

            } => {
                debug!("resurrect zombies");
                write!(
                    w,
                    "Resurrecting zombie lines in {}:{} ",
                    Escaped(&local.path),
                    local.line
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                write!(w, " \"{}\"", encoding_label(encoding))?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(w, changes, change, change_contents, encoding)?;
            }

            } => PrintableHunk::ResurrectZombies {
                path: local.path.clone(),
                line: local.line,
                pos: to_printable_pos(hashes, change.inode()),
                encoding: encoding.clone(),
                change: to_printable_edge_map(change, hashes),
                contents: get_change_contents(changes, change, change_contents)?,
            },

        .write(w)?;

fn encoding_label(encoding: &Option<Encoding>) -> &str {
    match encoding {
        Some(encoding) => encoding.label(),
        _ => BINARY_LABEL,
    }
}

    fn read(

    fn from_printable(

        current: &mut Option<Self>,

        h: &str,
    ) -> Result<Option<Self>, TextDeError> {
        use self::text_changes::*;
        use regex::Regex;
        lazy_static! {
            static ref FILE_ADDITION: Regex =
                Regex::new(r#"^(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)"(?P<perm> \S+)? "(?P<encoding>[^"]*)""#).unwrap();
            static ref EDIT: Regex =
                Regex::new(r#"^([0-9]+)\. Edit in ([^:]+):(\d+) (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();
            static ref REPLACEMENT: Regex =
                Regex::new(r#"^([0-9]+)\. Replacement in ([^:]+):(\d+) (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();
            static ref FILE_DELETION: Regex =
                Regex::new(r#"^([0-9]+)\. File deletion: "([^"]*)" (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();
            static ref FILE_UNDELETION: Regex =
                Regex::new(r#"^([0-9]+)\. File un-deletion: "([^"]*)" (\d+\.\d+) "(?P<encoding>[^"]*)""#).unwrap();
            static ref MOVE: Regex =
                Regex::new(r#"^([0-9]+)\. Moved: "(?P<former>[^"]*)" "(?P<new>[^"]*)" (?P<perm>[^ ]+ )?(?P<inode>.*)"#).unwrap();
            static ref MOVE_: Regex = Regex::new(r#"^([0-9]+)\. Moved: "([^"]*)" (.*)"#).unwrap();
            static ref NAME_CONFLICT: Regex = Regex::new(
                r#"^([0-9]+)\. ((Solving)|(Un-solving)) a name conflict in "([^"]*)" (.*): .*"#
            )
            .unwrap();
            static ref ORDER_CONFLICT: Regex = Regex::new(
                r#"^([0-9]+)\. ((Solving)|(Un-solving)) an order conflict in (.*):(\d+) (\d+\.\d+)"#
            )
            .unwrap();
            static ref ZOMBIE: Regex =
                Regex::new(r#"^([0-9]+)\. Resurrecting zombie lines in (?P<path>"[^"]+"):(?P<line>\d+) (?P<inode>\d+\.\d+) "(?P<encoding>[^"]*)""#)
                    .unwrap();
            static ref CONTEXT: Regex = Regex::new(
                r#"up ((\d+\.\d+ )*\d+\.\d+)(, new (\d+):(\d+))?(, down ((\d+\.\d+ )*\d+\.\d+))?"#
            )
            .unwrap();
        }
        if let Some(cap) = FILE_ADDITION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)

        (hunk_id, hunk): (u64, PrintableHunk),
    ) -> Result<Self, TextDeError> {
        // TODO: should we push, or not?
        contents_.push(0);
        match hunk {
            PrintableHunk::FileMoveV {
                path,
                name,
                perms,
                pos,
                up_context,
                down_context,
                del,
            } => {
                let mut add = default_newvertex();
                add.start = ChangePosition(contents_.len().into());
                add.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
                let meta = FileMetadata {
                    metadata: InodeMetadata(match perms {
                        // TODO: deduplicate
                        PrintablePerms::IsDir => 0o1100,
                        PrintablePerms::IsExecutable => 0o100,
                        PrintablePerms::IsFile => 0,
                    }),
                    basename: &name,
                    encoding: None,
                };
                meta.write(contents_);
                add.end = ChangePosition(contents_.len().into());
                add.up_context = from_printable_pos_vec_offsets(changes, offsets, &up_context)?;
                add.down_context = from_printable_pos_vec_offsets(changes, offsets, &down_context)?;
                Ok(Hunk::FileMove {
                    add: Atom::NewVertex(add),
                    del: Atom::EdgeMap(EdgeMap {
                        inode: from_printable_pos(changes, pos)?,
                        edges: from_printable_edge_map(&del, changes)?,
                    }),
                    path,
                })
            }
            PrintableHunk::FileMoveE {
                path,
                pos,
                add,
                del,
            } => {
                let inode = from_printable_pos(changes, pos)?;
                Ok(Hunk::FileMove {
                    add: Atom::EdgeMap(EdgeMap {
                        inode,
                        edges: from_printable_edge_map(&add, changes)?,
                    }),
                    del: Atom::EdgeMap(EdgeMap {
                        inode,
                        edges: from_printable_edge_map(&del, changes)?,
                    }),
                    path,
                })

            let mut add_name = default_newvertex();
            add_name.start = ChangePosition(contents_.len().into());
            add_name.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = unescape(&cap.name("name").unwrap().as_str());
            let path = {
                let parent = cap.name("parent").unwrap().as_str();
                (if parent == "/" {
                    String::new()
                } else {
                    unescape(&parent).to_string() + "/"
                }) + &name
            };
            debug!("cap = {:?}", cap);
            let meta = if let Some(perm) = cap.name("perm") {
                if perm.as_str() == " +dx" {
                    0o1100
                } else if perm.as_str() == " +x" {
                    0o100
                } else {
                    0

            PrintableHunk::FileAddition {
                name,
                parent,
                perms,
                encoding,
                up_context,
                start,
                end,
                contents,
            } => {
                let meta = FileMetadata {
                    metadata: InodeMetadata(match perms {
                        PrintablePerms::IsDir => 0o1100,
                        PrintablePerms::IsExecutable => 0o100,
                        PrintablePerms::IsFile => 0,
                    }),
                    basename: &name,
                    encoding: encoding.clone(),
                };
                let add_name = {
                    let mut x = default_newvertex();
                    x.start = ChangePosition(contents_.len().into());
                    meta.write(contents_);
                    x.end = ChangePosition(contents_.len().into());
                    x.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
                    x.up_context = from_printable_pos_vec_offsets(changes, offsets, &up_context)?;
                    x
                };
                let add_inode = {
                    let mut x = default_newvertex();
                    x.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
                    x.up_context.push(Position {
                        change: None,
                        pos: ChangePosition(contents_.len().into()),
                    });
                    contents_.push(0);
                    x.start = ChangePosition(contents_.len().into());
                    x.end = ChangePosition(contents_.len().into());
                    contents_.push(0);
                    x
                };
                if let Entry::Occupied(mut e) = updatables.entry(hunk_id as usize) {
                    if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {
                        offsets.insert(pos.0.into(), add_inode.start);
                        *pos = add_inode.start
                    }

            } else {
                0
            };
            let n = cap.name("n").unwrap().as_str().parse().unwrap();
            let encoding = encoding_from_label(cap);
            let meta = FileMetadata {
                metadata: InodeMetadata(meta),
                basename: &name,
                encoding: encoding.clone(),
            };
            meta.write(contents_);
            add_name.end = ChangePosition(contents_.len().into());

            let mut add_inode = default_newvertex();
            add_inode.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            add_inode.up_context.push(Position {
                change: None,
                pos: ChangePosition(contents_.len().into()),
            });

                // context
                offsets.insert(start, add_name.start);
                offsets.insert(end, add_name.end);
                offsets.insert(end + 1, add_name.end + 1);

            contents_.push(0);
            add_inode.start = ChangePosition(contents_.len().into());
            add_inode.end = ChangePosition(contents_.len().into());
            contents_.push(0);
            if let Entry::Occupied(mut e) = updatables.entry(n) {
                if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {
                    offsets.insert(pos.0.into(), add_inode.start);

                // contents
                let contents_res = {
                    let mut x = default_newvertex();
                    // The `-1` here comes from the extra 0
                    // padding bytes pushed onto `contents_`.
                    // TODO: verify this is correct
                    let inode = Position {
                        change: None,
                        pos: ChangePosition((contents_.len() - 1).into()),
                    };
                    x.up_context.push(inode);
                    x.inode = inode;
                    x.flag = EdgeFlags::BLOCK;
                    x.start = ChangePosition(contents_.len().into());
                    contents_.extend(&contents);
                    x.end = ChangePosition(contents_.len().into());
                    x
                };

                    *pos = add_inode.start
                }
            }
            Ok(std::mem::replace(
                current,
                Some(Hunk::FileAdd {

                Ok(Hunk::FileAdd {

                    contents: None,
                    path,

                    contents: Some(Atom::NewVertex(contents_res)),
                    path: parent + "/" + &name,

                }),
            ))
        } else if let Some(cap) = EDIT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)

                })

            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4])?;
            v.flag = EdgeFlags::BLOCK;
            Ok(std::mem::replace(
                current,
                Some(Hunk::Edit {
                    change: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                    encoding: encoding_from_label(cap),

            PrintableHunk::FileDel {
                path,
                pos,
                encoding,
                del_edges,
                content_edges,
                contents: _,
            } => Ok(Hunk::FileDel {
                del: Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&del_edges, changes)?,
                    inode: from_printable_pos(changes, pos)?,

            ))
        } else if let Some(cap) = REPLACEMENT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4])?;
            v.flag = EdgeFlags::BLOCK;
            Ok(std::mem::replace(
                current,
                Some(Hunk::Replacement {
                    change: Atom::NewVertex(v.clone()),
                    replacement: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                    encoding: encoding_from_label(cap),
                }),
            ))
        } else if let Some(cap) = FILE_DELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut del = default_edgemap();
            del.inode = parse_pos(changes, &cap[3])?;
            Ok(std::mem::replace(
                current,
                Some(Hunk::FileDel {
                    del: Atom::EdgeMap(del),
                    contents: None,
                    path: cap[2].to_string(),
                    encoding: encoding_from_label(cap),
                }),
            ))
        } else if let Some(cap) = FILE_UNDELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut undel = default_edgemap();
            undel.inode = parse_pos(changes, &cap[3])?;
            Ok(std::mem::replace(
                current,
                Some(Hunk::FileUndel {
                    undel: Atom::EdgeMap(undel),
                    contents: None,
                    path: cap[2].to_string(),
                    encoding: encoding_from_label(cap),

                contents: Some(Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&content_edges, changes)?,
                    inode: from_printable_pos(changes, pos)?,
                })),
                path,
                encoding,
            }),
            PrintableHunk::FileUndel {
                path,
                pos,
                encoding,
                undel_edges,
                content_edges,
                contents: _,
            } => Ok(Hunk::FileUndel {
                undel: Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&undel_edges, changes)?,
                    inode: from_printable_pos(changes, pos)?,

            ))
        } else if let Some(cap) = NAME_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut name = default_edgemap();
            debug!("cap = {:?}", cap);
            name.inode = parse_pos(changes, &cap[6])?;
            Ok(std::mem::replace(
                current,
                if &cap[2] == "Solving" {
                    Some(Hunk::SolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                } else {
                    Some(Hunk::UnsolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                },
            ))
        } else if let Some(cap) = MOVE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)

                contents: Some(Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&content_edges, changes)?,
                    inode: from_printable_pos(changes, pos)?,
                })),
                path,
                encoding,
            }),
            PrintableHunk::Edit {
                path,
                line,
                pos,
                encoding,
                change,
                contents,
            } => {
                let inode = from_printable_pos(changes, pos)?;
                let change = match change {
                    PrintableAtom::NewVertex(new_vertex) => {
                        let mut x = default_newvertex();
                        x.inode = inode;
                        x.flag = EdgeFlags::BLOCK;
                        x.up_context = from_printable_pos_vec(changes, &new_vertex.up_context)?;
                        x.down_context = from_printable_pos_vec(changes, &new_vertex.down_context)?;
                        x.start = ChangePosition(contents_.len().into());
                        contents_.extend(&contents);
                        x.end = ChangePosition(contents_.len().into());
                        Atom::NewVertex(x)
                    }
                    PrintableAtom::Edges(edges) => Atom::EdgeMap(EdgeMap {
                        edges: from_printable_edge_map(&edges, changes)?,
                        inode: inode,
                    }),
                };
                Ok(Hunk::Edit {
                    change,
                    local: Local { path, line },
                    encoding,
                })

            let mut add = default_newvertex();
            add.start = ChangePosition(contents_.len().into());
            add.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = unescape(cap.name("new").unwrap().as_str());
            let meta = if let Some(perm) = cap.name("perm") {
                debug!("perm = {:?}", perm.as_str());
                if perm.as_str() == "+dx " {
                    0o1100
                } else if perm.as_str() == "+x " {
                    0o100
                } else {
                    0
                }
            } else {
                0
            };
            let meta = FileMetadata {
                metadata: InodeMetadata(meta),
                basename: &name,
                encoding: None,
            };
            meta.write(contents_);
            add.end = ChangePosition(contents_.len().into());

            PrintableHunk::Replace {
                path,
                line,
                pos,
                encoding,
                change,
                replacement,
                change_contents: _,
                replacement_contents,
            } => {
                let inode = from_printable_pos(changes, pos)?;

            let mut del = default_edgemap();
            del.inode = parse_pos(changes, cap.name("inode").unwrap().as_str())?;
            Ok(std::mem::replace(
                current,
                Some(Hunk::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::NewVertex(add),
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = MOVE_.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)

                let replacement = {
                    let mut x = default_newvertex();
                    x.inode = inode;
                    x.flag = EdgeFlags::BLOCK;
                    x.up_context = from_printable_pos_vec(changes, &replacement.up_context)?;
                    x.down_context = from_printable_pos_vec(changes, &replacement.down_context)?;
                    x.start = ChangePosition(contents_.len().into());
                    contents_.extend(&replacement_contents);
                    x.end = ChangePosition(contents_.len().into());
                    Atom::NewVertex(x)
                };
                Ok(Hunk::Replacement {
                    change: Atom::EdgeMap(EdgeMap {
                        edges: from_printable_edge_map(&change, changes)?,
                        inode: inode,
                    }),
                    replacement,
                    local: Local { path, line },
                    encoding,
                })

            let mut add = default_edgemap();
            let mut del = default_edgemap();
            add.inode = parse_pos(changes, &cap[3])?;
            del.inode = add.inode;
            Ok(std::mem::replace(
                current,
                Some(Hunk::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::EdgeMap(add),
                    path: cap[2].to_string(),

            PrintableHunk::SolveNameConflict {
                path,
                pos,
                names: _,
                edges,
            } => Ok(Hunk::SolveNameConflict {
                name: Atom::EdgeMap(EdgeMap {
                    inode: from_printable_pos(changes, pos)?,
                    edges: from_printable_edge_map(&edges, changes)?,

            ))
        } else if let Some(cap) = ORDER_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }

                path,
            }),
            PrintableHunk::UnsolveNameConflict {
                path,
                pos,
                names: _,
                edges,
            } => Ok(Hunk::UnsolveNameConflict {
                name: Atom::EdgeMap(EdgeMap {
                    inode: from_printable_pos(changes, pos)?,
                    edges: from_printable_edge_map(&edges, changes)?,
                }),
                path,
            }),
            PrintableHunk::SolveOrderConflict {
                path,
                line,
                pos,
                encoding: _,
                change,
                contents,
            } => {
                // TODO: this code block looks suspect. Check the correctness.
                let mut c = default_newvertex();
                c.inode = from_printable_pos(changes, pos)?;
                c.up_context = from_printable_pos_vec(changes, &change.up_context)?;
                c.down_context = from_printable_pos_vec(changes, &change.down_context)?;
                // TODO: this maths is probably unnecessarily complicated
                c.start = ChangePosition(contents_.len().into());
                c.end = ChangePosition((contents_.len() as u64 + change.end - change.start).into());
                offsets.insert(change.end, c.end);
                c.start = ChangePosition(contents_.len().into());
                contents_.extend(&contents);
                c.end = ChangePosition(contents_.len().into());

            Ok(std::mem::replace(
                current,
                Some(if &cap[2] == "Solving" {
                    let mut v = default_newvertex();
                    v.inode = parse_pos(changes, &cap[7])?;
                    Hunk::SolveOrderConflict {
                        change: Atom::NewVertex(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                } else {
                    let mut v = default_edgemap();
                    v.inode = parse_pos(changes, &cap[7])?;
                    Hunk::UnsolveOrderConflict {
                        change: Atom::EdgeMap(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                }),
            ))
        } else if let Some(cap) = ZOMBIE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)

                Ok(Hunk::SolveOrderConflict {
                    change: Atom::NewVertex(c),
                    local: Local { path, line },
                })

            let mut v = default_edgemap();
            v.inode = parse_pos(changes, &cap.name("inode").unwrap().as_str())?;
            Ok(std::mem::replace(
                current,
                Some(Hunk::ResurrectZombies {
                    change: Atom::EdgeMap(v),
                    local: Local {
                        path: cap.name("path").unwrap().as_str().parse().unwrap(),
                        line: cap.name("line").unwrap().as_str().parse().unwrap(),
                    },
                    encoding: encoding_from_label(cap),

            PrintableHunk::UnsolveOrderConflict {
                path,
                line,
                pos,
                encoding: _,
                change,
                contents: _,
            } => Ok(Hunk::UnsolveOrderConflict {
                change: Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&change, changes)?,
                    inode: from_printable_pos(changes, pos)?,

            ))
        } else {
            match current {
                Some(Hunk::FileAdd {
                    ref mut contents,
                    ref mut add_name,
                    encoding,
                    ..
                }) => {
                    if h.starts_with('+') {
                        if contents.is_none() {
                            let mut v = default_newvertex();
                            // The `-1` here comes from the extra 0
                            // padding bytes pushed onto `contents_`.
                            let inode = Position {
                                change: None,
                                pos: ChangePosition((contents_.len() - 1).into()),
                            };
                            v.up_context.push(inode);
                            v.inode = inode;
                            v.flag = EdgeFlags::BLOCK;
                            v.start = ChangePosition(contents_.len().into());
                            *contents = Some(Atom::NewVertex(v));
                        }
                        if let Some(Atom::NewVertex(ref mut contents)) = contents {
                            if h.starts_with('+') {
                                text_changes::parse_line_add(h, contents, contents_, encoding)
                            }
                        }
                    } else if h.starts_with('\\') {
                        if let Some(Atom::NewVertex(mut c)) = contents.take() {
                            if c.end > c.start {
                                if contents_[c.end.us() - 1] == b'\n' {
                                    assert_eq!(c.end.us(), contents_.len());
                                    contents_.pop();
                                    c.end.0 -= 1;
                                }
                                *contents = Some(Atom::NewVertex(c))
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut name) = add_name {
                            name.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                offsets.insert(new_start.as_str().parse().unwrap(), name.start);
                                offsets.insert(new_end.as_str().parse().unwrap(), name.end);
                                offsets.insert(
                                    new_end.as_str().parse::<u64>().unwrap() + 1,
                                    name.end + 1,
                                );
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::FileDel {
                    ref mut del,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        if let Atom::EdgeMap(ref mut e) = del {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::FileUndel {
                    ref mut undel,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        if let Atom::EdgeMap(ref mut e) = undel {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::FileMove {
                    ref mut del,
                    ref mut add,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        if edges[0].flag.contains(EdgeFlags::DELETED) {
                            *del = Atom::EdgeMap(EdgeMap {
                                inode: del.inode(),
                                edges,
                            });
                            return Ok(None);
                        } else if let Atom::EdgeMap(ref mut add) = add {
                            if add.edges.is_empty() {
                                *add = EdgeMap {
                                    inode: add.inode,
                                    edges,
                                };
                                return Ok(None);
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = add {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::Edit {
                    ref mut change,
                    encoding,
                    ..
                }) => {
                    debug!("edit {:?}", h);
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len().into());
                            }
                            text_changes::parse_line_add(h, change, contents_, encoding)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.end > change.start && contents_[change.end.us() - 1] == b'\n'
                            {
                                assert_eq!(change.end.us(), contents_.len());
                                contents_.pop();
                                change.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = change {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h)? {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Hunk::Replacement {
                    ref mut change,
                    ref mut replacement,
                    encoding,
                    ..
                }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if repl.start == repl.end {
                                repl.start = ChangePosition(contents_.len().into());
                            }
                            text_changes::parse_line_add(h, repl, contents_, encoding)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if repl.end > repl.start && contents_[repl.end.us() - 1] == b'\n' {
                                assert_eq!(repl.end.us(), contents_.len());
                                contents_.pop();
                                repl.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            repl.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                repl.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h)? {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Hunk::SolveNameConflict { ref mut name, .. })
                | Some(Hunk::UnsolveNameConflict { ref mut name, .. }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        *name = Atom::EdgeMap(EdgeMap {
                            edges,
                            inode: name.inode(),
                        })
                    }
                    Ok(None)
                }
                Some(Hunk::SolveOrderConflict { ref mut change, .. }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len().into());
                            }
                            // TODO encoding
                            text_changes::parse_line_add(h, change, contents_, &None)
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut change) = change {
                            change.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                change.down_context =
                                    parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                let new_start = new_start.as_str().parse::<u64>().unwrap();
                                let new_end = new_end.as_str().parse::<u64>().unwrap();
                                change.start = ChangePosition(contents_.len().into());
                                change.end = ChangePosition(
                                    (contents_.len() as u64 + new_end - new_start).into(),
                                );
                                offsets.insert(new_end, change.end);
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::UnsolveOrderConflict { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                Some(Hunk::ResurrectZombies { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h)? {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                None => {
                    debug!("current = {:#?}", current);
                    debug!("h = {:?}", h);
                    Ok(None)
                }
            }

                local: Local { path, line },
            }),
            PrintableHunk::ResurrectZombies {
                path,
                line,
                pos,
                encoding,
                change,
                contents: _,
            } => Ok(Hunk::ResurrectZombies {
                change: Atom::EdgeMap(EdgeMap {
                    edges: from_printable_edge_map(&change, changes)?,
                    inode: from_printable_pos(changes, pos)?,
                }),
                local: Local { path, line },
                encoding,
            }),

fn encoding_from_label(cap: Captures) -> Option<Encoding> {
    let encoding_label = cap.name("encoding").unwrap().as_str();
    if encoding_label != BINARY_LABEL {
        Some(Encoding::for_label(encoding_label))
    } else {
        None
    }
}
lazy_static! {
    static ref POS: regex::Regex = regex::Regex::new(r#"(\d+)\.(\d+)"#).unwrap();
    static ref EDGE: regex::Regex =
        regex::Regex::new(r#"\s*(?P<prev>[BFD]*):(?P<flag>[BFD]*)\s+(?P<up_c>\d+)\.(?P<up_l>\d+)\s*->\s*(?P<c>\d+)\.(?P<l0>\d+):(?P<l1>\d+)/(?P<intro>\d+)\s*"#).unwrap();
}

        inode: Position {
            change: Some(Hash::None),
            pos: ChangePosition(L64(0)),
        },
    }
}
pub fn default_edgemap() -> EdgeMap<Option<Hash>> {
    EdgeMap {
        edges: Vec::new(),

pub fn has_newvertices<L>(current: &Option<Hunk<Option<Hash>, L>>) -> bool {
    match current {
        Some(Hunk::FileAdd { contents: None, .. }) | None => false,
        Some(rec) => rec.iter().any(|e| matches!(e, Atom::NewVertex(_))),
    }
}
pub fn parse_pos_vec(

// TODO: rename
pub fn from_printable_pos_vec_offsets(

    s: &str,

    s: &[PrintablePos],

    for pos in POS.captures_iter(s) {
        let change: usize = (&pos[1]).parse().unwrap();
        let pos: u64 = (&pos[2]).parse().unwrap();
        let pos = if change == 0 {

    for PrintablePos(change, pos) in s {
        let pos = if *change == 0 {

                return Err(TextDeError::MissingPosition(pos));

                return Err(TextDeError::MissingPosition(*pos));

            change: change_ref(changes, change)?,

            change: change_ref(changes, *change)?,

pub fn parse_pos(

pub fn from_printable_pos(

    s: &str,

    pos: PrintablePos,

    let pos = POS.captures(s).unwrap();
    let change: usize = (&pos[1]).parse().unwrap();
    let pos: u64 = (&pos[2]).parse().unwrap();

        change: change_ref(changes, change)?,
        pos: ChangePosition(L64(pos.to_le())),

        change: change_ref(changes, pos.0)?,
        pos: ChangePosition(L64(pos.1.to_le())),

pub fn parse_edges(

pub fn from_printable_pos_vec(

    s: &str,
) -> Result<Option<Vec<NewEdge<Option<Hash>>>>, TextDeError> {
    debug!("parse_edges {:?}", s);
    let mut result = Vec::new();
    for edge in s.split(',') {
        debug!("parse edge {:?}", edge);
        if let Some(cap) = EDGE.captures(edge) {
            let previous = read_flag(cap.name("prev").unwrap().as_str());
            let flag = read_flag(cap.name("flag").unwrap().as_str());
            let change0: usize = cap.name("up_c").unwrap().as_str().parse().unwrap();
            let pos0: u64 = cap.name("up_l").unwrap().as_str().parse().unwrap();
            let change1: usize = cap.name("c").unwrap().as_str().parse().unwrap();
            let start1: u64 = cap.name("l0").unwrap().as_str().parse().unwrap();
            let end1: u64 = cap.name("l1").unwrap().as_str().parse().unwrap();
            let introduced_by: usize = cap.name("intro").unwrap().as_str().parse().unwrap();
            result.push(NewEdge {
                previous,
                flag,
                from: Position {
                    change: change_ref(changes, change0)?,
                    pos: ChangePosition(L64(pos0.to_le())),
                },
                to: Vertex {
                    change: change_ref(changes, change1)?,
                    start: ChangePosition(L64(start1.to_le())),
                    end: ChangePosition(L64(end1.to_le())),
                },
                introduced_by: change_ref(changes, introduced_by)?,
            })
        } else {
            debug!("not parsed");
            return Ok(None);
        }

    pos: &[PrintablePos],
) -> Result<Vec<Position<Option<Hash>>>, TextDeError> {
    let mut buf = Vec::new();
    for p in pos {
        buf.push(from_printable_pos(changes, *p)?);

    Ok(Some(result))

    Ok(buf)

pub fn parse_line_add(
    h: &str,
    change: &mut NewVertex<Option<Hash>>,
    contents_: &mut Vec<u8>,
    encoding: &Option<Encoding>,
) {
    let h = match encoding {
        Some(encoding) => encoding.encode(h),
        None => std::borrow::Cow::Borrowed(h.as_bytes()),
    };
    debug!("parse_line_add {:?} {:?}", change.end, change.start);
    debug!("parse_line_add {:?}", h);
    if h.len() > 2 {
        let h = &h[2..h.len()];
        contents_.extend(h);
    } else if h.len() > 1 {
        contents_.push(b'\n');
    }
    debug!("contents_.len() = {:?}", contents_.len());
    trace!("contents_ = {:?}", contents_);
    change.end = ChangePosition(contents_.len().into());
}

        write!(self, "{}b{}", pref, data_encoding::BASE64.encode(contents))

        writeln!(self, "{}b{}", pref, data_encoding::BASE64.encode(contents))

pub fn print_contents<W: WriteChangeLine>(
    w: &mut W,
    pref: &str,
    contents: &[u8],
    encoding: &Option<Encoding>,
) -> Result<(), std::io::Error> {
    if let Some(encoding) = encoding {
        let dec = encoding.decode(&contents);
        let dec = if dec.ends_with("\n") {
            &dec[..dec.len() - 1]
        } else {
            &dec
        };
        for a in dec.split('\n') {
            w.write_change_line(pref, a)?
        }
    } else {
        writeln!(w, "{}b{}", pref, data_encoding::BASE64.encode(contents))?
    }
    Ok(())
}

pub fn print_change_contents<W: WriteChangeLine, C: ChangeStore>(
    w: &mut W,

pub fn get_change_contents<C: ChangeStore>(

    encoding: &Option<Encoding>,
) -> Result<(), TextSerError<C::Error>> {
    debug!("print_change_contents {:?}", change);

) -> Result<Vec<u8>, TextSerError<C::Error>> {
    debug!("get_change_contents {:?}", change);

        Atom::NewVertex(ref n) => {
            let c = &change_contents[n.start.us()..n.end.us()];
            print_contents(w, "+", c, encoding)?;
            if !c.ends_with(b"\n") {
                debug!("print_change_contents {:?}", c);
                writeln!(w, "\n\\")?
            }
            Ok(())
        }
        Atom::EdgeMap(ref n) if n.edges.is_empty() => return Err(TextSerError::InvalidChange),

        Atom::NewVertex(ref n) => Ok(change_contents[n.start.us()..n.end.us()].to_vec()),
        Atom::EdgeMap(ref n) if n.edges.is_empty() => Err(TextSerError::InvalidChange),

            // TODO: get rid of `tmp` and/or `buf`

            let mut tmp = Vec::new();

                buf.clear();

                tmp.clear();

                    .get_contents_ext(e.to, &mut buf)

                    .get_contents_ext(e.to, &mut tmp)

                print_contents(w, "-", &buf[..], &encoding)?;
                if !buf.ends_with(b"\n") {
                    debug!("print_change_contents {:?}", buf);
                    writeln!(w)?;
                }

                buf.extend_from_slice(&tmp);

            Ok(())

            Ok(buf)

        _ => Ok(()),

        _ => Ok(Vec::new()),

pub fn write_deleted_names<W: std::io::Write, C: ChangeStore>(
    w: &mut W,

pub fn get_deleted_names<C: ChangeStore>(

) -> Result<(), TextSerError<C::Error>> {

) -> Result<Vec<String>, TextSerError<C::Error>> {
    let mut res = Vec::new();

        let mut buf = Vec::new();
        let mut is_first = true;

        let mut tmp = Vec::new();

            buf.clear();

            tmp.clear();

                .get_contents_ext(d.to, &mut buf)

                .get_contents_ext(d.to, &mut tmp)

            if !buf.is_empty() {
                let FileMetadata { basename: name, .. } = FileMetadata::read(&buf);
                write!(w, "{}{:?}", if is_first { "" } else { ", " }, name)?;
                is_first = false;

            if !tmp.is_empty() {
                let FileMetadata { basename: name, .. } = FileMetadata::read(&tmp);
                res.push(name.to_string());

    Ok(())

    Ok(res)

pub fn write_flag<W: std::io::Write>(mut w: W, flag: EdgeFlags) -> Result<(), std::io::Error> {
    if flag.contains(EdgeFlags::BLOCK) {
        w.write_all(b"B")?;
    }
    if flag.contains(EdgeFlags::FOLDER) {
        w.write_all(b"F")?;
    }
    if flag.contains(EdgeFlags::DELETED) {
        w.write_all(b"D")?;
    }
    assert!(!flag.contains(EdgeFlags::PARENT));
    assert!(!flag.contains(EdgeFlags::PSEUDO));
    Ok(())
}
pub fn read_flag(s: &str) -> EdgeFlags {
    let mut f = EdgeFlags::empty();
    for i in s.chars() {
        match i {
            'B' => f |= EdgeFlags::BLOCK,
            'F' => f |= EdgeFlags::FOLDER,
            'D' => f |= EdgeFlags::DELETED,
            c => panic!("read_flag: {:?}", c),
        }
    }
    f
}
pub fn write_pos<W: std::io::Write>(
    mut w: W,

pub fn to_printable_pos(

) -> Result<(), std::io::Error> {

) -> PrintablePos {

    write!(w, "{}.{}", change, pos.pos.0)?;
    Ok(())

    PrintablePos(change, pos.pos.0 .0)

pub fn write_atom<W: std::io::Write>(
    w: &mut W,

pub fn to_printable_pos_vec(

    atom: &Atom<Option<Hash>>,
) -> Result<(), std::io::Error> {
    match atom {
        Atom::NewVertex(ref n) => write_newvertex(w, hashes, n),
        Atom::EdgeMap(ref n) => write_edgemap(w, hashes, n),
    }

    pos: &[Position<Option<Hash>>],
) -> Vec<PrintablePos> {
    pos.iter().map(|c| to_printable_pos(hashes, *c)).collect()

pub fn write_newvertex<W: std::io::Write>(
    mut w: W,
    hashes: &HashMap<Hash, usize>,
    n: &NewVertex<Option<Hash>>,
) -> Result<(), std::io::Error> {
    write!(w, "  up")?;
    for c in n.up_context.iter() {
        write!(w, " ")?;
        write_pos(&mut w, hashes, *c)?
    }
    write!(w, ", new {}:{}", n.start.0, n.end.0)?;
    if !n.down_context.is_empty() {
        write!(w, ", down")?;
        for c in n.down_context.iter() {
            write!(w, " ")?;
            write_pos(&mut w, hashes, *c)?
        }
    }
    w.write_all(b"\n")?;
    Ok(())
}
pub fn write_edgemap<W: std::io::Write>(
    mut w: W,
    hashes: &HashMap<Hash, usize>,
    n: &EdgeMap<Option<Hash>>,
) -> Result<(), std::io::Error> {
    let mut is_first = true;
    for c in n.edges.iter() {
        if !is_first {
            write!(w, ", ")?;
        }
        is_first = false;
        write_flag(&mut w, c.previous)?;
        write!(w, ":")?;
        write_flag(&mut w, c.flag)?;
        write!(w, " ")?;
        write_pos(&mut w, hashes, c.from)?;
        write!(w, " -> ")?;
        write_pos(&mut w, hashes, c.to.start_pos())?;
        let h = if let Some(h) = hashes.get(c.introduced_by.as_ref().unwrap()) {
            h
        } else {
            panic!("introduced_by = {:?}, not found", c.introduced_by);
        };
        write!(w, ":{}/{}", c.to.end.0, h)?;
    }
    writeln!(w)?;
    Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Section {
    Header(String),
    Deps,
    Changes {
        changes: Vec<Hunk<Option<Hash>, Local>>,
        current: Option<Hunk<Option<Hash>, Local>>,
        offsets: HashMap<u64, ChangePosition>,
    },
}

use std::fmt;
#[cfg(test)]
use quickcheck::{Arbitrary, Gen};
#[cfg(test)]
use PrintableHunk::*;
use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StringFragment<'a> {
    Literal(&'a str),
    EscapedChar(char),
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum PrintablePerms {
    IsDir,
    IsExecutable,
    IsFile,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct PrintableEdgeFlags {
    pub block: bool,
    pub folder: bool,
    pub deleted: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PrintableEdge {
    pub previous: PrintableEdgeFlags,
    pub flag: PrintableEdgeFlags,
    pub from: PrintablePos,
    pub to_start: PrintablePos,
    pub to_end: u64,
    pub introduced_by: usize,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PrintableNewVertex {
    pub up_context: Vec<PrintablePos>,
    pub start: u64,
    pub end: u64,
    pub down_context: Vec<PrintablePos>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum PrintableAtom {
    NewVertex(PrintableNewVertex),
    Edges(Vec<PrintableEdge>),
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct PrintablePos(pub usize, pub u64);
// TODO: Some of these are untested: I didn't know how to create them from the
// command line
// NOTE: contents must be valid under the chosen encoding
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum PrintableHunk {
    FileMoveV {
        path: String,
        name: String,
        perms: PrintablePerms,
        pos: PrintablePos,
        up_context: Vec<PrintablePos>,
        down_context: Vec<PrintablePos>,
        del: Vec<PrintableEdge>,
    },
    FileMoveE {
        path: String,
        pos: PrintablePos,
        add: Vec<PrintableEdge>,
        del: Vec<PrintableEdge>,
    },
    FileAddition {
        name: String,
        parent: String,
        perms: PrintablePerms,
        encoding: Option<Encoding>,
        up_context: Vec<PrintablePos>,
        start: u64,
        end: u64,
        contents: Vec<u8>,
    },
    FileDel {
        path: String,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        del_edges: Vec<PrintableEdge>,
        content_edges: Vec<PrintableEdge>,
        contents: Vec<u8>,
    },
    FileUndel {
        path: String,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        undel_edges: Vec<PrintableEdge>,
        content_edges: Vec<PrintableEdge>,
        contents: Vec<u8>,
    },
    Edit {
        path: String,
        line: usize,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        change: PrintableAtom,
        contents: Vec<u8>,
    },
    Replace {
        path: String,
        line: usize,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        change: Vec<PrintableEdge>,
        replacement: PrintableNewVertex,
        change_contents: Vec<u8>,
        replacement_contents: Vec<u8>,
    },
    SolveNameConflict {
        path: String,
        pos: PrintablePos,
        names: Vec<String>,
        edges: Vec<PrintableEdge>,
    },
    UnsolveNameConflict {
        path: String,
        pos: PrintablePos,
        names: Vec<String>,
        edges: Vec<PrintableEdge>,
    },
    SolveOrderConflict {
        path: String,
        line: usize,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        change: PrintableNewVertex,
        contents: Vec<u8>,
    },
    UnsolveOrderConflict {
        path: String,
        line: usize,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        change: Vec<PrintableEdge>,
        contents: Vec<u8>,
    },
    ResurrectZombies {
        path: String,
        line: usize,
        pos: PrintablePos,
        encoding: Option<Encoding>,
        change: Vec<PrintableEdge>,
        contents: Vec<u8>,
    },
}
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct PrintableDep {
    pub type_: DepType,
    pub hash: String,
}
// TODO: make names more precise. I don't know what these should be named.
#[derive(PartialEq, Eq, Clone, Debug)]
pub enum DepType {
    Numbered(usize, bool), // (number, plus-sign)
    ExtraKnown,
    ExtraUnknown,
}
pub struct Escaped<'a>(pub &'a str);
impl<'a> fmt::Display for Escaped<'a> {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "\"")?;
        for c in self.0.chars() {
            if c == '\n' {
                write!(fmt, "\\n")?
            } else if c == '\r' {
                write!(fmt, "\\r")?
            } else if c == '\t' {
                write!(fmt, "\\t")?
            } else if c == '\u{08}' {
                write!(fmt, "\\b")?
            } else if c == '\u{0C}' {
                write!(fmt, "\\f")?
            } else if c == '\\' {
                write!(fmt, "\\\\")?
            } else if c == '"' {
                write!(fmt, "\\\"")?
            } else {
                write!(fmt, "{}", c)?
            }
        }
        write!(fmt, "\"")?;
        Ok(())
    }
}
impl PrintablePerms {
    pub fn from_metadata(perms: InodeMetadata) -> Self {
        if perms.0 & 0o1000 == 0o1000 {
            PrintablePerms::IsDir
        } else if perms.0 & 0o100 == 0o100 {
            PrintablePerms::IsExecutable
        } else {
            PrintablePerms::IsFile
        }
    }
    pub fn to_metadata(self) -> InodeMetadata {
        InodeMetadata(match self {
            PrintablePerms::IsDir => 0o1100,
            PrintablePerms::IsExecutable => 0o100,
            PrintablePerms::IsFile => 0o0,
        })
    }
}
impl fmt::Display for PrintablePos {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}.{}", self.0, self.1)
    }
}
impl fmt::Display for PrintablePerms {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "{}",
            match self {
                PrintablePerms::IsDir => " +dx",
                PrintablePerms::IsExecutable => " +x",
                PrintablePerms::IsFile => "",
            }
        )
    }
}
impl PrintableEdgeFlags {
    pub fn from(ef: EdgeFlags) -> Self {
        assert!(!ef.contains(EdgeFlags::PARENT));
        assert!(!ef.contains(EdgeFlags::PSEUDO));
        Self {
            block: ef.contains(EdgeFlags::BLOCK),
            folder: ef.contains(EdgeFlags::FOLDER),
            deleted: ef.contains(EdgeFlags::DELETED),
        }
    }
    // TODO: make this nicer
    pub fn to(self) -> EdgeFlags {
        let mut f = EdgeFlags::empty();
        if self.block {
            f |= EdgeFlags::BLOCK;
        }
        if self.folder {
            f |= EdgeFlags::FOLDER;
        }
        if self.deleted {
            f |= EdgeFlags::DELETED;
        }
        f
    }
}
impl fmt::Display for PrintableEdgeFlags {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        if self.block {
            write!(fmt, "B")?;
        }
        if self.folder {
            write!(fmt, "F")?;
        }
        if self.deleted {
            write!(fmt, "D")?;
        }
        Ok(())
    }
}
impl fmt::Display for PrintableEdge {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "{}:{} {} -> {}:{}/{}",
            self.previous, self.flag, self.from, self.to_start, self.to_end, self.introduced_by
        )
    }
}
impl fmt::Display for PrintableNewVertex {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "  up")?;
        for c in self.up_context.iter() {
            write!(fmt, " {}", c)?
        }
        write!(fmt, ", new {}:{}, down", self.start, self.end)?;
        for c in self.down_context.iter() {
            write!(fmt, " {}", c)?;
        }
        Ok(())
    }
}
impl fmt::Display for PrintableAtom {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match self {
            PrintableAtom::NewVertex(x) => write!(fmt, "{}", x),
            PrintableAtom::Edges(x) => {
                for (i, edge) in x.iter().enumerate() {
                    if i > 0 {
                        write!(fmt, ", ")?;
                    }
                    write!(fmt, "{}", edge)?;
                }
                Ok(())
            }
        }
    }
}
impl PrintableHunk {
    pub fn write<W: WriteChangeLine>(&self, w: &mut W) -> Result<(), std::io::Error> {
        use PrintableHunk::*;
        match self {
            FileMoveV {
                path,
                name,
                perms,
                pos,
                up_context,
                down_context,
                del,
            } => {
                writeln!(
                    w,
                    "Moved: {} {} {} {}",
                    Escaped(path),
                    Escaped(name),
                    perms,
                    pos,
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(del.to_vec()))?;
                write!(w, "up")?;
                for c in up_context.iter() {
                    write!(w, " {}", c)?
                }
                write!(w, ", down")?;
                for c in down_context.iter() {
                    write!(w, " {}", c)?
                }
                writeln!(w)?;
            }
            FileMoveE {
                path,
                pos,
                add,
                del,
            } => {
                writeln!(w, "Moved: {} {}", Escaped(path), pos)?;
                writeln!(w, "{}", PrintableAtom::Edges(add.to_vec()))?;
                writeln!(w, "{}", PrintableAtom::Edges(del.to_vec()))?;
            }
            FileAddition {
                name,
                parent,
                perms,
                encoding,
                up_context,
                start,
                end,
                contents,
            } => {
                write!(
                    w,
                    "File addition: {} in {}{} {}\n  up",
                    Escaped(name),
                    Escaped(parent),
                    perms,
                    Escaped(encoding_label(encoding)),
                )?;
                for c in up_context.iter() {
                    write!(w, " {}", c)?
                }
                writeln!(w, ", new {}:{}", start, end)?;
                print_contents(w, "+", contents, encoding)?;
            }
            FileDel {
                path,
                pos,
                encoding,
                del_edges,
                content_edges,
                contents,
            } => {
                writeln!(
                    w,
                    "File deletion: {} {} {}",
                    Escaped(path),
                    pos,
                    Escaped(encoding_label(encoding)),
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(del_edges.to_vec()))?;
                writeln!(w, "{}", PrintableAtom::Edges(content_edges.to_vec()))?;
                print_contents(w, "-", contents, encoding)?;
            }
            FileUndel {
                path,
                pos,
                encoding,
                undel_edges,
                content_edges,
                contents,
            } => {
                writeln!(
                    w,
                    "File un-deletion: {} {} {}",
                    Escaped(path),
                    pos,
                    Escaped(encoding_label(encoding)),
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(undel_edges.to_vec()))?;
                writeln!(w, "{}", PrintableAtom::Edges(content_edges.to_vec()))?;
                print_contents(w, "+", contents, encoding)?;
            }
            Edit {
                path,
                line,
                pos,
                encoding,
                change,
                contents,
            } => {
                writeln!(
                    w,
                    "Edit in {}:{} {} {}",
                    Escaped(&path),
                    line,
                    pos,
                    Escaped(encoding_label(encoding))
                )?;
                writeln!(w, "{}", change)?;
                print_contents(w, "+", contents, encoding)?;
            }
            Replace {
                path,
                line,
                pos,
                encoding,
                change,
                replacement,
                change_contents,
                replacement_contents,
            } => {
                writeln!(
                    w,
                    "Replacement in {}:{} {} {}",
                    Escaped(&path),
                    line,
                    pos,
                    Escaped(encoding_label(encoding))
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(change.clone()))?;
                writeln!(w, "{}", PrintableAtom::NewVertex(replacement.clone()))?;
                print_contents(w, "-", change_contents, encoding)?;
                print_contents(w, "+", replacement_contents, encoding)?;
            }
            SolveNameConflict {
                path,
                pos,
                names,
                edges,
            } => {
                write!(w, "Solving a name conflict in {} {}: ", Escaped(path), pos,)?;
                write_names(w, names)?;
                writeln!(w)?;
                writeln!(w, "{}", PrintableAtom::Edges(edges.clone()))?;
            }
            UnsolveNameConflict {
                path,
                pos,
                names,
                edges,
            } => {
                write!(
                    w,
                    "Un-solving a name conflict in {} {}: ",
                    Escaped(path),
                    pos,
                )?;
                write_names(w, names)?;
                writeln!(w)?;
                writeln!(w, "{}", PrintableAtom::Edges(edges.clone()))?;
            }
            SolveOrderConflict {
                path,
                line,
                pos,
                encoding,
                change,
                contents,
            } => {
                writeln!(
                    w,
                    "Solving an order conflict in {}:{} {} {}",
                    Escaped(path),
                    line,
                    pos,
                    Escaped(encoding_label(encoding)),
                )?;
                writeln!(w, "{}", change)?;
                print_contents(w, "+", contents, encoding)?;
            }
            UnsolveOrderConflict {
                path,
                line,
                pos,
                encoding,
                change,
                contents,
            } => {
                writeln!(
                    w,
                    "Un-solving an order conflict in {}:{} {} {}",
                    Escaped(path),
                    line,
                    pos,
                    Escaped(encoding_label(encoding))
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(change.clone()))?;
                print_contents(w, "-", contents, encoding)?;
            }
            ResurrectZombies {
                path,
                line,
                pos,
                encoding,
                change,
                contents,
            } => {
                writeln!(
                    w,
                    "Resurrecting zombie lines in {}:{} {} {}",
                    Escaped(path),
                    line,
                    pos,
                    Escaped(encoding_label(encoding))
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(change.clone()))?;
                print_contents(w, "+", contents, encoding)?;
            }
        };
        Ok(())
    }
}
pub fn write_names<W: std::io::Write>(w: &mut W, names: &[String]) -> Result<(), std::io::Error> {
    for (i, name) in names.iter().enumerate() {
        if i > 0 {
            write!(w, ", ")?;
        }
        write!(w, "{}", Escaped(name))?;
    }
    Ok(())
}
pub fn get_encoding(contents: &[u8]) -> Option<Encoding> {
    let mut detector = crate::chardetng::EncodingDetector::new();
    detector.feed(contents, true);
    if let Some(e) = detector.get_valid(None, true, &contents) {
        Some(Encoding(e))
    } else {
        None
    }
    // let (encoding_guess, may_be_right) = detector.guess_assess(None, true);
    // if may_be_right {
    //     Some(Encoding(encoding_guess))
    // } else {
    //     None
    // }
}
fn print_contents<W: WriteChangeLine>(
    w: &mut W,
    prefix: &str,
    contents: &[u8],
    encoding: &Option<Encoding>,
) -> Result<(), std::io::Error> {
    if let Some(encoding) = encoding {
        let dec = encoding.decode(&contents);
        let ends_with_newline = dec.ends_with("\n");
        let dec = if ends_with_newline {
            &dec[..dec.len() - 1]
        } else {
            &dec
        };
        for a in dec.split('\n') {
            writeln!(w, "{} {}", prefix, a)?;
        }
        if !ends_with_newline {
            writeln!(w, "\\")?;
        }
        Ok(())
    } else {
        writeln!(w, "{}b{}", prefix, data_encoding::BASE64.encode(contents))
    }
}
// QuickCheck instances
#[cfg(test)]
#[rustfmt::skip]
// This may be nicer if it was generated by a macro
impl Arbitrary for PrintableHunk {
    fn arbitrary(g: &mut Gen) -> Self {
        fn f<A: Arbitrary>(g: &mut Gen) -> A {
            Arbitrary::arbitrary(g)
        }
        fix_encoding(Gen::new(g.size()).choose(&[
            FileMoveV {
                path: f(g), name: f(g), perms: f(g), pos: f(g), up_context: f(g), down_context: f(g), del: f(g),
            },
            FileMoveE {
                path: f(g), pos: f(g), add: f(g), del: f(g),
            },
            FileAddition {
                name: f(g), parent: f(g), perms: f(g), encoding: f(g), up_context: f(g), start: f(g), end: f(g), contents: f(g),
            },
            FileDel {
                path: f(g), pos: f(g), encoding: f(g), del_edges: f(g), content_edges: f(g), contents: f(g),
            },
            FileUndel {
                path: f(g), pos: f(g), encoding: f(g), undel_edges: f(g), content_edges: f(g), contents: f(g),
            },
            Edit {
                path: f(g), line: f(g), pos: f(g), encoding: f(g), change: f(g), contents: f(g),
            },
            Replace {
                path: f(g), line: f(g), pos: f(g), encoding: f(g), change: f(g), replacement: f(g), change_contents: f(g), replacement_contents: f(g),
            },
            SolveNameConflict {
                path: f(g), pos: f(g), names: f(g), edges: f(g),
            },
            UnsolveNameConflict {
                path: f(g), pos: f(g), names: f(g), edges: f(g),
            },
            SolveOrderConflict {
                path: f(g), line: f(g), pos: f(g), encoding: f(g), change: f(g), contents: f(g),
            },
            UnsolveOrderConflict {
                path: f(g), line: f(g), pos: f(g), encoding: f(g), change: f(g), contents: f(g),
            },
            ResurrectZombies {
                path: f(g), line: f(g), pos: f(g), encoding: f(g), change: f(g), contents: f(g),
            },
        ])
        .unwrap().clone())
    }
    // Shrinking frequently blows stack. Investigate how to fix it.
    // You can disable shrinking by commenting out this function.
    // This may be best solved by switching to proptest crate
    /*
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        match self.clone() {
            FileMoveV { path, name, perms, pos, up_context, down_context, del } =>
                Box::new((path, name, perms, pos, up_context, down_context, del)
                .shrink().map(|(path, name, perms, pos, up_context, down_context, del)|
                fix_encoding(FileMoveV { path, name, perms, pos, up_context, down_context, del }))),
            FileMoveE { path, pos, add, del } =>
                Box::new((path, pos, add, del)
                .shrink().map(|(path, pos, add, del)|
                fix_encoding(FileMoveE { path, pos, add, del }))),
            FileAddition { name, parent, perms, encoding, up_context, start, end, contents } =>
                Box::new((name, parent, perms, encoding, up_context, start, end, contents)
                .shrink().map(|(name, parent, perms, encoding, up_context, start, end, contents)|
                fix_encoding(FileAddition { name, parent, perms, encoding, up_context, start, end, contents }))),
            FileDel { path, pos, encoding, del_edges, content_edges, contents } =>
                Box::new((path, pos, encoding, del_edges, content_edges, contents)
                .shrink().map(|(path, pos, encoding, del_edges, content_edges, contents)|
                fix_encoding(FileDel { path, pos, encoding, del_edges, content_edges, contents }))),
            FileUndel { path, pos, encoding, undel_edges, content_edges, contents } =>
                Box::new((path, pos, encoding, undel_edges, content_edges, contents)
                .shrink().map(|(path, pos, encoding, undel_edges, content_edges, contents)|
                fix_encoding(FileUndel { path, pos, encoding, undel_edges, content_edges, contents }))),
            Edit { path, line, pos, encoding, change, contents } =>
                Box::new((path, line, pos, encoding, change, contents)
                .shrink().map(|(path, line, pos, encoding, change, contents)|
                fix_encoding(Edit { path, line, pos, encoding, change, contents }))),
            Replace { path, line, pos, encoding, change, replacement, change_contents, replacement_contents } =>
                Box::new((path, line, pos, encoding, change, replacement, change_contents, replacement_contents)
                .shrink().map(|(path, line, pos, encoding, change, replacement, change_contents, replacement_contents)|
                fix_encoding(Replace { path, line, pos, encoding, change, replacement, change_contents, replacement_contents }))),
            SolveNameConflict { path, pos, names, edges } =>
                Box::new((path, pos, names, edges)
                .shrink().map(|(path, pos, names, edges)|
                fix_encoding(SolveNameConflict { path, pos, names, edges }))),
            UnsolveNameConflict { path, pos, names, edges } =>
                Box::new((path, pos, names, edges)
                .shrink().map(|(path, pos, names, edges)|
                fix_encoding(UnsolveNameConflict { path, pos, names, edges }))),
            SolveOrderConflict { path, line, pos, encoding, change, contents } =>
                Box::new((path, line, pos, encoding, change, contents)
                .shrink().map(|(path, line, pos, encoding, change, contents)|
                fix_encoding(SolveOrderConflict { path, line, pos, encoding, change, contents }))),
            UnsolveOrderConflict { path, line, pos, encoding, change, contents } =>
                Box::new((path, line, pos, encoding, change, contents)
                .shrink().map(|(path, line, pos, encoding, change, contents)|
                fix_encoding(UnsolveOrderConflict { path, line, pos, encoding, change, contents }))),
            ResurrectZombies { path, line, pos, encoding, change, contents } =>
                Box::new((path, line, pos, encoding, change, contents)
                .shrink().map(|(path, line, pos, encoding, change, contents)|
                fix_encoding(ResurrectZombies { path, line, pos, encoding, change, contents }))),
        }
    }
    */
}
#[cfg(test)]
/// This is the one thing that is not normalized on PrintableHunk: encoding
/// content must be valid, given the encoding. This function ensures that.
fn fix_encoding(mut hunk: PrintableHunk) -> PrintableHunk {
    // let mut h = hunk.clone();
    match &mut hunk {
        FileAddition {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        FileDel {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        FileUndel {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        Edit {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        Replace { encoding, .. } => *encoding = None,
        SolveOrderConflict {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        UnsolveOrderConflict {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        ResurrectZombies {
            encoding, contents, ..
        } => *encoding = get_encoding(contents),
        _ => (),
    };
    hunk
}
#[cfg(test)]
impl Arbitrary for PrintablePerms {
    fn arbitrary(g: &mut Gen) -> Self {
        *g.choose(&[
            PrintablePerms::IsDir,
            PrintablePerms::IsExecutable,
            PrintablePerms::IsFile,
        ])
        .unwrap()
    }
}
#[cfg(test)]
impl Arbitrary for PrintablePos {
    fn arbitrary(g: &mut Gen) -> Self {
        PrintablePos(usize::arbitrary(g), u64::arbitrary(g))
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        Box::new(
            self.0
                .shrink()
                .zip(self.1.shrink())
                .map(|(a, b)| PrintablePos(a, b)),
        )
    }
}
#[cfg(test)]
impl Arbitrary for PrintableEdge {
    fn arbitrary(g: &mut Gen) -> Self {
        Self {
            previous: Arbitrary::arbitrary(g),
            flag: Arbitrary::arbitrary(g),
            from: Arbitrary::arbitrary(g),
            to_start: Arbitrary::arbitrary(g),
            to_end: Arbitrary::arbitrary(g),
            introduced_by: Arbitrary::arbitrary(g),
        }
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        let Self {
            previous,
            flag,
            from,
            to_start,
            to_end,
            introduced_by,
        } = self.clone();
        Box::new(
            (previous, flag, from, to_start, to_end, introduced_by)
                .shrink()
                .map(
                    |(previous, flag, from, to_start, to_end, introduced_by)| Self {
                        previous,
                        flag,
                        from,
                        to_start,
                        to_end,
                        introduced_by,
                    },
                ),
        )
    }
}
#[cfg(test)]
impl Arbitrary for PrintableNewVertex {
    fn arbitrary(g: &mut Gen) -> Self {
        Self {
            up_context: Arbitrary::arbitrary(g),
            start: Arbitrary::arbitrary(g),
            end: Arbitrary::arbitrary(g),
            down_context: Arbitrary::arbitrary(g),
        }
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        let Self {
            up_context,
            start,
            end,
            down_context,
        } = self.clone();
        Box::new((up_context, start, end, down_context).shrink().map(
            |(up_context, start, end, down_context)| Self {
                up_context,
                start,
                end,
                down_context,
            },
        ))
    }
}
#[cfg(test)]
impl Arbitrary for PrintableAtom {
    fn arbitrary(g: &mut Gen) -> Self {
        Gen::new(g.size())
            .choose(&[
                PrintableAtom::NewVertex(Arbitrary::arbitrary(g)),
                PrintableAtom::Edges(Arbitrary::arbitrary(g)),
            ])
            .unwrap()
            .clone()
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        match self {
            PrintableAtom::NewVertex(x) => {
                Box::new(x.shrink().map(|x| PrintableAtom::NewVertex(x)))
            }
            PrintableAtom::Edges(x) => Box::new(x.shrink().map(|x| PrintableAtom::Edges(x))),
        }
    }
}
#[cfg(test)]
impl Arbitrary for PrintableEdgeFlags {
    fn arbitrary(g: &mut Gen) -> Self {
        Self {
            block: Arbitrary::arbitrary(g),
            folder: Arbitrary::arbitrary(g),
            deleted: Arbitrary::arbitrary(g),
        }
    }
    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        Box::new((self.block, self.folder, self.deleted).shrink().map(
            |(block, folder, deleted)| Self {
                block,
                folder,
                deleted,
            },
        ))
    }
}