Fix some tests

Author: lewazo

src/cli/src/dispatch.rs

@@ -564,9 +564,8 @@ pub async fn diff(
         )
     };
 
-    if is_remote {
-        let result = command::remote::diff(&repository, revision_1, &file_1).await?;
-        println!("{result}");
+    let result = if is_remote {
+        command::remote::diff(&repository, revision_1, &file_1).await?
     } else {
         command::compare(
             compare_strategy,
@@ -576,8 +575,10 @@ pub async fn diff(
             keys,
             targets,
             output,
-        )?;
-    }
+        )?
+    };
+
+    println!("{result}");
 
     Ok(())
 }

src/lib/src/api/local/compare.rs

@@ -67,7 +67,6 @@ pub fn compare_files(
         Ok(CompareResult::Tabular(result))
     } else if is_files_utf8(&file_1, &file_2) {
         let result = utf8_compare::compare(&file_1, &file_2)?;
-        println!("{result}");
 
         Ok(CompareResult::Text(result))
     } else {
@@ -90,7 +89,7 @@ fn compare_tabular(
     keys: Vec<String>,
     targets: Vec<String>,
     output: Option<PathBuf>,
-) -> Result<CompareTabular, OxenError> {
+) -> Result<(CompareTabular, String), OxenError> {
     let df_1 = tabular::read_df(file_1, DFOpts::empty())?;
     let df_2 = tabular::read_df(file_2, DFOpts::empty())?;
 
@@ -116,7 +115,6 @@ fn compare_tabular(
         compare_id,
     );
 
-    maybe_print_compare_output(&strategy, &compare_tabular_raw);
     maybe_save_compare_output(&strategy, &mut compare_tabular_raw, output)?;
     maybe_write_cache(
         repo,
@@ -126,7 +124,8 @@ fn compare_tabular(
         &mut compare_tabular_raw,
     )?;
 
-    Ok(compare)
+    let compare_string = compare_to_string(&strategy, &compare_tabular_raw);
+    Ok((compare, compare_string))
 }
 
 pub fn get_cached_compare(
@@ -637,35 +636,40 @@ fn maybe_write_cache(
     Ok(())
 }
 
-fn maybe_print_compare_output(strategy: &CompareStrategy, compare_tabular_raw: &CompareTabularRaw) {
+fn compare_to_string(
+    strategy: &CompareStrategy,
+    compare_tabular_raw: &CompareTabularRaw,
+) -> String {
     let left_only_df = &compare_tabular_raw.left_only_df;
     let right_only_df = &compare_tabular_raw.right_only_df;
     let diff_df = &compare_tabular_raw.diff_df;
     let match_df = &compare_tabular_raw.match_df;
 
+    let mut results: Vec<String> = vec![];
+
     match strategy {
         CompareStrategy::Hash => {
-            println!("Added rows");
-            println!("{:?}", left_only_df);
-
-            println!("Removed rows");
-            println!("{:?}", right_only_df);
+            results.push(format!("Added Rows\n\n{left_only_df}\n\n"));
+            results.push(format!("Removed Rows\n\n{right_only_df}\n\n"));
         }
 
         CompareStrategy::Join => {
-            println!("Rows with matching keys and DIFFERENT targets");
-            println!("{:?}", diff_df);
-
-            println!("Rows with matching keys and SAME targets");
-            println!("{:?}", match_df);
-
-            println!("Rows with keys only in LEFT DataFrame");
-            println!("{:?}", left_only_df);
-
-            println!("Rows with keys only in RIGHT DataFrame");
-            println!("{:?}", right_only_df);
+            results.push(format!(
+                "Rows with matching keys and DIFFERENT targets\n\n{diff_df}\n\n"
+            ));
+            results.push(format!(
+                "Rows with matching keys and SAME targets\n\n{match_df}\n\n"
+            ));
+            results.push(format!(
+                "Rows with keys only in LEFT DataFrame\n\n{left_only_df}\n\n"
+            ));
+            results.push(format!(
+                "Rows with keys only in RIGHT DataFrame\n\n{right_only_df}\n\n"
+            ));
         }
     }
+
+    results.join("\n")
 }
 
 fn maybe_save_compare_output(
@@ -805,7 +809,7 @@ mod tests {
                 None,
             )?;
 
-            if let CompareResult::Tabular(compare) = result {
+            if let CompareResult::Tabular((compare, _)) = result {
                 // Should be updated values
                 assert_eq!(compare.derived["left_only"].size.height, 2);
                 assert_eq!(compare.derived["right_only"].size.height, 1);
@@ -931,7 +935,7 @@ mod tests {
                 None,
             )?;
 
-            if let CompareResult::Tabular(new_compare) = result {
+            if let CompareResult::Tabular((new_compare, _)) = result {
                 // Should be updated values
                 assert_eq!(new_compare.derived["left_only"].size.height, 0);
                 assert_eq!(new_compare.derived["right_only"].size.height, 6);

src/lib/src/command/compare.rs

@@ -3,6 +3,7 @@ use crate::api::local::compare::CompareStrategy;
 use crate::error::OxenError;
 use crate::model::entry::commit_entry::{CommitPath, CompareEntry};
 use crate::model::LocalRepository;
+use crate::view::compare::CompareResult;
 use std::path::PathBuf;
 
 pub fn compare(
@@ -13,7 +14,7 @@ pub fn compare(
     keys: Vec<String>,
     targets: Vec<String>,
     output: Option<PathBuf>,
-) -> Result<(), OxenError> {
+) -> Result<String, OxenError> {
     let mut compare_entry_1 = CompareEntry {
         commit_entry: None,
         path: cpath_1.path.clone(),
@@ -46,7 +47,7 @@ pub fn compare(
         compare_entry_2.commit_entry = Some(entry_2);
     };
 
-    api::local::compare::compare_files(
+    let compare_result = api::local::compare::compare_files(
         compare_strategy,
         repo,
         None,
@@ -56,5 +57,11 @@ pub fn compare(
         targets,
         output,
     )?;
-    Ok(())
+
+    let text = match compare_result {
+        CompareResult::Tabular((_, text)) => text,
+        CompareResult::Text(text) => text,
+    };
+
+    Ok(text)
 }

src/lib/src/view/compare.rs

@@ -74,7 +74,7 @@ pub struct CompareTabular {
 
 #[derive(Debug)]
 pub enum CompareResult {
-    Tabular(CompareTabular),
+    Tabular((CompareTabular, String)),
     Text(String),
 }
 

src/server/src/controllers/compare.rs

@@ -8,11 +8,12 @@ use liboxen::core::index::{CommitReader, Merger};
 use liboxen::error::OxenError;
 use liboxen::message::OxenMessage;
 use liboxen::model::compare::tabular_compare::TabularCompareBody;
-use liboxen::model::{DataFrameSize, Schema};
+use liboxen::model::{Commit, DataFrameSize, LocalRepository, Schema};
 use liboxen::opts::df_opts::DFOptsView;
 use liboxen::opts::DFOpts;
 use liboxen::view::compare::{
-    CompareCommits, CompareCommitsResponse, CompareEntries, CompareResult, CompareTabularResponse,
+    CompareCommits, CompareCommitsResponse, CompareEntries, CompareEntryResponse, CompareResult,
+    CompareTabularResponse,
 };
 use liboxen::view::json_data_frame_view::{DFResourceType, DerivedDFResource, JsonDataFrameSource};
 use liboxen::view::{
@@ -121,6 +122,52 @@ pub async fn entries(
     Ok(HttpResponse::Ok().json(view))
 }
 
+pub async fn file(
+    req: HttpRequest,
+    query: web::Query<DFOptsQuery>,
+) -> actix_web::Result<HttpResponse, OxenHttpError> {
+    let app_data = app_data(&req)?;
+    let namespace = path_param(&req, "namespace")?;
+    let name = path_param(&req, "repo_name")?;
+    let base_head = path_param(&req, "base_head")?;
+
+    // Get the repository or return error
+    let repository = get_repo(&app_data.path, namespace, name)?;
+
+    // Parse the base and head from the base..head/resource string
+    // For Example)
+    //   main..feature/add-data/path/to/file.txt
+    let (base_commit, head_commit, resource) = parse_base_head_resource(&repository, &base_head)?;
+
+    let base_entry = api::local::entries::get_commit_entry(&repository, &base_commit, &resource)?;
+    let head_entry = api::local::entries::get_commit_entry(&repository, &head_commit, &resource)?;
+
+    let mut opts = DFOpts::empty();
+    opts = df_opts_query::parse_opts(&query, &mut opts);
+
+    let page_size = query.page_size.unwrap_or(constants::DEFAULT_PAGE_SIZE);
+    let page = query.page.unwrap_or(constants::DEFAULT_PAGE_NUM);
+
+    let start = if page == 0 { 0 } else { page_size * (page - 1) };
+    let end = page_size * page;
+    opts.slice = Some(format!("{}..{}", start, end));
+
+    let diff = api::local::diff::diff_entries(
+        &repository,
+        base_entry,
+        &base_commit,
+        head_entry,
+        &head_commit,
+        opts,
+    )?;
+
+    let view = CompareEntryResponse {
+        status: StatusMessage::resource_found(),
+        compare: diff,
+    };
+    Ok(HttpResponse::Ok().json(view))
+}
+
 pub async fn create_df_compare(
     req: HttpRequest,
     _query: web::Query<DFOptsQuery>,
@@ -191,7 +238,7 @@ pub async fn create_df_compare(
     )?;
 
     let view = match result {
-        CompareResult::Tabular(compare) => {
+        CompareResult::Tabular((compare, _)) => {
             let mut messages: Vec<OxenMessage> = vec![];
 
             if compare.dupes.left > 0 || compare.dupes.right > 0 {
@@ -297,7 +344,7 @@ pub async fn get_df_compare(
             )?;
 
             match result {
-                CompareResult::Tabular(compare) => {
+                CompareResult::Tabular((compare, _)) => {
                     let mut messages: Vec<OxenMessage> = vec![];
 
                     if compare.dupes.left > 0 || compare.dupes.right > 0 {
@@ -442,3 +489,49 @@ pub async fn get_derived_df(
         }
     }
 }
+
+fn parse_base_head_resource(
+    repo: &LocalRepository,
+    base_head: &str,
+) -> Result<(Commit, Commit, PathBuf), OxenError> {
+    log::debug!("Parsing base_head_resource: {}", base_head);
+
+    let mut split = base_head.split("..");
+    let base = split
+        .next()
+        .ok_or(OxenError::resource_not_found(base_head))?;
+    let head = split
+        .next()
+        .ok_or(OxenError::resource_not_found(base_head))?;
+
+    let base_commit = api::local::revisions::get(repo, base)?
+        .ok_or(OxenError::revision_not_found(base.into()))?;
+
+    // Split on / and find longest branch name
+    let split_head = head.split('/');
+    let mut longest_str = String::from("");
+    let mut head_commit: Option<Commit> = None;
+    let mut resource: Option<PathBuf> = None;
+
+    for s in split_head {
+        let maybe_revision = format!("{}{}", longest_str, s);
+        log::debug!("Checking maybe head revision: {}", maybe_revision);
+        let commit = api::local::revisions::get(repo, &maybe_revision)?;
+        if commit.is_some() {
+            head_commit = commit;
+            let mut r_str = head.replace(&maybe_revision, "");
+            // remove first char from r_str
+            r_str.remove(0);
+            resource = Some(PathBuf::from(r_str));
+        }
+        longest_str = format!("{}/", maybe_revision);
+    }
+
+    log::debug!("Got head_commit: {:?}", head_commit);
+    log::debug!("Got resource: {:?}", resource);
+
+    let head_commit = head_commit.ok_or(OxenError::revision_not_found(head.into()))?;
+    let resource = resource.ok_or(OxenError::revision_not_found(head.into()))?;
+
+    Ok((base_commit, head_commit, resource))
+}

src/server/src/routes.rs

@@ -154,6 +154,10 @@ pub fn config(cfg: &mut web::ServiceConfig) {
             "/{namespace}/{repo_name}/compare/entries/{base_head:.*}",
             web::get().to(controllers::compare::entries),
         )
+        .route(
+            "/{namespace}/{repo_name}/compare/file/{base_head:.*}",
+            web::get().to(controllers::compare::file),
+        )
         .route(
             "/{namespace}/{repo_name}/compare/data_frame/{compare_id}/{path}/{base_head:.*}",
             web::get().to(controllers::compare::get_derived_df),

tests/test_diff.rs

@@ -1,12 +1,12 @@
-use std::path::Path;
-
-use liboxen::api;
-use liboxen::command;
-use liboxen::error::OxenError;
-use liboxen::model::ContentType;
-use liboxen::opts::DFOpts;
-use liboxen::test;
-use liboxen::util;
+// use std::path::Path;
+
+// use liboxen::api;
+// use liboxen::command;
+// use liboxen::error::OxenError;
+// use liboxen::model::ContentType;
+// use liboxen::opts::DFOpts;
+// use liboxen::test;
+// use liboxen::util;
 
 // Test diff during a merge conflict should show conflicts for a dataframe
 // #[tokio::test]