wip: b

Author: lewazo

src/cli/src/cmd_setup.rs

@@ -11,7 +11,6 @@ pub const CHECKOUT: &str = "checkout";
 pub const CLONE: &str = "clone";
 pub const COMMIT_CACHE: &str = "commit-cache";
 pub const COMMIT: &str = "commit";
-pub const COMPARE: &str = "compare";
 pub const CONFIG: &str = "config";
 pub const CREATE_REMOTE: &str = "create-remote";
 pub const DF: &str = "df";
@@ -798,13 +797,6 @@ pub fn pull() -> Command {
 
 pub fn diff() -> Command {
     Command::new(DIFF)
-        .about("Compare two files against each other or against versions. The first parameter can be one of three things 1) another file 2) a commit hash 3) a branch name. If the first parameter is a revision it will compare the second parameter path to that version of the file.")
-        .arg(Arg::new("FILE_OR_REVISION").required(true))
-        .arg(Arg::new("PATH").required(false))
-}
-
-pub fn compare() -> Command {
-    Command::new(COMPARE)
         .about("Compare two tabular files with some schematic overlap. The two resource paramaters can be specified by filepath or `file:revision` syntax.")
         .arg(Arg::new("RESOURCE1")
             .required(true)

src/cli/src/dispatch.rs

@@ -498,21 +498,7 @@ pub async fn pull(remote: &str, branch: &str, all: bool) -> Result<(), OxenError
     Ok(())
 }
 
-pub async fn diff(commit_id: Option<&str>, path: &str, remote: bool) -> Result<(), OxenError> {
-    let repo_dir = env::current_dir().unwrap();
-    let repository = LocalRepository::from_dir(&repo_dir)?;
-    let path = Path::new(path);
-
-    let result = if remote {
-        command::remote::diff(&repository, commit_id, path).await?
-    } else {
-        command::diff(&repository, commit_id, path)?
-    };
-    println!("{result}");
-    Ok(())
-}
-
-pub fn compare(
+pub fn diff(
     file_1: PathBuf,
     revision_1: Option<&str>,
     file_2: Option<PathBuf>,

src/cli/src/main.rs

@@ -21,7 +21,6 @@ async fn main() {
         .subcommand(cmd_setup::clone())
         .subcommand(cmd_setup::commit_cache())
         .subcommand(cmd_setup::commit())
-        .subcommand(cmd_setup::compare())
         .subcommand(cmd_setup::config())
         .subcommand(cmd_setup::create_remote())
         .subcommand(cmd_setup::df())
@@ -56,13 +55,12 @@ async fn main() {
             parse_and_run::compute_commit_cache(sub_matches).await
         }
         Some((cmd_setup::COMMIT, sub_matches)) => parse_and_run::commit(sub_matches).await,
-        Some((cmd_setup::COMPARE, sub_matches)) => parse_and_run::compare(sub_matches).await,
+        Some((cmd_setup::DIFF, sub_matches)) => parse_and_run::diff(sub_matches).await,
         Some((cmd_setup::CONFIG, sub_matches)) => parse_and_run::config(sub_matches),
         Some((cmd_setup::CREATE_REMOTE, sub_matches)) => {
             parse_and_run::create_remote(sub_matches).await
         }
         Some((cmd_setup::DF, sub_matches)) => parse_and_run::df(sub_matches),
-        Some((cmd_setup::DIFF, sub_matches)) => parse_and_run::diff(sub_matches).await,
         Some((cmd_setup::DOWNLOAD, sub_matches)) => parse_and_run::download(sub_matches).await,
         Some((cmd_setup::INIT, sub_matches)) => parse_and_run::init(sub_matches).await,
         Some((cmd_setup::INFO, sub_matches)) => parse_and_run::info(sub_matches),

src/cli/src/parse_and_run.rs

@@ -944,10 +944,9 @@ pub async fn pull(sub_matches: &ArgMatches) {
 
 pub async fn remote_diff(sub_matches: &ArgMatches) {
     let is_remote = true;
-    p_diff(sub_matches, is_remote).await
 }
 
-pub async fn compare(sub_matches: &ArgMatches) {
+pub async fn diff(sub_matches: &ArgMatches) {
     let resource1 = sub_matches
         .get_one::<String>("RESOURCE1")
         .expect("required");
@@ -977,42 +976,14 @@ pub async fn compare(sub_matches: &ArgMatches) {
 
     let output = sub_matches.get_one::<String>("output").map(PathBuf::from);
 
-    match dispatch::compare(file1, revision1, file2, revision2, keys, targets, output) {
+    match dispatch::diff(file1, revision1, file2, revision2, keys, targets, output) {
         Ok(_) => {}
         Err(err) => {
             eprintln!("{err}")
         }
     }
 }
 
-pub async fn diff(sub_matches: &ArgMatches) {
-    let is_remote = false;
-    p_diff(sub_matches, is_remote).await
-}
-
-async fn p_diff(sub_matches: &ArgMatches, is_remote: bool) {
-    // First arg is optional
-    let file_or_commit_id = sub_matches
-        .get_one::<String>("FILE_OR_REVISION")
-        .expect("required");
-    let path = sub_matches.get_one::<String>("PATH");
-    if let Some(path) = path {
-        match dispatch::diff(Some(file_or_commit_id), path, is_remote).await {
-            Ok(_) => {}
-            Err(err) => {
-                eprintln!("{err}")
-            }
-        }
-    } else {
-        match dispatch::diff(None, file_or_commit_id, is_remote).await {
-            Ok(_) => {}
-            Err(err) => {
-                eprintln!("{err}")
-            }
-        }
-    }
-}
-
 pub async fn clone(sub_matches: &ArgMatches) {
     let url = sub_matches.get_one::<String>("URL").expect("required");
     let shallow = sub_matches.get_flag("shallow");

src/lib/src/api/local/diff.rs

@@ -39,30 +39,6 @@ struct DiffCommitEntry {
     pub base_entry: Option<CommitEntry>,
 }
 
-/// Get a String representation of a diff between two commits given a file
-pub fn diff_one(
-    repo: &LocalRepository,
-    original: &Commit,
-    compare: &Commit,
-    path: impl AsRef<Path>,
-) -> Result<String, OxenError> {
-    let base_path = get_version_file_from_commit(repo, original, &path)?;
-    let head_path = get_version_file_from_commit(repo, compare, &path)?;
-    diff_files(base_path, head_path)
-}
-
-/// Compare a file between commits
-pub fn diff_one_2(
-    repo: &LocalRepository,
-    original: &Commit,
-    compare: &Commit,
-    path: impl AsRef<Path>,
-) -> Result<GenericDiff, OxenError> {
-    let base_path = get_version_file_from_commit(repo, original, &path)?;
-    let head_path = get_version_file_from_commit(repo, compare, &path)?;
-    diff_files_2(base_path, head_path)
-}
-
 pub fn get_version_file_from_commit(
     repo: &LocalRepository,
     commit: &Commit,
@@ -101,110 +77,6 @@ pub fn get_version_file_from_commit_id(
     Ok(util::fs::version_path(repo, &entry))
 }
 
-pub fn diff_files(
-    original: impl AsRef<Path>,
-    compare: impl AsRef<Path>,
-) -> Result<String, OxenError> {
-    let original = original.as_ref();
-    let compare = compare.as_ref();
-    if util::fs::is_tabular(original) && util::fs::is_tabular(compare) {
-        let tabular_diff = diff_tabular(original, compare)?;
-        return Ok(tabular_diff.to_string());
-    } else if util::fs::is_utf8(original) && util::fs::is_utf8(compare) {
-        return diff_utf8(original, compare);
-    }
-    Err(OxenError::basic_str(format!(
-        "Diff not supported for files: {original:?} and {compare:?}"
-    )))
-}
-
-// TODO: this should be the one that is returned instead of a string
-pub fn diff_files_2(
-    original: impl AsRef<Path>,
-    compare: impl AsRef<Path>,
-) -> Result<GenericDiff, OxenError> {
-    let original = original.as_ref();
-    let compare = compare.as_ref();
-    if util::fs::is_tabular(original) && util::fs::is_tabular(compare) {
-        // TODO: consolidate TabularDiff and DataFrameDiff
-        // let tabular_diff = diff_tabular(original, compare)?;
-        // return Ok(GenericDiff::TabularDiff(tabular_diff));
-    }
-    Err(OxenError::basic_str(format!(
-        "Diff not supported for files: {original:?} and {compare:?}"
-    )))
-}
-
-pub fn diff_utf8(
-    original: impl AsRef<Path>,
-    compare: impl AsRef<Path>,
-) -> Result<String, OxenError> {
-    let original = original.as_ref();
-    let compare = compare.as_ref();
-    let original_data = util::fs::read_from_path(original)?;
-    let compare_data = util::fs::read_from_path(compare)?;
-    let Changeset { diffs, .. } = Changeset::new(&original_data, &compare_data, "\n");
-
-    let mut outputs: Vec<String> = vec![];
-    for diff in diffs {
-        match diff {
-            Difference::Same(ref x) => {
-                for split in x.split('\n') {
-                    outputs.push(format!(" {split}\n").normal().to_string());
-                }
-            }
-            Difference::Add(ref x) => {
-                for split in x.split('\n') {
-                    outputs.push(format!("+{split}\n").green().to_string());
-                }
-            }
-            Difference::Rem(ref x) => {
-                for split in x.split('\n') {
-                    outputs.push(format!("-{split}\n").red().to_string());
-                }
-            }
-        }
-    }
-
-    Ok(outputs.join(""))
-}
-
-pub fn diff_tabular(
-    base_path: impl AsRef<Path>,
-    head_path: impl AsRef<Path>,
-) -> Result<DataFrameDiff, OxenError> {
-    let base_path = base_path.as_ref();
-    let head_path = head_path.as_ref();
-    // Make sure files exist
-    if !base_path.exists() {
-        return Err(OxenError::entry_does_not_exist(base_path));
-    }
-
-    if !head_path.exists() {
-        return Err(OxenError::entry_does_not_exist(head_path));
-    }
-
-    // Read DFs and get schemas
-    let base_df = tabular::read_df(base_path, DFOpts::empty())?;
-    let head_df = tabular::read_df(head_path, DFOpts::empty())?;
-    let base_schema = Schema::from_polars(&base_df.schema());
-    let head_schema = Schema::from_polars(&head_df.schema());
-
-    log::debug!(
-        "Original df {} {base_path:?}\n{base_df:?}",
-        base_schema.hash
-    );
-    log::debug!("Compare df {} {head_path:?}\n{head_df:?}", head_schema.hash);
-
-    // If schemas don't match, figure out which columns are different
-    if base_schema.hash != head_schema.hash {
-        compute_new_columns_from_paths(base_path, head_path, &base_schema, &head_schema)
-    } else {
-        log::debug!("Computing diff for {base_path:?} to {head_path:?}");
-        compute_new_rows(&base_df, &head_df, &base_schema)
-    }
-}
-
 pub fn count_added_rows(base_df: DataFrame, head_df: DataFrame) -> Result<usize, OxenError> {
     // Hash the rows
     let base_df = tabular::df_hash_rows(base_df)?;

src/lib/src/command.rs

@@ -12,7 +12,6 @@ pub mod compare;
 pub mod config;
 pub mod db_inspect;
 pub mod df;
-pub mod diff;
 pub mod fetch;
 pub mod helpers;
 pub mod info;
@@ -37,7 +36,6 @@ pub use crate::command::clone::{clone, clone_url, deep_clone_url, shallow_clone_
 pub use crate::command::commit::commit;
 pub use crate::command::compare::compare;
 pub use crate::command::df::{df, schema};
-pub use crate::command::diff::diff;
 pub use crate::command::fetch::fetch;
 pub use crate::command::info::info;
 pub use crate::command::init::init;