@lamentis/naome 1.2.1 → 1.3.1

package/crates/naome-core/src/quality/scanner/analysis.rs

@@ -0,0 +1,175 @@
+mod normalize;
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::path::Path;
+
+use super::{FileAnalysis, NormalizedLine, SymbolAnalysis};
+use crate::quality::cache::{content_hash, QualityCache};
+use normalize::{normalize_line, token_set};
+
+pub(super) fn analyze_repo_file(
+    root: &Path,
+    path: &str,
+    added_lines: &HashMap<String, usize>,
+    blob_hashes: &HashMap<String, String>,
+    cache: &QualityCache,
+    allow_cache: bool,
+) -> Option<(FileAnalysis, bool)> {
+    let full_path = root.join(path);
+    if !full_path.is_file() || is_binary_extension(path) {
+        return None;
+    }
+    if allow_cache {
+        if let Some(blob_hash) = blob_hashes.get(path) {
+            if let Some(cached) = cache.read(path, blob_hash) {
+                return Some((cached, true));
+            }
+        }
+    }
+    let content = fs::read_to_string(&full_path).ok()?;
+    let file = analyze_file(path, &content, added_lines.get(path).copied().unwrap_or(0));
+    let hash = if allow_cache {
+        blob_hashes
+            .get(path)
+            .cloned()
+            .unwrap_or_else(|| content_hash(&content))
+    } else {
+        content_hash(&content)
+    };
+    let _ = cache.write(path, &hash, &file);
+    Some((file, false))
+}
+
+fn analyze_file(path: &str, content: &str, added_lines: usize) -> FileAnalysis {
+    let lines = content.lines().collect::<Vec<_>>();
+    let normalized_lines = lines
+        .iter()
+        .enumerate()
+        .filter_map(|(index, line)| normalize_line(line).map(|value| (index + 1, value)))
+        .map(|(line_number, value)| NormalizedLine { line_number, value })
+        .collect::<Vec<_>>();
+    let symbols = detect_symbols(&lines);
+    FileAnalysis {
+        path: path.to_string(),
+        line_count: lines.len(),
+        added_lines,
+        raw_lines: lines.iter().map(|line| (*line).to_string()).collect(),
+        normalized_lines,
+        symbols,
+    }
+}
+
+fn detect_symbols(lines: &[&str]) -> Vec<SymbolAnalysis> {
+    let mut starts = Vec::new();
+    for (index, line) in lines.iter().enumerate() {
+        let indent = indentation(line);
+        if let Some((kind, name)) = symbol_start(line.trim()) {
+            starts.push((index, indent, kind, name));
+        }
+    }
+
+    let mut symbols = Vec::new();
+    for (position, (start_index, indent, kind, name)) in starts.iter().enumerate() {
+        let end_index = starts
+            .iter()
+            .skip(position + 1)
+            .find(|(_, next_indent, _, _)| next_indent <= indent)
+            .map(|(next_index, _, _, _)| next_index.saturating_sub(1))
+            .unwrap_or_else(|| lines.len().saturating_sub(1));
+        let normalized_body = lines[*start_index..=end_index]
+            .iter()
+            .filter_map(|line| normalize_line(line))
+            .collect::<Vec<_>>();
+        let tokens = normalized_body
+            .iter()
+            .flat_map(|line| token_set(line))
+            .collect::<HashSet<_>>();
+        symbols.push(SymbolAnalysis {
+            kind: kind.clone(),
+            name: name.clone(),
+            start_line: start_index + 1,
+            end_line: end_index + 1,
+            indent: *indent,
+            tokens,
+        });
+    }
+    symbols
+}
+
+fn symbol_start(trimmed: &str) -> Option<(String, String)> {
+    let candidates = [
+        ("function", "function "),
+        ("function", "export function "),
+        ("function", "async function "),
+        ("function", "export async function "),
+        ("function", "def "),
+        ("function", "fn "),
+        ("function", "pub fn "),
+        ("function", "pub(crate) fn "),
+        ("function", "pub(super) fn "),
+        ("function", "func "),
+        ("class", "class "),
+        ("struct", "struct "),
+        ("struct", "pub struct "),
+        ("enum", "enum "),
+        ("enum", "pub enum "),
+        ("impl", "impl "),
+    ];
+    for (kind, prefix) in candidates {
+        if let Some(rest) = trimmed.strip_prefix(prefix) {
+            return Some((kind.to_string(), symbol_name(rest)));
+        }
+    }
+    for visibility in ["", "pub ", "pub(crate) ", "pub(super) "] {
+        for (kind, keyword) in [("const", "const "), ("static", "static ")] {
+            let prefix = format!("{visibility}{keyword}");
+            if let Some(rest) = trimmed.strip_prefix(&prefix) {
+                if !looks_like_typed_rust_item(rest) {
+                    continue;
+                }
+                return Some((kind.to_string(), symbol_name(rest)));
+            }
+        }
+    }
+    for prefix in ["const ", "let ", "export const ", "export let "] {
+        if let Some(rest) = trimmed.strip_prefix(prefix) {
+            if trimmed.contains("=>") || trimmed.contains("function") || trimmed.contains("React.")
+            {
+                return Some(("function".to_string(), symbol_name(rest)));
+            }
+        }
+    }
+    None
+}
+
+fn looks_like_typed_rust_item(rest: &str) -> bool {
+    rest.split('=').next().is_some_and(|before_assignment| {
+        before_assignment.contains(':') && !before_assignment.trim().is_empty()
+    })
+}
+
+fn symbol_name(rest: &str) -> String {
+    rest.chars()
+        .take_while(|character| character.is_ascii_alphanumeric() || *character == '_')
+        .collect::<String>()
+        .trim_matches('_')
+        .to_string()
+}
+
+fn indentation(line: &str) -> usize {
+    line.chars()
+        .take_while(|character| character.is_whitespace())
+        .map(|character| if character == '\t' { 2 } else { 1 })
+        .sum()
+}
+
+fn is_binary_extension(path: &str) -> bool {
+    let lower = path.to_ascii_lowercase();
+    [
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".wasm",
+        ".dylib", ".so", ".dll", ".exe", ".bin",
+    ]
+    .iter()
+    .any(|extension| lower.ends_with(extension))
+}

package/crates/naome-core/src/quality/scanner/repo_paths.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::Path;
 use std::process::Command;
@@ -36,7 +36,10 @@ pub(crate) fn collect_repo_paths(root: &Path) -> Result<Vec<String>, NaomeError>
     Ok(paths)
 }
 
-pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>, NaomeError> {
+pub(super) fn added_lines_by_path(
+    root: &Path,
+    target_paths: &HashSet<String>,
+) -> Result<HashMap<String, usize>, NaomeError> {
     let mut added = HashMap::new();
     for args in [
         vec!["diff", "--numstat"],
@@ -53,13 +56,20 @@ pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>,
             };
             let _deletions = parts.next();
             let Some(path) = parts.next() else { continue };
+            let path = path.replace('\\', "/");
+            if !target_paths.contains(&path) {
+                continue;
+            }
             let Ok(count) = additions.parse::<usize>() else {
                 continue;
             };
-            *added.entry(path.replace('\\', "/")).or_insert(0) += count;
+            *added.entry(path).or_insert(0) += count;
         }
     }
     for path in untracked_paths(root)? {
+        if !target_paths.contains(&path) {
+            continue;
+        }
         if let Ok(content) = fs::read_to_string(root.join(&path)) {
             added.insert(path, content.lines().count());
         }
@@ -67,6 +77,32 @@ pub(super) fn added_lines_by_path(root: &Path) -> Result<HashMap<String, usize>,
     Ok(added)
 }
 
+pub(super) fn tracked_blob_hashes(root: &Path) -> Result<HashMap<String, String>, NaomeError> {
+    let output = Command::new("git")
+        .args(["ls-files", "-s", "-z"])
+        .current_dir(root)
+        .output()?;
+    if !output.status.success() {
+        return Ok(HashMap::new());
+    }
+
+    let mut hashes = HashMap::new();
+    for entry in output.stdout.split(|byte| *byte == 0) {
+        if entry.is_empty() {
+            continue;
+        }
+        let entry = String::from_utf8_lossy(entry);
+        let Some((metadata, path)) = entry.split_once('\t') else {
+            continue;
+        };
+        let mut parts = metadata.split_whitespace();
+        let _mode = parts.next();
+        let Some(hash) = parts.next() else { continue };
+        hashes.insert(path.replace('\\', "/"), hash.to_string());
+    }
+    Ok(hashes)
+}
+
 fn collect_files_recursive(
     root: &Path,
     dir: &Path,