Improve CLI, use std::io::Lines

Author: kaleidawave

lines-of-code/Cargo.lock

@@ -20,3 +20,4 @@ test = "spectra check README.md 'target/debug/lines-of-code --rpc --interactive'
 
 [dependencies]
 glob = "0.3.3"
+json-builder-macro = "0.0.1"

lines-of-code/Cargo.toml

@@ -1,19 +1,22 @@
+use std::io::{BufRead, BufReader};
+
 #[derive(Default, Debug)]
 pub struct RustSection {
-    pub lines: usize,
+    pub package_name: String,
+    pub lines: u64,
     /// lines dedicated to tests.
     /// these can be within the `tests` folder or surrounded by `#[cfg(test)]`
-    pub test_lines: usize,
+    pub test_lines: u64,
     /// lines dedicated to examples
-    pub example_lines: usize,
-    enums: usize,
-    structs: usize,
-    type_aliases: usize,
-    fns: usize,
-    impls: usize,
-    variables: usize,
-    comments: usize,
-    pub modules: usize,
+    pub example_lines: u64,
+    enums: u64,
+    structs: u64,
+    type_aliases: u64,
+    fns: u64,
+    impls: u64,
+    variables: u64,
+    comments: u64,
+    pub modules: u64,
 }
 
 impl std::ops::AddAssign for RustSection {
@@ -30,6 +33,7 @@ impl std::ops::AddAssign for RustSection {
             lines,
             modules,
             type_aliases,
+            package_name: _,
         } = other;
         self.enums += enums;
         self.structs += structs;
@@ -45,14 +49,15 @@ impl std::ops::AddAssign for RustSection {
     }
 }
 
-pub fn measure(on: &str) -> RustSection {
+pub fn measure<R: std::io::Read>(on: BufReader<R>) -> RustSection {
     let mut is_test = false;
-    let mut test_indent: Option<&str> = None;
+    let mut test_indent: Option<String> = None;
     let mut code = RustSection::default();
     let mut is_multiline_comment = false;
 
     for line in on.lines() {
-        if let Some(indent) = test_indent {
+        let line = line.unwrap();
+        if let Some(ref indent) = test_indent {
             if let Some(rest) = line.strip_prefix(indent)
                 && rest == "}"
             {
@@ -78,7 +83,7 @@ pub fn measure(on: &str) -> RustSection {
         if std::mem::take(&mut is_test) {
             if line.trim_end().ends_with('{') {
                 let indent_count = line.len() - line.trim_start().len();
-                test_indent = Some(&line[..indent_count]);
+                test_indent = Some(line[..indent_count].to_owned());
             }
             continue;
         }
@@ -147,6 +152,7 @@ pub fn measure(on: &str) -> RustSection {
 impl RustSection {
     pub fn to_json(&self) -> String {
         let Self {
+            package_name,
             enums,
             structs,
             fns,
@@ -159,9 +165,28 @@ impl RustSection {
             example_lines,
             type_aliases,
         } = self;
-        format!(
-            r#"{{"modules":{modules},"lines":{lines},"variables":{variables},"type_aliases":{type_aliases},"example_lines":{example_lines},"comments":{comments},"enums":{enums},"structs":{structs},"fns":{fns},"impls":{impls},"test_lines":{test_lines}}}"#
-        )
+
+        let mut buf = String::new();
+        {
+            let mut builder = json_builder_macro::Builder::new(&mut buf);
+            if !package_name.is_empty() {
+                builder.add("name", package_name.as_str());
+            }
+
+            builder.add("modules", *modules);
+            builder.add("lines", *lines);
+            builder.add("variables", *variables);
+            builder.add("type_aliases", *type_aliases);
+            builder.add("comments", *comments);
+            builder.add("enums", *enums);
+            builder.add("structs", *structs);
+            builder.add("functions", *fns);
+            builder.add("implementations", *impls);
+            builder.add("test_lines", *test_lines);
+            builder.add("example_lines", *example_lines);
+            builder.end();
+        }
+        buf
     }
 
     pub fn debug(&self) {
@@ -177,6 +202,7 @@ impl RustSection {
             modules,
             type_aliases,
             example_lines,
+            package_name: _,
         } = self;
         if *lines > 0 {
             println!("lines: {lines}");

lines-of-code/lib.rs

@@ -1,36 +1,97 @@
 use lines_of_code::{RustSection, measure};
+use std::io::{BufRead, BufReader};
 
 fn main() {
-    let arg = std::env::args().nth(1);
-
-    if let Some("--interactive") = arg.as_deref() {
-        run_interactive()
-    } else {
-        let mut code = RustSection::default();
-
-        let pattern = arg.as_deref().unwrap_or("**/*.rs");
-
-        let files = glob::glob(pattern)
-            .unwrap()
-            .filter_map(Result::ok)
-            .filter(|path| path.is_file());
-
-        for path in files {
-            code.modules += 1;
-            let content = std::fs::read_to_string(&path).unwrap();
-            let file = measure(&content);
-
-            let path_str = path.as_os_str().to_str();
-            if path_str.is_some_and(|path| path.contains("examples")) {
-                code.example_lines += file.lines;
-            } else if path_str.is_some_and(|path| path.contains("tests")) {
-                code.test_lines += file.lines;
-            } else {
-                code += file;
-            }
+    let mut arguments = std::env::args().skip(1);
+
+    let first_argument = arguments.next();
+    let endpoint = first_argument.as_deref().unwrap_or("**/*.rs");
+
+    match endpoint {
+        // For testing
+        "--interactive" => run_interactive(),
+        "info" | "--help" => {
+            let run_id = option_env!("GITHUB_RUN_ID");
+            let date = option_env!("GIT_LAST_COMMIT").unwrap_or_default();
+            let after = run_id
+                .map(|commit| format!(" (commit {commit} {date})"))
+                .unwrap_or_default();
+
+            eprintln!("lines-of-code{after}");
+            eprintln!("count lines of code and other items in Rust projects");
         }
+        argument => {
+            let mut pattern = argument;
+
+            let mut count = RustSection::default();
+            let mut trace = false;
+
+            // WIP
+            for argument in arguments {
+                if let "--trace" = argument.as_str() {
+                    trace = true;
+                } else {
+                    eprintln!("unknown argument {argument:?}");
+                }
+            }
+
+            let p;
+            if let Ok(entry) = std::fs::metadata(pattern)
+                && entry.is_dir()
+            {
+                p = format!("{pattern}/**");
+                pattern = &p;
+            }
+
+            {
+                let path = pattern.split_once('*').unwrap_or((pattern, "")).0;
+                let path = path.rsplit_once(['\\', '/']).unwrap_or((path, "")).0;
+                let path = if path.ends_with("src") {
+                    &path[..path.len() - 4]
+                } else {
+                    path
+                };
 
-        println!("{json}", json = code.to_json());
+                if let Ok(cargo_toml) =
+                    std::fs::File::open(std::path::Path::new(path).join("Cargo.toml"))
+                {
+                    for line in BufReader::new(cargo_toml).lines().map_while(Result::ok) {
+                        if let Some(item) = line.strip_prefix("name") {
+                            let (_, item) = item.split_once('"').unwrap();
+                            let (item, _) = item.rsplit_once('"').unwrap();
+                            count.package_name = item.to_owned();
+                            break;
+                        }
+                    }
+                }
+            }
+
+            let files = glob::glob(pattern)
+                .unwrap()
+                .filter_map(Result::ok)
+                .filter(|path| path.is_file());
+
+            for path in files {
+                if trace {
+                    eprintln!("Reading {path:?}");
+                }
+                count.modules += 1;
+
+                let content = std::fs::File::open(&path).unwrap();
+                let inner_count = measure(BufReader::new(content));
+
+                let path_str = path.as_os_str().to_str();
+                if path_str.is_some_and(|path| path.contains("examples")) {
+                    count.example_lines += inner_count.lines;
+                } else if path_str.is_some_and(|path| path.contains("tests")) {
+                    count.test_lines += inner_count.lines;
+                } else {
+                    count += inner_count;
+                }
+            }
+
+            println!("{json}", json = count.to_json());
+        }
     }
 }
 
@@ -50,9 +111,7 @@ fn run_interactive() {
         }
 
         if line == "end" {
-            let output = String::from_utf8_lossy(&buf);
-
-            measure(&output).debug();
+            measure(BufReader::new(buf.as_slice())).debug();
 
             println!("end");
             buf.clear();

lines-of-code/main.rs

@@ -1,7 +1,7 @@
 #[test]
 fn main() -> std::process::ExitCode {
     let output = std::process::Command::new("spectra")
-        .arg("check")
+        .arg("test")
         .arg("README.md")
         .arg("./target/debug/lines-of-code --rpc --interactive")
         .status()