code-gauge 4.3.1 → 4.5.0

package/native/src/languages.rs

@@ -7,6 +7,10 @@ pub struct LanguageDefinition {
     grammar_id: GrammarId,
     pub function_node_types: &'static [&'static str],
     pub decision_node_types: &'static [&'static str],
+    /// Whether every file's top-level code runs as a module body (a component of its own in the
+    /// file's cyclomatic complexity); C# and Kotlin decide per file by the presence of top-level
+    /// statements (never for a Kotlin file with parse errors).
+    pub executes_top_level: bool,
     pub nesting_node_types: &'static [&'static str],
     pub ncss_node_types: &'static [&'static str],
     pub ncss_container_node_types: &'static [&'static str],
@@ -656,6 +660,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -666,6 +671,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -676,6 +682,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::TypeScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -686,6 +693,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Tsx,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -696,6 +704,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Python,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: PYTHON_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -706,6 +715,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Go,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: GO_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: GO_NESTING_NODES,
         ncss_node_types: GO_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -716,6 +726,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Rust,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: RUST_NCSS_NODES,
         ncss_container_node_types: RUST_NCSS_CONTAINERS,
@@ -726,6 +737,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Java,
         function_node_types: JAVA_FUNCTION_NODES,
         decision_node_types: JAVA_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: JAVA_DECISION_NODES,
         ncss_node_types: JAVA_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -736,6 +748,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Ruby,
         function_node_types: RUBY_FUNCTION_NODES,
         decision_node_types: RUBY_DECISION_NODES,
+        executes_top_level: true,
         nesting_node_types: RUBY_DECISION_NODES,
         ncss_node_types: RUBY_NCSS_NODES,
         ncss_container_node_types: RUBY_NCSS_CONTAINERS,
@@ -746,6 +759,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::C,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: C_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: C_DECISION_NODES,
         ncss_node_types: C_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -756,6 +770,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Cpp,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: CPP_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: CPP_DECISION_NODES,
         ncss_node_types: CPP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -766,6 +781,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::CSharp,
         function_node_types: CSHARP_FUNCTION_NODES,
         decision_node_types: CSHARP_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: CSHARP_DECISION_NODES,
         ncss_node_types: CSHARP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -776,6 +792,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Kotlin,
         function_node_types: KOTLIN_FUNCTION_NODES,
         decision_node_types: KOTLIN_DECISION_NODES,
+        executes_top_level: false,
         nesting_node_types: KOTLIN_DECISION_NODES,
         ncss_node_types: KOTLIN_NCSS_NODES,
         ncss_container_node_types: KOTLIN_NCSS_CONTAINERS,

package/native/src/lib.rs

@@ -21,10 +21,12 @@ mod util;
 /// together with `expectedPayloadVersion` in src/nativeMetrics.ts.
 #[napi]
 pub fn payload_version() -> u32 {
-    5
+    7
 }
 
-/// Measures code metrics for the given source, returning the NativeMetrics payload as JSON.
+/// Measures code metrics for the given source, returning the NativeMetrics payload as JSON; with
+/// `include_cross_file_data`, the payload also carries the file's cross-file clone-detection
+/// contribution from the same parse.
 /// The TypeScript wrapper derives the remaining float metrics (Halstead volume/effort/...): they
 /// involve transcendental functions whose last-bit results can differ between V8 and Rust's libm,
 /// and results must not depend on which side computes them.
@@ -36,6 +38,7 @@ pub fn measure_code_native(
     min_tokens: Option<u32>,
     max_gap_tokens: Option<u32>,
     min_similarity_percent: Option<u32>,
+    include_cross_file_data: Option<bool>,
 ) -> Result<String> {
     let definition = find_language(&language)?;
     let settings = to_duplication_settings(min_tokens, max_gap_tokens, min_similarity_percent);
@@ -43,6 +46,7 @@ pub fn measure_code_native(
         &code,
         definition,
         include_syntax_tree.unwrap_or(false),
+        include_cross_file_data.unwrap_or(false),
         &settings,
     )
     .map_err(Error::from_reason)?;

package/native/src/measure.rs

@@ -7,7 +7,8 @@ use crate::complexity::{
 };
 use crate::dep_degree::measure_dep_degree;
 use crate::duplication::{
-    collect_cross_file_file_data, hash_text, measure_duplication, DuplicationSettings,
+    collect_cross_file_file_data, hash_text, measure_duplication, tokenize, DuplicationSettings,
+    TokenizedSource,
 };
 use crate::functions::{
     collect_nodes, count_parameters, find_function_name, is_implemented_function,
@@ -25,6 +26,7 @@ pub fn measure(
     code: &str,
     language: &LanguageDefinition,
     include_syntax_tree: bool,
+    include_cross_file_data: bool,
     duplication_settings: &DuplicationSettings,
 ) -> Result<NativeMetrics, String> {
     let source = Source::new(code);
@@ -38,11 +40,12 @@ pub fn measure(
         .filter(|node| !is_lambda_body_block(*node) && is_implemented_function(*node))
         .collect();
 
-    let body_metrics_by_node_id = measure_function_body_metrics(root, &sets, code);
+    let body_metrics = measure_function_body_metrics(root, &sets, code);
     let function_metrics: Vec<FunctionMetrics> = functions
         .iter()
         .map(|node| {
-            let body_metrics = body_metrics_by_node_id
+            let body_metrics = body_metrics
+                .by_function
                 .get(&node.id())
                 .expect("every collected function node opens a frame in the body-metrics pass");
             FunctionMetrics {
@@ -71,11 +74,22 @@ pub fn measure(
     let global_complexity = measure_complexity(root, &sets, code);
     let (lines, code_line_numbers) = classify_lines(code, root);
     let halstead_counts = measure_halstead(root, code);
+    let tokenized = tokenize(root, code);
 
     Ok(NativeMetrics {
         language: language.name.to_string(),
         bytes: code.code.len(),
         lines,
+        // McCabe's v = e - n + 2p over the file's components: every function, every initializer
+        // block, and the module body when the file runs top-level code; decisions outside functions
+        // belong to the file.
+        cyclomatic_complexity: function_metrics
+            .iter()
+            .map(|function| function.cyclomatic_complexity)
+            .sum::<u64>()
+            + body_metrics.top_level_decisions
+            + u64::from(language.executes_top_level || has_top_level_statements(root, language))
+            + count_initializer_blocks(root),
         cognitive_complexity: global_complexity.cognitive_complexity,
         max_cognitive_complexity: function_metrics
             .iter()
@@ -84,7 +98,14 @@ pub fn measure(
             .unwrap_or(0),
         nesting_depth: global_complexity.nesting_depth,
         ncss_count: crate::ncss::count_ncss(root, &sets.ncss_nodes, &sets.ncss_containers),
-        duplication: measure_duplication(root, &code_line_numbers, code, duplication_settings),
+        duplication: measure_duplication(&tokenized, &code_line_numbers, duplication_settings),
+        cross_file_data: include_cross_file_data.then(|| {
+            to_cross_file_data(
+                &tokenized,
+                &code_line_numbers,
+                duplication_settings.min_tokens,
+            )
+        }),
         halstead_counts,
         functions: function_metrics,
         syntax_tree: if include_syntax_tree {
@@ -95,6 +116,76 @@ pub fn measure(
     })
 }
 
+/// Initializer blocks run code of their own, so each is a component like a function: Java static
+/// and instance initializers, Kotlin `init` blocks, and JavaScript/TypeScript class `static`
+/// blocks. Their decisions already count as decisions outside functions.
+fn count_initializer_blocks(root: Node<'_>) -> u64 {
+    let initializer_types: HashSet<&'static str> = [
+        "static_initializer",
+        "anonymous_initializer",
+        "class_static_block",
+        "block",
+    ]
+    .into_iter()
+    .collect();
+    collect_nodes(root, &initializer_types)
+        .into_iter()
+        .filter(|node| {
+            // A bare block is an initializer only as a direct member of a Java class or enum body.
+            node.kind() != "block"
+                || node.parent().is_some_and(|parent| {
+                    matches!(parent.kind(), "class_body" | "enum_body_declarations")
+                })
+        })
+        .count() as u64
+}
+
+/// A C# top-level statement: a `global_statement`, or a statement inside a top-level `#if` block,
+/// which the grammar does not wrap in `global_statement`; preprocessor blocks are transparent.
+fn is_csharp_top_level_statement(node: Node<'_>) -> bool {
+    if node.kind().starts_with("preproc_") {
+        return named_children(node)
+            .into_iter()
+            .any(is_csharp_top_level_statement);
+    }
+    node.kind() == "global_statement"
+        || node.kind() == "block"
+        || node.kind().ends_with("_statement")
+}
+
+/// Whether a C# or Kotlin file runs top-level code: C# top-level statements, or a Kotlin script's
+/// statements beside its declarations.
+fn has_top_level_statements(root: Node<'_>, language: &LanguageDefinition) -> bool {
+    const KOTLIN_DECLARATIONS: &[&str] = &[
+        "package_header",
+        "import_list",
+        "class_declaration",
+        "object_declaration",
+        "function_declaration",
+        "property_declaration",
+        "type_alias",
+        "shebang_line",
+        "file_annotation",
+        "getter",
+        "setter",
+    ];
+    let children = named_children(root);
+    match language.name {
+        "csharp" => children.into_iter().any(is_csharp_top_level_statement),
+        // The grammar mis-parses some valid declarations (non-empty companion objects, `fun
+        // interface`) and leaves recovery residue at the top level, so a file with parse errors is
+        // never taken for a script.
+        "kotlin" => {
+            !root.has_error()
+                && children.iter().any(|child| {
+                    !KOTLIN_DECLARATIONS.contains(&child.kind())
+                        && !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind())
+                })
+        }
+        _ => false,
+    }
+}
+
 /// Collects one file's cross-file clone-detection contribution; see CrossFileFileData.
 pub fn collect_cross_file_data(
     code: &str,
@@ -104,17 +195,30 @@ pub fn collect_cross_file_data(
     let source = Source::new(code);
     let tree = parse_source(&source, language)?;
     let root = tree.root_node();
-    let (candidates, tokens, container_statements) =
-        collect_cross_file_file_data(root, &source, min_tokens);
     let (_, code_line_numbers) = classify_lines(&source, root);
-    let mut code_line_numbers: Vec<usize> = code_line_numbers.into_iter().collect();
+    Ok(to_cross_file_data(
+        &tokenize(root, &source),
+        &code_line_numbers,
+        min_tokens,
+    ))
+}
+
+fn to_cross_file_data(
+    tokenized: &TokenizedSource<'_>,
+    code_line_numbers: &HashSet<usize>,
+    min_tokens: usize,
+) -> CrossFileFileData {
+    let (candidates, tokens, container_statements, near_miss_blocks) =
+        collect_cross_file_file_data(tokenized, min_tokens);
+    let mut code_line_numbers: Vec<usize> = code_line_numbers.iter().copied().collect();
     code_line_numbers.sort_unstable();
-    Ok(CrossFileFileData {
+    CrossFileFileData {
         candidates,
         tokens,
         container_statements,
+        near_miss_blocks,
         code_line_numbers,
-    })
+    }
 }
 
 /// Name-carrying leaf types anonymized by tokenize_function so consistent renames still match.
@@ -133,7 +237,7 @@ const IDENTIFIER_LEAF_NODE_TYPES: &[&str] = &[
 ];
 
 /// Normalized token hash sequences of every function, index-parallel to the functions array of
-/// measure(); a faithful port of tokenizeFunction in src/metrics.ts.
+/// measure().
 pub fn collect_function_token_sequences(
     code: &str,
     language: &LanguageDefinition,
@@ -245,8 +349,9 @@ struct CommentSpan {
     end_column: usize,
 }
 
-/// 1-based numbers of lines that are neither blank nor comment-only, matching classifyLines in
-/// metrics.ts so duplication line coverage and its code-line denominator agree.
+/// Line metrics plus the 1-based numbers of lines that are neither blank nor comment-only, shared
+/// by the line counts and duplication line coverage so the coverage and its code-line denominator
+/// agree.
 fn classify_lines(code: &Source<'_>, root: Node<'_>) -> (LineMetrics, HashSet<usize>) {
     let source_lines = split_lines(code.code);
     // Spans are bucketed by line so classification stays linear.
@@ -525,7 +630,7 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "none",
 ];
 
-/// Non-leaf literals counted as one Halstead operand without descending; see metrics.ts.
+/// Non-leaf literals counted as one Halstead operand without descending.
 /// `character_literal` is a leaf in Java and Kotlin but wraps a content node in C#; Kotlin's
 /// suffixed numbers (`1L`, `1u`) wrap the bare literal, so `1` and `1L` stay distinct.
 const ATOMIC_OPERAND_NODE_TYPES: &[&str] = &[

package/native/src/types.rs

@@ -11,11 +11,15 @@ pub struct NativeMetrics {
     pub bytes: usize,
     pub lines: LineMetrics,
     pub functions: Vec<FunctionMetrics>,
+    pub cyclomatic_complexity: u64,
     pub cognitive_complexity: u64,
     pub max_cognitive_complexity: u64,
     pub nesting_depth: u64,
     pub ncss_count: u64,
     pub duplication: DuplicationMetrics,
+    /// Collected from the same parse on request, so a directory scan tokenizes each file once.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cross_file_data: Option<CrossFileFileData>,
     pub halstead_counts: HalsteadCounts,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub syntax_tree: Option<String>,
@@ -79,6 +83,8 @@ pub struct CrossFileFileData {
     pub candidates: Vec<CrossFileCandidate>,
     pub tokens: Vec<CrossFileToken>,
     pub container_statements: Vec<Vec<CrossFileTokenRange>>,
+    /// The mutually disjoint blocks cross-file near-miss (Type-3) comparison considers.
+    pub near_miss_blocks: Vec<CrossFileTokenRange>,
     /// 1-based lines that are neither blank nor comment-only, sorted ascending.
     pub code_line_numbers: Vec<usize>,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.3.1",
+  "version": "4.5.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -89,12 +89,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.3.1",
-    "code-gauge-linux-arm64-gnu": "4.3.1",
-    "code-gauge-linux-x64-musl": "4.3.1",
-    "code-gauge-linux-arm64-musl": "4.3.1",
-    "code-gauge-darwin-x64": "4.3.1",
-    "code-gauge-darwin-arm64": "4.3.1",
-    "code-gauge-win32-x64-msvc": "4.3.1"
+    "code-gauge-linux-x64-gnu": "4.5.0",
+    "code-gauge-linux-arm64-gnu": "4.5.0",
+    "code-gauge-linux-x64-musl": "4.5.0",
+    "code-gauge-linux-arm64-musl": "4.5.0",
+    "code-gauge-darwin-x64": "4.5.0",
+    "code-gauge-darwin-arm64": "4.5.0",
+    "code-gauge-win32-x64-msvc": "4.5.0"
   }
 }