churn_vs_complexity 1.7.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbfecd03ad25cb8f79ae5b52564f591b122eab2b8ee13e3fe80d1d33883e2747
-  data.tar.gz: 4ba6ffb8794bb11c9e87103f26b481b9b6bb29230eb1c55fa7fff7c46aaa0687
+  metadata.gz: 612c6e1945c04f5be2c72cdbdfbd4bc91157da01c6d4ab66f5a502a7e109c805
+  data.tar.gz: c84417b6b7eeeeb4fac050e32c89f037b010977c342e8db14762d28b2f63d557
 SHA512:
-  metadata.gz: c7463ac718037f9f8d13ba08d1c39b775557246f85bd3e29852ee573b1af55625026e792d239e3d38df118923f80b68d75243508f5dd98b6739bd1b80408fe20
-  data.tar.gz: 35358bac1704bc9bca9cb9204d053c3484d9aa5e4d1e378b0feb48e2236f014354494b8ddcd36d12d127865361add543f511e514bfa412d01f7b34f038fb1042
+  metadata.gz: a8d9617c65744a1b04910c0e9206d788cddcc02133820a05d9bad5bdc160d9c11e05552080bee72d2a1a9b53c765e884cd249095e54a866e38cdb6f3b803880e
+  data.tar.gz: 7174c9a6d71d2db643b83b72c49973aef249b09aafacc41112e25407b58a3a46675af29f968c5f84226b8e53fb114c3546664f4f9c2b35940277d68d8f9e5fda

data/CHANGELOG.md

@@ -1,3 +1,48 @@
+## [1.9.0] - 2026-09-20
+
+### Fixed
+- Churn counted only the commits made since the 30th most recent commit. The
+  underlying `git` gem caps a log at 30 entries by default, and the clamp that
+  is meant to stop `--since` reaching past the first commit was reading that cap
+  as the first commit. Any repository with more than 30 commits was undercounted.
+- Timetravel built its commit window from bare dates, which git treats as
+  approximate and resolves against the clock and the timezone. Commits on the
+  first and last day of the period were included or dropped depending on when
+  and where the command ran. Both ends are now given an explicit time.
+- Running any mode against a repository with no commits raised
+  `NoMethodError: undefined method 'date' for nil`. It now says which folder has
+  no commits.
+- Errors the tool raises on purpose, such as telling you which analyser to
+  install, were printed underneath a backtrace. The backtrace is now kept for
+  genuinely unexpected failures. These still exit 2, so a gate failure (exit 1)
+  stays distinguishable from a tool that could not run.
+- `--gate --max-gamma 0` crashed with `FloatDomainError: Infinity`, because the
+  percentage by which a score exceeds the threshold divided by it. Violations are
+  now reported against a zero threshold with `exceeds_by` set to null.
+- A negative `--max-gamma` is now rejected instead of reporting every file as a
+  violation with a negative excess.
+- Timetravel raised `ArgumentError: invalid slice size` when no commits fell in
+  the requested period. An empty period now produces an empty result.
+- The `churn_vs_complexity` executable failed with a `LoadError` when run from
+  inside a project that uses Bundler, which is most of the repositories the tool
+  exists to analyse. It required `bundler/setup`, so it resolved against the
+  analysed project's Gemfile instead of its own installed gems.
+
+### Changed
+- The `git` dependency moves from 2.x to 5.x and `flog` from 4.8 to 4.9.
+- The published gem no longer carries the test fixtures, the Dockerfiles or the
+  other development files it had been shipping.
+
+### Documentation
+- The README told Go users to install gocyclo. The Go calculator runs gocognit,
+  and has since Go support was added.
+
+## [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/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.
 
@@ -32,8 +32,10 @@ External tool dependencies per language:
 - **Java**: Requires [PMD](https://pmd.github.io) on the search path as `pmd`. On macOS: `brew install pmd`.
 - **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`.
+- **Go**: Requires [gocognit](https://github.com/uudashr/gocognit) on the search path. Install with `go install github.com/uudashr/gocognit/cmd/gocognit@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/bin/churn_vs_complexity

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'bundler/setup'
 require 'churn_vs_complexity'
 
 begin
@@ -9,6 +8,12 @@ begin
 rescue ChurnVsComplexity::ValidationError => e
   warn e.message
   exit 1
+rescue ChurnVsComplexity::Error => e
+  # Raised deliberately, so the message is the point and a backtrace only
+  # buries it. Exit 2, because exit 1 is how the gate reports a codebase that
+  # failed its threshold.
+  warn e.message
+  exit 2
 rescue StandardError => e
   warn e.backtrace
   warn e.message

data/lib/churn_vs_complexity/churn.rb

@@ -23,13 +23,28 @@ module ChurnVsComplexity
         end
 
         def date_of_latest_commit(folder:)
-          repo(folder).log.first.date
+          latest = repo(folder).log(1).execute.first
+          raise Error, "#{folder} has no commits to measure churn against" if latest.nil?
+
+          latest.date
         end
 
         private
 
+        # Asks git for the root commits directly. Reading it off `repo(folder).log`
+        # instead would silently answer with the 30th most recent commit, because
+        # that is where the git gem caps a log by default.
         def date_of_first_commit(folder:)
-          repo(folder).log.last&.date&.to_date || Time.at(0).to_date
+          git_dir = File.join(folder, '.git')
+          cmd = %(git --git-dir #{git_dir} --work-tree #{folder} log --max-parents=0 --format=%ad --date=short)
+          dates = `(#{cmd}) 2>/dev/null`.split("\n").filter_map { |line| parse_date(line) }
+          dates.min || Time.at(0).to_date
+        end
+
+        def parse_date(line)
+          Date.parse(line)
+        rescue Date::Error
+          nil
         end
 
         def repo(folder)

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/kotlin_calculator.rb

@@ -16,7 +16,7 @@ module ChurnVsComplexity
         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
+        LIZARD_LINE_PATTERN = /^\d+,(\d+),\d+,\d+,\d+,"[^"]*","([^"]*)"/
 
         def parse_lizard_output(csv_output, files:)
           scores = Hash.new(0)

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/serializer.rb

@@ -62,6 +62,7 @@ module ChurnVsComplexity
 
       module PassThrough
         extend Normal::Serializer::None
+
         def self.has_commit_summary? = true
       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/gate/config.rb

@@ -29,6 +29,7 @@ module ChurnVsComplexity
         LanguageValidator.validate!(@language)
         @since_validator.validate!(since: @since, relative_period: nil)
         @complexity_validator.validate!(@language)
+        validate_max_gamma!
       end
 
       def checker
@@ -43,6 +44,12 @@ module ChurnVsComplexity
 
       private
 
+      def validate_max_gamma!
+        return unless @max_gamma.negative?
+
+        raise ValidationError, "Max gamma must not be negative, got #{@max_gamma}"
+      end
+
       def gate_serializer
         case @serializer
         when :json then Serializer::Json

data/lib/churn_vs_complexity/gate/serializer.rb

@@ -24,10 +24,17 @@ module ChurnVsComplexity
               gamma = GammaScore.calculate(values[0], values[1]).round(2)
               next unless gamma > max_gamma
 
-              exceeds_pct = (((gamma - max_gamma) / max_gamma) * 100).round(0)
-              { file:, gamma_score: gamma, exceeds_by: "#{exceeds_pct}%" }
+              { file:, gamma_score: gamma, exceeds_by: excess(gamma, max_gamma) }
             end
           end
+
+          # There is no percentage by which a score exceeds zero, so a zero
+          # threshold reports the violation without one.
+          def excess(gamma, max_gamma)
+            return nil if max_gamma.zero?
+
+            "#{(((gamma - max_gamma) / max_gamma) * 100).round(0)}%"
+          end
         end
       end
     end

data/lib/churn_vs_complexity/git_strategy.rb

@@ -23,7 +23,7 @@ module ChurnVsComplexity
     def surrounding(commit:)
       current = object(commit)
       child_sha = `git -C #{@folder} log --reverse --ancestry-path #{current.sha}..HEAD --format=%H`.lines.first&.chomp
-      next_commit = child_sha&.empty? ? nil : child_sha
+      next_commit = child_sha.nil? || child_sha.empty? ? nil : child_sha
       [current.parent&.sha, next_commit]
     end
 
@@ -39,8 +39,22 @@ module ChurnVsComplexity
       `#{command}`
     end
 
+    # Both ends are given an explicit time. A bare date is an approximate date
+    # to git, resolved against the clock and the timezone, so the window it
+    # produces is not the window that was asked for.
+    def commits_in(git_period)
+      @repo.log(1_000_000)
+           .since(start_of_day(git_period.effective_start_date))
+           .until(end_of_day(git_period.end_date))
+           .execute.to_a
+    end
+
+    def start_of_day(date) = date.strftime('%Y-%m-%dT00:00:00')
+
+    def end_of_day(date) = date.strftime('%Y-%m-%dT23:59:59')
+
     def resolve_commits_with_interval(git_period:, jump_days:)
-      candidates = @repo.log(1_000_000).since(git_period.effective_start_date).until(git_period.end_date).to_a
+      candidates = commits_in(git_period)
 
       commits_by_date = candidates.filter { |c| c.date.to_date >= git_period.effective_start_date }
                                   .group_by { |c| c.date.to_date }

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/normal/serializer/summary_hash.rb

@@ -11,18 +11,31 @@ module ChurnVsComplexity
 
             return empty_summary(end_date) if values_by_file.empty?
 
-            churn_values = values_by_file.map { |_, values| values[0].to_f }
-            complexity_values = values_by_file.map { |_, values| values[1].to_f }
-            gamma_scores = values_by_file.map { |_, values| GammaScore.calculate(values[0], values[1]) }
-
-            stats(churn_values).transform_keys { |k| :"#{k}_churn" }
-              .merge(stats(complexity_values).transform_keys { |k| :"#{k}_complexity" })
-              .merge(stats(gamma_scores).slice(:mean, :median).transform_keys { |k| :"#{k}_gamma_score" })
-              .merge(end_date:)
+            summarise(values_by_file).merge(end_date:)
           end
 
           private
 
+          def summarise(values_by_file)
+            churn_stats(values_by_file)
+              .merge(complexity_stats(values_by_file), gamma_stats(values_by_file))
+          end
+
+          def churn_stats(values_by_file)
+            values = values_by_file.map { |_, pair| pair[0].to_f }
+            stats(values).transform_keys { |key| :"#{key}_churn" }
+          end
+
+          def complexity_stats(values_by_file)
+            values = values_by_file.map { |_, pair| pair[1].to_f }
+            stats(values).transform_keys { |key| :"#{key}_complexity" }
+          end
+
+          def gamma_stats(values_by_file)
+            values = values_by_file.map { |_, pair| GammaScore.calculate(pair[0], pair[1]) }
+            stats(values).slice(:mean, :median).transform_keys { |key| :"#{key}_gamma_score" }
+          end
+
           def stats(values)
             { mean: values.sum / values.size, median: values.sort[values.size / 2], max: values.max, min: values.min }
           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/timetravel/traveller.rb

@@ -35,6 +35,8 @@ module ChurnVsComplexity
       end
 
       def make_chunks(commits)
+        return [] if commits.empty?
+
         chunk_size = (commits.size / 3.0).ceil
         commits.each_slice(chunk_size).map do |chunk|
           { chunk:, pipe: @factory.pipe }

data/lib/churn_vs_complexity/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: churn_vs_complexity
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Erik T. Madsen
@@ -15,33 +15,33 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '4.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '4.9'
 - !ruby/object:Gem::Dependency
   name: git
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '5.0'
 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:
@@ -49,16 +49,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".devcontainer/devcontainer.json"
-- ".rubocop.yml"
 - CHANGELOG.md
-- CLAUDE.md
-- Dockerfile
-- Dockerfile.dev
 - LICENSE.txt
 - README.md
-- Rakefile
-- TODO
 - bin/churn_vs_complexity
 - lib/churn_vs_complexity.rb
 - lib/churn_vs_complexity/churn.rb
@@ -74,6 +67,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
@@ -130,37 +125,11 @@ files:
 - lib/churn_vs_complexity/triage/config.rb
 - lib/churn_vs_complexity/triage/serializer.rb
 - lib/churn_vs_complexity/version.rb
-- package-lock.json
 - tmp/eslint-support/complexity-calculator.js
 - tmp/eslint-support/package.json
 - tmp/pmd-support/ruleset.xml
 - tmp/template/graph.html
 - tmp/template/timetravel_graph.html
-- tmp/test-support/delta/ruby-summary.txt
-- tmp/test-support/delta/ruby.csv
-- tmp/test-support/go/main.go
-- tmp/test-support/go/utils.go
-- tmp/test-support/java/small-example/src/main/java/org/example/Main.java
-- tmp/test-support/java/small-example/src/main/java/org/example/spice/Checker.java
-- tmp/test-support/javascript/complex.js
-- 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/txt/abc.txt
-- tmp/test-support/txt/d.txt
-- tmp/test-support/txt/ef.txt
-- tmp/test-support/txt/ghij.txt
-- tmp/test-support/txt/klm.txt
-- tmp/test-support/txt/nopq.txt
-- tmp/test-support/txt/r.txt
-- tmp/test-support/txt/st.txt
-- tmp/test-support/txt/uvx.txt
-- tmp/test-support/txt/yz.txt
-- tmp/timetravel/.keep
 homepage: https://github.com/beatmadsen/churn_vs_complexity
 licenses:
 - MIT
@@ -182,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.9
 specification_version: 4
 summary: Analyse churn vs complexity to find refactoring hotspots, gate CI quality,
   triage risky files, and track codebase health over time.

data/.devcontainer/devcontainer.json

@@ -1,26 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile
-{
-	"name": "Existing Dockerfile",
-	"build": {
-		// Sets the run context to one level up instead of the .devcontainer folder.
-		"context": "..",
-		// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
-		"dockerfile": "../Dockerfile.dev"
-	}
-
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	// "features": {},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Uncomment the next line to run commands after the container is created.
-	// "postCreateCommand": "cat /etc/os-release",
-
-	// Configure tool-specific properties.
-	// "customizations": {},
-
-	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "devcontainer"
-}

data/.rubocop.yml

@@ -1,25 +0,0 @@
-AllCops:
-  TargetRubyVersion: 3.3
-  NewCops: enable
-
-Layout/LineLength:
-  Max: 120
-
-
-Style/Documentation:
-  Enabled: false
-
-Style/ModuleFunction:
-  Enabled: false
-
-Style/TrailingCommaInArrayLiteral:
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma
-
-Style/TrailingCommaInHashLiteral:
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma
-
-Style/TrailingCommaInArguments:
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma

data/CLAUDE.md

@@ -1,60 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## 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.
-
-## Commands
-
-```bash
-# Run tests (TLDR framework)
-bundle exec rake          # default task runs tldr
-bundle exec tldr          # direct
-
-# Run a single test file
-bundle exec tldr test/churn_vs_complexity/engine_test.rb
-
-# Run a single test by name
-bundle exec tldr --name test_something test/path/to_test.rb
-
-# Lint
-bundle exec rubocop
-bundle exec rubocop -a    # auto-fix safe offenses
-
-# Build/install gem
-bundle exec rake build
-bundle exec rake install
-```
-
-## Architecture
-
-Three operating modes, each with its own Config/Checker/Serializer pipeline:
-
-- **Normal** (`Normal::Config` → `Engine` → `ConcurrentCalculator`): Analyzes a folder, computing churn + complexity per file. Outputs CSV, HTML graph, or text summary.
-- **Timetravel** (`Timetravel::Config` → `Traveller`): Samples quality scores across historical commits at N-day intervals. Uses forked processes with git worktrees for isolation.
-- **Delta** (`Delta::Config` → `MultiChecker` → `Checker`): Analyzes complexity of files changed in specific commits. Uses threads with git worktrees.
-
-Entry point: `CLI::run!` → `CLI::Parser` → `CLI::Main.run!` → mode-specific Config → checker.
-
-### Key interfaces
-
-- **Complexity calculators**: `folder_based?`, `calculate(folder:)` or `calculate(files:)`
-- **Churn calculators**: `calculate(folder:, file:, since:)`, `date_of_latest_commit(folder:)`
-- **Serializers**: `serialize(result)`
-- **File selectors**: `select_files(folder)` → `{ included: [...], explicitly_excluded: [...] }`
-
-### Concurrency model
-
-- Normal: threads (nprocessors) for per-file churn calculation
-- Timetravel: forked child processes with IO.pipe for IPC
-- Delta: threads (2x nprocessors) for concurrent commit analysis
-
-## Code Style
-
-RuboCop config (`.rubocop.yml`):
-- Max line length: 120
-- Trailing commas enforced on multiline (arrays, hashes, arguments)
-- `NewCops: enable`
-- No class/module documentation required (`Style::Documentation` disabled)

data/Dockerfile

@@ -1,34 +0,0 @@
-# Create a build image with wget and unzip
-FROM ubuntu:latest as pmd_builder
-# Install wget and unzip
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-      wget unzip
-
-RUN wget https://github.com/pmd/pmd/releases/download/pmd_releases%2F7.0.0/pmd-dist-7.0.0-bin.zip --no-check-certificate
-RUN unzip pmd-dist-7.0.0-bin.zip
-
-FROM ruby:3.3-bullseye
-# Install git and java JDK
-
-RUN apt-get update; \
-	  apt-get install -y --no-install-recommends \
-      git openjdk-17-jdk
-
-# copy PMD from build image
-COPY --from=pmd_builder /pmd-bin-7.0.0 /usr/local/bin/pmd-bin-7.0.0
-# make pmd available in the PATH
-RUN ln -s /usr/local/bin/pmd-bin-7.0.0/bin/pmd /usr/local/bin/pmd
-
-COPY *.gemspec Gemfile* /app/
-COPY lib /app/lib
-
-WORKDIR /app
-
-RUN bundle install
-
-COPY bin /app/bin
-COPY tmp/pmd-support /app/tmp/pmd-support
-COPY tmp/template /app/tmp/template
-
-CMD ["/bin/sh", "-c", "echo 'It works!'"]

data/Dockerfile.dev

@@ -1,27 +0,0 @@
-# Create a build image with wget and unzip
-FROM ubuntu:latest as pmd_builder
-# Install wget and unzip
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-      wget unzip
-
-RUN wget https://github.com/pmd/pmd/releases/download/pmd_releases%2F7.0.0/pmd-dist-7.0.0-bin.zip --no-check-certificate
-RUN unzip pmd-dist-7.0.0-bin.zip
-
-FROM ruby:3.3-bullseye
-# Install git and java JDK
-
-RUN apt-get update; \
-	  apt-get install -y --no-install-recommends \
-      git openjdk-17-jdk
-
-# copy PMD from build image
-COPY --from=pmd_builder /pmd-bin-7.0.0 /usr/local/bin/pmd-bin-7.0.0
-# make pmd available in the PATH
-RUN ln -s /usr/local/bin/pmd-bin-7.0.0/bin/pmd /usr/local/bin/pmd
-
-COPY *.gemspec Gemfile* ./
-COPY lib/churn_vs_complexity/version.rb lib/churn_vs_complexity/version.rb
-RUN bundle install
-
-CMD ["/bin/sh", "-c", "echo 'It works!'"]

data/Rakefile

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'tldr/rake'
-
-task default: :tldr

data/TODO

@@ -1,11 +0,0 @@
-TODO:
-
-- Move Timetravel calculations away from serializer
-
-- Database, where we can prepopulate the state of every file and every commit
-  - Populate incrementally from each commit in log. 
-  - Only need to care about deltas between commits, and copy everything else from previous commit.
-  - processed_commit table with sha and version of processing logic
-- Unit tests for simpler new classes
-- Integration test for Timetravel
-- Candlebars on mean dots in graph

data/package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "churn_vs_complexity",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}

data/tmp/test-support/delta/ruby-summary.txt

@@ -1,55 +0,0 @@
-Commit:   b20a9bddd04afb9c7a736cf4530fd3188b5f785e
-Parent:   4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0
-Next:     8cdaac516365bd7007b9f755bbe6f6e86d8e13dd
-
-
-File, relative path:  lib/churn_vs_complexity/serializer/timetravel.rb
-Type of change:       modified
-Complexity:           58.34326171010786
-
-File, relative path:  lib/churn_vs_complexity/serializer/timetravel/stats_calculator.rb
-Type of change:       new
-Complexity:           80.35549194682164
-
-File, relative path:  test/churn_vs_complexity/serializer/timetravel/quality_calculator_test.rb
-Type of change:       modified
-Complexity:           13.054183368177016
-
-File, relative path:  test/churn_vs_complexity/serializer/timetravel/stats_calculator_test.rb
-Type of change:       new
-Complexity:           12.2198021565134
-
-
-
-Commit:   4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0
-Parent:   83deeccf8aa40e46cd0ca7e2c603c9726633256e
-Next:     b20a9bddd04afb9c7a736cf4530fd3188b5f785e
-
-
-File, relative path:  lib/churn_vs_complexity/config.rb
-Type of change:       modified
-Complexity:           70.26655854867414
-
-File, relative path:  lib/churn_vs_complexity/serializer/pass_through.rb
-Type of change:       new
-Complexity:           19.309088021254183
-
-File, relative path:  lib/churn_vs_complexity/serializer/summary_hash.rb
-Type of change:       modified
-Complexity:           89.25682464940157
-
-File, relative path:  lib/churn_vs_complexity/serializer/timetravel.rb
-Type of change:       modified
-Complexity:           131.0989019732436
-
-File, relative path:  lib/churn_vs_complexity/serializer/timetravel/quality_calculator.rb
-Type of change:       new
-Complexity:           23.324498016752965
-
-File, relative path:  test/churn_vs_complexity/serializer/summary_hash_test.rb
-Type of change:       modified
-Complexity:           14.396336540125482
-
-File, relative path:  test/churn_vs_complexity/serializer/timetravel/quality_calculator_test.rb
-Type of change:       new
-Complexity:           13.054183368177016

data/tmp/test-support/delta/ruby.csv

@@ -1,12 +0,0 @@
-Commit, Relative Path, Type of Change, Complexity
-b20a9bddd04afb9c7a736cf4530fd3188b5f785e, lib/churn_vs_complexity/serializer/timetravel.rb, modified, 58.34326171010786
-b20a9bddd04afb9c7a736cf4530fd3188b5f785e, lib/churn_vs_complexity/serializer/timetravel/stats_calculator.rb, new, 80.35549194682164
-b20a9bddd04afb9c7a736cf4530fd3188b5f785e, test/churn_vs_complexity/serializer/timetravel/quality_calculator_test.rb, modified, 13.054183368177016
-b20a9bddd04afb9c7a736cf4530fd3188b5f785e, test/churn_vs_complexity/serializer/timetravel/stats_calculator_test.rb, new, 12.2198021565134
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, lib/churn_vs_complexity/config.rb, modified, 70.26655854867414
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, lib/churn_vs_complexity/serializer/pass_through.rb, new, 19.309088021254183
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, lib/churn_vs_complexity/serializer/summary_hash.rb, modified, 89.25682464940157
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, lib/churn_vs_complexity/serializer/timetravel.rb, modified, 131.0989019732436
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, lib/churn_vs_complexity/serializer/timetravel/quality_calculator.rb, new, 23.324498016752965
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, test/churn_vs_complexity/serializer/summary_hash_test.rb, modified, 14.396336540125482
-4f3151f83e982eb8f2b8a4e7a7572a0af156c3c0, test/churn_vs_complexity/serializer/timetravel/quality_calculator_test.rb, new, 13.054183368177016

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

@@ -1,11 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("Hello, world!")
-}
-
-func add(a, b int) int {
-	return a + b
-}

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

@@ -1,13 +0,0 @@
-package main
-
-func calculateSum(numbers []int) int {
-	total := 0
-	for _, n := range numbers {
-		total += n
-	}
-	return total
-}
-
-func isEven(n int) bool {
-	return n%2 == 0
-}

data/tmp/test-support/java/small-example/src/main/java/org/example/Main.java

@@ -1,10 +0,0 @@
-package org.example;
-
-import org.example.spice.Checker;
-
-public class Main {
-    public static void main(String[] args) {
-        new Checker().check();
-    }
-
-}

data/tmp/test-support/java/small-example/src/main/java/org/example/spice/Checker.java

@@ -1,28 +0,0 @@
-package org.example.spice;
-
-import java.util.Iterator;
-import java.util.PrimitiveIterator;
-import java.util.Random;
-
-public class Checker {
-    public void check() {
-        for (int j = 0; j < 3; j++) {
-            var iter = tenRandomInts();
-            while (iter.hasNext()) {
-                var i = iter.nextInt();
-                if (i < 100) {
-                    System.out.println("Bongo");
-                } else if (i > 200) {
-                    System.out.println("Dingo");
-                } else {
-                    System.out.println("Zapp");
-                }
-            }
-        }
-    }
-
-    private static PrimitiveIterator.OfInt tenRandomInts() {
-        var randomInts = new Random().ints();
-        return randomInts.limit(10).iterator();
-    }
-}

data/tmp/test-support/javascript/complex.js

@@ -1,43 +0,0 @@
-function analyzeNumber(num) {
-    let result = '';
-
-    if (num < 0) {
-        result += 'negative ';
-    } else if (num > 0) {
-        result += 'positive ';
-    } else {
-        return 'zero';
-    }
-
-    if (num % 2 === 0) {
-        result += 'even ';
-    } else {
-        result += 'odd ';
-    }
-
-    if (num % 3 === 0) {
-        result += 'divisible by 3 ';
-    }
-
-    if (num % 5 === 0) {
-        result += 'divisible by 5 ';
-    }
-
-    if (isPrime(num)) {
-        result += 'prime ';
-    }
-
-    return result.trim();
-}
-
-function isPrime(num) {
-    if (num <= 1) return false;
-    for (let i = 2; i <= Math.sqrt(num); i++) {
-        if (num % i === 0) return false;
-    }
-    return true;
-}
-
-console.log(analyzeNumber(17));
-console.log(analyzeNumber(30));
-console.log(analyzeNumber(-7));

data/tmp/test-support/javascript/moderate.js

@@ -1,12 +0,0 @@
-function fibonacci(n) {
-    if (n <= 1) return n;
-    return fibonacci(n - 1) + fibonacci(n - 2);
-}
-
-function printFibonacciSequence(length) {
-    for (let i = 0; i < length; i++) {
-        console.log(fibonacci(i));
-    }
-}
-
-printFibonacciSequence(10);

data/tmp/test-support/javascript/simple.js

@@ -1,5 +0,0 @@
-function greet(name) {
-    return `Hello, ${name}!`;
-}
-
-console.log(greet('World'));

data/tmp/test-support/javascript/typescript-example.ts

@@ -1,26 +0,0 @@
-interface Person {
-    name: string;
-    age: number;
-}
-
-function createGreeting(person: Person): string {
-    let greeting = `Hello, ${person.name}!`;
-
-    if (person.age < 18) {
-        greeting += " You're still a minor.";
-    } else if (person.age >= 18 && person.age < 65) {
-        greeting += " You're an adult.";
-    } else {
-        greeting += " You're a senior citizen.";
-    }
-
-    return greeting;
-}
-
-const alice: Person = { name: 'Alice', age: 30 };
-const bob: Person = { name: 'Bob', age: 17 };
-const charlie: Person = { name: 'Charlie', age: 70 };
-
-console.log(createGreeting(alice));
-console.log(createGreeting(bob));
-console.log(createGreeting(charlie));

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

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

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

@@ -1,11 +0,0 @@
-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/python/example.py

@@ -1,6 +0,0 @@
-def hello():
-    print("Hello, world!")
-
-
-def add(a, b):
-    return a + b

data/tmp/test-support/python/utils.py

@@ -1,9 +0,0 @@
-def calculate_sum(numbers):
-    total = 0
-    for n in numbers:
-        total += n
-    return total
-
-
-def is_even(n):
-    return n % 2 == 0