churn_vs_complexity 1.2.0 → 1.4.0

data/lib/churn_vs_complexity/serializer/timetravel/quality_calculator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Serializer
+    module Timetravel
+      EPSILON = 0.0001
+
+      class QualityCalculator
+        def initialize(min_churn:, max_churn:, min_complexity:, max_complexity:)
+          @min_churn = min_churn
+          @max_churn = max_churn
+          @min_complexity = min_complexity
+          @max_complexity = max_complexity
+        end
+
+        def alpha_score(raw_churn, raw_complexity)
+          # harmonic mean of normalised churn and complexity
+          churn = normalise(raw_churn, @min_churn, @max_churn, EPSILON)
+          complexity = normalise(raw_complexity, @min_complexity, @max_complexity, EPSILON)
+
+          (2 * churn * complexity) / (churn + complexity)
+        end
+
+        def beta_score(raw_churn, raw_complexity)
+          # geometric mean of normalised churn and complexity
+          churn = normalise(raw_churn, @min_churn, @max_churn, EPSILON)
+          complexity = normalise(raw_complexity, @min_complexity, @max_complexity, EPSILON)
+
+          Math.sqrt(churn * complexity)
+        end
+
+        private
+
+        def normalise(score, min, max, epsilon) = (score + epsilon - min) / (epsilon + max - min)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/serializer/timetravel/stats_calculator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Serializer
+    module Timetravel
+      class StatsCalculator
+        # ['some_sha', { 'end_date' => '2024-01-01', 'values' => [[1, 2], [3, 4]] }]
+        def summaries(result)
+          observations = result.sort_by do |_sha, summary|
+            summary['end_date']
+          end.map { |entry| entry[1] }
+
+          quality_calculator = QualityCalculator.new(**extrema(observations))
+          observations.map do |o|
+            end_date = o['end_date']
+            scores = o['values'].map do |(churn, complexity)|
+              alpha = quality_calculator.alpha_score(churn, complexity)
+              beta = quality_calculator.beta_score(churn, complexity)
+              [churn, complexity, alpha, beta]
+            end
+            {
+              'end_date' => end_date,
+              'mean_churn' => mean(scores.map { |s| s[0] }),
+              'median_churn' => median(scores.map { |s| s[0] }),
+              'mean_complexity' => mean(scores.map { |s| s[1] }),
+              'median_complexity' => median(scores.map { |s| s[1] }),
+              'mean_alpha_score' => mean(scores.map { |s| s[2] }),
+              'median_alpha_score' => median(scores.map { |s| s[2] }),
+              'mean_beta_score' => mean(scores.map { |s| s[3] }),
+              'median_beta_score' => median(scores.map { |s| s[3] }),
+            }
+          end
+        end
+
+        private
+
+        def extrema(observations)
+          churn_series = observations.flat_map { |o| o['values'] }.map { |(churn, _)| churn }
+          max_churn = churn_series.max
+          min_churn = churn_series.min
+
+          complexity_series = observations.flat_map { |o| o['values'] }.map { |(_, complexity)| complexity }
+          max_complexity = complexity_series.max
+          min_complexity = complexity_series.min
+
+          { max_churn:, min_churn:, max_complexity:, min_complexity: }
+        end
+
+        def mean(series)
+          series.sum / series.size
+        end
+
+        def median(series)
+          sorted = series.sort
+          sorted[sorted.size / 2]
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/serializer/timetravel.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'timetravel/quality_calculator'
+require_relative 'timetravel/stats_calculator'
+
+module ChurnVsComplexity
+  module Serializer
+    module Timetravel
+      def self.summaries(result)
+        StatsCalculator.new.summaries(result)
+      end
+
+      def self.resolve(serializer:, git_period:, relative_period:, jump_days:)
+        case serializer
+        when :csv
+          CSV
+        when :graph
+          Graph.new(git_period:, relative_period:, jump_days:)
+        end
+      end
+
+      module CSV
+        def self.serialize(result)
+          summaries = Timetravel.summaries(result)
+
+          # 2. Add title row to front of summaries
+          summaries.unshift(
+            {
+              'end_date' => 'Date',
+              'mean_churn' => 'Mean Churn',
+              'median_churn' => 'Median Churn',
+              'mean_complexity' => 'Mean Complexity',
+              'median_complexity' => 'Median Complexity',
+              'mean_alpha_score' => 'Mean Alpha Score',
+              'median_alpha_score' => 'Median Alpha Score',
+              'mean_beta_score' => 'Mean Beta Score',
+              'median_beta_score' => 'Median Beta Score',
+            },
+          )
+
+          # 3. convert to csv
+          summaries.map do |summary|
+            "#{summary['end_date']},#{summary['mean_churn']},#{summary['median_churn']},#{summary['mean_complexity']},#{summary['median_complexity']},#{summary['mean_alpha_score']},#{summary['median_alpha_score']},#{summary['mean_beta_score']},#{summary['median_beta_score']}"
+          end.join("\n")
+        end
+      end
+
+      # TODO: unit test
+      class Graph
+        def initialize(git_period:, relative_period:, jump_days:, template: Graph.load_template_file)
+          @template = template
+          @git_period = git_period
+          @relative_period = relative_period
+          @jump_days = jump_days
+        end
+
+        def self.load_template_file
+          file_path = File.expand_path('../../../tmp/template/timetravel_graph.html', __dir__)
+          File.read(file_path)
+        end
+
+        def serialize(result)
+          summaries = Timetravel.summaries(result)
+
+          data = summaries.map do |summary|
+            JSON.dump(summary)
+          end.join(",\n") + "\n"
+
+          @template.gsub("// INSERT DATA\n", data)
+                   .gsub('INSERT TITLE', title)
+                   .gsub('INSERT CHURN MODIFIER', churn_modifier)
+        end
+
+        private
+
+        def title
+          "#{churn_modifier}churn and complexity since #{since} evaluated every #{@jump_days} days"
+        end
+
+        def since
+          if @git_period.requested_start_date.nil?
+            'start of project'
+          else
+            @git_period.effective_start_date.strftime('%Y-%m-%d').to_s
+          end
+        end
+
+        def churn_modifier
+          case @relative_period
+          when :month
+            'Monthly '
+          when :quarter
+            'Quarterly '
+          when :year
+            'Yearly '
+          else
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/serializer.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'serializer/timetravel'
+require_relative 'serializer/summary_hash'
+require_relative 'serializer/summary'
+require_relative 'serializer/csv'
+require_relative 'serializer/graph'
+require_relative 'serializer/pass_through'
+
 module ChurnVsComplexity
   module Serializer
     def self.title(result)
@@ -15,65 +22,5 @@ module ChurnVsComplexity
     module None
       def self.serialize(result) = result
     end
-
-    module Summary
-      def self.serialize(result)
-        values_by_file = result[:values_by_file]
-        churn_values = values_by_file.map { |_, values| values[0].to_f }
-        complexity_values = values_by_file.map { |_, values| values[1].to_f }
-
-        mean_churn = churn_values.sum / churn_values.size
-        median_churn = churn_values.sort[churn_values.size / 2]
-        mean_complexity = complexity_values.sum / complexity_values.size
-        median_complexity = complexity_values.sort[complexity_values.size / 2]
-
-        product = values_by_file.map { |_, values| values[0].to_f * values[1].to_f }
-        mean_product = product.sum / product.size
-        median_product = product.sort[product.size / 2]
-
-        <<~SUMMARY
-          #{Serializer.title(result)}
-
-          Number of observations: #{values_by_file.size}
-
-          Churn:
-          Mean #{mean_churn}, Median #{median_churn}
-
-          Complexity:
-          Mean #{mean_complexity}, Median #{median_complexity}
-
-          Product of churn and complexity:
-          Mean #{mean_product}, Median #{median_product}
-        SUMMARY
-      end
-    end
-
-    module CSV
-      def self.serialize(result)
-        values_by_file = result[:values_by_file]
-        values_by_file.map do |file, values|
-          "#{file},#{values[0]},#{values[1]}\n"
-        end.join
-      end
-    end
-
-    class Graph
-      def initialize(template: Graph.load_template_file)
-        @template = template
-      end
-
-      def serialize(result)
-        data = result[:values_by_file].map do |file, values|
-          "{ file_path: '#{file}', churn: #{values[0]}, complexity: #{values[1]} }"
-        end.join(",\n") + "\n"
-        title = Serializer.title(result)
-        @template.gsub("// INSERT DATA\n", data).gsub('INSERT TITLE', title)
-      end
-
-      def self.load_template_file
-        file_path = File.expand_path('../../tmp/template/graph.html', __dir__)
-        File.read(file_path)
-      end
-    end
   end
 end

data/lib/churn_vs_complexity/timetravel/traveller.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  # TODO: unit test and integration test
+  module Timetravel
+    class Traveller
+      def initialize(since:, relative_period:, engine:, serializer:, jump_days:, factory: Factory)
+        @relative_period = relative_period
+        @engine = engine
+        @jump_days = jump_days
+        @serializer = serializer
+        @git_period = GitDate.git_period(since, Time.now.to_date)
+        @factory = factory
+      end
+
+      def go(folder:)
+        git_strategy = @factory.git_strategy(folder:)
+        commits = git_strategy.resolve_commits_with_interval(git_period: @git_period, jump_days: @jump_days)
+
+        chunked = make_chunks(commits)
+        work_on(chunked:, folder:, git_strategy:)
+        combined = chunked.map { |c_and_p| read_result(c_and_p[:pipe]) }.reduce({}, :merge)
+
+        serializer.serialize(combined)
+      end
+
+      private
+
+      def work_on(chunked:, folder:, git_strategy:)
+        chunked.map.with_index do |c_and_p, i|
+          worktree = @factory.worktree(root_folder: folder, git_strategy:, number: i)
+          worktree.prepare
+          schedule_work(worktree:, **c_and_p)
+        end
+      end
+
+      def make_chunks(commits)
+        chunk_size = (commits.size / 3.0).ceil
+        commits.each_slice(chunk_size).map do |chunk|
+          { chunk:, pipe: @factory.pipe }
+        end.to_a
+      end
+
+      def read_result(pipe)
+        part = begin
+          JSON.parse(pipe[0].gets)
+        rescue StandardError => e
+          warn "Error parsing JSON: #{e}"
+          {}
+        end
+        pipe.each(&:close)
+        part
+      end
+
+      def schedule_work(chunk:, worktree:, pipe:)
+        @factory.worker(engine: @engine, worktree:)
+                .schedule(chunk:, pipe:)
+      end
+
+      def serializer
+        @factory.serializer(serializer: @serializer, git_period: @git_period,
+                            relative_period: @relative_period, jump_days: @jump_days,)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/timetravel/worktree.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'tmpdir'
+
+module ChurnVsComplexity
+  module Timetravel
+    class Worktree
+      attr_reader :folder
+
+      def initialize(root_folder:, git_strategy:, number:)
+        @root_folder = root_folder
+        @git_strategy = git_strategy
+        @number = number
+      end
+
+      def prepare
+        @folder = prepare_worktree
+      end
+
+      def checkout(sha)
+        raise Error, 'Worktree not prepared' if @folder.nil?
+
+        @git_strategy.checkout_in_worktree(@folder, sha)
+      end
+
+      def remove
+        raise Error, 'Worktree not prepared' if @folder.nil?
+
+        @git_strategy.remove_worktree(@folder)
+      end
+
+      private
+
+      def tt_folder
+        folder_hash = Digest::SHA256.hexdigest(@root_folder)[0..7]
+        File.join(Dir.tmpdir, 'churn_vs_complexity', 'timetravel', folder_hash)
+      end
+
+      def prepare_worktree
+        worktree_folder = File.join(tt_folder, "worktree_#{@number}")
+
+        unless File.directory?(worktree_folder)
+          begin
+            FileUtils.mkdir_p(worktree_folder)
+          rescue StandardError
+            nil
+          end
+          @git_strategy.add_worktree(worktree_folder)
+        end
+
+        worktree_folder
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/timetravel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'timetravel/traveller'
+require_relative 'timetravel/worktree'
+
+module ChurnVsComplexity
+  module Timetravel
+    class Factory
+      def self.git_strategy(folder:) = GitStrategy.new(folder:)
+      def self.pipe = IO.pipe
+      def self.worker(engine:, worktree:) = Worker.new(engine:, worktree:)
+      def self.worktree(root_folder:, git_strategy:, number:) = Worktree.new(root_folder:, git_strategy:, number:)
+      def self.serializer(**args) = Serializer::Timetravel.resolve(**args)
+    end
+
+    class Worker
+      def initialize(engine:, worktree:)
+        @engine = engine
+        @worktree = worktree
+      end
+
+      def schedule(chunk:, pipe:)
+        fork do
+          results = chunk.to_h do |commit|
+            sha = commit.sha
+            @worktree.checkout(sha)
+            result = @engine.check(folder: @worktree.folder)
+            [sha, result]
+          end
+          @worktree.remove
+          pipe[1].puts(JSON.dump(results))
+          pipe[1].close
+        end
+      end
+    end
+
+    class GitStrategy
+      def initialize(folder:)
+        @repo = Git.open(folder)
+        @folder = folder
+      end
+
+      def checkout_in_worktree(worktree_folder, sha)
+        command = "(cd #{worktree_folder} && git checkout #{sha}) > /dev/null 2>&1"
+        `#{command}`
+      end
+
+      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
+
+        commits_by_date = candidates.filter { |c| c.date.to_date >= git_period.effective_start_date }
+                                    .group_by { |c| c.date.to_date }
+
+        found_dates = GitDate.select_dates_with_at_least_interval(commits_by_date.keys, jump_days)
+
+        found_dates.map { |date| commits_by_date[date].max_by(&:date) }
+      end
+
+      def add_worktree(wt_folder)
+        command = "(cd #{@folder} && git worktree add -f #{wt_folder}) > /dev/null 2>&1"
+        `#{command}`
+      end
+
+      def remove_worktree(worktree_folder)
+        command = "(cd #{worktree_folder} && git worktree remove -f #{worktree_folder}) > /dev/null 2>&1"
+        `#{command}`
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/version.rb

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

data/lib/churn_vs_complexity.rb

@@ -13,7 +13,9 @@ require_relative 'churn_vs_complexity/cli'
 require_relative 'churn_vs_complexity/config'
 require_relative 'churn_vs_complexity/serializer'
 require_relative 'churn_vs_complexity/git_date'
+require_relative 'churn_vs_complexity/timetravel'
 
 module ChurnVsComplexity
   class Error < StandardError; end
+  class ValidationError < Error; end
 end

data/package-lock.json

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

data/tmp/eslint-support/complexity-calculator.js

@@ -0,0 +1,51 @@
+import { ESLint } from 'eslint';
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+async function analyzeComplexity(files) {
+    const overrideConfig = tseslint.config(
+        eslint.configs.recommended,
+        ...tseslint.configs.recommended,
+        {
+            rules: {
+                'complexity': ['warn', 0],
+            },
+                        
+        }
+    );
+
+    const linter = new ESLint({
+        overrideConfigFile: true,
+        overrideConfig,
+        cwd: '/',
+    });
+
+    try {
+        const results = await linter.lintFiles(files);
+        const complexityResults = results.map(result => {
+            const messages = result.messages.filter(msg => msg.ruleId === 'complexity');
+            const complexity = messages.reduce((sum, msg) => {
+                const complexityValue = parseInt(msg.message.match(/\d+/)[0], 10);
+                return sum + complexityValue;
+            }, 0);
+            
+            if (complexity === 0) {
+                console.error("File has no complexity", result);
+            }
+
+            return {
+                file: result.filePath,
+                complexity,
+            };
+        });
+
+        console.log(JSON.stringify(complexityResults));
+    } catch (error) {
+        console.error('Error during analysis:', error);
+        process.exit(1);
+    }
+}
+
+const files = JSON.parse(process.argv[2]);
+analyzeComplexity(files);

data/tmp/eslint-support/package.json

@@ -0,0 +1,11 @@
+{
+  "type": "module",
+  "dependencies": {
+    "eslint-plugin-complexity": "^1.0.2",
+    "@eslint/js": "^9.11.1",
+    "@types/eslint__js": "^8.42.3",
+    "eslint": "^9.11.1",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0"
+  }
+}

data/tmp/template/graph.html

@@ -16,10 +16,7 @@
     ];
 
     // Extract data for Chart.js
-    const labels = dataPoints.map(point => point.file_path);
-    const churnData = dataPoints.map(point => point.churn);
-    const complexityData = dataPoints.map(point => point.complexity);
-
+    const labels = dataPoints.map(point => point.file_path);    
     // Prepare data in Chart.js format
     const data = {
       labels: labels,

data/tmp/template/timetravel_graph.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>INSERT TITLE</title>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-date-fns"></script>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+    }
+    h1 {
+      text-align: center;
+      font-size: 24px;
+      font-weight: bold;
+      margin-bottom: 20px;
+      color: #333;
+    }
+    canvas {
+      margin: 20px auto;
+    }
+  </style>
+</head>
+<body>
+  <h1>INSERT TITLE</h1>
+  <canvas id="complexityChart" width="800" height="400"></canvas>
+  <canvas id="churnChart" width="800" height="400"></canvas>
+  <canvas id="alphaScoreChart" width="800" height="400"></canvas>
+  <canvas id="betaScoreChart" width="800" height="400"></canvas>
+
+  <script>
+    
+    const dataPoints = [
+      // INSERT DATA
+    ];
+
+    // Extract dates for x-axis
+    const labels = dataPoints.map(point => point.end_date);
+
+    // Function to create a dataset
+    function createDataset(label, data, color) {
+      return {
+        label: label,
+        data: data,
+        borderColor: color,
+        backgroundColor: color,
+        fill: false,
+        tension: 0.1
+      };
+    }
+
+    // Function to create a chart
+    function createChart(ctx, title, datasets) {
+      return new Chart(ctx, {
+        type: 'line',
+        data: { labels: labels, datasets: datasets },
+        options: {
+          responsive: true,
+          plugins: {
+            title: { display: true, text: title }
+          },
+          scales: {
+            x: { type: 'time', time: { parser: 'yyyy-MM-dd', tooltipFormat: 'll' } },
+            y: { beginAtZero: true }
+          }
+        }
+      });
+    }
+
+    // Create Complexity Chart
+    const complexityCtx = document.getElementById('complexityChart').getContext('2d');
+    createChart(complexityCtx, 'Complexity Over Time', [
+      createDataset('Mean Complexity', dataPoints.map(p => ({ x: p.end_date, y: p.mean_complexity })), 'rgb(75, 192, 192)'),
+      createDataset('Median Complexity', dataPoints.map(p => ({ x: p.end_date, y: p.median_complexity })), 'rgb(255, 99, 132)')
+    ]);
+
+    // Create Churn Chart
+    const churnCtx = document.getElementById('churnChart').getContext('2d');
+    createChart(churnCtx, 'INSERT CHURN MODIFIERChurn Over Time', [
+      createDataset('Mean Churn', dataPoints.map(p => ({ x: p.end_date, y: p.mean_churn })), 'rgb(54, 162, 235)'),
+      createDataset('Median Churn', dataPoints.map(p => ({ x: p.end_date, y: p.median_churn })), 'rgb(255, 206, 86)')
+    ]);
+
+    // Create Alpha Score Chart
+    const alphaScoreCtx = document.getElementById('alphaScoreChart').getContext('2d');
+    createChart(alphaScoreCtx, 'Alpha Score Over Time', [
+      createDataset('Mean Alpha Score', dataPoints.map(p => ({ x: p.end_date, y: p.mean_alpha_score })), 'rgb(153, 102, 255)'),
+      createDataset('Median Alpha Score', dataPoints.map(p => ({ x: p.end_date, y: p.median_alpha_score })), 'rgb(255, 159, 64)')
+    ]);
+
+    // Create Beta Score Chart  
+    const betaScoreCtx = document.getElementById('betaScoreChart').getContext('2d');
+    createChart(betaScoreCtx, 'Beta Score Over Time', [
+      createDataset('Mean Beta Score', dataPoints.map(p => ({ x: p.end_date, y: p.mean_beta_score })), 'rgb(153, 102, 255)'),
+      createDataset('Median Beta Score', dataPoints.map(p => ({ x: p.end_date, y: p.median_beta_score })), 'rgb(255, 159, 64)')
+    ]);
+  </script>
+</body>
+</html>