// org id jgSEtEI/xIjz/bF+vtGtYbEA9bNIeFWLqnZT+M51S64=

use std::fmt;

// use encoding_rs::Encoding;

use serde::{de::Visitor, Deserialize, Serialize};

    fn decode_file(&mut self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {

    /// Read the file into the buffer, decoding to UTF-8 for text files
    ///
    /// Returns the encoding used or None if it was a binary file
    fn decode_file(
        &mut self,
        file: &str,
        buffer: &mut Vec<u8>,
    ) -> Result<Option<Encoding>, Self::Error> {

        let (mut decoded, encoding) = if tree_magic_mini::from_u8(&uncoded).starts_with("text/") {

        let mime = tree_magic_mini::from_u8(&uncoded);
        debug!("mime = {:?}", mime);
        let (mut decoded, encoding) = if mime.starts_with("text/") {

                (decoded.as_bytes().to_vec(), Some(encoding))

                (decoded.as_bytes().to_vec(), Some(Encoding(encoding)))

        Ok(encoding)
    }
}

        Ok(())

#[derive(Debug, PartialEq, Eq)]
pub struct Encoding(&'static encoding_rs::Encoding);
impl Encoding {
    pub(crate) fn for_label(label: &str) -> Encoding {
        Encoding(encoding_rs::Encoding::for_label_no_replacement(label.as_bytes()).unwrap())
    }
    pub(crate) fn label(&self) -> &str {
        self.0.name()
    }
}
impl Clone for Encoding {
    fn clone(&self) -> Self {
        Encoding(self.0)
    }
}
impl Serialize for Encoding {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.label())
    }
}
struct EncodingVisitor;
impl<'de> Deserialize<'de> for Encoding {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        impl<'de> Visitor<'de> for EncodingVisitor {
            type Value = Encoding;
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a string label meeting the encoding standard https://encoding.spec.whatwg.org/#concept-encoding-get")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(Encoding::for_label(v))
            }
        }
        deserializer.deserialize_str(EncodingVisitor)

const CHECK_UTF8: usize = 1000;

        let contents = if meta.is_file() {

        let (contents, encoding) = if meta.is_file() {

            working_copy.decode_file(&item.full_path, &mut self.rec.contents)?;

            let encoding = working_copy.decode_file(&item.full_path, &mut self.rec.contents)?;

            self.rec.has_binary_files |= {
                let s = start.0 as usize;
                let e = (end.0 as usize).min(s + CHECK_UTF8 + 4);
                let mime = tree_magic_mini::from_u8(&self.rec.contents[s..e]);
                debug!("mime = {:?}", mime);
                !mime.starts_with("text/")
            };

            self.rec.has_binary_files |= encoding.is_none();

                Some(Atom::NewVertex(NewVertex {
                    up_context: vec![Position {
                        change: None,
                        pos: inode_pos,
                    }],
                    down_context: vec![],
                    start,
                    end,
                    flag: EdgeFlags::empty(),
                    inode: Position {
                        change: None,
                        pos: inode_pos,
                    },
                }))

                (
                    Some(Atom::NewVertex(NewVertex {
                        up_context: vec![Position {
                            change: None,
                            pos: inode_pos,
                        }],
                        down_context: vec![],
                        start,
                        end,
                        flag: EdgeFlags::empty(),
                        inode: Position {
                            change: None,
                            pos: inode_pos,
                        },
                    })),
                    encoding,
                )

                None

                (None, encoding)

            None

            (None, None)

            encoding,

use crate::pristine::*;
use chrono::{DateTime, Utc};

use chrono::{DateTime, Utc};
use crate::{pristine::*, working_copy::Encoding};

                ..

        encoding: Option<Encoding>,

                encoding,

                encoding,

const BINARY_LABEL: &str = "binary";

                encoding,

                    };
                    let encoding_label = match encoding {
                        Some(encoding) => encoding.label(),
                        _ => BINARY_LABEL,

                        "File addition: {:?} in {:?} {:o}\n  up",
                        name, parent, perms.0

                        "File addition: {:?} in {:?} {:o} {:?}\n  up",
                        name, parent, perms.0, encoding_label

                Regex::new(r#"^(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)" (?P<perm>\d+)"#).unwrap();

                Regex::new(r#"^(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)" (?P<perm>\d+) "(?P<encoding>[^"]*)""#).unwrap();

            let encoding_label = cap.name("encoding").unwrap().as_str();
            let encoding = if encoding_label != BINARY_LABEL {
                Some(Encoding::for_label(encoding_label))
            } else {
                None
            };

                    encoding,