use libpijul::pristine::{sanakirja::Txn, ChannelRef, DepsTxnT, GraphTxnT, TreeTxnT};

use libpijul::pristine::{sanakirja::Txn, ChannelRef, DepsTxnT, GraphTxnT, TreeTxnT, TxnErr};

use thiserror::*;

impl TryFrom<Log> for LogIterator {
    type Error = anyhow::Error;
    fn try_from(cmd: Log) -> Result<LogIterator, Self::Error> {
        let repo = Repository::find_root(cmd.repo_path.clone())?;
        let repo_path = repo.path.clone();
        let txn = repo.pristine.txn_begin()?;
        let channel_name = if let Some(ref c) = cmd.channel {
            c
        } else {
            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
        };
        // The only situation that's disallowed is if the user's trying to apply
        // path filters AND get the logs for a channel other than the one they're
        // currently using (where using means the one that comprises the working copy)
        if !cmd.filters.is_empty()
            && !(channel_name == txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL))
        {
            bail!("Currently, log filters can only be applied to the channel currently in use.")
        }
        let channel_ref = if let Some(channel) = txn.load_channel(channel_name)? {
            channel
        } else {
            bail!("No such channel: {:?}", channel_name)
        };
        let changes = repo.changes;
        let limit = cmd.limit.unwrap_or(std::usize::MAX);
        let offset = cmd.offset.unwrap_or(0);
        let mut id_path = repo.path.join(libpijul::DOT_DIR);
        id_path.push("identities");
        Ok(Self {
            txn,
            cmd,
            changes,
            repo_path,
            id_path,
            channel_ref,
            limit,
            offset,
        })
    }
}
#[derive(Debug, Error)]
pub enum Error<E: std::error::Error> {
    #[error("pijul log couldn't find a file or directory corresponding to `{}`", 0)]
    NotFound(String),
    #[error(transparent)]
    Txn(#[from] libpijul::pristine::sanakirja::SanakirjaError),
    #[error(transparent)]
    TxnErr(#[from] TxnErr<libpijul::pristine::sanakirja::SanakirjaError>),
    #[error(transparent)]
    Fs(#[from] libpijul::FsError<libpijul::pristine::sanakirja::SanakirjaError>),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error("pijul log couldn't assemble file prefix for pattern `{}`: {} was not a file in the repository at {}", pat, canon_path.display(), repo_path.display())]
    FilterPath {
        pat: String,
        canon_path: PathBuf,
        repo_path: PathBuf,
    },
    #[error("pijul log couldn't assemble file prefix for pattern `{}`: the path contained invalid UTF-8", 0)]
    InvalidUtf8(String),
    #[error(transparent)]
    E(E),
    #[error(transparent)]
    Filesystem(#[from] libpijul::changestore::filesystem::Error),
}

fn get_inodes(
    txn: &impl libpijul::pristine::TreeTxnT,

fn get_inodes<E: std::error::Error>(
    txn: &Txn,

) -> Result<Vec<libpijul::Inode>, anyhow::Error> {

) -> Result<Vec<libpijul::Inode>, Error<E>> {

                bail!(
                    "pijul log couldn't find a file or directory corresponding to `{}`",
                    pat
                )

                return Err(Error::NotFound(pat.to_string()))

            Err(_) => bail!(
                "pijul log couldn't assemble file prefix for pattern `{}`; \
                {} was not a file in the repository at {}",
                pat,
                canon_path.display(),
                repo_path.display()
            ),

            Err(_) => {
                return Err(Error::FilterPath {
                    pat: pat.to_string(),
                    canon_path,
                    repo_path: repo_path.to_path_buf(),
                })
            }

            Ok(None) => bail!(
                "pijul log couldn't assemble file prefix for pattern `{}`; \
                the path contained invalid UTF-8",
                pat
            ),
            Ok(Some(s)) => match libpijul::fs::find_inode(txn, s) {
                Err(e) => bail!(
                    "pijul log couldn't assemble file prefix for pattern `{}`; \
                    no Inode found for the corresponding path. Internal error: {:?}",
                    pat,
                    e
                ),
                Ok(inode) => {
                    inodes.push(inode);
                }
            },

            Ok(None) => return Err(Error::InvalidUtf8(pat.to_string())),
            Ok(Some(s)) => inodes.push(libpijul::fs::find_inode(txn, s)?),

fn filtered_hashes<T: TreeTxnT + GraphTxnT + DepsTxnT>(
    txn: &T,

fn filtered_hashes<E: std::error::Error>(
    txn: &Txn,

) -> Result<HashSet<libpijul::Hash>, anyhow::Error> {

) -> Result<HashSet<libpijul::Hash>, Error<E>> {

            None => bail!("Failed to get matching inode: {:?}", inode),

            None => continue,

                match txn.get_external(touched_change_id)? {
                    Some(ser_h) => {
                        hashes.insert(libpijul::Hash::from(*ser_h));
                    }
                    _ => {
                        log::error!(
                            "`get_external` failed to retrieve full hash for ChangeId {:?}",
                            touched_change_id
                        );
                        bail!("Failed to retrieve full hash for {:?}", touched_change_id)
                    }
                }

                let ser_h = txn.get_external(touched_change_id)?.unwrap();
                hashes.insert(libpijul::Hash::from(*ser_h));

impl TryFrom<Log> for LogIterator {
    type Error = anyhow::Error;
    fn try_from(cmd: Log) -> Result<LogIterator, Self::Error> {
        let repo = Repository::find_root(cmd.repo_path.clone())?;
        let repo_path = repo.path.clone();
        let txn = repo.pristine.txn_begin()?;
        let channel_name = if let Some(ref c) = cmd.channel {
            c
        } else {
            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
        };
        // The only situation that's disallowed is if the user's trying to apply
        // path filters AND get the logs for a channel other than the one they're
        // currently using (where using means the one that comprises the working copy)
        if !cmd.filters.is_empty()
            && !(channel_name == txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL))
        {
            bail!("Currently, log filters can only be applied to the channel currently in use.")
        }

        let channel_ref = if let Some(channel) = txn.load_channel(channel_name)? {
            channel
        } else {
            bail!("No such channel: {:?}", channel_name)
        };
        let changes = repo.changes;
        let limit = cmd.limit.unwrap_or(std::usize::MAX);
        let offset = cmd.offset.unwrap_or(0);
        let mut id_path = repo.path.join(libpijul::DOT_DIR);
        id_path.push("identities");
        Ok(Self {
            txn,
            cmd,
            changes,
            repo_path,
            id_path,
            channel_ref,
            limit,
            offset,
        })
    }
}

    fn for_each<A, E>(

    fn for_each<A, E: std::error::Error>(

    ) -> Result<(), anyhow::Error>
    where
        E: std::fmt::Display,
    {

    ) -> Result<(), Error<E>> {

                if let Err(e) = f(entry) {
                    return Err(anyhow::Error::msg(format!("{}", e)));
                }

                f(entry).map_err(Error::E)?;

    fn mk_log_entry<'x>(

    fn mk_log_entry<'x, E: std::error::Error>(

    ) -> Result<LogEntry, anyhow::Error> {

    ) -> Result<LogEntry, Error<E>> {

    // In order to accommodate both pretty-printing and efficient serialization to a serde
    // target format, this now delegates mostly to [`LogIterator`].

    // In order to accommodate both pretty-printing and efficient
    // serialization to a serde target format, this now delegates
    // mostly to [`LogIterator`].

                LogIterator::try_from(self)?.for_each(|entry| write!(&mut stdout, "{}", entry))?

                LogIterator::try_from(self)?.for_each(|entry| {
                    match write!(&mut stdout, "{}", entry) {
                        Ok(_) => Ok(()),
                        Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => Ok(()),
                        Err(e) => Err(e),
                    }
                })?

thiserror = "1.0"

version = "1.0.0-alpha.47"

version = "1.0.0-alpha.48"

 "thiserror",

name = "threadpool"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
dependencies = [
 "num_cpus",
]
[[package]]

name = "xxhash-rust"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e575e15bedf6e57b5c2d763ffc6c3c760143466cbd09d762d539680ab5992ded"
[[package]]

version = "0.1.7"

version = "0.2.0"

checksum = "3e3b99cee88f0309ca765c6aa8c284a00394c35ef8ca012e2409485fc369bf2f"

checksum = "62d9eace42d7bf64591d547cb727d89277e3de1c1b934e3d9d0af8c6687587ef"

 "cc",

 "threadpool",

 "xxhash-rust",