churn_vs_complexity 1.6.2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d0895177148a918e4aab91d71e25978c2f0429d8f46920851d3aee7eb8a9525
-  data.tar.gz: 32df8627394b7f85cdf7aa81093ba560bef79309efa10a606941f298e176bf34
+  metadata.gz: b5a149d026d33ac7319cc78d8c57af7e03113edf42d69f35612bbd72be708c77
+  data.tar.gz: c87fb3252fc699c681fd8da590fe02fe2d06e47b85fd5b7667fe314bd8ce3393
 SHA512:
-  metadata.gz: 1bdb515d824ab01dcd9f279f072d430c9dbb5a386bde4c569e5821b63895eefb256e26d22c79f1da65c59e1c0508057487db5008155de946ea54652ca1947687
-  data.tar.gz: d3c5c601f54b852d5ed47d683e1e9c8d88526fce57191caab66f553c3326d9166008f3c409a7e1178535d290908b95f1780599af763c8bb1d995ff1117e38457
+  metadata.gz: '09d8eddfd30cd8c56abbd200d5f4e31529ac5fc1171837e3420ccfe2536bf203e3d003a8fbebe7c4c6b0fb54be9a84d71071ca447b9526538edd814953c8b436'
+  data.tar.gz: ad11518d39553ff5b03fb6c8ea0bc44989ba47d034cbd3b82582279055cad86806612cf0f71c1888b6ecf2aa312a20afce3ad80c8d36b5ab85480152e213e570

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [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
+- Kotlin support for complexity calculation (via [lizard](https://github.com/terryyin/lizard), install with `pip install lizard`)
+
 ## [1.6.2] - 2026-02-19
 
 ### Changed

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), and Java (via PMD). 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, and Go.
+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.
 
@@ -33,6 +33,9 @@ External tool dependencies per language:
 - **JavaScript/TypeScript**: Requires [Node.js](https://nodejs.org) (uses ESLint internally).
 - **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
 
@@ -48,6 +51,9 @@ Languages:
                                      Check complexity of javascript and typescript files
         --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
@@ -121,6 +127,15 @@ churn_vs_complexity --java -m --since 2019-03-01 --timetravel 30 --graph my_java
 
 # Analyse complexity of specific commits
 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

@@ -34,6 +34,18 @@ module ChurnVsComplexity
             options[:language] = :go
           end
 
+          opts.on('--kotlin', 'Check complexity of kotlin files') do
+            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/kotlin_calculator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module ChurnVsComplexity
+  module Complexity
+    module KotlinCalculator
+      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+,"[^"]*","([^"]*)"/.freeze
+
+        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/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

@@ -5,6 +5,9 @@ require_relative 'complexity/flog_calculator'
 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

@@ -12,6 +12,12 @@ module ChurnVsComplexity
         Complexity::PythonCalculator.check_dependencies!
       when :go
         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

@@ -38,6 +38,12 @@ module ChurnVsComplexity
           FileSelector::Python.predefined(included:, excluded:)
         when :go
           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
 
@@ -53,6 +59,12 @@ module ChurnVsComplexity
           Complexity::PythonCalculator
         when :go
           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

@@ -14,6 +14,12 @@ module ChurnVsComplexity
         ['.py']
       when :go
         ['.go']
+      when :kotlin
+        ['.kt', '.kts']
+      when :rust
+        ['.rs']
+      when :swift
+        ['.swift']
       else
         raise Error, "Unsupported language: #{language}"
       end
@@ -130,5 +136,35 @@ module ChurnVsComplexity
         Predefined.new(included:, extensions: FileSelector.extensions(:go), excluded:)
       end
     end
+
+    module Kotlin
+      def self.excluding(excluded)
+        Excluding.new(FileSelector.extensions(:kotlin), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        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].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

@@ -75,6 +75,30 @@ module ChurnVsComplexity
             serializer:,
             since: @since || @relative_period,
           )
+        when :kotlin
+          Engine.concurrent(
+            complexity: Complexity::KotlinCalculator,
+            churn:,
+            file_selector: FileSelector::Kotlin.excluding(@excluded),
+            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

@@ -14,6 +14,9 @@ module ChurnVsComplexity
   #   Python         Radon     Cyclomatic complexity  1        ~44                 5-50
   #   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.6.2'
+  VERSION = '1.8.0'
 end

data/tmp/test-support/kotlin/Main.kt

@@ -0,0 +1,7 @@
+fun main() {
+    println("Hello, world!")
+}
+
+fun add(a: Int, b: Int): Int {
+    return a + b
+}

data/tmp/test-support/kotlin/Utils.kt

@@ -0,0 +1,11 @@
+fun calculateSum(numbers: List<Int>): Int {
+    var total = 0
+    for (n in numbers) {
+        total += n
+    }
+    return total
+}
+
+fun isEven(n: Int): Boolean {
+    return n % 2 == 0
+}

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.6.2
+  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,
-  and Go. 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:
@@ -69,10 +69,13 @@ files:
 - lib/churn_vs_complexity/complexity/eslint_calculator.rb
 - lib/churn_vs_complexity/complexity/flog_calculator.rb
 - lib/churn_vs_complexity/complexity/go_calculator.rb
+- lib/churn_vs_complexity/complexity/kotlin_calculator.rb
 - lib/churn_vs_complexity/complexity/pmd.rb
 - 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
@@ -145,8 +148,14 @@ files:
 - tmp/test-support/javascript/moderate.js
 - tmp/test-support/javascript/simple.js
 - tmp/test-support/javascript/typescript-example.ts
+- tmp/test-support/kotlin/Main.kt
+- 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
@@ -179,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Analyse churn vs complexity to find refactoring hotspots, gate CI quality,
   triage risky files, and track codebase health over time.