oxen-cli 0.48.3

Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use async_trait::async_trait;
use clap::{Arg, ArgMatches, Command};

use glob::glob;
use liboxen::error::OxenError;
use liboxen::model::LocalRepository;
use liboxen::model::staged_data::StagedDataOpts;
use liboxen::repositories;
use std::collections::HashSet;
use std::path::PathBuf;

use crate::helpers::check_repo_migration_needed;

use crate::cmd::RunCmd;
pub const NAME: &str = "status";
pub struct StatusCmd;

#[async_trait]
impl RunCmd for StatusCmd {
    fn name(&self) -> &str {
        NAME
    }
    fn args(&self) -> Command {
        Command::new(NAME)
            .about("View the repository status, including staged, untracked, modified, and removed files")
            .arg(
                Arg::new("skip")
                    .long("skip")
                    .short('s')
                    .help("Allows you to skip and paginate through the file list preview.")
                    .default_value("0")
                    .action(clap::ArgAction::Set),
            )
            .arg(
                Arg::new("limit")
                    .long("limit")
                    .short('l')
                    .help("Allows you to view more file list preview.")
                    .default_value("10")
                    .action(clap::ArgAction::Set),
            )
            .arg(
                Arg::new("ignore")
                    .long("ignore")
                    .short('i')
                    .help("Ignore files at this path.")
                    .action(clap::ArgAction::Set)
                    .required(false),
            )
            .arg(
                Arg::new("print_all")
                    .long("print_all")
                    .short('a')
                    .help("If present, does not truncate the output of status at all.")
                    .action(clap::ArgAction::SetTrue),
            )
            .arg(
                Arg::new("paths")
                    .num_args(0..)
                    .trailing_var_arg(true)  // Collect all remaining args as paths
                    .help("Specify one or more paths")
            )
    }

    async fn run(&self, args: &ArgMatches) -> Result<(), OxenError> {
        let skip = args
            .get_one::<String>("skip")
            .expect("Must supply skip")
            .parse::<usize>()
            .expect("skip must be a valid integer.");
        let limit = args
            .get_one::<String>("limit")
            .expect("Must supply limit")
            .parse::<usize>()
            .expect("limit must be a valid integer.");
        let print_all = args.get_flag("print_all");

        let repository = LocalRepository::from_current_dir()?;
        check_repo_migration_needed(&repository)?;

        let paths = args
            .get_many::<String>("paths")
            .map(|vals| vals.map(|v| repository.path.join(v)).collect())
            .unwrap_or_else(|| vec![repository.path.clone()]);
        let is_remote = false;
        let opts = StagedDataOpts {
            paths,
            skip,
            limit,
            print_all,
            is_remote,
            ignore: parse_ignore_files(args.get_one::<String>("ignore")),
        };
        log::debug!("status opts: {opts:?}");

        let repo_status = repositories::status::status_from_opts(&repository, &opts).await?;

        if let Some(current_branch) = repositories::branches::current_branch(&repository)? {
            println!(
                "On branch {} -> {}\n",
                current_branch.name, current_branch.commit_id
            );
        } else if let Some(head) = repositories::commits::head_commit_maybe(&repository)? {
            println!(
                "You are in 'detached HEAD' state.\nHEAD is now at {} {}\n",
                head.id, head.message
            );
        }

        repo_status.print_with_params(&opts);

        Ok(())
    }
}

fn parse_ignore_files(paths: Option<&String>) -> Option<HashSet<PathBuf>> {
    let paths_str = paths?;

    match glob(paths_str) {
        Ok(paths) => {
            let mut results: HashSet<PathBuf> = HashSet::new();
            for path in paths.flatten() {
                results.insert(path);
            }
            Some(results)
        }
        Err(err) => {
            log::error!("Err: {err:?}");
            None
        }
    }
}