use std::path::{Path, PathBuf};

use std::path::PathBuf;

use canonical_path::CanonicalPathBuf;

            &repo.path,

            CanonicalPathBuf::canonicalize(&repo.path)?,

        repo_path: &Path,

        repo_path: CanonicalPathBuf,

use canonical_path::CanonicalPathBuf;

        &repo.repo.path,

        &CanonicalPathBuf::canonicalize(&repo.repo.path)?,

    repo_path: &Path,

    repo_path: &CanonicalPathBuf,

) -> Result<
    (usize, Option<libpijul::Hash>, Option<libpijul::Merkle>),
    libpijul::LocalApplyError<T::Error>,
> {

) -> Result<(usize, Option<libpijul::Hash>, libpijul::Merkle), libpijul::LocalApplyError<T::Error>>
{

        let result =
            working_copy.record_prefix(txn, channel, changes, &mut state, repo_path, p, num_cpus);

        let result = working_copy.record_prefix(
            txn,
            channel,
            changes,
            &mut state,
            repo_path.clone(),
            p,
            num_cpus,
        );

use canonical_path::CanonicalPathBuf;

        let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;

                if let Ok((full, prefix)) = get_prefix(Some(&repo.path), path) {
                    repo.working_copy
                        .add_prefix_rec(&mut txn, &repo.path, &full, &prefix, threads)?

                if let Ok((full, prefix)) = get_prefix(Some(repo_path.as_ref()), path) {
                    repo.working_copy.add_prefix_rec(
                        &mut txn,
                        repo_path.clone(),
                        full.clone(),
                        &prefix,
                        threads,
                    )?

use canonical_path::CanonicalPathBuf;

                &repo.path,

                CanonicalPathBuf::canonicalize(&repo.path)?,

canonical-path = "2.0"

use canonical_path::{CanonicalPath, CanonicalPathBuf};

use std::borrow::Cow;

    repo_path: Option<&Path>,

    repo_path: Option<&CanonicalPath>,

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

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

        std::fs::canonicalize(repo)?

        Cow::Borrowed(repo)

        std::env::current_dir()?

        Cow::Owned(canonical_path::CanonicalPathBuf::canonicalize(
            std::env::current_dir()?,
        )?)

    let prefix_ = if let Ok(prefix_) = std::fs::canonicalize(repo.join(&prefix)) {
        prefix_
    } else {
        repo.join(&prefix)
    };

    let prefix_ = repo.join(&prefix)?;

    if let Ok(prefix) = prefix_.strip_prefix(repo) {

    if let Ok(prefix) = prefix_.as_path().strip_prefix(repo.as_path()) {

        repo_path: &Path,

        repo_path: CanonicalPathBuf,

                repo_path,

                repo_path.clone(),

                repo_path,

                repo_path.clone(),

        repo_path: &Path,
        full: &Path,

        repo_path: CanonicalPathBuf,
        full: CanonicalPathBuf,

        let repo_path_ = std::fs::canonicalize(repo_path)?;

        debug!("{:?}", full.strip_prefix(&repo_path_));

        let full = full.to_path_buf();

        debug!("{:?}", full.as_path().strip_prefix(repo_path.as_path()));

                            debug!("entry path = {:?} {:?}", entry.path(), repo_path_);
                            if let Ok(path) = entry.path().strip_prefix(&repo_path_) {
                                let is_dir = entry.file_type().unwrap().is_dir();
                                sender.send((path.to_path_buf(), is_dir)).unwrap();
                            } else {
                                debug!("entry = {:?}", entry.path());

                            debug!("entry path = {:?} {:?}", entry.path(), repo_path);
                            if let Ok(entry_path) = CanonicalPathBuf::canonicalize(entry.path()) {
                                if let Ok(path) = entry_path.as_path().strip_prefix(&repo_path) {
                                    let is_dir = entry.file_type().unwrap().is_dir();
                                    sender.send((path.to_path_buf(), is_dir)).unwrap();
                                } else {
                                    debug!("entry = {:?}", entry.path());
                                }

                } else if let Ok(path) = full.strip_prefix(&repo_path_) {

                } else if let Ok(path) = full.as_path().strip_prefix(&repo_path.as_path()) {

        repo_path: &Path,

        repo_path: CanonicalPathBuf,

        if let Ok((full, prefix)) = get_prefix(Some(&repo_path), prefix) {
            self.add_prefix_rec(txn, repo_path, &full, &prefix, threads)?;

        if let Ok((full, prefix)) = get_prefix(Some(repo_path.as_ref()), prefix) {
            self.add_prefix_rec(txn, repo_path, full, &prefix, threads)?;

                debug!("new actions: {:?}", &self.rec.actions.len() - len);

                debug!(
                    "new actions: {:?}, total {:?}",
                    &self.rec.actions.len() - len,
                    self.rec.actions.len()
                );

ondisk-repos = [ "mmap", "zstd", "ignore" ]

ondisk-repos = [ "mmap", "zstd", "ignore", "canonical-path" ]

canonical-path = { version = "2.0", optional = true }

[[package]]
name = "canonical-path"
version = "2.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6e9e01327e6c86e92ec72b1c798d4a94810f147209bbe3ffab6a86954937a6f"

 "canonical-path",

 "canonical-path",