churn_vs_complexity 1.4.0 → 1.5.2

data/lib/churn_vs_complexity/delta/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Delta
+    class Config
+      def initialize(
+        language:,
+        serializer:,
+        commits:,
+        excluded: [],
+        complexity_validator: ComplexityValidator,
+        factory: Factory,
+        **_options
+      )
+        @language = language
+        @serializer = serializer
+        @excluded = excluded
+        @commits = commits
+        @factory = factory
+      end
+
+      def validate!
+        validate_commits!
+        LanguageValidator.validate!(@language)
+        SerializerValidator.validate!(serializer: @serializer)
+        @factory.complexity_validator.validate!(@language)
+      end
+
+      def checker
+        MultiChecker.new(serializer:, excluded: @excluded, factory: @factory, commits: @commits,
+                         language: @language,)
+      end
+
+      private
+
+      def validate_commits!
+        @commits.each { |commit| validate_commit!(commit) }
+      end
+
+      def validate_commit!(commit)
+        return if commit == 'HEAD' || commit.match?(/\A[0-9a-f]{40}\z/i) || commit.match?(/\A[0-9a-f]{8}\z/i)
+
+        raise ValidationError,
+              "Invalid commit: #{commit}. It must be a valid 40-character SHA-1 hash or an 8-character shortened form."
+      end
+
+      def serializer = Serializer.resolve(@serializer)
+    end
+  end
+end

data/lib/churn_vs_complexity/delta/factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Delta
+    module Factory
+      def self.complexity_validator = ComplexityValidator
+      def self.git_strategy(folder:) = GitStrategy.new(folder:)
+
+      def self.worktree(root_folder:, git_strategy:, data_isolation_id:)
+        Timetravel::Worktree.new(
+          root_folder:,
+          git_strategy:,
+          number: data_isolation_id,
+        )
+      end
+
+      def self.engine(cache_components:, language:, excluded:, files:)
+        Delta.engine(cache_components:, language:, excluded:, files:)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/delta/multi_checker.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Delta
+    CONCURRENCY = Etc.nprocessors * 2
+
+    class MultiChecker
+      def initialize(serializer:, factory:, commits:, language:, excluded:)
+        @serializer = serializer
+        @excluded = excluded
+        @factory = factory
+        @commits = commits
+        @language = language
+      end
+
+      def check(folder:)
+        indexed_commits = @commits.map.with_index do |commit, index|
+          [commit, index]
+        end
+
+        results = []
+
+        concurrency = [CONCURRENCY, indexed_commits.size].min
+
+        concurrency.times.map do |ci|
+          Thread.new do
+            loop do
+              commit, index = indexed_commits.shift
+              break if commit.nil?
+
+              result = check_commit(commit:, data_isolation_id: ci, folder:)
+              results[index] = result
+            end
+          end
+        end.each(&:join)
+
+        @serializer.serialize(results)
+      end
+
+      private
+
+      def check_commit(commit:, data_isolation_id:, folder:)
+        Checker.new(serializer: Serializer::PassThrough, factory: @factory, commit:, language: @language,
+                    excluded: @excluded, data_isolation_id:,).check(folder:)
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/delta/serializer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Delta
+    module Serializer
+      def self.resolve(serializer)
+        case serializer
+        when :none
+          Normal::Serializer::None
+        when :csv
+          CSV
+        when :summary
+          Summary
+        when :pass_through
+          PassThrough
+        end
+      end
+
+      module CSV
+        def self.serialize(result)
+          results = result.is_a?(Array) ? result : [result]
+          changes = results.flat_map { |r| r[:changes].each { |c| c[:commit] = r[:commit] } }
+          rows = ['Commit, Relative Path, Type of Change, Complexity']
+          changes.each do |change|
+            rows << "#{change[:commit]}, #{change[:path]}, #{change[:type]}, #{change[:complexity]}"
+          end
+          rows.join("\n")
+        end
+
+        def has_commit_summary? = false
+      end
+
+      module Summary
+        class << self
+          def serialize(result)
+            results = result.is_a?(Array) ? result : [result]
+            results.map { |r| serialize_single(r) }.join("\n\n\n\n")
+          end
+
+          def has_commit_summary? = true
+
+          private
+
+          def serialize_single(result)
+            changes = result[:changes]
+
+            commit_text = "Commit:   #{result[:commit]}\nParent:   #{result[:parent]}\nNext:     #{result[:next_commit]}"
+            change_text = changes.empty? ? '(No changes)' : describe(changes)
+
+            "#{commit_text}\n\n\n#{change_text}"
+          end
+
+          def describe(changes)
+            changes.map do |change|
+              a = "File, relative path:  #{change[:path]}\nType of change:       #{change[:type]}"
+              b = "\nComplexity:           #{change[:complexity]}" unless change[:complexity].nil?
+              "#{a}#{b}"
+            end.join("\n\n")
+          end
+        end
+      end
+
+      module PassThrough
+        extend Normal::Serializer::None
+        def self.has_commit_summary? = true
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/delta.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'delta/config'
+require_relative 'delta/checker'
+require_relative 'delta/serializer'
+require_relative 'delta/factory'
+require_relative 'delta/complexity_annotator'
+require_relative 'delta/multi_checker'
+require_relative 'delta/commit_hydrator'
+
+module ChurnVsComplexity
+  module Delta
+    module SerializerValidator
+      def self.validate!(serializer:); end
+    end
+
+    class << self
+      def engine(cache_components:, language:, excluded:, files:)
+        file_selector = file_selector(language:, included: files, excluded:)
+        Engine.concurrent(
+          since: nil, complexity: complexity(language, cache_components), churn: Churn::Disabled,
+          serializer: Normal::Serializer::None,
+          file_selector:,
+        )
+      end
+
+      private
+
+      def file_selector(language:, included:, excluded:)
+        case language
+        when :java
+          FileSelector::Java.predefined(included:, excluded:)
+        when :ruby
+          FileSelector::Ruby.predefined(included:, excluded:)
+        when :javascript
+          FileSelector::JavaScript.predefined(included:, excluded:)
+        end
+      end
+
+      def complexity(language, cache_components)
+        case language
+        when :java
+          Complexity::PMD::FilesCalculator.new(cache_components:)
+        when :ruby
+          Complexity::FlogCalculator
+        when :javascript
+          Complexity::ESLintCalculator
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/engine.rb

@@ -15,7 +15,7 @@ module ChurnVsComplexity
       @serializer.serialize(result)
     end
 
-    def self.concurrent(since:, complexity:, churn:, serializer: Serializer::None, file_selector: FileSelector::Any)
+    def self.concurrent(since:, complexity:, churn:, serializer: Normal::Serializer::None, file_selector: FileSelector::Any)
       Engine.new(since:, file_selector:, serializer:, calculator: ConcurrentCalculator.new(complexity:, churn:))
     end
   end

data/lib/churn_vs_complexity/file_selector.rb

@@ -2,6 +2,19 @@
 
 module ChurnVsComplexity
   module FileSelector
+    def self.extensions(language)
+      case language
+      when :java
+        ['.java']
+      when :ruby
+        ['.rb']
+      when :javascript
+        ['.js', '.jsx', '.ts', '.tsx']
+      else
+        raise Error, "Unsupported language: #{language}"
+      end
+    end
+
     module Any
       def self.select_files(folder)
         included = Dir.glob("#{folder}/**/*").select { |f| File.file?(f) }
@@ -19,7 +32,7 @@ module ChurnVsComplexity
       def select_files(folder)
         were_excluded = []
         were_included = []
-        Dir.glob("#{folder}/**/*").each do |f|
+        candidates(folder).each do |f|
           if has_excluded_pattern?(f)
             were_excluded << f
           elsif has_correct_extension?(f) && File.file?(f)
@@ -33,6 +46,12 @@ module ChurnVsComplexity
         { explicitly_excluded: were_excluded, included: were_included }
       end
 
+      protected
+
+      def candidates(folder)
+        Dir.glob("#{folder}/**/*")
+      end
+
       private
 
       def has_correct_extension?(file_path)
@@ -44,21 +63,45 @@ module ChurnVsComplexity
       end
     end
 
+    class Predefined < Excluding
+      def initialize(included:, extensions:, excluded:, convert_to_absolute_path: false)
+        super(extensions, excluded, convert_to_absolute_path)
+        @included = included
+      end
+
+      protected
+
+      def candidates(*) = @included
+    end
+
     module Java
       def self.excluding(excluded)
-        Excluding.new(['.java'], excluded)
+        Excluding.new(FileSelector.extensions(:java), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:java), excluded:)
       end
     end
 
     module Ruby
       def self.excluding(excluded)
-        Excluding.new(['.rb'], excluded)
+        Excluding.new(FileSelector.extensions(:ruby), excluded)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:ruby), excluded:)
       end
     end
 
     module JavaScript
       def self.excluding(excluded)
-        Excluding.new(['.js', '.jsx', '.ts', '.tsx'], excluded, true)
+        Excluding.new(FileSelector.extensions(:javascript), excluded, true)
+      end
+
+      def self.predefined(included:, excluded:)
+        Predefined.new(included:, extensions: FileSelector.extensions(:javascript), excluded:,
+                       convert_to_absolute_path: true,)
       end
     end
   end

data/lib/churn_vs_complexity/git_strategy.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  class GitStrategy
+    def initialize(folder:)
+      @repo = Git.open(folder)
+      @folder = folder
+    end
+
+    def valid_commit?(commit:)
+      @repo.object(commit)
+      true
+    rescue Git::GitExecuteError
+      false
+    end
+
+    def object(commit)
+      commit.is_a?(Git::Object::Commit) ? commit : @repo.object(commit)
+    end
+
+    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]
+    end
+
+    def changes(commit:)
+      commit_object = @repo.object(commit)
+      base = commit_object.parent
+      commit_object.diff(base).map do |change|
+        { path: change.path, type: change.type.to_sym }
+      end
+    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

data/lib/churn_vs_complexity/language_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module LanguageValidator
+    def self.validate!(language)
+      raise ValidationError, "Unsupported language: #{language}" unless %i[java ruby javascript].include?(language)
+    end
+  end
+end

data/lib/churn_vs_complexity/normal/config.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    class Config
+      def initialize(
+        language:,
+        serializer:,
+        excluded: [],
+        since: nil,
+        relative_period: nil,
+        complexity_validator: ComplexityValidator,
+        since_validator: SinceValidator,
+        **options
+      )
+        @language = language
+        @serializer = serializer
+        @excluded = excluded
+        @since = since
+        @relative_period = relative_period
+        @complexity_validator = complexity_validator
+        @since_validator = since_validator
+        @options = options
+      end
+
+      def validate!
+        LanguageValidator.validate!(@language)
+
+        SerializerValidator.validate!(serializer: @serializer)
+
+        @since_validator.validate!(since: @since, relative_period: @relative_period)
+        RelativePeriodValidator.validate!(relative_period: @relative_period)
+        @complexity_validator.validate!(@language)
+      end
+
+      def checker
+        case @language
+        when :java
+          Engine.concurrent(
+            complexity: Complexity::PMD::FolderCalculator,
+            churn:,
+            file_selector: FileSelector::Java.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
+        when :ruby
+          Engine.concurrent(
+            complexity: Complexity::FlogCalculator,
+            churn:,
+            file_selector: FileSelector::Ruby.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
+        when :javascript
+          Engine.concurrent(
+            complexity: Complexity::ESLintCalculator,
+            churn:,
+            file_selector: FileSelector::JavaScript.excluding(@excluded),
+            serializer:,
+            since: @since || @relative_period,
+          )
+        end
+      end
+
+      private
+
+      def churn = Churn::GitCalculator
+
+      def serializer
+        case @serializer
+        when :none
+          Serializer::None
+        when :csv
+          Serializer::CSV
+        when :graph
+          Serializer::Graph.new
+        when :summary
+          Serializer::Summary
+        when :pass_through
+          Serializer::PassThrough
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      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
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      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.join(ROOT_PATH, 'tmp/template/graph.html')
+          File.read(file_path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      module PassThrough
+        class << self
+          def serialize(result)
+            values_by_file = result[:values_by_file]
+            end_date = result[:git_period].end_date
+            values = values_by_file.map do |_, values|
+              [values[0].to_f, values[1].to_f]
+            end
+            {
+              end_date:,
+              values:,
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      module Summary
+        def self.serialize(result)
+          values_by_file = result[:values_by_file]
+          summary = SummaryHash.serialize(result)
+
+          <<~SUMMARY
+            #{Serializer.title(result)}
+
+            Number of observations: #{values_by_file.size}
+
+            Churn:
+            Mean #{summary[:mean_churn]}, Median #{summary[:median_churn]}
+
+            Complexity:
+            Mean #{summary[:mean_complexity]}, Median #{summary[:median_complexity]}
+
+            Gamma score:
+            Mean #{summary[:mean_gamma_score]}, Median #{summary[:median_gamma_score]}
+          SUMMARY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ChurnVsComplexity
+  module Normal
+    module Serializer
+      module SummaryHash
+        class << self
+          def 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]
+
+            max_churn = churn_values.max
+            min_churn = churn_values.min
+            max_complexity = complexity_values.max
+            min_complexity = complexity_values.min
+
+            epsilon = 0.0001
+            gamma_score = values_by_file.map do |_, values|
+              # unnormalised harmonic mean of churn and complexity,
+              # since the summary needs to be comparable over time
+              churn = values[0].to_f + epsilon
+              complexity = values[1].to_f + epsilon
+
+              (2 * churn * complexity) / (churn + complexity)
+            end
+
+            mean_gamma_score = gamma_score.sum / gamma_score.size
+            median_gamma_score = gamma_score.sort[gamma_score.size / 2]
+
+            end_date = result[:git_period].end_date
+
+            {
+              mean_churn:,
+              median_churn:,
+              max_churn:,
+              min_churn:,
+              mean_complexity:,
+              median_complexity:,
+              max_complexity:,
+              min_complexity:,
+              mean_gamma_score:,
+              median_gamma_score:,
+              end_date:,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/churn_vs_complexity/normal/serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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 Normal
+    module Serializer
+      def self.title(result)
+        requested_start_date = result[:git_period].requested_start_date
+        end_date = result[:git_period].end_date
+        if requested_start_date.nil?
+          "Churn until #{end_date.strftime('%Y-%m-%d')} vs complexity"
+        else
+          "Churn between #{requested_start_date.strftime('%Y-%m-%d')} and #{end_date.strftime('%Y-%m-%d')} vs complexity"
+        end
+      end
+
+      module None
+        extend self
+
+        def serialize(result) = result
+      end
+    end
+  end
+end