pub(crate) fn to_path_buf(&self) -> PathBuf {

        self.0.clone()

    }

    fn entries(&self) -> std::io::Result<impl Iterator<Item = DirEntry>> {

        std::fs::read_dir(self.0.parent().unwrap()).map(|iter| {

            iter.filter_map(|e| e.ok()).filter(|e| {

                if e.file_name() == INDEX_NAME {

                    return false;

                }

                // skip entries that are not files

                !e.file_type().map(|ft| ft.is_file()).unwrap_or_default()

            })

        })

    }

    pub(crate) fn file_paths(&self) -> std::io::Result<impl Iterator<Item = PathBuf>> {

        self.entries().map(|f| f.map(|e| e.path()))

    }

    pub(crate) fn files(&self) -> std::io::Result<impl Iterator<Item = String>> {

        self.entries()

            .map(|f| f.filter_map(|path| path.file_name().to_str().map(|s| s.to_string())))

    }

    pub(crate) fn dir_name(&self) -> &OsStr {

        self.0.parent().unwrap().file_name().unwrap()

    }

    pub(crate) fn date(&self) -> DateTime<Utc> {

        DateTime::parse_from_rfc3339(self.dir_name().to_str().unwrap())

            .unwrap()

            .into()

    }

#[derive(Debug, thiserror::Error)]

    fn try_from(dir: PathBuf) -> Result<Self, Self::Error> {

        let file_name = if let Some(file_name) = dir.file_name() {

            file_name

            return Err(InvalidIndexPath(

                format!("{} does not contain a file name.", dir.display()),

                dir,

            ));

        let file_name = if let Some(file_name) = file_name.to_str() {

            file_name

            return Err(InvalidIndexPath(

                format!(

                    "The name {} is not valid unicode",

                    file_name.to_string_lossy()

                ),

                dir,

            ));

        if DateTime::parse_from_rfc3339(file_name).is_err() {

            return Err(InvalidIndexPath(

                format!("{} is not a valid rfc339 date", file_name),

                dir,

            ));

        }

        let path = dir.join(INDEX_NAME);

        if !path.exists() {

            return Err(InvalidIndexPath(

                format!("{} does not exist", path.display()),

                dir,

            ));

        }

        Ok(Self(path))

    }

    fn try_from(value: &Path) -> Result<Self, Self::Error> {

        IndexPath::try_from(value.to_path_buf())

    }

    fn as_ref(&self) -> &Path {

        &self.0

    }