churn_vs_complexity 1.5.2 → 1.6.0

data/lib/churn_vs_complexity/focus/checker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Focus
+    class Checker
+      def initialize(engine:, subcommand:, serializer:, baseline_path:)
+        @engine = engine
+        @subcommand = subcommand
+        @serializer = serializer
+        @baseline_path = baseline_path
+      end
+
+      def check(folder:)
+        resolved_path = resolve_baseline_path(folder)
+        case @subcommand
+        when :start then run_start(folder, resolved_path)
+        when :end then run_end(folder, resolved_path)
+        end
+      end
+
+      private
+
+      def run_start(folder, baseline_path)
+        raw_result = @engine.check(folder:)
+        entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+
+        baseline = {
+          timestamp: Time.now.utc.iso8601,
+          files: entries.map { |e| { file: e[:file], gamma_score: e[:gamma_score] } },
+        }
+
+        File.write(baseline_path, JSON.generate(baseline))
+        "Baseline saved to #{baseline_path} (#{entries.size} files)"
+      end
+
+      def run_end(folder, baseline_path)
+        raw_result = @engine.check(folder:)
+        current_entries = RiskAnnotator.annotate(raw_result[:values_by_file])
+
+        baseline = load_baseline(baseline_path)
+        @serializer.serialize(baseline:, current: current_entries)
+      end
+
+      def load_baseline(baseline_path)
+        return unless File.exist?(baseline_path)
+
+        JSON.parse(File.read(baseline_path))
+      end
+
+      def resolve_baseline_path(folder)
+        return @baseline_path if File.absolute_path?(@baseline_path)
+
+        File.join(folder, @baseline_path)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus/config.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Focus
+    class Config
+      DEFAULT_BASELINE_PATH = '.focus-baseline.json'
+
+      def initialize(
+        language:,
+        subcommand:,
+        serializer: :json,
+        since: nil,
+        excluded: [],
+        baseline_path: DEFAULT_BASELINE_PATH,
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @subcommand = subcommand.to_sym
+        @serializer = serializer
+        @since = since
+        @excluded = excluded
+        @baseline_path = baseline_path
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+        validate_subcommand!
+      end
+
+      def checker
+        Checker.new(
+          engine: normal_engine,
+          subcommand: @subcommand,
+          serializer: focus_serializer,
+          baseline_path: @baseline_path,
+        )
+      end
+
+      private
+
+      def normal_engine
+        Normal::Config.new(language: @language, serializer: :none, since: @since, excluded: @excluded).checker
+      end
+
+      def validate_subcommand!
+        return if %i[start end].include?(@subcommand)
+
+        raise ValidationError, "Invalid focus subcommand: #{@subcommand}. Use 'start' or 'end'."
+      end
+
+      def focus_serializer
+        case @subcommand
+        when :start then nil # start doesn't need a serializer
+        when :end then Serializer::Json
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus/serializer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Focus
+    module Serializer
+      module Json
+        def self.serialize(baseline:, current:)
+          baseline ? build_report(baseline, current) : build_fallback_report(current)
+        end
+
+        def self.build_report(baseline, current)
+          before_gammas = baseline['files'].to_h { |f| [f['file'], f['gamma_score']] }
+          after_gammas = current.to_h { |e| [e[:file], e[:gamma_score]] }
+          touched = find_touched_files(before_gammas, after_gammas)
+
+          JSON.generate(
+            session: session_data(started: baseline['timestamp'], files_modified: touched.size),
+            impact: impact_data(before: mean(before_gammas.values), after: mean(after_gammas.values)),
+            files_touched: touched,
+          )
+        end
+
+        def self.build_fallback_report(current)
+          after_scores = current.map { |e| e[:gamma_score] }
+
+          report = {
+            warning: 'No baseline found. Comparing against current state only.',
+            session: session_data(started: nil, files_modified: 0),
+            impact: { mean_gamma_before: nil, mean_gamma_after: mean(after_scores), direction: 'unknown' },
+            files_touched: [],
+          }
+          JSON.generate(report)
+        end
+
+        def self.session_data(started:, files_modified:)
+          { started:, ended: Time.now.utc.iso8601, files_modified: }
+        end
+
+        def self.impact_data(before:, after:)
+          { mean_gamma_before: before, mean_gamma_after: after, direction: direction(before, after) }
+        end
+
+        def self.mean(scores)
+          return 0.0 if scores.empty?
+
+          (scores.sum.to_f / scores.size).round(2)
+        end
+
+        def self.direction(before, after)
+          diff = after - before
+          return 'unchanged' if diff.abs < 0.5
+
+          diff.positive? ? 'degraded' : 'improved'
+        end
+
+        def self.find_touched_files(before_files, after_files)
+          all_files = (before_files.keys + after_files.keys).uniq
+          all_files.filter_map { |file| build_touched_entry(file, before_files[file], after_files[file]) }
+        end
+
+        def self.build_touched_entry(file, old_gamma, new_gamma)
+          return if old_gamma == new_gamma
+
+          {
+            file:,
+            gamma_before: old_gamma, gamma_after: new_gamma,
+            complexity_added: new_gamma ? (new_gamma - (old_gamma || 0)).round(2) : 0,
+            has_tests: test_file_exists?(file),
+            recommendation: recommend(old_gamma, new_gamma),
+          }
+        end
+
+        def self.test_file_exists?(file)
+          return false unless file
+
+          base = File.basename(file, File.extname(file))
+          ext = File.extname(file)
+          %w[test spec].any? do |dir|
+            File.exist?(File.join(dir, File.dirname(file), "#{base}_#{dir == 'test' ? 'test' : 'spec'}#{ext}"))
+          end
+        end
+
+        def self.recommend(old_gamma, new_gamma)
+          return 'File removed.' if new_gamma.nil?
+          return 'New file. Add test coverage.' if old_gamma.nil?
+
+          new_gamma > old_gamma ? 'Complexity increased. Consider adding tests.' : 'Complexity decreased. Good.'
+        end
+
+        private_class_method :build_report, :build_fallback_report, :session_data, :impact_data,
+                             :mean, :direction, :find_touched_files, :build_touched_entry,
+                             :test_file_exists?, :recommend
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/focus.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'focus/config'
+require_relative 'focus/checker'
+require_relative 'focus/serializer'
+
+module ChurnVsComplexity
+  module Focus
+  end
+end

data/lib/churn_vs_complexity/gamma_score.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module GammaScore
+    EPSILON = 0.0001
+
+    def self.calculate(churn, complexity)
+      c = churn.to_f + EPSILON
+      x = complexity.to_f + EPSILON
+      (2 * c * x) / (c + x)
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/checker.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Gate
+    class Checker
+      class Result
+        def initialize(json, passed:)
+          @json = json
+          @passed = passed
+        end
+
+        def passed?
+          @passed
+        end
+
+        def to_s
+          @json
+        end
+      end
+
+      def initialize(engine:, serializer:, max_gamma:)
+        @engine = engine
+        @serializer = serializer
+        @max_gamma = max_gamma
+      end
+
+      def check(folder:)
+        raw_result = @engine.check(folder:)
+        json = @serializer.serialize(raw_result, max_gamma: @max_gamma)
+        Result.new(json, passed: JSON.parse(json)['passed'])
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Gate
+    class Config
+      DEFAULT_MAX_GAMMA = 25
+
+      def initialize(
+        language:,
+        serializer: :json,
+        max_gamma: DEFAULT_MAX_GAMMA,
+        since: nil,
+        excluded: [],
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @serializer = serializer
+        @max_gamma = max_gamma
+        @since = since
+        @excluded = excluded
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+      end
+
+      def checker
+        normal_config = Normal::Config.new(
+          language: @language,
+          serializer: :none,
+          since: @since,
+          excluded: @excluded,
+        )
+        Checker.new(engine: normal_config.checker, serializer: gate_serializer, max_gamma: @max_gamma)
+      end
+
+      private
+
+      def gate_serializer
+        case @serializer
+        when :json then Serializer::Json
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate/serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Gate
+    module Serializer
+      module Json
+        class << self
+          def serialize(result, max_gamma:)
+            violations = find_violations(result[:values_by_file], max_gamma)
+
+            JSON.generate(
+              passed: violations.empty?,
+              threshold: { max_gamma: },
+              violations:,
+            )
+          end
+
+          private
+
+          def find_violations(values_by_file, max_gamma)
+            values_by_file.filter_map do |file, values|
+              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}%" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/gate.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'gate/serializer'
+require_relative 'gate/config'
+require_relative 'gate/checker'
+
+module ChurnVsComplexity
+  module Gate
+  end
+end

data/lib/churn_vs_complexity/git_strategy.rb

@@ -2,6 +2,8 @@
 
 module ChurnVsComplexity
   class GitStrategy
+    EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'
+
     def initialize(folder:)
       @repo = Git.open(folder)
       @folder = folder
@@ -20,15 +22,14 @@ module ChurnVsComplexity
 
     def surrounding(commit:)
       current = object(commit)
-      is_head = current.sha == @repo.object('HEAD').sha
-      next_commit = is_head ? nil : @repo.log(100_000).find { |c| c.parents.map(&:sha).include?(current.sha) }
-      [current.parent&.sha, next_commit&.sha]
+      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
+      [current.parent&.sha, next_commit]
     end
 
     def changes(commit:)
       commit_object = @repo.object(commit)
-      base = commit_object.parent
-      commit_object.diff(base).map do |change|
+      diff_from_parent(commit_object).map do |change|
         { path: change.path, type: change.type.to_sym }
       end
     end
@@ -58,5 +59,12 @@ module ChurnVsComplexity
       command = "(cd #{worktree_folder} && git worktree remove -f #{worktree_folder}) > /dev/null 2>&1"
       `#{command}`
     end
+
+    private
+
+    def diff_from_parent(commit_object)
+      base = commit_object.parent
+      base ? base.diff(commit_object) : @repo.diff(EMPTY_TREE_SHA, commit_object.sha)
+    end
   end
 end

data/lib/churn_vs_complexity/hotspots/checker.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Hotspots
+    class Checker
+      def initialize(engine:, serializer:)
+        @engine = engine
+        @serializer = serializer
+      end
+
+      def check(folder:)
+        raw_result = @engine.check(folder:)
+        @serializer.serialize(raw_result)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Hotspots
+    class Config
+      def initialize(
+        language:,
+        serializer: :json,
+        since: nil,
+        excluded: [],
+        complexity_validator: ComplexityValidator,
+        since_validator: Normal::SinceValidator,
+        **options
+      )
+        @language = language
+        @serializer = serializer
+        @since = since
+        @excluded = excluded
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+        @since_validator.validate!(since: @since, relative_period: nil)
+        @complexity_validator.validate!(@language)
+      end
+
+      def checker
+        normal_config = Normal::Config.new(
+          language: @language,
+          serializer: :none,
+          since: @since,
+          excluded: @excluded,
+        )
+        Checker.new(engine: normal_config.checker, serializer: hotspots_serializer)
+      end
+
+      private
+
+      def hotspots_serializer
+        case @serializer
+        when :json then Serializer::Json
+        when :markdown then Serializer::Markdown
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots/serializer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Hotspots
+    module Serializer
+      module Json
+        def self.serialize(result)
+          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries.sort_by! { |e| -e[:gamma_score] }
+
+          JSON.generate({ generated: Time.now.utc.iso8601, files: entries,
+                          summary: RiskAnnotator.risk_summary(entries), })
+        end
+      end
+
+      module Markdown
+        RISK_HEADINGS = {
+          'high' => 'High Risk -- require tests and careful review',
+          'medium' => 'Medium Risk -- exercise judgement',
+          'low' => 'Low Risk -- safe for quick changes',
+        }.freeze
+
+        def self.serialize(result)
+          entries = RiskAnnotator.annotate(result[:values_by_file])
+          entries.sort_by! { |e| -e[:gamma_score] }
+          grouped = entries.group_by { |e| e[:risk] }
+
+          lines = ["## Hotspots (generated #{Date.today})", '']
+          RISK_HEADINGS.each { |level, heading| append_section(lines, grouped[level], heading) }
+          lines.join("\n")
+        end
+
+        def self.append_section(lines, entries, heading)
+          return unless entries&.any?
+
+          lines << "### #{heading}"
+          entries.each do |e|
+            lines << "- `#{e[:file]}` (gamma: #{e[:gamma_score]}, churn: #{e[:churn]}, complexity: #{e[:complexity]})"
+          end
+          lines << ''
+        end
+
+        private_class_method :append_section
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/hotspots.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'hotspots/serializer'
+require_relative 'hotspots/config'
+require_relative 'hotspots/checker'
+
+module ChurnVsComplexity
+  module Hotspots
+  end
+end

data/lib/churn_vs_complexity/language_validator.rb

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

data/lib/churn_vs_complexity/normal/config.rb

@@ -59,6 +59,22 @@ module ChurnVsComplexity
             serializer:,
             since: @since || @relative_period,
           )
+        when :python
+          Engine.concurrent(
+            complexity: Complexity::PythonCalculator,
+            churn:,
+            file_selector: FileSelector::Python.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
+        when :go
+          Engine.concurrent(
+            complexity: Complexity::GoCalculator,
+            churn:,
+            file_selector: FileSelector::Go.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
         end
       end
 
@@ -78,6 +94,8 @@ module ChurnVsComplexity
           Serializer::Summary
         when :pass_through
           Serializer::PassThrough
+        when :json
+          Serializer::Json
         end
       end
     end

data/lib/churn_vs_complexity/normal/serializer/json.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      module Json
+        class << self
+          def serialize(result)
+            values_by_file = result[:values_by_file]
+            summary = SummaryHash.serialize(result)
+
+            files = values_by_file.map { |file, values| build_file_entry(file, values) }
+
+            JSON.generate({
+                            files:,
+                            summary: summary.merge(end_date: summary[:end_date].to_s),
+                          })
+          end
+
+          private
+
+          def build_file_entry(file, values)
+            {
+              file:,
+              churn: values[0],
+              complexity: values[1].to_f,
+              gamma_score: GammaScore.calculate(values[0], values[1]).round(2),
+            }
+          end
+        end
+      end
+    end
+  end
+end