name = "glob"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
[[package]]

 "glob",

csv = "1"
glob = "0.3"
hostname = "0.3"

hostname = "0.3.1"
csv = "1.1.3"

#[derive(Debug, Serialize, Deserialize)]

#[derive(Debug, Serialize, Deserialize, Ord, PartialOrd, PartialEq, Eq)]

    pub time_finished: DateTime<Utc>,
    pub time_start: DateTime<Utc>,
    pub hostname: String,

    pub time_finished: DateTime<Utc>,
    pub time_start: DateTime<Utc>,

            hostname: start.hostname,

use anyhow::{
    anyhow,
    Result,
};

use anyhow::Result;

use std::io::Write;

        _ => Err(anyhow!("unkown {}", command)),

        _ => {
            let stdout = std::io::stdout();
            let mut handle = stdout.lock();
            store::new()
                .get_nth_entries(25)?
                .into_iter()
                .map(|entry| handle.write_all(format!("{:?}\n", entry).as_bytes()))
                .collect::<Result<_, _>>()?;
            Ok(())
        }

    #[error("can not get hostname: {0}")]
    GetHostname(std::io::Error),

    pub hostname: String,

        let command = env::args().into_iter().skip(2).next().unwrap_or_default();

        let command = env::args().into_iter().nth(2).unwrap_or_default();

        let hostname = hostname::get()
            .map_err(Error::GetHostname)?
            .to_string_lossy()
            .to_string();

            hostname,

        match self {
            Self::Stop => true,
            _ => false,
        }

        matches!(self, Self::Stop)

    path::PathBuf,

    path::{
        Path,
        PathBuf,
    },

    #[error("can not get hostname: {0}")]
    GetHostname(std::io::Error),

    #[error("glob is not valid: {0}")]
    InvalidGlob(glob::PatternError),
    #[error("problem while iterating glob: {0}")]
    GlobIteration(glob::GlobError),
    #[error("can not read log file {0:?}: {1}")]
    ReadLogFile(PathBuf, csv::Error),

        let hostname = hostname::get().map_err(Error::GetHostname)?;

        let hostname = &entry.hostname;

        self.commit()?;

        self.commit(hostname)?;

    fn commit(&self) -> Result<(), Error> {

    fn commit(&self, hostname: &str) -> Result<(), Error> {

        let hostname = hostname::get().map_err(Error::GetHostname)?;

    }
    pub fn get_nth_entries(&self, count: usize) -> Result<Vec<Entry>, Error> {
        let xdg_dirs = xdg::BaseDirectories::with_prefix("histdb-rs").unwrap();
        let datadir_path = xdg_dirs.get_data_home();
        let glob_string = datadir_path.join("*").join("*").join("*").join("*.csv");
        let glob = glob::glob(&glob_string.to_string_lossy()).map_err(Error::InvalidGlob)?;
        let index_paths = glob
            .collect::<Result<Vec<PathBuf>, glob::GlobError>>()
            .map_err(Error::GlobIteration)?;
        let mut entries: Vec<_> = index_paths
            .into_iter()
            .map(Self::read_metadata_file)
            .collect::<Result<Vec<Vec<_>>, Error>>()?
            .into_iter()
            .flatten()
            .collect();
        entries.sort();
        let entries = entries.into_iter().rev().take(count).collect();
        Ok(entries)
    }
    fn read_metadata_file<P: AsRef<Path>>(file_path: P) -> Result<Vec<Entry>, Error> {
        let file = std::fs::File::open(&file_path)
            .map_err(|err| Error::OpenLogFile(file_path.as_ref().to_path_buf(), err))?;
        let reader = std::io::BufReader::new(file);
        Self::read_metadata(reader)
            .map_err(|err| Error::ReadLogFile(file_path.as_ref().to_path_buf(), err))

    fn read_metadata<R: std::io::Read>(reader: R) -> Result<Vec<Entry>, csv::Error> {
        let mut csv_reader = csv::ReaderBuilder::new().from_reader(reader);
        csv_reader
            .deserialize()
            .collect::<Result<Vec<Entry>, csv::Error>>()
    }