ruby-maat 1.0.0 → 1.3.4

data/lib/ruby_maat/analysis/churn.rb

@@ -105,7 +105,7 @@ module RubyMaat
           end
 
           # Filter by minimum revisions and format results
-          filtered_results = results.values.map do |result|
+          filtered_results = results.values.filter_map do |result|
             next if result[:revisions].size < min_revs
 
             {
@@ -114,7 +114,7 @@ module RubyMaat
               deleted: result[:deleted],
               commits: result[:revisions].size
             }
-          end.compact
+          end
 
           # Sort by total churn descending
           filtered_results.sort_by! { |r| -(r[:added] + r[:deleted]) }

data/lib/ruby_maat/analysis/effort.rb

@@ -76,13 +76,13 @@ module RubyMaat
           results = []
 
           entity_authors.each do |entity, authors|
-            total_revisions = authors.values.map(&:size).sum
+            total_revisions = authors.values.sum(&:size)
             next if total_revisions < min_revs
 
             # Find author with most revisions
             main_author, revisions = authors.max_by { |_author, revs| revs.size }
 
-            total_revisions = authors.values.map(&:size).sum
+            total_revisions = authors.values.sum(&:size)
 
             results << {
               entity: entity,
@@ -122,14 +122,14 @@ module RubyMaat
           results = []
 
           entity_contributions.each do |entity, authors|
-            total_revisions = authors.values.map(&:size).sum
+            total_revisions = authors.values.sum(&:size)
             next if total_revisions < min_revs
 
             # Calculate fractal value: 1 - sum(p_i^2) where p_i is proportion of each author
-            sum_of_squares = authors.values.map do |revisions|
+            sum_of_squares = authors.values.sum do |revisions|
               proportion = revisions.size.to_f / total_revisions
               proportion**2
-            end.sum
+            end
 
             fractal_value = 1.0 - sum_of_squares
 

data/lib/ruby_maat/analysis_presets.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "date"
+
+module RubyMaat
+  module AnalysisPresets
+    # Analysis configurations with appropriate time ranges and descriptions
+    ANALYSIS_CONFIGS = {
+      "authors" => {
+        name: "Developer Activity Analysis",
+        description: "Shows number of developers working on each module",
+        time_sensitive: true,
+        presets: {
+          "team-activity" => {
+            description: "Team activity patterns (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "recent-team" => {
+            description: "Recent team changes (3 months)",
+            since: -> { (Date.today - 90).strftime("%Y-%m-%d") }
+          },
+          "team-history" => {
+            description: "Complete team evolution (2 years)",
+            since: -> { (Date.today - 730).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "coupling" => {
+        name: "Logical Coupling Analysis",
+        description: "Finds modules that change together (hidden dependencies)",
+        time_sensitive: true,
+        presets: {
+          "recent-coupling" => {
+            description: "Current coupling patterns (3 months)",
+            since: -> { (Date.today - 90).strftime("%Y-%m-%d") }
+          },
+          "coupling-trends" => {
+            description: "Coupling evolution (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          },
+          "architecture-review" => {
+            description: "Deep architecture analysis (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "age" => {
+        name: "Code Age Analysis",
+        description: "Shows how recently each module was modified",
+        time_sensitive: false,
+        presets: {
+          "full-history" => {
+            description: "Complete age analysis (all history)"
+          }
+        }
+      },
+
+      "abs-churn" => {
+        name: "Absolute Code Churn",
+        description: "Total lines added/deleted over time",
+        time_sensitive: true,
+        presets: {
+          "recent-churn" => {
+            description: "Recent development activity (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "yearly-churn" => {
+            description: "Annual churn patterns (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          },
+          "project-churn" => {
+            description: "Project lifecycle churn (2 years)",
+            since: -> { (Date.today - 730).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "author-churn" => {
+        name: "Author Churn Analysis",
+        description: "Code churn by individual developers",
+        time_sensitive: true,
+        presets: {
+          "contributor-activity" => {
+            description: "Current contributor patterns (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "team-contributions" => {
+            description: "Team contribution history (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "entity-churn" => {
+        name: "Module Churn Analysis",
+        description: "Churn by individual modules/files",
+        time_sensitive: true,
+        presets: {
+          "hotspot-analysis" => {
+            description: "Current hotspots (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "stability-review" => {
+            description: "Module stability patterns (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "entity-ownership" => {
+        name: "Code Ownership Analysis",
+        description: "Shows ownership distribution of code",
+        time_sensitive: true,
+        presets: {
+          "current-ownership" => {
+            description: "Current ownership patterns (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          },
+          "ownership-evolution" => {
+            description: "Ownership changes over time (2 years)",
+            since: -> { (Date.today - 730).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "main-dev" => {
+        name: "Main Developer Analysis",
+        description: "Identifies primary developer for each module",
+        time_sensitive: true,
+        presets: {
+          "current-maintainers" => {
+            description: "Current module maintainers (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          },
+          "maintainer-history" => {
+            description: "Maintainer evolution (2 years)",
+            since: -> { (Date.today - 730).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "entity-effort" => {
+        name: "Development Effort Analysis",
+        description: "Effort distribution across modules",
+        time_sensitive: true,
+        presets: {
+          "effort-focus" => {
+            description: "Recent effort distribution (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "effort-trends" => {
+            description: "Effort patterns over time (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "communication" => {
+        name: "Team Communication Analysis",
+        description: "Developer collaboration patterns",
+        time_sensitive: true,
+        presets: {
+          "team-collaboration" => {
+            description: "Current collaboration patterns (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "communication-trends" => {
+            description: "Communication evolution (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "summary" => {
+        name: "Project Summary",
+        description: "High-level project statistics",
+        time_sensitive: true,
+        presets: {
+          "project-overview" => {
+            description: "Current project state (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          },
+          "full-summary" => {
+            description: "Complete project history"
+          }
+        }
+      },
+
+      "revisions" => {
+        name: "Revision Count Analysis",
+        description: "Number of changes per module",
+        time_sensitive: true,
+        presets: {
+          "activity-hotspots" => {
+            description: "Current activity patterns (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "change-history" => {
+            description: "Complete change patterns (2 years)",
+            since: -> { (Date.today - 730).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      # Analyses that don't benefit from time filtering
+      "identity" => {
+        name: "Identity Analysis",
+        description: "Raw parsed data (debugging/export)",
+        time_sensitive: false,
+        presets: {
+          "full-data" => {
+            description: "Complete dataset export"
+          }
+        }
+      },
+
+      "soc" => {
+        name: "Sum of Coupling",
+        description: "Total coupling strength per module",
+        time_sensitive: true,
+        presets: {
+          "coupling-strength" => {
+            description: "Current coupling analysis (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "refactoring-main-dev" => {
+        name: "Refactoring Main Developer",
+        description: "Main developer in refactoring contexts",
+        time_sensitive: true,
+        presets: {
+          "refactoring-leads" => {
+            description: "Recent refactoring activity (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "main-dev-by-revs" => {
+        name: "Main Developer (by Revisions)",
+        description: "Main developer by revision count",
+        time_sensitive: true,
+        presets: {
+          "revision-leaders" => {
+            description: "Current revision leaders (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "fragmentation" => {
+        name: "Development Fragmentation",
+        description: "How fragmented development effort is",
+        time_sensitive: true,
+        presets: {
+          "team-fragmentation" => {
+            description: "Current team fragmentation (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          }
+        }
+      },
+
+      "messages" => {
+        name: "Commit Message Analysis",
+        description: "Analyzes commit message patterns",
+        time_sensitive: true,
+        presets: {
+          "message-patterns" => {
+            description: "Recent commit patterns (6 months)",
+            since: -> { (Date.today - 180).strftime("%Y-%m-%d") }
+          },
+          "communication-style" => {
+            description: "Team communication style (1 year)",
+            since: -> { (Date.today - 365).strftime("%Y-%m-%d") }
+          }
+        }
+      }
+    }.freeze
+
+    def self.analysis_config(analysis_name)
+      ANALYSIS_CONFIGS[analysis_name]
+    end
+
+    def self.available_analyses
+      ANALYSIS_CONFIGS.keys.sort
+    end
+
+    def self.analysis_description(analysis_name)
+      config = ANALYSIS_CONFIGS[analysis_name]
+      return "Unknown analysis" unless config
+      "#{config[:name]} - #{config[:description]}"
+    end
+
+    def self.presets_for_analysis(analysis_name)
+      config = ANALYSIS_CONFIGS[analysis_name]
+      return {} unless config
+
+      # Evaluate lambda functions in preset options
+      config[:presets].transform_values do |preset|
+        preset.transform_values { |v| v.is_a?(Proc) ? v.call : v }
+      end
+    end
+
+    def self.time_sensitive?(analysis_name)
+      config = ANALYSIS_CONFIGS[analysis_name]
+      config ? config[:time_sensitive] : false
+    end
+  end
+end

data/lib/ruby_maat/app.rb

@@ -44,6 +44,7 @@ module RubyMaat
       change_records = parser.parse
 
       # Apply data transformations
+      change_records = apply_merge_grouping(change_records)
       change_records = apply_grouping(change_records)
       change_records = apply_temporal_grouping(change_records)
       change_records = apply_team_mapping(change_records)
@@ -94,6 +95,30 @@ module RubyMaat
       end
     end
 
+    def apply_merge_grouping(change_records)
+      return change_records unless @options[:group_by_merge]
+      return change_records if change_records.nil? || change_records.empty?
+
+      # Check for non-nil parent_revisions (not non-empty) because root commits
+      # legitimately have parent_revisions == [] when parsed with the parents format.
+      records_with_parents = change_records.count { |record| !record.parent_revisions.nil? }
+      records_without_parents = change_records.count { |record| record.parent_revisions.nil? }
+
+      if records_with_parents.zero?
+        raise ArgumentError,
+          "--group-by-merge requires parent revision metadata in the log. " \
+          "Please regenerate the log using the 'pr-coupling' preset or another format that includes parent hashes."
+      elsif records_without_parents.positive?
+        raise ArgumentError,
+          "--group-by-merge requires parent revision metadata for all commits, " \
+          "but the provided log mixes records with and without parent hashes. " \
+          "Please regenerate the log using the 'pr-coupling' preset or another format that includes parent hashes."
+      end
+
+      grouper = RubyMaat::Groupers::MergeCommitGrouper.new
+      grouper.group(change_records)
+    end
+
     def apply_grouping(change_records)
       return change_records unless @options[:group]
 

data/lib/ruby_maat/change_record.rb

@@ -4,9 +4,10 @@ module RubyMaat
   # Represents a single change/modification record from VCS
   # This is the fundamental data structure that flows through the entire pipeline
   class ChangeRecord
-    attr_reader :entity, :author, :date, :revision, :message, :loc_added, :loc_deleted
+    attr_reader :entity, :author, :date, :revision, :message, :loc_added, :loc_deleted, :parent_revisions
 
-    def initialize(entity:, author:, date:, revision:, message: nil, loc_added: nil, loc_deleted: nil)
+    def initialize(entity:, author:, date:, revision:, message: nil, loc_added: nil, loc_deleted: nil,
+      parent_revisions: nil)
       @entity = entity
       @author = author
       @date = date.is_a?(Date) ? date : Date.parse(date)
@@ -14,6 +15,14 @@ module RubyMaat
       @message = message
       @loc_added = loc_added.to_i if loc_added && (!loc_added.is_a?(Float) || !loc_added.nan?)
       @loc_deleted = loc_deleted.to_i if loc_deleted && (!loc_deleted.is_a?(Float) || !loc_deleted.nan?)
+      @parent_revisions = parent_revisions
+    end
+
+    # True when the commit has multiple parents (i.e., a merge commit).
+    # Returns false when parent metadata is unavailable (nil), since the parser
+    # could not determine the parent count.
+    def merge_commit?
+      parent_revisions.is_a?(Array) && parent_revisions.size >= 2
     end
 
     def to_h
@@ -24,7 +33,8 @@ module RubyMaat
         revision: revision,
         message: message,
         loc_added: loc_added,
-        loc_deleted: loc_deleted
+        loc_deleted: loc_deleted,
+        parent_revisions: parent_revisions
       }
     end