@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-core/src/quality/reconcile_anchors.rs

@@ -0,0 +1,64 @@
+pub(super) fn changed_paths_introduce_adapter(adapter: &str, changed_paths: &[String]) -> bool {
+    match adapter {
+        "rust" => changed_paths
+            .iter()
+            .any(|path| path.ends_with("Cargo.toml")),
+        "javascript-typescript" => changed_paths.iter().any(|path| {
+            path.ends_with("package.json")
+                || path.ends_with("tsconfig.json")
+                || path.ends_with("jsconfig.json")
+        }),
+        "swift" => changed_paths
+            .iter()
+            .any(|path| path.ends_with("Package.swift") || path.ends_with(".swift")),
+        "xcode" => changed_paths
+            .iter()
+            .any(|path| path.contains(".xcodeproj/") || path.contains(".xcworkspace/")),
+        "xctest" => changed_paths.iter().any(|path| {
+            let lower = path.to_ascii_lowercase();
+            lower.contains("/tests/")
+                && (lower.ends_with("tests.swift") || lower.ends_with("uitests.swift"))
+        }),
+        "swiftui" => changed_paths.iter().any(|path| {
+            path.ends_with("App.swift")
+                || path.ends_with("View.swift")
+                || path.contains("Preview Content/")
+        }),
+        "ios-app-structure" => changed_paths.iter().any(|path| {
+            path.ends_with("AppDelegate.swift")
+                || path.ends_with("SceneDelegate.swift")
+                || path.ends_with("Info.plist")
+                || path.contains(".xcassets/")
+                || path.ends_with(".entitlements")
+        }),
+        "swift-package" => changed_paths.iter().any(|path| {
+            path.ends_with("Package.swift")
+                || path.starts_with("Sources/")
+                || path.contains("/Sources/")
+                || path.starts_with("Tests/")
+                || path.contains("/Tests/")
+        }),
+        "ios-resources" => changed_paths.iter().any(|path| {
+            path.contains(".xcassets/")
+                || path.ends_with(".strings")
+                || path.ends_with(".stringsdict")
+                || path.ends_with(".plist")
+                || path.ends_with(".entitlements")
+                || path.ends_with(".storyboard")
+                || path.ends_with(".xib")
+        }),
+        "generated-ios" => changed_paths.iter().any(generated_ios_path),
+        _ => false,
+    }
+}
+
+fn generated_ios_path(path: &String) -> bool {
+    let lower = path.to_ascii_lowercase();
+    lower.contains("/generated/")
+        || lower.contains("/swiftgen/")
+        || lower.contains("/sourcery/")
+        || lower.ends_with("r.generated.swift")
+        || lower.ends_with(".generated.swift")
+        || lower.ends_with(".pb.swift")
+        || lower.ends_with(".grpc.swift")
+}

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

@@ -28,11 +28,7 @@ pub(super) fn analyze_repo_file(
         }
     }
     let content = fs::read_to_string(&full_path).ok()?;
-    let file = analyze_file(
-        path,
-        &content,
-        added_lines.get(path).copied().unwrap_or(0),
-    );
+    let file = analyze_file(path, &content, added_lines.get(path).copied().unwrap_or(0));
     let hash = if allow_cache {
         blob_hashes
             .get(path)
@@ -110,6 +106,8 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
         ("function", "def "),
         ("function", "fn "),
         ("function", "pub fn "),
+        ("function", "pub(crate) fn "),
+        ("function", "pub(super) fn "),
         ("function", "func "),
         ("class", "class "),
         ("struct", "struct "),
@@ -123,6 +121,17 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
             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.")
@@ -134,6 +143,12 @@ fn symbol_start(trimmed: &str) -> Option<(String, String)> {
     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 == '_')

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

@@ -93,12 +93,36 @@ pub fn scan_repository(
     config: RepositoryQualityConfig,
 ) -> Result<QualityContext, NaomeError> {
     let changed_paths = git::changed_paths(root)?;
+    scan_repository_with_targets(root, mode, config, changed_paths, true)
+}
+
+pub fn scan_repository_paths(
+    root: &Path,
+    config: RepositoryQualityConfig,
+    paths: &[String],
+) -> Result<QualityContext, NaomeError> {
+    let mut target_paths = paths
+        .iter()
+        .map(|path| normalize_target_path(path))
+        .collect::<Result<Vec<_>, _>>()?;
+    target_paths.sort();
+    target_paths.dedup();
+    scan_repository_with_targets(root, QualityMode::PathScoped, config, target_paths, false)
+}
+
+fn scan_repository_with_targets(
+    root: &Path,
+    mode: QualityMode,
+    config: RepositoryQualityConfig,
+    changed_paths: Vec<String>,
+    include_comparison_files: bool,
+) -> Result<QualityContext, NaomeError> {
     let target_paths = changed_paths.iter().cloned().collect::<HashSet<_>>();
     let mut whole_repo_paths = collect_repo_paths(root)?;
     whole_repo_paths.sort();
     whole_repo_paths.dedup();
     let scan_paths = match mode {
-        QualityMode::ChangedFast => changed_paths.clone(),
+        QualityMode::ChangedFast | QualityMode::PathScoped => changed_paths.clone(),
         QualityMode::Report | QualityMode::DeepReport => whole_repo_paths.clone(),
     };
     let added_lines = if mode.is_changed() {
@@ -121,18 +145,22 @@ pub fn scan_repository(
         &ignore_patterns,
         &mut state,
     );
-    let comparison_files = analyze_comparison_paths(
-        root,
-        mode,
-        &whole_repo_paths,
-        &target_paths,
-        &comparison_added_lines,
-        &blob_hashes,
-        &cache,
-        &ignore_patterns,
-        files.len(),
-        &mut state,
-    );
+    let comparison_files = if include_comparison_files {
+        analyze_comparison_paths(
+            root,
+            mode,
+            &whole_repo_paths,
+            &target_paths,
+            &comparison_added_lines,
+            &blob_hashes,
+            &cache,
+            &ignore_patterns,
+            files.len(),
+            &mut state,
+        )
+    } else {
+        Vec::new()
+    };
 
     files.sort_by(|left, right| left.path.cmp(&right.path));
     Ok(QualityContext {
@@ -150,6 +178,17 @@ pub fn scan_repository(
     })
 }
 
+fn normalize_target_path(path: &str) -> Result<String, NaomeError> {
+    let normalized = path.trim_start_matches("./").replace('\\', "/");
+    let has_parent_segment = normalized.split('/').any(|segment| segment == "..");
+    if normalized.is_empty() || normalized.starts_with('/') || has_parent_segment {
+        return Err(NaomeError::new(format!(
+            "quality path must be a repository-relative path: {path}"
+        )));
+    }
+    Ok(normalized)
+}
+
 #[derive(Default)]
 struct ScanState {
     cache_hits: usize,
@@ -196,9 +235,14 @@ fn analyze_primary_paths(
             state.truncate("max_file_bytes");
             continue;
         }
-        if let Some((file, cache_hit)) =
-            analyze_repo_file(root, path, added_lines, blob_hashes, cache, !mode.is_changed())
-        {
+        if let Some((file, cache_hit)) = analyze_repo_file(
+            root,
+            path,
+            added_lines,
+            blob_hashes,
+            cache,
+            !mode.is_changed(),
+        ) {
             state.record_cache_result(cache_hit);
             files.push(file);
         }
@@ -258,6 +302,7 @@ pub fn stable_fingerprint(parts: &[&str]) -> String {
 fn max_scanned_files(mode: QualityMode) -> usize {
     match mode {
         QualityMode::ChangedFast => 2_000,
+        QualityMode::PathScoped => 128,
         QualityMode::Report => 5_000,
         QualityMode::DeepReport => usize::MAX,
     }
@@ -265,7 +310,7 @@ fn max_scanned_files(mode: QualityMode) -> usize {
 
 fn max_file_bytes(mode: QualityMode) -> u64 {
     match mode {
-        QualityMode::ChangedFast => 512 * 1024,
+        QualityMode::ChangedFast | QualityMode::PathScoped => 512 * 1024,
         QualityMode::Report => 1024 * 1024,
         QualityMode::DeepReport => 8 * 1024 * 1024,
     }

package/crates/naome-core/src/quality/semantic/checks.rs

@@ -112,6 +112,9 @@ fn has_legacy_fixture_signal(keys: &BTreeSet<String>) -> bool {
 }
 
 fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
+    if is_shared_fixture_path(&candidate.path) {
+        return true;
+    }
     let Some(symbol) = &candidate.symbol else {
         return false;
     };
@@ -123,6 +126,20 @@ fn is_shared_fixture_factory(candidate: &ObjectCandidate) -> bool {
     .any(|marker| normalized.contains(marker))
 }
 
+fn is_shared_fixture_path(path: &str) -> bool {
+    let normalized = path.replace('\\', "/").to_ascii_lowercase();
+    [
+        "/fixtures/",
+        "/fixture/",
+        "/support/",
+        "_support/",
+        "-support/",
+        "/test-support.",
+    ]
+    .iter()
+    .any(|marker| normalized.contains(marker))
+}
+
 fn group_applies_to_mode(context: &QualityContext, group: &[&ObjectCandidate]) -> bool {
     if context.mode.is_deep() {
         return true;

package/crates/naome-core/src/quality/semantic/route.rs

@@ -4,7 +4,7 @@ use crate::quality::types::QualityMode;
 
 pub(super) fn finding_mode(context: &QualityContext) -> &'static str {
     match context.mode {
-        QualityMode::ChangedFast => "changed-blocking",
+        QualityMode::ChangedFast | QualityMode::PathScoped => "changed-blocking",
         QualityMode::Report => "report",
         QualityMode::DeepReport => "deep-report",
     }

package/crates/naome-core/src/quality/structure/adapter_ios.rs

@@ -0,0 +1,149 @@
+use crate::quality::adapter_support::{
+    detects_generated_ios_project, detects_ios_app_structure_project,
+    detects_ios_resources_project, detects_swift_package_project, detects_swift_project,
+    detects_swiftui_project, detects_xcode_project, detects_xctest_project,
+};
+
+use super::adapters::StructureAdapter;
+
+pub(super) fn adapters() -> Vec<StructureAdapter> {
+    let mut adapters = Vec::new();
+    adapters.extend_from_slice(IOS_CORE_STRUCTURE_ADAPTERS);
+    adapters.extend_from_slice(IOS_APP_STRUCTURE_ADAPTERS);
+    adapters
+}
+
+const IOS_CORE_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "swift",
+        detect: detects_swift_project,
+        source_roots: &[
+            "Sources/**",
+            "**/Sources/**",
+            "Source/**",
+            "App/**",
+            "Features/**",
+            "Modules/**",
+            "Shared/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &[
+            "Sources/*/**",
+            "**/Sources/*/**",
+            "App/**",
+            "Features/*/**",
+            "Modules/*/**",
+        ],
+        allowed_root_files: &[],
+    },
+    StructureAdapter {
+        id: "xcode",
+        detect: detects_xcode_project,
+        source_roots: &[],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[
+            "DerivedData/**",
+            "**/DerivedData/**",
+            "Build/**",
+            "**/Build/**",
+            "**/*.xcarchive/**",
+        ],
+        module_roots: &[],
+        allowed_root_files: &["*.xcodeproj", "*.xcworkspace"],
+    },
+    StructureAdapter {
+        id: "xctest",
+        detect: detects_xctest_project,
+        source_roots: &[],
+        test_roots: &[
+            "Tests/**",
+            "**/Tests/**",
+            "*Tests/**",
+            "**/*Tests/**",
+            "*UITests/**",
+            "**/*UITests/**",
+        ],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &[],
+        allowed_root_files: &[],
+    },
+];
+
+const IOS_APP_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "swiftui",
+        detect: detects_swiftui_project,
+        source_roots: &[
+            "Views/**",
+            "**/Views/**",
+            "Preview Content/**",
+            "**/Preview Content/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Views/*/**", "**/Views/*/**"],
+        allowed_root_files: &[],
+    },
+    StructureAdapter {
+        id: "ios-app-structure",
+        detect: detects_ios_app_structure_project,
+        source_roots: &[
+            "App/**",
+            "Application/**",
+            "Features/**",
+            "Modules/**",
+            "Shared/**",
+        ],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Features/*/**", "Modules/*/**", "App/**"],
+        allowed_root_files: &["Info.plist", "*.entitlements", "Podfile", "Cartfile"],
+    },
+    StructureAdapter {
+        id: "swift-package",
+        detect: detects_swift_package_project,
+        source_roots: &["Sources/**", "**/Sources/**"],
+        test_roots: &["Tests/**", "**/Tests/**"],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Sources/*/**", "**/Sources/*/**"],
+        allowed_root_files: &["Package.swift", "Package.resolved"],
+    },
+    StructureAdapter {
+        id: "ios-resources",
+        detect: detects_ios_resources_project,
+        source_roots: &["Resources/**", "**/Resources/**"],
+        test_roots: &[],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["Resources/**", "**/Resources/**"],
+        allowed_root_files: &["Info.plist", "*.entitlements"],
+    },
+    StructureAdapter {
+        id: "generated-ios",
+        detect: detects_generated_ios_project,
+        source_roots: &[],
+        test_roots: &[],
+        generated_roots: &[
+            "Generated/**",
+            "**/Generated/**",
+            "SwiftGen/**",
+            "**/SwiftGen/**",
+            "Sourcery/**",
+            "**/Sourcery/**",
+            "**/*.generated.swift",
+            "**/*.pb.swift",
+            "**/*.grpc.swift",
+            "**/R.generated.swift",
+        ],
+        artifact_roots: &[],
+        module_roots: &[],
+        allowed_root_files: &[],
+    },
+];

package/crates/naome-core/src/quality/structure/adapters.rs

@@ -5,17 +5,21 @@ use crate::quality::adapter_support::{
     find_adapter_by_id, validate_ids, AdapterDescriptor, RepoSignals,
 };
 
+use super::adapter_ios;
 use super::model::RepositoryStructureConfig;
 
 const CONFIG_PATH: &str = ".naome/repository-structure.json";
 
-struct StructureAdapter {
-    id: &'static str,
-    detect: fn(&RepoSignals<'_>) -> bool,
-    source_roots: &'static [&'static str],
-    test_roots: &'static [&'static str],
-    module_roots: &'static [&'static str],
-    allowed_root_files: &'static [&'static str],
+#[derive(Clone, Copy)]
+pub(super) struct StructureAdapter {
+    pub(super) id: &'static str,
+    pub(super) detect: fn(&RepoSignals<'_>) -> bool,
+    pub(super) source_roots: &'static [&'static str],
+    pub(super) test_roots: &'static [&'static str],
+    pub(super) generated_roots: &'static [&'static str],
+    pub(super) artifact_roots: &'static [&'static str],
+    pub(super) module_roots: &'static [&'static str],
+    pub(super) allowed_root_files: &'static [&'static str],
 }
 
 impl AdapterDescriptor for StructureAdapter {
@@ -29,17 +33,21 @@ impl AdapterDescriptor for StructureAdapter {
 }
 
 pub fn detected_structure_adapter_ids(paths: &[String]) -> Vec<String> {
-    detected_ids(paths, registry())
+    let registry = registry();
+    detected_ids(paths, &registry)
 }
 
 pub fn apply_structure_adapters(
     mut config: RepositoryStructureConfig,
 ) -> Result<RepositoryStructureConfig, NaomeError> {
-    validate_structure_adapter_ids(&config.enabled_adapters)?;
+    let registry = registry();
+    validate_ids(&config.enabled_adapters, &registry, CONFIG_PATH)?;
     for adapter_id in config.enabled_adapters.clone() {
-        let adapter = find_adapter_by_id(registry(), &adapter_id, CONFIG_PATH)?;
+        let adapter = find_adapter_by_id(&registry, &adapter_id, CONFIG_PATH)?;
         extend_unique(&mut config.source_roots, adapter.source_roots);
         extend_unique(&mut config.test_roots, adapter.test_roots);
+        extend_unique(&mut config.generated_roots, adapter.generated_roots);
+        extend_unique(&mut config.artifact_roots, adapter.artifact_roots);
         extend_unique(&mut config.module_roots, adapter.module_roots);
         extend_unique(&mut config.allowed_root_files, adapter.allowed_root_files);
     }
@@ -47,38 +55,48 @@ pub fn apply_structure_adapters(
 }
 
 pub fn validate_structure_adapter_ids(ids: &[String]) -> Result<(), NaomeError> {
-    validate_ids(ids, registry(), CONFIG_PATH)
+    let registry = registry();
+    validate_ids(ids, &registry, CONFIG_PATH)
 }
 
-fn registry() -> &'static [StructureAdapter] {
-    &[
-        StructureAdapter {
-            id: "rust",
-            detect: detects_rust_project,
-            source_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
-            test_roots: &["tests/**", "crates/*/tests/**", "**/crates/*/tests/**"],
-            module_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
-            allowed_root_files: &["Cargo.toml", "Cargo.lock"],
-        },
-        StructureAdapter {
-            id: "javascript-typescript",
-            detect: detects_javascript_typescript_project,
-            source_roots: &[
-                "src/**",
-                "app/**",
-                "pages/**",
-                "components/**",
-                "packages/*/src/**",
-                "**/packages/*/src/**",
-            ],
-            test_roots: &["test/**", "tests/**", "__tests__/**", "packages/*/tests/**"],
-            module_roots: &["src/**", "app/**", "packages/*/src/**"],
-            allowed_root_files: &[
-                "package.json",
-                "tsconfig.json",
-                "vite.config.ts",
-                "next.config.js",
-            ],
-        },
-    ]
+const BASE_STRUCTURE_ADAPTERS: &[StructureAdapter] = &[
+    StructureAdapter {
+        id: "rust",
+        detect: detects_rust_project,
+        source_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+        test_roots: &["tests/**", "crates/*/tests/**", "**/crates/*/tests/**"],
+        generated_roots: &[],
+        artifact_roots: &[],
+        module_roots: &["src/**", "crates/*/src/**", "**/crates/*/src/**"],
+        allowed_root_files: &["Cargo.toml", "Cargo.lock"],
+    },
+    StructureAdapter {
+        id: "javascript-typescript",
+        detect: detects_javascript_typescript_project,
+        source_roots: &[
+            "src/**",
+            "app/**",
+            "pages/**",
+            "components/**",
+            "packages/*/src/**",
+            "**/packages/*/src/**",
+        ],
+        test_roots: &["test/**", "tests/**", "__tests__/**", "packages/*/tests/**"],
+        generated_roots: &[],
+        artifact_roots: &["coverage/**", "**/coverage/**", ".next/**", "**/.next/**"],
+        module_roots: &["src/**", "app/**", "packages/*/src/**"],
+        allowed_root_files: &[
+            "package.json",
+            "tsconfig.json",
+            "vite.config.ts",
+            "next.config.js",
+        ],
+    },
+];
+
+fn registry() -> Vec<StructureAdapter> {
+    let mut adapters = Vec::new();
+    adapters.extend_from_slice(BASE_STRUCTURE_ADAPTERS);
+    adapters.extend(adapter_ios::adapters());
+    adapters
 }

package/crates/naome-core/src/quality/structure/checks/directory.rs

@@ -83,10 +83,12 @@ pub(super) fn case_collisions(
     mode: QualityMode,
     violations: &mut Vec<QualityViolation>,
 ) {
-    for group in model.lowercase_paths.values().filter(|group| group.len() > 1) {
-        let changed_group = group.iter().any(|path| {
-            model.changed_paths.contains(path)
-        });
+    for group in model
+        .lowercase_paths
+        .values()
+        .filter(|group| group.len() > 1)
+    {
+        let changed_group = group.iter().any(|path| model.changed_paths.contains(path));
         if mode.is_changed() && !changed_group {
             continue;
         }