Remove status command and workspace reader

5 files changed, 0 insertions, 505 deletions

diff --git a/src/cmds/arg/status.rs b/src/cmds/arg/status.rs
deleted file mode 100644
index fbfe5f5..0000000
--- a/src/cmds/arg/status.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use clap::Parser;
-
-#[derive(Parser, Debug)]
-pub struct JVStatusArgument {
-    what: Option<String>, // status of what to query
-}
diff --git a/src/cmds/cmd/status.rs b/src/cmds/cmd/status.rs
deleted file mode 100644
index 3ca2a25..0000000
--- a/src/cmds/cmd/status.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use std::{any::TypeId, collections::HashMap, time::SystemTime};
-
-use crate::{
-    cmd_output,
-    cmds::{
-        arg::status::JVStatusArgument,
-        collect::status::JVStatusCollect,
-        r#in::empty::JVEmptyInput,
-        out::status::{JVStatusOutput, JVStatusWrongModifyReason},
-    },
-    systems::cmd::{
-        cmd_system::JVCommandContext,
-        errors::{CmdExecuteError, CmdPrepareError},
-        workspace_reader::LocalWorkspaceReader,
-    },
-};
-use cmd_system_macros::exec;
-use just_enough_vcs::lib::{
-    constants::VAULT_HOST_NAME, data::local::workspace_analyzer::ModifiedRelativePathBuf,
-};
-
-pub struct JVStatusCommand;
-type Cmd = JVStatusCommand;
-type Arg = JVStatusArgument;
-type In = JVEmptyInput;
-type Collect = JVStatusCollect;
-
-fn help_str() -> String {
-    "".to_string()
-}
-
-async fn prepare(_args: &Arg, _ctx: &JVCommandContext) -> Result<In, CmdPrepareError> {
-    Ok(In {})
-}
-
-async fn collect(_args: &Arg, _ctx: &JVCommandContext) -> Result<Collect, CmdPrepareError> {
-    // Initialize a reader for the local workspace and a default result structure
-    let mut reader = LocalWorkspaceReader::default();
-    let mut collect = JVStatusCollect::default();
-
-    // Analyze the current status of the local workspace
-    // (detects changes like created, modified, moved, etc.)
-    let analyzed = reader.analyze_local_status().await?;
-
-    // Retrieve the current account (member) ID
-    let account = reader.current_account().await?;
-
-    // Retrieve the name of the current sheet
-    let sheet_name = reader.sheet_name().await?;
-
-    // Is Host Mode
-    let is_host_mode = reader.is_host_mode().await?;
-
-    let cached_sheet = reader.cached_sheet(&sheet_name).await?;
-    let sheet_holder = cached_sheet.holder().cloned().unwrap_or_default();
-    let is_ref_sheet = sheet_holder == VAULT_HOST_NAME;
-
-    // Get Latest file data
-    let latest_file_data = reader.pop_latest_file_data(&account).await?;
-
-    // Get the timestamp of the last update, defaulting to the current time if not available
-    let update_time = reader
-        .latest_info()
-        .await?
-        .update_instant
-        .unwrap_or(SystemTime::now());
-
-    // Record the current system time
-    let now_time = SystemTime::now();
-
-    // Populate the result structure with the gathered data
-    collect.current_account = account;
-    collect.current_sheet = sheet_name;
-    collect.is_host_mode = is_host_mode;
-    collect.in_ref_sheet = is_ref_sheet;
-    collect.analyzed_result = analyzed;
-    collect.update_time = update_time;
-    collect.now_time = now_time;
-    collect.latest_file_data = latest_file_data;
-    Ok(collect)
-}
-
-#[exec]
-async fn exec(
-    _input: In,
-    collect: Collect,
-) -> Result<(Box<dyn std::any::Any + Send + 'static>, TypeId), CmdExecuteError> {
-    let mut wrong_modified_items: HashMap<ModifiedRelativePathBuf, JVStatusWrongModifyReason> =
-        HashMap::new();
-
-    let latest_file_data = &collect.latest_file_data;
-
-    // Calculate whether modifications are correc
-    let modified = &collect.analyzed_result.modified;
-    for item in modified {
-        // Get mapping
-        let Ok(mapping) = collect.local_sheet_data.mapping_data(&item) else {
-            continue;
-        };
-
-        // Check base version
-        {
-            let base_version = mapping.version_when_updated().clone();
-            let Some(latest_version) = latest_file_data
-                .file_version(mapping.mapping_vfid())
-                .cloned()
-            else {
-                continue;
-            };
-
-            // Base version dismatch
-            if base_version != latest_version {
-                wrong_modified_items.insert(
-                    item.clone(),
-                    JVStatusWrongModifyReason::BaseVersionMismatch {
-                        base_version,
-                        latest_version,
-                    },
-                );
-                continue;
-            }
-        }
-
-        // Check edit right (only check when current is not HOST)
-        if collect.current_account != VAULT_HOST_NAME {
-            let holder = latest_file_data.file_holder(mapping.mapping_vfid());
-            if holder.is_none() {
-                wrong_modified_items.insert(item.clone(), JVStatusWrongModifyReason::NoHolder);
-                continue;
-            }
-
-            let holder = holder.cloned().unwrap();
-            if &collect.current_account != &holder {
-                wrong_modified_items.insert(
-                    item.clone(),
-                    JVStatusWrongModifyReason::ModifiedButNotHeld { holder: holder },
-                );
-            }
-        }
-    }
-
-    let output = JVStatusOutput {
-        current_account: collect.current_account,
-        current_sheet: collect.current_sheet,
-        is_host_mode: collect.is_host_mode,
-        in_ref_sheet: collect.in_ref_sheet,
-        analyzed_result: collect.analyzed_result,
-        wrong_modified_items: wrong_modified_items,
-        update_time: collect.update_time,
-        now_time: collect.now_time,
-    };
-
-    cmd_output!(JVStatusOutput => output)
-}
-
-crate::command_template!();
diff --git a/src/cmds/collect/status.rs b/src/cmds/collect/status.rs
deleted file mode 100644
index fba86c2..0000000
--- a/src/cmds/collect/status.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::time::SystemTime;
-
-use just_enough_vcs::lib::data::{
-    local::{
-        latest_file_data::LatestFileData, local_sheet::LocalSheetData,
-        workspace_analyzer::AnalyzeResultPure,
-    },
-    member::MemberId,
-    sheet::SheetName,
-};
-
-pub struct JVStatusCollect {
-    pub current_account: MemberId,
-    pub current_sheet: SheetName,
-    pub is_host_mode: bool,
-    pub in_ref_sheet: bool,
-    pub analyzed_result: AnalyzeResultPure,
-    pub latest_file_data: LatestFileData,
-    pub local_sheet_data: LocalSheetData,
-    pub update_time: SystemTime,
-    pub now_time: SystemTime,
-}
-
-impl Default for JVStatusCollect {
-    fn default() -> Self {
-        Self {
-            current_account: MemberId::default(),
-            current_sheet: SheetName::default(),
-            is_host_mode: false,
-            in_ref_sheet: false,
-            analyzed_result: AnalyzeResultPure::default(),
-            latest_file_data: LatestFileData::default(),
-            local_sheet_data: LocalSheetData::default(),
-            update_time: SystemTime::now(),
-            now_time: SystemTime::now(),
-        }
-    }
-}
diff --git a/src/cmds/out/status.rs b/src/cmds/out/status.rs
deleted file mode 100644
index 417c94c..0000000
--- a/src/cmds/out/status.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use std::{collections::HashMap, time::SystemTime};
-
-use just_enough_vcs::lib::data::{
-    local::workspace_analyzer::{AnalyzeResultPure, ModifiedRelativePathBuf},
-    member::MemberId,
-    sheet::SheetName,
-};
-use serde::Serialize;
-
-#[derive(Serialize)]
-pub struct JVStatusOutput {
-    pub current_account: MemberId,
-    pub current_sheet: SheetName,
-    pub is_host_mode: bool,
-    pub in_ref_sheet: bool,
-    pub analyzed_result: AnalyzeResultPure,
-    pub wrong_modified_items: HashMap<ModifiedRelativePathBuf, JVStatusWrongModifyReason>,
-    pub update_time: SystemTime,
-    pub now_time: SystemTime,
-}
-
-#[derive(Serialize)]
-pub enum JVStatusWrongModifyReason {
-    BaseVersionMismatch {
-        base_version: String,
-        latest_version: String,
-    },
-    ModifiedButNotHeld {
-        holder: String,
-    },
-    NoHolder,
-}
-
-impl Default for JVStatusOutput {
-    fn default() -> Self {
-        Self {
-            current_account: MemberId::default(),
-            current_sheet: SheetName::default(),
-            is_host_mode: false,
-            in_ref_sheet: false,
-            analyzed_result: AnalyzeResultPure::default(),
-            wrong_modified_items: HashMap::new(),
-            update_time: SystemTime::now(),
-            now_time: SystemTime::now(),
-        }
-    }
-}
diff --git a/src/cmds/renderer/status.rs b/src/cmds/renderer/status.rs
deleted file mode 100644
index 573e74e..0000000
--- a/src/cmds/renderer/status.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use cli_utils::{
-    display::{SimpleTable, md},
-    env::auto_update_outdate,
-};
-use render_system_macros::result_renderer;
-use rust_i18n::t;
-
-use crate::cmds::out::status::JVStatusWrongModifyReason;
-use crate::{
-    cmds::out::status::JVStatusOutput,
-    r_println,
-    systems::{cmd::errors::CmdRenderError, render::renderer::JVRenderResult},
-};
-
-enum Mode {
-    StructuralChangesMode,
-    ContentChangesMode,
-    Clean,
-}
-
-#[result_renderer(JVStatusRenderer)]
-pub async fn render(data: &JVStatusOutput) -> Result<JVRenderResult, CmdRenderError> {
-    let mut r = JVRenderResult::default();
-
-    // Render Header
-    render_header(&mut r, data);
-
-    // Render Info and Mode
-    render_info_and_mode(&mut r, data);
-
-    // Render Hint
-    render_hint(&mut r, data);
-
-    Ok(r)
-}
-
-fn render_header(r: &mut JVRenderResult, data: &JVStatusOutput) {
-    let account = &data.current_account;
-    let sheet = &data.current_sheet;
-    r_println!(
-        r,
-        "{}",
-        md(t!("status.header", account = account, sheet = sheet))
-    );
-}
-
-fn render_info_and_mode(r: &mut JVRenderResult, data: &JVStatusOutput) {
-    let mut info_erased = String::default();
-    let mut info_moved = String::default();
-    let mut info_lost = String::default();
-    let mut info_created = String::default();
-    let mut info_modified = String::default();
-
-    // Collect erased items
-    if !data.analyzed_result.erased.is_empty() {
-        info_erased.push_str(format!("{}\n", md(t!("status.info_display.erased.header"))).as_str());
-        for erased in data.analyzed_result.erased.iter() {
-            info_erased.push_str(
-                format!(
-                    "{}\n",
-                    md(t!(
-                        "status.info_display.erased.item",
-                        item = erased.display()
-                    ))
-                )
-                .as_str(),
-            );
-        }
-    }
-
-    // Collect moved items
-    if !data.analyzed_result.moved.is_empty() {
-        let mut table = SimpleTable::new(vec![
-            format!("{}", md(t!("status.info_display.moved.header"))),
-            "".to_string(),
-        ]);
-        for (_, (from, to)) in data.analyzed_result.moved.iter() {
-            table.push_item(vec![
-                format!(
-                    "{}",
-                    md(t!("status.info_display.moved.left", left = from.display()))
-                ),
-                format!(
-                    "{}",
-                    md(t!("status.info_display.moved.right", right = to.display()))
-                ),
-            ]);
-        }
-        info_moved.push_str(table.to_string().as_str());
-    }
-
-    // Collect lost items
-    if !data.analyzed_result.lost.is_empty() {
-        info_lost.push_str(format!("{}\n", md(t!("status.info_display.lost.header"))).as_str());
-        for lost in data.analyzed_result.lost.iter() {
-            info_lost.push_str(
-                format!(
-                    "{}\n",
-                    md(t!("status.info_display.lost.item", item = lost.display()))
-                )
-                .as_str(),
-            );
-        }
-    }
-
-    // Collect created items
-    if !data.analyzed_result.created.is_empty() {
-        info_created
-            .push_str(format!("{}\n", md(t!("status.info_display.created.header"))).as_str());
-        for created in data.analyzed_result.created.iter() {
-            info_created.push_str(
-                format!(
-                    "{}\n",
-                    md(t!(
-                        "status.info_display.created.item",
-                        item = created.display()
-                    ))
-                )
-                .as_str(),
-            );
-        }
-    }
-
-    // Collect modified items
-    if !data.analyzed_result.modified.is_empty() {
-        info_modified
-            .push_str(format!("{}\n", md(t!("status.info_display.modified.header"))).as_str());
-        for modified in data.analyzed_result.modified.iter() {
-            if let Some(reason) = data.wrong_modified_items.get(modified) {
-                let reason_str = match reason {
-                    JVStatusWrongModifyReason::BaseVersionMismatch {
-                        base_version,
-                        latest_version,
-                    } => md(t!(
-                        "status.info_display.modified.reason.base_version_mismatch",
-                        base_version = base_version,
-                        latest_version = latest_version
-                    )),
-                    JVStatusWrongModifyReason::ModifiedButNotHeld { holder } => md(t!(
-                        "status.info_display.modified.reason.modified_but_not_held",
-                        holder = holder
-                    )),
-                    JVStatusWrongModifyReason::NoHolder => {
-                        md(t!("status.info_display.modified.reason.no_holder"))
-                    }
-                };
-                info_modified.push_str(
-                    format!(
-                        "{}\n",
-                        md(t!(
-                            "status.info_display.modified.item_wrong",
-                            item = modified.display(),
-                            reason = reason_str
-                        ))
-                    )
-                    .as_str(),
-                );
-                continue;
-            }
-            info_modified.push_str(
-                format!(
-                    "{}\n",
-                    md(t!(
-                        "status.info_display.modified.item",
-                        item = modified.display()
-                    ))
-                )
-                .as_str(),
-            );
-        }
-    }
-
-    let structural_info = vec![info_erased, info_moved, info_lost].join("\n");
-    let content_info = vec![info_created, info_modified].join("\n");
-
-    let mode = get_mode(data);
-    match mode {
-        Mode::StructuralChangesMode => {
-            r_println!(
-                r,
-                "{}",
-                md(t!("status.current_mode.structural", info = structural_info))
-            );
-        }
-        Mode::ContentChangesMode => {
-            r_println!(
-                r,
-                "{}",
-                md(t!("status.current_mode.content", info = content_info))
-            );
-        }
-        Mode::Clean => r_println!(r, "{}", md(t!("status.current_mode.clean"))),
-    }
-}
-
-fn render_hint(r: &mut JVRenderResult, data: &JVStatusOutput) {
-    // Outdate Hint
-    let update_time = &data.update_time;
-    let now_time = &data.now_time;
-    let duration_minutes: i64 = (now_time
-        .duration_since(*update_time)
-        .unwrap_or_default()
-        .as_secs()
-        / 60) as i64;
-    let outdate_minutes = auto_update_outdate();
-
-    // Outdated
-    if duration_minutes > outdate_minutes {
-        let hours = duration_minutes / 60;
-        let minutes = duration_minutes % 60;
-        let seconds = (now_time
-            .duration_since(*update_time)
-            .unwrap_or_default()
-            .as_secs()
-            % 60) as i64;
-
-        r_println!(
-            r,
-            "{}",
-            md(t!(
-                "status.hints.outdate",
-                h = hours,
-                m = minutes,
-                s = seconds
-            ))
-        );
-    }
-
-    let in_ref_sheet = &data.in_ref_sheet;
-    let is_host_mode = &data.is_host_mode;
-
-    // Readonly
-    if *in_ref_sheet && !is_host_mode {
-        r_println!(r, "{}", md(t!("status.hints.readonly")));
-    }
-
-    // Host
-    if *is_host_mode {
-        r_println!(r, "{}", md(t!("status.hints.host")));
-    }
-}
-
-fn get_mode(data: &JVStatusOutput) -> Mode {
-    let analyzed = &data.analyzed_result;
-
-    // If there are any lost, moved, or erased items, use structural changes mode
-    if !analyzed.moved.is_empty() || !analyzed.lost.is_empty() || !analyzed.erased.is_empty() {
-        Mode::StructuralChangesMode
-    }
-    // Otherwise, if there are any created or modified items, use content changes mode
-    else if !analyzed.created.is_empty() || !analyzed.modified.is_empty() {
-        Mode::ContentChangesMode
-    }
-    // Otherwise, it's clean
-    else {
-        Mode::Clean
-    }
-}