churn_vs_complexity 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbfecd03ad25cb8f79ae5b52564f591b122eab2b8ee13e3fe80d1d33883e2747
-  data.tar.gz: 4ba6ffb8794bb11c9e87103f26b481b9b6bb29230eb1c55fa7fff7c46aaa0687
+  metadata.gz: b5a149d026d33ac7319cc78d8c57af7e03113edf42d69f35612bbd72be708c77
+  data.tar.gz: c87fb3252fc699c681fd8da590fe02fe2d06e47b85fd5b7667fe314bd8ce3393
 SHA512:
-  metadata.gz: c7463ac718037f9f8d13ba08d1c39b775557246f85bd3e29852ee573b1af55625026e792d239e3d38df118923f80b68d75243508f5dd98b6739bd1b80408fe20
-  data.tar.gz: 35358bac1704bc9bca9cb9204d053c3484d9aa5e4d1e378b0feb48e2236f014354494b8ddcd36d12d127865361add543f511e514bfa412d01f7b34f038fb1042
+  metadata.gz: '09d8eddfd30cd8c56abbd200d5f4e31529ac5fc1171837e3420ccfe2536bf203e3d003a8fbebe7c4c6b0fb54be9a84d71071ca447b9526538edd814953c8b436'
+  data.tar.gz: ad11518d39553ff5b03fb6c8ea0bc44989ba47d034cbd3b82582279055cad86806612cf0f71c1888b6ecf2aa312a20afce3ad80c8d36b5ab85480152e213e570

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [1.8.0] - 2026-04-05
+
+### Added
+- Rust support for complexity calculation (via [lizard](https://github.com/terryyin/lizard), install with `pip install lizard`)
+- Swift support for complexity calculation (via [lizard](https://github.com/terryyin/lizard), install with `pip install lizard`)
+
 ## [1.7.0] - 2026-04-05
 
 ### Added

data/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-`churn_vs_complexity` is a Ruby gem that analyzes code quality by correlating file churn (how often files change) with complexity scores. It supports Ruby (via Flog), JavaScript/TypeScript (via ESLint), Java (via PMD), Python (via Radon), Go (via gocognit), and Kotlin (via lizard). Requires Ruby >= 3.3.
+`churn_vs_complexity` is a Ruby gem that analyzes code quality by correlating file churn (how often files change) with complexity scores. It supports Ruby (via Flog), JavaScript/TypeScript (via ESLint), Java (via PMD), Python (via Radon), Go (via gocognit), Kotlin (via lizard), Rust (via lizard), and Swift (via lizard). Requires Ruby >= 3.3.
 
 ## Commands
 

data/README.md

@@ -2,7 +2,7 @@
 
 # ChurnVsComplexity
 
-Correlates file churn (how often files change) with complexity scores to identify refactoring hotspots and track codebase health over time. Supports Ruby, JavaScript/TypeScript, Java, Python, Go, and Kotlin.
+Correlates file churn (how often files change) with complexity scores to identify refactoring hotspots and track codebase health over time. Supports Ruby, JavaScript/TypeScript, Java, Python, Go, Kotlin, Rust, and Swift.
 
 Modes include hotspots ranking, triage assessment, CI quality gate, diff comparison, focus sessions, and timetravel history.
 
@@ -34,6 +34,8 @@ External tool dependencies per language:
 - **Python**: Requires [Radon](https://radon.readthedocs.io) on the search path as `radon`. Install with `pip install radon`.
 - **Go**: Requires [gocyclo](https://github.com/fzipp/gocyclo) on the search path. Install with `go install github.com/fzipp/gocyclo/cmd/gocyclo@latest`.
 - **Kotlin**: Requires [lizard](https://github.com/terryyin/lizard) on the search path. Install with `pip install lizard`.
+- **Rust**: Requires [lizard](https://github.com/terryyin/lizard) on the search path. Install with `pip install lizard`.
+- **Swift**: Requires [lizard](https://github.com/terryyin/lizard) on the search path. Install with `pip install lizard`.
 
 ## Usage
 
@@ -50,6 +52,8 @@ Languages:
         --python                     Check complexity of python files
         --go                         Check complexity of go files
         --kotlin                     Check complexity of kotlin files
+        --rust                       Check complexity of rust files
+        --swift                      Check complexity of swift files
 
 Modes (mutually exclusive):
         --timetravel N               Calculate summary for all commits at intervals of N days throughout project history or from the date specified with --since
@@ -126,6 +130,12 @@ churn_vs_complexity --js --delta HEAD --summary my_js_project
 
 # Kotlin project hotspots
 churn_vs_complexity --kotlin --hotspots my_kotlin_project
+
+# Rust project CSV report
+churn_vs_complexity --rust --csv my_rust_project > ~/Desktop/rust-demo.csv
+
+# Swift project summary
+churn_vs_complexity --swift --summary -q my_swift_project
 ```
 
 ## Development

data/lib/churn_vs_complexity/cli/parser.rb

@@ -38,6 +38,14 @@ module ChurnVsComplexity
             options[:language] = :kotlin
           end
 
+          opts.on('--rust', 'Check complexity of rust files') do
+            options[:language] = :rust
+          end
+
+          opts.on('--swift', 'Check complexity of swift files') do
+            options[:language] = :swift
+          end
+
           opts.separator ''
           opts.separator 'Modes (mutually exclusive):'
 

data/lib/churn_vs_complexity/complexity/rust_calculator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module ChurnVsComplexity
+  module Complexity
+    module RustCalculator
+      class << self
+        attr_writer :command_runner
+
+        def folder_based? = false
+
+        def calculate(files:)
+          csv_output = run_lizard(files)
+          parse_lizard_output(csv_output, files:)
+        end
+
+        # Lizard CSV format: NLOC,CCN,tokens,params,length,"loc","file","func","long_func",start,end
+        LIZARD_LINE_PATTERN = /^\d+,(\d+),\d+,\d+,\d+,"[^"]*","([^"]*)"/
+
+        def parse_lizard_output(csv_output, files:)
+          scores = Hash.new(0)
+          csv_output.each_line do |line|
+            match = line.match(LIZARD_LINE_PATTERN)
+            next unless match
+
+            scores[match[2]] += match[1].to_i
+          end
+          files.to_h { |file| [file, scores[file] || 0] }
+        end
+
+        def check_dependencies!
+          command_runner.call('lizard --version 2>&1')
+        rescue Errno::ENOENT
+          raise Error, 'Needs lizard installed (pip install lizard)'
+        end
+
+        private
+
+        def command_runner
+          @command_runner || Open3.method(:capture2)
+        end
+
+        def run_lizard(files)
+          files_arg = files.map { |f| "'#{f}'" }.join(' ')
+          stdout, status = command_runner.call("lizard --csv #{files_arg}")
+          raise Error, "lizard failed (exit #{status.exitstatus}). Is it installed?" unless status.success?
+
+          stdout
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity/swift_calculator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module ChurnVsComplexity
+  module Complexity
+    module SwiftCalculator
+      class << self
+        attr_writer :command_runner
+
+        def folder_based? = false
+
+        def calculate(files:)
+          csv_output = run_lizard(files)
+          parse_lizard_output(csv_output, files:)
+        end
+
+        # Lizard CSV format: NLOC,CCN,tokens,params,length,"loc","file","func","long_func",start,end
+        LIZARD_LINE_PATTERN = /^\d+,(\d+),\d+,\d+,\d+,"[^"]*","([^"]*)"/
+
+        def parse_lizard_output(csv_output, files:)
+          scores = Hash.new(0)
+          csv_output.each_line do |line|
+            match = line.match(LIZARD_LINE_PATTERN)
+            next unless match
+
+            scores[match[2]] += match[1].to_i
+          end
+          files.to_h { |file| [file, scores[file] || 0] }
+        end
+
+        def check_dependencies!
+          command_runner.call('lizard --version 2>&1')
+        rescue Errno::ENOENT
+          raise Error, 'Needs lizard installed (pip install lizard)'
+        end
+
+        private
+
+        def command_runner
+          @command_runner || Open3.method(:capture2)
+        end
+
+        def run_lizard(files)
+          files_arg = files.map { |f| "'#{f}'" }.join(' ')
+          stdout, status = command_runner.call("lizard --csv #{files_arg}")
+          raise Error, "lizard failed (exit #{status.exitstatus}). Is it installed?" unless status.success?
+
+          stdout
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/complexity.rb

@@ -6,6 +6,8 @@ require_relative 'complexity/eslint_calculator'
 require_relative 'complexity/python_calculator'
 require_relative 'complexity/go_calculator'
 require_relative 'complexity/kotlin_calculator'
+require_relative 'complexity/rust_calculator'
+require_relative 'complexity/swift_calculator'
 
 module ChurnVsComplexity
   module Complexity

data/lib/churn_vs_complexity/complexity_validator.rb

@@ -14,6 +14,10 @@ module ChurnVsComplexity
         Complexity::GoCalculator.check_dependencies!
       when :kotlin
         Complexity::KotlinCalculator.check_dependencies!
+      when :rust
+        Complexity::RustCalculator.check_dependencies!
+      when :swift
+        Complexity::SwiftCalculator.check_dependencies!
       end
     end
   end

data/lib/churn_vs_complexity/delta.rb

@@ -40,6 +40,10 @@ module ChurnVsComplexity
           FileSelector::Go.predefined(included:, excluded:)
         when :kotlin
           FileSelector::Kotlin.predefined(included:, excluded:)
+        when :rust
+          FileSelector::Rust.predefined(included:, excluded:)
+        when :swift
+          FileSelector::Swift.predefined(included:, excluded:)
         end
       end
 
@@ -57,6 +61,10 @@ module ChurnVsComplexity
           Complexity::GoCalculator
         when :kotlin
           Complexity::KotlinCalculator
+        when :rust
+          Complexity::RustCalculator
+        when :swift
+          Complexity::SwiftCalculator
         end
       end
     end

data/lib/churn_vs_complexity/file_selector.rb

@@ -16,6 +16,10 @@ module ChurnVsComplexity
         ['.go']
       when :kotlin
         ['.kt', '.kts']
+      when :rust
+        ['.rs']
+      when :swift
+        ['.swift']
       else
         raise Error, "Unsupported language: #{language}"
       end
@@ -142,5 +146,25 @@ module ChurnVsComplexity
         Predefined.new(included:, extensions: FileSelector.extensions(:kotlin), excluded:)
       end
     end
+
+    module Rust
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:rust), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:rust), excluded:)
+      end
+    end
+
+    module Swift
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:swift), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:swift), excluded:)
+      end
+    end
   end
 end

data/lib/churn_vs_complexity/language_validator.rb

@@ -2,7 +2,7 @@
 
 module ChurnVsComplexity
   module LanguageValidator
-    SUPPORTED = %i[java ruby javascript python go kotlin].freeze
+    SUPPORTED = %i[java ruby javascript python go kotlin rust swift].freeze
 
     def self.validate!(language)
       raise ValidationError, "Unsupported language: #{language}" unless SUPPORTED.include?(language)

data/lib/churn_vs_complexity/normal/config.rb

@@ -83,6 +83,22 @@ module ChurnVsComplexity
             serializer:,
             since: @since || @relative_period,
           )
+        when :rust
+          Engine.concurrent(
+            complexity: Complexity::RustCalculator,
+            churn:,
+            file_selector: FileSelector::Rust.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
+        when :swift
+          Engine.concurrent(
+            complexity: Complexity::SwiftCalculator,
+            churn:,
+            file_selector: FileSelector::Swift.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
         end
       end
 

data/lib/churn_vs_complexity/risk_classifier.rb

@@ -15,6 +15,8 @@ module ChurnVsComplexity
   #   Java           PMD       Cyclomatic complexity  1        ~39                 1-40
   #   Go             gocognit  Cognitive complexity   0        ~87                 0-50
   #   Kotlin         lizard    Cyclomatic complexity  1        ~40                 1-40
+  #   Rust           lizard    Cyclomatic complexity  1        ~40                 1-40
+  #   Swift          lizard    Cyclomatic complexity  1        ~40                 1-40
   #
   # The DEFAULT_LOW and DEFAULT_HIGH thresholds below are rough midpoints
   # suitable for Java/Python/JS. They are too aggressive for Ruby (Flog

data/lib/churn_vs_complexity/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChurnVsComplexity
-  VERSION = '1.7.0'
+  VERSION = '1.8.0'
 end

data/tmp/test-support/rust/main.rs

@@ -0,0 +1,7 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+fn add(a: i32, b: i32) -> i32 {
+    a + b
+}

data/tmp/test-support/rust/utils.rs

@@ -0,0 +1,20 @@
+fn calculate_sum(numbers: &[i32]) -> i32 {
+    let mut total = 0;
+    for n in numbers {
+        total += n;
+    }
+    total
+}
+
+fn classify(value: i32) -> &'static str {
+    match value {
+        0 => "zero",
+        1..=10 => "low",
+        11..=100 => "medium",
+        _ => "high",
+    }
+}
+
+fn is_even(n: i32) -> bool {
+    n % 2 == 0
+}

data/tmp/test-support/swift/main.swift

@@ -0,0 +1,7 @@
+func main() {
+    print("Hello, world!")
+}
+
+func add(_ a: Int, _ b: Int) -> Int {
+    return a + b
+}

data/tmp/test-support/swift/utils.swift

@@ -0,0 +1,24 @@
+func calculateSum(_ numbers: [Int]) -> Int {
+    var total = 0
+    for n in numbers {
+        total += n
+    }
+    return total
+}
+
+func classify(_ value: Int) -> String {
+    switch value {
+    case 0:
+        return "zero"
+    case 1...10:
+        return "low"
+    case 11...100:
+        return "medium"
+    default:
+        return "high"
+    }
+}
+
+func isEven(_ n: Int) -> Bool {
+    return n % 2 == 0
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: churn_vs_complexity
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Erik T. Madsen
@@ -39,9 +39,9 @@ dependencies:
         version: '2.1'
 description: Correlates file churn (how often files change) with complexity scores
   to identify refactoring hotspots. Supports Ruby, JavaScript/TypeScript, Java, Python,
-  Go, and Kotlin. Modes include hotspots ranking, triage assessment, CI quality gate,
-  diff comparison, focus sessions, and timetravel history. Inspired by Michael Feathers'
-  article "Getting Empirical about Refactoring".
+  Go, Kotlin, Rust, and Swift. Modes include hotspots ranking, triage assessment,
+  CI quality gate, diff comparison, focus sessions, and timetravel history. Inspired
+  by Michael Feathers' article "Getting Empirical about Refactoring".
 email:
 - beatmadsen@gmail.com
 executables:
@@ -74,6 +74,8 @@ files:
 - lib/churn_vs_complexity/complexity/pmd/files_calculator.rb
 - lib/churn_vs_complexity/complexity/pmd/folder_calculator.rb
 - lib/churn_vs_complexity/complexity/python_calculator.rb
+- lib/churn_vs_complexity/complexity/rust_calculator.rb
+- lib/churn_vs_complexity/complexity/swift_calculator.rb
 - lib/churn_vs_complexity/complexity_validator.rb
 - lib/churn_vs_complexity/concurrent_calculator.rb
 - lib/churn_vs_complexity/delta.rb
@@ -150,6 +152,10 @@ files:
 - tmp/test-support/kotlin/Utils.kt
 - tmp/test-support/python/example.py
 - tmp/test-support/python/utils.py
+- tmp/test-support/rust/main.rs
+- tmp/test-support/rust/utils.rs
+- tmp/test-support/swift/main.swift
+- tmp/test-support/swift/utils.swift
 - tmp/test-support/txt/abc.txt
 - tmp/test-support/txt/d.txt
 - tmp/test-support/txt/ef.txt