Support --json output for status command (#11)

Author: AliSoftware

Cargo.lock

@@ -24,6 +24,8 @@ git2 = { version = "^0.20", features = ["vendored-openssl", "vendored-libgit2"]
 anyhow = "^1.0"
 indoc = "^2.0"
 const_format = "^0.2"
+serde = { version = "^1.0", features = ["derive"] }
+serde_json = "^1.0"
 
 [target.'cfg(windows)'.dependencies]
 windows-permissions = "0.2.4"

Cargo.toml

@@ -14,6 +14,7 @@ mod filter;
 mod fs_helpers;
 mod key;
 mod repo;
+mod status;
 
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
@@ -81,6 +82,9 @@ enum Commands {
         /// Files to check (if empty, shows repository status)
         #[arg(value_name = "FILE")]
         files: Vec<String>,
+        /// Output status in JSON format
+        #[arg(long)]
+        json: bool,
     },
     /// Key management commands
     #[command(about = "Manage encryption key")]
@@ -143,7 +147,7 @@ fn main() -> Result<()> {
         Commands::Init => cmd_init(),
         Commands::Unlock { key_source } => cmd_unlock(key_source),
         Commands::Lock { force } => cmd_lock(force),
-        Commands::Status { files } => cmd_status(files),
+        Commands::Status { files, json } => cmd_status(files, json),
         Commands::Key { key_cmd } => cmd_key(key_cmd),
         Commands::Filter { filter_cmd } => cmd_filter(filter_cmd),
     }
@@ -240,54 +244,58 @@ fn cmd_lock(force: bool) -> Result<()> {
     Ok(())
 }
 
-fn cmd_status(files: Vec<String>) -> Result<()> {
+fn cmd_status(files: Vec<String>, json: bool) -> Result<()> {
     let repo = repo::Repo::discover()?;
 
     if files.is_empty() {
         // Show repository status
-        println!("Repository: {}", repo.workdir().display());
-        let is_unlocked = repo.is_unlocked()?;
-        println!(
-            "Status: {}",
-            if is_unlocked { "unlocked" } else { "locked" }
-        );
-
+        let repo_status = if repo.is_unlocked()? {
+            status::LockStatus::Unlocked
+        } else {
+            status::LockStatus::Locked
+        };
         let filters_configured = repo.filters_configured()?;
-        println!(
-            "Filters configured: {}",
-            if filters_configured { "yes" } else { "no" }
-        );
-
-        println!("\nTracked files configured for encryption by Git filter:");
-        let mut has_files = false;
-        for file_result in repo.find_filtered_files()? {
-            let file = file_result?;
-            println!("  🔒 {}", file.display());
-            has_files = true;
-        }
-        if !has_files {
-            println!("  (none)");
-        }
-
-        // Only show warning if there are actually untracked files
-        if repo.has_untracked_files()? {
-            println!(
-                "\nNote: You have untracked files in your working copy. Even if some\n\
-                of those new files match the filter patterns in `.gitattributes`,\n\
-                they won't be listed here until you `git add` them to the staging area."
-            );
+        let has_untracked_files = repo.has_untracked_files()?;
+        let encrypted_files: Vec<_> = repo
+            .find_filtered_files()?
+            .collect::<Result<Vec<_>>>()
+            .context("Failed to get file path")?;
+
+        let status = status::RepositoryStatus {
+            repository: repo.workdir().to_string_lossy().into_owned(),
+            status: repo_status,
+            filters_configured,
+            encrypted_files,
+            has_untracked_files,
+        };
+
+        if json {
+            println!("{}", serde_json::to_string_pretty(&status)?);
+        } else {
+            print!("{}", status);
         }
     } else {
         // Check status for specific files
-        for file_str in &files {
-            let file_path = std::path::Path::new(file_str);
-            let is_filtered = repo.is_filtered_file(file_path)?;
-            let status = if is_filtered {
-                "🔒 Encrypted in the repository"
-            } else {
-                "👀 Not encrypted in the repository"
-            };
-            println!("{:20}: {}", file_str, status);
+        let file_statuses: Vec<status::FileStatus> = files
+            .iter()
+            .map(|file_str| {
+                let file_path = std::path::Path::new(file_str);
+                let is_filtered = repo.is_filtered_file(file_path)?;
+                Ok(status::FileStatus {
+                    file: file_path.to_path_buf(),
+                    encrypted: is_filtered,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        let status_list = status::FileStatusList {
+            files: file_statuses,
+        };
+
+        if json {
+            println!("{}", serde_json::to_string_pretty(&status_list)?);
+        } else {
+            print!("{}", status_list);
         }
     }
 

src/main.rs

@@ -0,0 +1,95 @@
+use serde::Serialize;
+use std::fmt;
+use std::path::PathBuf;
+
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum LockStatus {
+    Locked,
+    Unlocked,
+}
+
+impl fmt::Display for LockStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LockStatus::Locked => write!(f, "locked"),
+            LockStatus::Unlocked => write!(f, "unlocked"),
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct RepositoryStatus {
+    pub repository: String,
+    pub status: LockStatus,
+    pub filters_configured: bool,
+    pub encrypted_files: Vec<PathBuf>,
+    pub has_untracked_files: bool,
+}
+
+impl fmt::Display for RepositoryStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "Repository: {}", self.repository)?;
+        writeln!(f, "Status: {}", self.status)?;
+        writeln!(
+            f,
+            "Filters configured: {}",
+            if self.filters_configured { "yes" } else { "no" }
+        )?;
+
+        writeln!(
+            f,
+            "\nTracked files configured for encryption by Git filter:"
+        )?;
+        if self.encrypted_files.is_empty() {
+            writeln!(f, "  (none)")?;
+        } else {
+            for file in &self.encrypted_files {
+                writeln!(f, "  🔒 {}", file.to_string_lossy())?;
+            }
+        }
+
+        // Only show warning if there are actually untracked files
+        if self.has_untracked_files {
+            writeln!(
+                f,
+                "\nNote: You have untracked files in your working copy. Even if some\n\
+                of those new files match the filter patterns in `.gitattributes`,\n\
+                they won't be listed here until you `git add` them to the staging area."
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Serialize)]
+pub struct FileStatus {
+    pub file: PathBuf,
+    pub encrypted: bool,
+}
+
+impl fmt::Display for FileStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let status = if self.encrypted {
+            "🔒 Encrypted in the repository"
+        } else {
+            "👀 Not encrypted in the repository"
+        };
+        write!(f, "{:20}: {}", self.file.to_string_lossy(), status)
+    }
+}
+
+#[derive(Serialize)]
+pub struct FileStatusList {
+    pub files: Vec<FileStatus>,
+}
+
+impl fmt::Display for FileStatusList {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for file_status in &self.files {
+            writeln!(f, "{}", file_status)?;
+        }
+        Ok(())
+    }
+}