churn_vs_complexity 1.4.0 → 1.5.2

data/lib/churn_vs_complexity/config.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module ChurnVsComplexity
-  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!
-      raise ValidationError, "Unsupported language: #{@language}" unless %i[java ruby javascript].include?(@language)
-
-      SerializerValidator.validate!(serializer: @serializer, mode: @options[:mode])
-
-      @since_validator.validate!(since: @since, relative_period: @relative_period, mode: @options[:mode])
-      RelativePeriodValidator.validate!(relative_period: @relative_period, mode: @options[:mode])
-      @complexity_validator.validate!(@language)
-    end
-
-    def timetravel
-      engine = timetravel_engine_config.to_engine
-      Timetravel::Traveller.new(
-        since: @since,
-        relative_period: @relative_period,
-        engine:,
-        jump_days: @options[:jump_days],
-        serializer: @serializer,
-      )
-    end
-
-    def to_engine
-      case @language
-      when :java
-        Engine.concurrent(
-          complexity: Complexity::PMDCalculator,
-          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 timetravel_engine_config
-      Config.new(
-        language: @language,
-        serializer: :pass_through,
-        excluded: @excluded,
-        since: nil, # since has a different meaning in timetravel mode
-        relative_period: @relative_period,
-        complexity_validator: @complexity_validator,
-        since_validator: @since_validator,
-        **@options,
-      )
-    end
-
-    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
-
-    module ComplexityValidator
-      def self.validate!(language)
-        case language
-        when :java
-          Complexity::PMDCalculator.check_dependencies!
-        end
-      end
-    end
-
-    # TODO: unit test
-    module SerializerValidator
-      def self.validate!(serializer:, mode:)
-        raise ValidationError, "Unsupported serializer: #{serializer}" \
-          unless %i[none csv graph summary].include?(serializer)
-        raise ValidationError, 'Does not support --summary in --timetravel mode' \
-         if serializer == :summary && mode == :timetravel
-      end
-    end
-
-    # TODO: unit test
-    module RelativePeriodValidator
-      def self.validate!(relative_period:, mode:)
-        if mode == :timetravel && relative_period.nil?
-          raise ValidationError,
-                'Relative period is required in timetravel mode'
-        end
-        return if relative_period.nil? || %i[month quarter year].include?(relative_period)
-
-        raise ValidationError, "Invalid relative period #{relative_period}"
-      end
-    end
-
-    module SinceValidator
-      def self.validate!(since:, relative_period:, mode:)
-        # since can be nil, a date string or a keyword (:month, :quarter, :year)
-        return if since.nil?
-
-        unless mode == :timetravel || since.nil? || relative_period.nil?
-          raise ValidationError,
-                '--since and relative period (--month, --quarter, --year) can only be used together in --timetravel mode'
-        end
-
-        raise ValidationError, "Invalid since value #{since}" unless since.is_a?(String)
-
-        begin
-          Date.strptime(since, '%Y-%m-%d')
-        rescue Date::Error
-          raise ValidationError, "Invalid date #{since}, please use correct format, YYYY-MM-DD"
-        end
-      end
-    end
-  end
-end

data/lib/churn_vs_complexity/serializer/csv.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module ChurnVsComplexity
-  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

data/lib/churn_vs_complexity/serializer/graph.rb

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

data/lib/churn_vs_complexity/serializer/pass_through.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module ChurnVsComplexity
-  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

data/lib/churn_vs_complexity/serializer/summary.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module ChurnVsComplexity
-  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

data/lib/churn_vs_complexity/serializer/summary_hash.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module ChurnVsComplexity
-  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

data/lib/churn_vs_complexity/serializer.rb

@@ -1,26 +0,0 @@
-# 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)
-      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
-      def self.serialize(result) = result
-    end
-  end
-end