@lamentis/naome 1.3.12 → 1.3.14

package/crates/naome-core/src/architecture/scan/imports/resolver.rs

@@ -35,6 +35,11 @@ pub(super) fn resolve_import(
             return ImportTarget::File(path);
         }
     }
+    if from_path.ends_with(".swift") {
+        if let Some(path) = resolve_swift_module_import(from_path, specifier, repository_files) {
+            return ImportTarget::File(path);
+        }
+    }
     external_target(specifier)
 }
 
@@ -225,6 +230,40 @@ fn go_mod_module(root: &Path, go_mod_path: &str) -> Option<String> {
     })
 }
 
+fn resolve_swift_module_import(
+    from_path: &str,
+    specifier: &str,
+    repository_files: &BTreeSet<String>,
+) -> Option<String> {
+    if specifier.contains('/') || specifier.contains('.') {
+        return None;
+    }
+    let sources_root = swift_sources_root(from_path)?;
+    let target_prefix = format!("{sources_root}{specifier}/");
+    let conventional_file = format!("{target_prefix}{specifier}.swift");
+    if repository_files.contains(&conventional_file) {
+        return Some(conventional_file);
+    }
+    repository_files
+        .iter()
+        .find(|path| path.starts_with(&target_prefix) && path.ends_with(".swift"))
+        .cloned()
+}
+
+fn swift_sources_root(from_path: &str) -> Option<String> {
+    if from_path.starts_with("Sources/") {
+        return Some("Sources/".to_string());
+    }
+    if from_path.starts_with("Tests/") {
+        return Some("Sources/".to_string());
+    }
+    if let Some((prefix, _)) = from_path.split_once("/Sources/") {
+        return Some(format!("{prefix}/Sources/"));
+    }
+    let (prefix, _) = from_path.split_once("/Tests/")?;
+    Some(format!("{prefix}/Sources/"))
+}
+
 fn resolve_candidates(
     candidate: &str,
     repository_files: &BTreeSet<String>,
@@ -286,10 +325,11 @@ fn extensions_for_language(language: Option<&str>) -> &'static [&'static str] {
         Some("rust") => &["", ".rs"],
         Some("python") => &["", ".py"],
         Some("go") => &["", ".go"],
+        Some("swift") => &["", ".swift"],
         Some("typescript") => &["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
         Some("javascript") => &["", ".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
         _ => &[
-            "", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".py", ".go",
+            "", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".py", ".go", ".swift",
         ],
     }
 }

package/crates/naome-core/src/architecture/scan/imports.rs

@@ -70,6 +70,7 @@ pub(super) fn language_for_path(path: &str) -> Option<&'static str> {
         "rs" => Some("rust"),
         "py" => Some("python"),
         "go" => Some("go"),
+        "swift" => Some("swift"),
         _ => None,
     }
 }

package/crates/naome-core/src/architecture/scan/manifest/common.rs

@@ -0,0 +1,102 @@
+use std::path::Path;
+
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+pub(super) enum ManifestKind {
+    PackageJson,
+    CargoToml,
+    PyprojectToml,
+    GoMod,
+    PomXml,
+    BuildGradle,
+    PackageSwift,
+    XcodeProject,
+}
+
+pub(super) fn manifest_kind(path: &str) -> Option<ManifestKind> {
+    match path.rsplit('/').next()? {
+        "package.json" => Some(ManifestKind::PackageJson),
+        "Cargo.toml" => Some(ManifestKind::CargoToml),
+        "pyproject.toml" => Some(ManifestKind::PyprojectToml),
+        "go.mod" => Some(ManifestKind::GoMod),
+        "pom.xml" => Some(ManifestKind::PomXml),
+        "build.gradle" | "build.gradle.kts" => Some(ManifestKind::BuildGradle),
+        "Package.swift" => Some(ManifestKind::PackageSwift),
+        "project.pbxproj" => {
+            if path.contains(".xcodeproj/") {
+                Some(ManifestKind::XcodeProject)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+pub(super) fn fact(
+    path: &str,
+    ecosystem: &str,
+    package_name: String,
+    mut dependencies: Vec<ManifestDependency>,
+    confidence: f32,
+) -> ManifestFact {
+    dependencies.sort_by(|left, right| {
+        left.name
+            .cmp(&right.name)
+            .then(left.dependency_kind.cmp(&right.dependency_kind))
+    });
+    dependencies.dedup_by(|left, right| {
+        left.name == right.name && left.dependency_kind == right.dependency_kind
+    });
+    ManifestFact {
+        path: path.to_string(),
+        ecosystem: ecosystem.to_string(),
+        package_name,
+        dependencies,
+        confidence,
+        extractor: format!("manifest:{}", manifest_kind_label(path)),
+    }
+}
+
+pub(super) fn dependency(
+    name: impl Into<String>,
+    dependency_kind: impl Into<String>,
+    version: Option<String>,
+    confidence: f32,
+) -> ManifestDependency {
+    ManifestDependency {
+        name: name.into(),
+        dependency_kind: dependency_kind.into(),
+        version,
+        confidence,
+    }
+}
+
+pub(super) fn fallback_package_name(path: &str, ecosystem: &str) -> String {
+    let parent = Path::new(path)
+        .parent()
+        .map(|path| path.to_string_lossy().replace('\\', "/"))
+        .filter(|path| !path.is_empty())
+        .unwrap_or_else(|| path.to_string());
+    format!("{ecosystem}:{parent}")
+}
+
+pub(super) fn quoted_value(value: &str) -> Option<String> {
+    let trimmed = value.trim();
+    trimmed
+        .strip_prefix('"')
+        .and_then(|value| value.split_once('"').map(|(value, _)| value.to_string()))
+        .or_else(|| {
+            trimmed
+                .strip_prefix('\'')
+                .and_then(|value| value.split_once('\'').map(|(value, _)| value.to_string()))
+        })
+}
+
+pub(super) fn clean_toml_line(line: &str) -> &str {
+    line.split('#').next().unwrap_or_default().trim()
+}
+
+fn manifest_kind_label(path: &str) -> &str {
+    path.rsplit('/').next().unwrap_or(path)
+}

package/crates/naome-core/src/architecture/scan/manifest/parsers/json.rs

@@ -0,0 +1,46 @@
+use serde_json::Value;
+
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{dependency, fact, fallback_package_name};
+
+pub(in crate::architecture::scan::manifest) fn package_json(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let value = serde_json::from_str::<Value>(content).ok()?;
+    let package_name = value
+        .get("name")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+        .unwrap_or_else(|| fallback_package_name(path, "npm"));
+    let mut dependencies = Vec::new();
+    push_dependency_object(&mut dependencies, &value, "dependencies", "runtime");
+    push_dependency_object(&mut dependencies, &value, "devDependencies", "development");
+    push_dependency_object(&mut dependencies, &value, "peerDependencies", "peer");
+    push_dependency_object(
+        &mut dependencies,
+        &value,
+        "optionalDependencies",
+        "optional",
+    );
+    Some(fact(path, "npm", package_name, dependencies, 0.98))
+}
+
+fn push_dependency_object(
+    dependencies: &mut Vec<ManifestDependency>,
+    value: &Value,
+    field: &str,
+    kind: &str,
+) {
+    if let Some(object) = value.get(field).and_then(Value::as_object) {
+        dependencies.extend(object.iter().map(|(name, version)| {
+            dependency(
+                name.clone(),
+                kind,
+                version.as_str().map(str::to_string),
+                0.98,
+            )
+        }));
+    }
+}

package/crates/naome-core/src/architecture/scan/manifest/parsers/other.rs

@@ -0,0 +1,280 @@
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{dependency, fact, fallback_package_name, quoted_value};
+
+pub(in crate::architecture::scan::manifest) fn go_mod(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = content
+        .lines()
+        .find_map(|line| line.trim().strip_prefix("module "))
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| fallback_package_name(path, "go"));
+    let mut dependencies = Vec::new();
+    let mut in_require_block = false;
+    for raw_line in content.lines() {
+        let line = raw_line.split("//").next().unwrap_or_default().trim();
+        if line == "require (" {
+            in_require_block = true;
+            continue;
+        }
+        if in_require_block && line == ")" {
+            in_require_block = false;
+            continue;
+        }
+        let require_line = line.strip_prefix("require ").unwrap_or(line);
+        if !in_require_block && !line.starts_with("require ") {
+            continue;
+        }
+        if let Some((name, version)) = first_two_fields(require_line) {
+            dependencies.push(dependency(name, "runtime", version, 0.95));
+        }
+    }
+    Some(fact(path, "go", package_name, dependencies, 0.95))
+}
+
+pub(in crate::architecture::scan::manifest) fn pom_xml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let project_content = xml_without_parent_blocks(content);
+    let package_group = first_xml_tag(&project_content, "groupId")
+        .or_else(|| first_xml_tag(content, "groupId"))
+        .unwrap_or_else(|| "maven".to_string());
+    let package_artifact = first_xml_tag(&project_content, "artifactId")
+        .unwrap_or_else(|| fallback_package_name(path, "maven"));
+    let package_name = format!("{package_group}:{package_artifact}");
+    let dependency_content = xml_without_blocks(
+        &xml_without_blocks(content, "dependencyManagement"),
+        "build",
+    );
+    let dependencies = project_dependency_sections(&dependency_content)
+        .into_iter()
+        .flat_map(|section| section.split("<dependency>").skip(1).collect::<Vec<_>>())
+        .filter_map(|block| {
+            let group = first_xml_tag(block, "groupId")?;
+            let artifact = first_xml_tag(block, "artifactId")?;
+            Some(dependency(
+                format!("{group}:{artifact}"),
+                first_xml_tag(block, "scope").unwrap_or_else(|| "runtime".into()),
+                first_xml_tag(block, "version"),
+                0.75,
+            ))
+        })
+        .collect();
+    Some(fact(path, "maven", package_name, dependencies, 0.75))
+}
+
+pub(in crate::architecture::scan::manifest) fn build_gradle(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = fallback_package_name(path, "gradle");
+    let dependencies = content.lines().filter_map(gradle_dependency).collect();
+    Some(fact(path, "gradle", package_name, dependencies, 0.7))
+}
+
+pub(in crate::architecture::scan::manifest) fn package_swift(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let active_content = swift_active_content(content);
+    let package_name = swift_argument_value(&active_content, "name")
+        .unwrap_or_else(|| fallback_package_name(path, "swift"));
+    let dependencies = active_content
+        .split(".package")
+        .skip(1)
+        .filter_map(|block| {
+            let url = swift_argument_value(block, "url")?;
+            Some(dependency(
+                package_name_from_url(&url),
+                "runtime",
+                swift_package_version(block),
+                0.8,
+            ))
+        })
+        .collect();
+    Some(fact(path, "swift", package_name, dependencies, 0.8))
+}
+
+pub(in crate::architecture::scan::manifest) fn xcode_project(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = fallback_package_name(path, "xcode");
+    let dependencies = content
+        .lines()
+        .filter_map(|line| {
+            let url = line
+                .trim()
+                .strip_prefix("repositoryURL = ")
+                .and_then(quoted_value)?;
+            Some(dependency(
+                package_name_from_url(&url),
+                "runtime",
+                None,
+                0.65,
+            ))
+        })
+        .collect();
+    Some(fact(path, "xcode", package_name, dependencies, 0.65))
+}
+
+fn first_two_fields(line: &str) -> Option<(String, Option<String>)> {
+    let mut parts = line.split_whitespace();
+    Some((parts.next()?.to_string(), parts.next().map(str::to_string)))
+}
+
+fn first_xml_tag(content: &str, tag: &str) -> Option<String> {
+    let open = format!("<{tag}>");
+    let close = format!("</{tag}>");
+    content
+        .split_once(&open)?
+        .1
+        .split_once(&close)
+        .map(|(value, _)| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn xml_without_parent_blocks(content: &str) -> String {
+    xml_without_blocks(content, "parent")
+}
+
+fn xml_without_blocks(content: &str, tag: &str) -> String {
+    let open = format!("<{tag}>");
+    let close = format!("</{tag}>");
+    let mut remaining = content;
+    let mut output = String::new();
+    while let Some((before, after_open)) = remaining.split_once(&open) {
+        output.push_str(before);
+        let Some((_, after_close)) = after_open.split_once(&close) else {
+            output.push_str(after_open);
+            return output;
+        };
+        remaining = after_close;
+    }
+    output.push_str(remaining);
+    output
+}
+
+fn project_dependency_sections(content: &str) -> Vec<&str> {
+    content
+        .split("<dependencies>")
+        .skip(1)
+        .filter_map(|block| block.split_once("</dependencies>").map(|(block, _)| block))
+        .collect()
+}
+
+fn gradle_dependency(line: &str) -> Option<ManifestDependency> {
+    let trimmed = line.split("//").next().unwrap_or_default().trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    let kind = [
+        "implementation",
+        "api",
+        "compileOnly",
+        "runtimeOnly",
+        "testImplementation",
+    ]
+    .into_iter()
+    .find(|kind| trimmed.contains(&format!("{kind} ")) || trimmed.contains(&format!("{kind}(")))?;
+    let coordinate_text = trimmed
+        .split_once(&format!("{kind} "))
+        .map(|(_, value)| value.trim())
+        .or_else(|| {
+            trimmed
+                .split_once(&format!("{kind}("))
+                .map(|(_, value)| value.trim_end_matches(')').trim())
+        })?;
+    if let Some(coordinate) = quoted_value(coordinate_text) {
+        return gradle_coordinate_dependency(&coordinate, kind);
+    }
+    let group = gradle_map_value(coordinate_text, "group")?;
+    let artifact = gradle_map_value(coordinate_text, "name")?;
+    Some(dependency(
+        format!("{group}:{artifact}"),
+        kind,
+        gradle_map_value(coordinate_text, "version"),
+        0.7,
+    ))
+}
+
+fn gradle_coordinate_dependency(coordinate: &str, kind: &str) -> Option<ManifestDependency> {
+    let mut parts = coordinate.split(':');
+    let group = parts.next()?;
+    let artifact = parts.next()?;
+    Some(dependency(
+        format!("{group}:{artifact}"),
+        kind,
+        parts.next().map(str::to_string),
+        0.7,
+    ))
+}
+
+fn gradle_map_value(text: &str, key: &str) -> Option<String> {
+    text.split(',').find_map(|part| {
+        let (name, value) = part.trim().split_once(':')?;
+        if name.trim() == key {
+            quoted_value(value.trim())
+        } else {
+            None
+        }
+    })
+}
+
+fn swift_argument_value(content: &str, key: &str) -> Option<String> {
+    let marker = format!("{key}:");
+    let (_, value) = content.split_once(&marker)?;
+    quoted_value(value.trim())
+}
+
+fn swift_active_content(content: &str) -> String {
+    content
+        .lines()
+        .map(strip_swift_line_comment)
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn strip_swift_line_comment(line: &str) -> &str {
+    let mut in_quote = false;
+    let mut escaped = false;
+    let mut previous = '\0';
+    for (index, character) in line.char_indices() {
+        if in_quote {
+            if character == '"' && !escaped {
+                in_quote = false;
+            }
+            escaped = character == '\\' && !escaped;
+        } else if character == '"' {
+            in_quote = true;
+            escaped = false;
+        } else if previous == '/' && character == '/' {
+            return &line[..index - 1];
+        }
+        if character != '\\' {
+            escaped = false;
+        }
+        previous = character;
+    }
+    line
+}
+
+fn swift_package_version(block: &str) -> Option<String> {
+    swift_argument_value(block, "from")
+        .or_else(|| swift_argument_value(block, "exact"))
+        .or_else(|| swift_argument_value(block, "branch"))
+}
+
+fn package_name_from_url(url: &str) -> String {
+    url.trim_end_matches(".git")
+        .trim_end_matches('/')
+        .rsplit('/')
+        .next()
+        .unwrap_or(url)
+        .to_string()
+}

package/crates/naome-core/src/architecture/scan/manifest/parsers/toml.rs

@@ -0,0 +1,184 @@
+use crate::architecture::scan::{ManifestDependency, ManifestFact};
+
+use super::super::common::{
+    clean_toml_line, dependency, fact, fallback_package_name, quoted_value,
+};
+
+pub(in crate::architecture::scan::manifest) fn cargo_toml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = toml_string(content, "package", "name")
+        .unwrap_or_else(|| fallback_package_name(path, "cargo"));
+    let dependencies = toml_dependency_sections(
+        content,
+        &[
+            ("dependencies", "runtime"),
+            ("dev-dependencies", "development"),
+            ("build-dependencies", "build"),
+        ],
+    );
+    Some(fact(path, "cargo", package_name, dependencies, 0.9))
+}
+
+pub(in crate::architecture::scan::manifest) fn pyproject_toml(
+    path: &str,
+    content: &str,
+) -> Option<ManifestFact> {
+    let package_name = toml_string(content, "project", "name")
+        .unwrap_or_else(|| fallback_package_name(path, "python"));
+    let mut dependencies = toml_string_array(content, "project", "dependencies")
+        .into_iter()
+        .map(|value| dependency(python_dependency_name(&value), "runtime", Some(value), 0.85))
+        .collect::<Vec<_>>();
+    dependencies.extend(
+        toml_dependency_sections(content, &[("tool.poetry.dependencies", "runtime")])
+            .into_iter()
+            .filter(|dependency| dependency.name != "python"),
+    );
+    Some(fact(path, "python", package_name, dependencies, 0.85))
+}
+
+fn toml_string(content: &str, section: &str, key: &str) -> Option<String> {
+    section_value(content, section, key).and_then(quoted_value)
+}
+
+fn toml_string_array(content: &str, section: &str, key: &str) -> Vec<String> {
+    let mut current_section = "";
+    let mut collecting = false;
+    let mut array = String::new();
+    for line in content.lines().map(clean_toml_line) {
+        if !collecting {
+            if let Some(section_name) = line
+                .strip_prefix('[')
+                .and_then(|line| line.strip_suffix(']'))
+            {
+                current_section = section_name.trim();
+                continue;
+            }
+            if current_section != section {
+                continue;
+            }
+            let Some(value) = line
+                .strip_prefix(key)
+                .and_then(|line| line.trim().strip_prefix('='))
+            else {
+                continue;
+            };
+            array.push_str(value.trim());
+            if value.contains(']') {
+                break;
+            }
+            collecting = value.trim_start().starts_with('[');
+            continue;
+        }
+        array.push(' ');
+        array.push_str(line);
+        if line.contains(']') {
+            break;
+        }
+    }
+    array
+        .trim()
+        .trim_start_matches('[')
+        .trim_end_matches(']')
+        .split(',')
+        .filter_map(quoted_value)
+        .collect()
+}
+
+fn section_value<'a>(content: &'a str, section: &str, key: &str) -> Option<&'a str> {
+    let mut current_section = "";
+    for line in content.lines().map(clean_toml_line) {
+        if let Some(section_name) = line
+            .strip_prefix('[')
+            .and_then(|line| line.strip_suffix(']'))
+        {
+            current_section = section_name.trim();
+            continue;
+        }
+        if current_section == section {
+            if let Some(value) = line
+                .strip_prefix(key)
+                .and_then(|line| line.trim().strip_prefix('='))
+            {
+                return Some(value.trim());
+            }
+        }
+    }
+    None
+}
+
+fn toml_dependency_sections(content: &str, sections: &[(&str, &str)]) -> Vec<ManifestDependency> {
+    let mut current_kind = None;
+    let mut table_dependency = None;
+    let mut dependencies = Vec::new();
+    for line in content.lines().map(clean_toml_line) {
+        if let Some(section_name) = line
+            .strip_prefix('[')
+            .and_then(|line| line.strip_suffix(']'))
+        {
+            push_table_dependency(&mut dependencies, table_dependency.take());
+            let section_name = section_name.trim();
+            current_kind = sections
+                .iter()
+                .find(|(section, _)| *section == section_name)
+                .map(|(_, kind)| *kind);
+            if current_kind.is_none() {
+                table_dependency = dependency_table(section_name, sections);
+            }
+            continue;
+        }
+        if let Some((name, kind, version)) = table_dependency.as_mut() {
+            if let Some((key, value)) = line.split_once('=') {
+                if key.trim() == "version" {
+                    *version = quoted_value(value.trim());
+                }
+            }
+            if !name.is_empty() && !kind.is_empty() {
+                continue;
+            }
+        }
+        if let (Some(kind), Some((name, value))) = (current_kind, line.split_once('=')) {
+            dependencies.push(dependency(
+                name.trim().to_string(),
+                kind,
+                quoted_value(value.trim()),
+                0.85,
+            ));
+        }
+    }
+    push_table_dependency(&mut dependencies, table_dependency);
+    dependencies
+}
+
+fn dependency_table<'a>(
+    section_name: &str,
+    sections: &[(&str, &'a str)],
+) -> Option<(String, &'a str, Option<String>)> {
+    sections.iter().find_map(|(section, kind)| {
+        let dependency_name = section_name.strip_prefix(&format!("{section}."))?;
+        if dependency_name.is_empty() || dependency_name.contains('.') {
+            return None;
+        }
+        Some((dependency_name.to_string(), *kind, None))
+    })
+}
+
+fn push_table_dependency(
+    dependencies: &mut Vec<ManifestDependency>,
+    table_dependency: Option<(String, &str, Option<String>)>,
+) {
+    if let Some((name, kind, version)) = table_dependency {
+        dependencies.push(dependency(name, kind, version, 0.85));
+    }
+}
+
+fn python_dependency_name(value: &str) -> String {
+    value
+        .split(['<', '>', '=', '!', '~', '[', ';', ' '])
+        .next()
+        .unwrap_or(value)
+        .trim()
+        .to_string()
+}

package/crates/naome-core/src/architecture/scan/manifest/parsers.rs

@@ -0,0 +1,3 @@
+pub(super) mod json;
+pub(super) mod other;
+pub(super) mod toml;