attractor 2.6.0 → 2.7.1

data/lib/attractor/cache.rb

@@ -22,6 +22,10 @@ module Attractor
         adapter.clear
       end
 
+      def reset!
+        adapter.reset!
+      end
+
       private
 
       def adapter
@@ -33,9 +37,16 @@ module Attractor
   module CacheAdapter
     class Base
       include Singleton
+
+      def reset!
+        # subclasses may override
+      end
     end
 
     class JSON < Base
+      SCHEMA_VERSION = 2
+      SCHEMA_KEY = "schema_version"
+
       def initialize
         super
 
@@ -43,14 +54,16 @@ module Attractor
         FileUtils.mkdir_p @data_directory
         FileUtils.touch filename
 
-        begin
-          @store = ::JSON.parse(File.read(filename))
-        rescue ::JSON::ParserError
-          @store = {}
-        end
+        load_store
+      end
+
+      def reset!
+        load_store
       end
 
       def read(file_path:)
+        return nil if file_path == SCHEMA_KEY
+
         value_hash = @store[file_path]
 
         Value.new(**value_hash.values.first.transform_keys(&:to_sym)) unless value_hash.nil?
@@ -67,6 +80,7 @@ module Attractor
       end
 
       def persist!
+        @store[SCHEMA_KEY] ||= SCHEMA_VERSION
         File.write(filename, ::JSON.dump(@store))
       end
 
@@ -77,6 +91,23 @@ module Attractor
       def filename
         "#{@data_directory}/attractor-cache.json"
       end
+
+      private
+
+      def load_store
+        FileUtils.touch filename
+
+        begin
+          @store = ::JSON.parse(File.read(filename))
+        rescue ::JSON::ParserError
+          @store = {}
+        end
+
+        if @store[SCHEMA_KEY] != SCHEMA_VERSION
+          @store = {SCHEMA_KEY => SCHEMA_VERSION}
+          persist!
+        end
+      end
     end
   end
 end

data/lib/attractor/calculators/base_calculator.rb

@@ -8,14 +8,16 @@ module Attractor
   # calculates churn and complexity
   class BaseCalculator
     attr_reader :type
+    attr_accessor :files
 
-    def initialize(file_prefix: "", ignores: "", file_extension: "rb", minimum_churn_count: 3, start_ago: "5y", verbose: false)
+    def initialize(file_prefix: "", ignores: "", file_extension: "rb", minimum_churn_count: 3, start_ago: "5y", verbose: false, files: nil)
       @file_prefix = file_prefix
       @file_extension = file_extension
       @minimum_churn_count = minimum_churn_count
       @start_date = Date.today - Attractor::DurationParser.new(start_ago).duration
       @ignores = ignores
       @verbose = verbose
+      @files = files
     end
 
     def calculate
@@ -27,29 +29,29 @@ module Attractor
         ignores: @ignores
       ).report(false)
 
-      puts "Calculating churn and complexity values for #{churn[:churn][:changes].size} #{type} files" if @verbose
+      changes_by_path = churn[:churn][:changes].each_with_object({}) do |change, hash|
+        hash[change[:file_path]] = change
+      end
 
-      values = churn[:churn][:changes].map do |change|
-        history = git_history_for_file(file_path: change[:file_path])
-        commit = history&.first&.first
+      target_paths = if @files && !@files.empty?
+        # `file_extension` is a pattern, not a literal: the JavaScript calculator
+        # passes "(js|jsx)". `end_with?` would drop every file it lists.
+        extension = /\.(?:#{@file_extension})\z/
+        @files.uniq.select { |file_path| file_path.match?(extension) }
+      else
+        changes_by_path.keys
+      end
 
-        cached_value = Cache.read(file_path: change[:file_path])
+      puts "Calculating churn and complexity values for #{target_paths.size} #{type} files" if @verbose
 
-        if !cached_value.nil? && !cached_value.current_commit.nil? && cached_value.current_commit == commit
-          value = cached_value
-        else
-          complexity, details = yield(change)
+      values = target_paths.filter_map do |file_path|
+        change = changes_by_path[file_path]
 
-          value = Value.new(file_path: change[:file_path],
-            churn: change[:times_changed],
-            complexity: complexity,
-            details: details,
-            history: history)
-          Cache.write(file_path: change[:file_path], value: value)
+        if change
+          build_value(change) { |c| yield(c) if block_given? }
+        elsif @files && !@files.empty? && !File.exist?(file_path)
+          missing_value(file_path)
         end
-
-        print "." if @verbose
-        value
       end
 
       Cache.persist!
@@ -61,6 +63,39 @@ module Attractor
 
     private
 
+    def build_value(change)
+      if @files && !@files.empty? && !File.exist?(change[:file_path])
+        return missing_value(change[:file_path], churn: change[:times_changed])
+      end
+
+      history = git_history_for_file(file_path: change[:file_path])
+      commit = history&.first&.first
+
+      cached_value = Cache.read(file_path: change[:file_path])
+
+      if !cached_value.nil? && !cached_value.current_commit.nil? && cached_value.current_commit == commit
+        cached_value
+      elsif block_given?
+        complexity, details = yield(change)
+
+        value = Value.new(file_path: change[:file_path],
+          churn: change[:times_changed],
+          complexity: complexity,
+          details: details,
+          history: history)
+        Cache.write(file_path: change[:file_path], value: value)
+        value
+      end
+    end
+
+    def missing_value(file_path, churn: 0)
+      Value.new(file_path: file_path,
+        churn: churn,
+        complexity: nil,
+        details: [],
+        history: git_history_for_file(file_path: file_path))
+    end
+
     def git_history_for_file(file_path:, limit: 10)
       history = `git log --oneline -n #{limit} -- #{file_path}`
       history.split("\n")

data/lib/attractor/cli.rb

@@ -7,13 +7,21 @@ require "attractor"
 module Attractor
   # contains methods implementing the CLI
   class CLI < Thor
+    SHARED_DEFAULTS = {
+      ignore: "",
+      minimum_churn: 3,
+      start_ago: "5y"
+    }.freeze
+
     shared_options = [[:file_prefix, aliases: :p],
       [:verbose, aliases: :v, type: :boolean],
-      [:ignore, aliases: :i, default: ""],
+      [:ignore, aliases: :i],
+      [:files, type: :string],
       [:watch, aliases: :w, type: :boolean],
-      [:minimum_churn, aliases: :c, type: :numeric, default: 3],
-      [:start_ago, aliases: :s, type: :string, default: "5y"],
-      [:type, aliases: :t]]
+      [:minimum_churn, aliases: :c, type: :numeric],
+      [:start_ago, aliases: :s, type: :string],
+      [:type, aliases: :t],
+      [:config, type: :string, default: ".attractor.yml", desc: "Path to .attractor.yml config file"]]
 
     advanced_options = [[:format, aliases: :f, default: "html"],
       [:no_open_browser, type: :boolean],
@@ -39,7 +47,7 @@ module Attractor
     end
     def init
       puts "Warming attractor cache"
-      Attractor.init(calculators(options))
+      Attractor.init(calculators(effective_options))
     end
 
     desc "calc", "Calculates churn and complexity for all ruby files in current directory"
@@ -48,10 +56,13 @@ module Attractor
     end
     option(:format, aliases: :f, default: :table)
     def calc
-      file_prefix = options[:file_prefix]
-      output_format = options[:format]
+      require "attractor/reporters/console_reporter"
+
+      opts = effective_options
+      file_prefix = opts[:file_prefix]
+      output_format = opts[:format]
 
-      report! Attractor::ConsoleReporter.new(file_prefix: file_prefix, ignores: options[:ignore], calculators: calculators(options), format: output_format)
+      report! Attractor::ConsoleReporter.new(file_prefix: file_prefix, ignores: opts[:ignore], calculators: calculators(opts), format: output_format), opts
     rescue RuntimeError => e
       puts "Runtime error: #{e.message}"
     end
@@ -61,10 +72,13 @@ module Attractor
       option(*option)
     end
     def report
-      file_prefix = options[:file_prefix]
-      open_browser = !(options[:no_open_browser] || options[:ci])
+      require "attractor/reporters/html_reporter"
+
+      opts = effective_options
+      file_prefix = opts[:file_prefix]
+      open_browser = !(opts[:no_open_browser] || opts[:ci])
 
-      report! Attractor::HtmlReporter.new(file_prefix: file_prefix, ignores: options[:ignore], calculators: calculators(options), open_browser: open_browser)
+      report! Attractor::HtmlReporter.new(file_prefix: file_prefix, ignores: opts[:ignore], calculators: calculators(opts), open_browser: open_browser), opts
     rescue RuntimeError => e
       puts "Runtime error: #{e.message}"
     end
@@ -74,24 +88,83 @@ module Attractor
       option(*option)
     end
     def serve
-      file_prefix = options[:file_prefix]
-      open_browser = !(options[:no_open_browser] || options[:ci])
+      require "attractor/reporters/sinatra_reporter"
+
+      opts = effective_options
+      file_prefix = opts[:file_prefix]
+      open_browser = !(opts[:no_open_browser] || opts[:ci])
+
+      report! Attractor::SinatraReporter.new(file_prefix: file_prefix, ignores: opts[:ignore], calculators: calculators(opts), open_browser: open_browser), opts
+    end
 
-      report! Attractor::SinatraReporter.new(file_prefix: file_prefix, ignores: options[:ignore], calculators: calculators(options), open_browser: open_browser)
+    desc "diff", "Calculates complexity delta between two git refs"
+    option :base, required: true
+    option :head, required: true
+    shared_options.each do |shared_option|
+      option(*shared_option)
+    end
+    option :format, aliases: :f, default: :table
+    def diff
+      require "attractor/diff_calculator"
+      require "attractor/reporters/diff_reporter"
+
+      opts = effective_options
+      file_list = parse_files(opts[:files])
+      file_list ||= default_diff_files(opts[:base], opts[:head])
+
+      data = Attractor::DiffCalculator.new(
+        base_ref: opts[:base],
+        head_ref: opts[:head],
+        files: file_list,
+        file_prefix: opts[:file_prefix],
+        minimum_churn_count: opts[:minimum_churn],
+        ignores: opts[:ignore],
+        start_ago: opts[:start_ago],
+        verbose: opts[:verbose],
+        type: opts[:type]
+      ).calculate
+
+      Attractor::DiffReporter.new(format: opts[:format]).report(data)
+    rescue ArgumentError, RuntimeError => e
+      puts "Runtime error: #{e.message}"
     end
 
     private
 
+    def effective_options
+      @effective_options ||= begin
+        config_options = Attractor::Config.load(options[:config])
+        cli_options = options.to_hash.transform_keys(&:to_sym).reject { |_, v| v.nil? }
+        merged = config_options.merge(cli_options)
+        SHARED_DEFAULTS.merge(merged) { |_key, default, val| val.nil? ? default : val }
+      end
+    end
+
     def calculators(options)
       Attractor.calculators_for_type(options[:type],
         file_prefix: options[:file_prefix],
         minimum_churn_count: options[:minimum_churn],
         ignores: options[:ignore],
         start_ago: options[:start_ago],
-        verbose: options[:verbose])
+        verbose: options[:verbose],
+        files: parse_files(options[:files]))
+    end
+
+    def parse_files(value)
+      return nil if value.nil? || value.to_s.empty?
+
+      if value == "-"
+        $stdin.read.lines(chomp: true).reject(&:empty?)
+      else
+        value.split(",").map(&:strip).reject(&:empty?)
+      end
+    end
+
+    def default_diff_files(base_ref, head_ref)
+      `git diff --name-only #{base_ref}...#{head_ref}`.lines(chomp: true).reject(&:empty?)
     end
 
-    def report!(reporter)
+    def report!(reporter, options)
       if options[:watch]
         puts "Listening for file changes..."
         reporter.watch

data/lib/attractor/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Attractor
+  # Reads `.attractor.yml` configuration from disk and exposes it
+  # as a hash of CLI-compatible options.
+  class Config
+    DEFAULT_PATH = ".attractor.yml"
+
+    def self.load(path = DEFAULT_PATH)
+      new(path).to_options
+    end
+
+    def initialize(path = DEFAULT_PATH)
+      @path = path
+      @data = load_yaml
+    end
+
+    # Translates the YAML structure into options understood by the CLI.
+    # Unknown keys (e.g. branches, skip) are ignored because they are
+    # currently only relevant in CI/SaaS contexts.
+    def to_options
+      return {} unless @data
+
+      report = @data["report"] || {}
+
+      {
+        file_prefix: report["app_root"],
+        minimum_churn: report["minimum_churn"],
+        ignore: report["ignore"],
+        start_ago: report["start_ago"]
+      }.compact
+    end
+
+    private
+
+    def load_yaml
+      return {} unless File.exist?(@path)
+
+      contents = File.read(@path)
+      parsed = if Psych::VERSION >= "5.0"
+        YAML.safe_load(contents, permitted_classes: [], permitted_symbols: [], aliases: true)
+      else
+        YAML.safe_load(contents, [], [], true)
+      end
+
+      parsed || {}
+    rescue Psych::SyntaxError => e
+      raise Error, "Error parsing #{@path}: #{e.message}"
+    end
+  end
+end

data/lib/attractor/diff_calculator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "attractor"
+require "attractor/git"
+
+module Attractor
+  # Calculates complexity deltas between two git refs using temporary worktrees
+  class DiffCalculator
+    attr_reader :base_ref, :head_ref, :files, :options
+
+    def initialize(base_ref:, head_ref:, files: nil, **options)
+      @base_ref = base_ref
+      @head_ref = head_ref
+      @files = files
+      @options = options
+    end
+
+    def calculate
+      validate_refs!
+      file_list = @files || Git.diff_files(@base_ref, @head_ref)
+
+      base_worktree = Git::Worktree.new(@base_ref).checkout
+      head_worktree = Git::Worktree.new(@head_ref).checkout
+
+      base_values = calculate_in_worktree(base_worktree, file_list)
+      head_values = calculate_in_worktree(head_worktree, file_list)
+
+      Attractor::Cache.reset!
+      build_diff(base_values, head_values, file_list)
+    ensure
+      base_worktree&.cleanup
+      head_worktree&.cleanup
+    end
+
+    private
+
+    def validate_refs!
+      case [@base_ref, @head_ref]
+      in [nil | "", _]
+        raise ArgumentError, "base_ref is required"
+      in [_, nil | ""]
+        raise ArgumentError, "head_ref is required"
+      else
+        Git.validate_ref!(@base_ref)
+        Git.validate_ref!(@head_ref)
+      end
+    end
+
+    def calculate_in_worktree(worktree, files)
+      Attractor::Cache.reset!
+      worktree.chdir do
+        Attractor.calculators_for_type(@options[:type],
+          file_prefix: @options[:file_prefix],
+          minimum_churn_count: @options[:minimum_churn_count],
+          ignores: @options[:ignores],
+          start_ago: @options[:start_ago],
+          verbose: @options[:verbose],
+          files: files).transform_values(&:calculate)
+      end
+    end
+
+    def build_diff(base_values, head_values, files)
+      base_by_path = flatten_values(base_values)
+      head_by_path = flatten_values(head_values)
+      file_types = build_file_types(base_values, head_values)
+
+      base_refactor_files = refactor_files(base_by_path.values)
+      head_refactor_files = refactor_files(head_by_path.values)
+
+      rows = files.uniq.map do |file_path|
+        build_row(file_path, base_by_path[file_path], head_by_path[file_path], base_refactor_files, head_refactor_files, file_types[file_path])
+      end
+
+      rows.sort_by! { |row| -row[:delta].abs }
+
+      total_score_base = base_by_path.values.sum { |value| value.score || 0 }
+      total_score_head = head_by_path.values.sum { |value| value.score || 0 }
+
+      {
+        base_ref: @base_ref,
+        head_ref: @head_ref,
+        total_score_base: total_score_base,
+        total_score_head: total_score_head,
+        trend: total_score_head - total_score_base,
+        files: rows
+      }
+    end
+
+    def flatten_values(values_by_type)
+      values_by_type.each_with_object({}) do |(_type, values), hash|
+        Array(values).compact.each do |value|
+          hash[value.file_path] = value
+        end
+      end
+    end
+
+    def build_file_types(base_values, head_values)
+      [base_values, head_values].each_with_object({}) do |values_by_type, hash|
+        values_by_type.each do |type, values|
+          Array(values).compact.each do |value|
+            hash[value.file_path] ||= type
+          end
+        end
+      end
+    end
+
+    def refactor_files(values)
+      Suggester.new(values).suggest.map(&:file_path)
+    end
+
+    def build_row(file_path, base_value, head_value, base_refactor_files, head_refactor_files, type)
+      complexity_base = base_value&.complexity
+      complexity_head = head_value&.complexity
+
+      delta = case [complexity_base, complexity_head]
+      in [nil, nil]
+        0
+      in [nil, head]
+        head.to_f
+      in [base, nil]
+        -base.to_f
+      in [base, head]
+        head.to_f - base.to_f
+      end
+
+      {
+        file_path: file_path,
+        type: type,
+        complexity_base: complexity_base,
+        complexity_head: complexity_head,
+        delta: delta,
+        churn: head_value&.churn,
+        score_base: base_value&.score,
+        score_head: head_value&.score,
+        refactor_base: base_refactor_files.include?(file_path),
+        refactor_head: head_refactor_files.include?(file_path),
+        details_base: base_value&.details,
+        details_head: head_value&.details
+      }
+    end
+  end
+end

data/lib/attractor/formatters/format_strategy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Attractor
+  module Formatters
+    module FormatStrategy
+      private
+
+      def format_strategy(format)
+        case format.to_sym
+        when :csv then Formats::CSV.new
+        when :json then Formats::JSON.new
+        when :markdown then Formats::Markdown.new
+        when :table then Formats::Table.new
+        else
+          raise ArgumentError, "Unknown format: #{format}"
+        end
+      end
+    end
+  end
+end

data/lib/attractor/formatters/formats/csv.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Attractor
+  module Formatters
+    module Formats
+      class CSV
+        def call(report)
+          ::CSV.generate do |csv|
+            csv << report.columns
+            report.rows.each do |row|
+              csv << report.columns.map { |column| row[column] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attractor/formatters/formats/json.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Attractor
+  module Formatters
+    module Formats
+      class JSON
+        def call(report)
+          report.metadata.merge(
+            :title => report.title,
+            :summary => report.sections.empty? ? nil : report.sections,
+            report.rows_key => rows_for(report),
+            :footer => report.footer
+          ).compact.to_json
+        end
+
+        private
+
+        def rows_for(report)
+          return report.rows unless report.group_by
+
+          report.rows.group_by { |row| row[report.group_by] }
+        end
+      end
+    end
+  end
+end

data/lib/attractor/formatters/formats/markdown.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Attractor
+  module Formatters
+    module Formats
+      class Markdown
+        def call(report)
+          lines = []
+          lines << "#{title_prefix(report)} #{report.title}"
+          lines << ""
+
+          report.metadata.each do |key, value|
+            lines << "**#{format_key(key)}:** #{value}"
+          end
+          lines << "" unless report.metadata.empty?
+
+          report.sections.each do |section|
+            lines << "### #{section[:title]}"
+            lines << ""
+            lines += render_table(section[:columns], section[:rows])
+            lines << ""
+          end
+
+          if report.collapsed_table
+            lines << "<details>"
+            lines << "<summary>All files</summary>"
+            lines << ""
+          end
+
+          lines += render_table(report.columns, report.rows)
+
+          if report.collapsed_table
+            lines << ""
+            lines << "</details>"
+          end
+
+          if report.footer
+            lines << ""
+            lines << report.footer
+          end
+
+          lines.join("\n")
+        end
+
+        private
+
+        def render_table(columns, rows)
+          return [] if columns.empty?
+
+          lines = []
+          lines << "| #{columns.join(" | ")} |"
+          lines << "| #{columns.map { |column| "-" * column.to_s.length }.join(" | ")} |"
+
+          rows.each do |row|
+            lines << "| #{columns.map { |column| format_cell(column, row) }.join(" | ")} |"
+          end
+
+          lines
+        end
+
+        def format_cell(column, row)
+          value = row[column]
+
+          if column == :delta
+            return "new" if row[:complexity_base].nil? && !row[:complexity_head].nil?
+            return "deleted" if row[:complexity_head].nil? && !row[:complexity_base].nil?
+          end
+
+          value
+        end
+
+        def title_prefix(report)
+          (report.sections.any? || report.collapsed_table) ? "##" : "#"
+        end
+
+        def format_key(key)
+          key.to_s.split("_").map(&:capitalize).join(" ")
+        end
+      end
+    end
+  end
+end