directive
                            .add_meta(common_keys::FILENAME, file.as_str())
                            .add_meta(common_keys::LINE_NUMBER, position.line());

                        directive.add_meta(common_keys::LINE_NUMBER, position.line());

use alloc::borrow::Cow;

use beancount_types::common_keys;

use miette::Result; // TODO

use miette::Result;
use relative_path::RelativePathBuf; // TODO

    ) -> Result<Cow<'a, Utf8Path>> {
        let destination = archive::file_name(importer, &self.archive_directory, file)?;
        if self.dry_run || file == destination {
            return Ok(Cow::Borrowed(file));

    ) -> Result<Option<RelativePathBuf>> {
        if self.dry_run {
            return Ok(None);

        tracing::info!(?file, ?destination, "archiving file");

        let relative_destination = archive::file_name(importer, file)?;
        let destination = relative_destination.to_logical_path(&self.archive_directory);
        let destination = Utf8Path::from_path(&destination).expect("should be UTF-8");
        if file != destination {
            tracing::info!(?file, ?destination, "archiving file");

        if destination.exists() {
            miette::ensure!(
                self.overwrite,
                "destination {destination:?} already exists",
                destination = destination,
            );

            if destination.exists() {
                miette::ensure!(
                    self.overwrite,
                    "destination {destination:?} already exists",
                    destination = destination,
                );
            }
            archive::move_file(file, destination).wrap_err("while moving file into archive")?;

        archive::move_file(file, &destination).wrap_err("while moving file into archive")?;
        Ok(Cow::Owned(destination))

        Ok(Some(relative_destination))

        let file = self

        let relative_destination = self

        // let file = file.strip_prefix(&self.archive_directory).unwrap_or(&file);

        let destination = relative_destination.as_ref().map_or_else(
            || file.to_path_buf(),
            |relative_destination| {
                let destination = relative_destination.to_path(&self.archive_directory);
                Utf8PathBuf::from_path_buf(destination).expect("path to be UTF-8")
            },
        );

            .extract(&file, &[]) // TODO load existing transactions

            .extract(&destination, &[]) // TODO load existing transactions

        if let Some(path) = relative_destination {
            for directive in &mut extracted_directives {
                directive.add_meta(common_keys::FILENAME, path.as_str());
            }
        }

use camino::Utf8PathBuf;

use relative_path::RelativePathBuf;

    base: &Utf8Path,

) -> Result<Utf8PathBuf> {
    use std::fmt::Write;

) -> Result<RelativePathBuf> {

    let sep = std::path::MAIN_SEPARATOR;

        !name.contains(sep),

        !name.contains(std::path::MAIN_SEPARATOR),

    let mut path = base.to_string();
    let additional = account.len() + 10 + 1 + name.len() + 5 + 2; // account name + date + dot + name + extra separators
    path.reserve(additional);
    account
        .segments()
        .for_each(|segment| write!(path, "{sep}{segment}").unwrap());

    let mut path = RelativePathBuf::new();
    path.extend(account.segments().map(|seg| &**seg));

    write!(path, "{sep}{date}.{name}").unwrap();

    let file_name = format!("{date}.{name}");
    path.set_file_name(file_name);

    Ok(Utf8PathBuf::from(path))

    Ok(path)

camino.workspace    = true
clap.workspace      = true
delegate.workspace  = true
inventory.workspace = true
miette.workspace    = true
snafu.workspace     = true
time-tz.workspace   = true
time.workspace      = true
tracing.workspace   = true

camino.workspace        = true
clap.workspace          = true
delegate.workspace      = true
inventory.workspace     = true
miette.workspace        = true
relative-path.workspace = true
snafu.workspace         = true
time-tz.workspace       = true
time.workspace          = true
tracing.workspace       = true

relative-path        = "1.8.0"

 "relative-path",

name = "relative-path"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4bf2521270932c3c7bed1a59151222bd7643c79310f2916f01925e1e16255698"
[[package]]