ruby-maat 1.0.0 → 1.3.4

data/lib/ruby_maat/generators/git_generator.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "base_generator"
+
+module RubyMaat
+  module Generators
+    class GitGenerator < BaseGenerator
+      PRESETS = {
+        "git2-format" => {
+          description: "Standard format for git2 parser (recommended)",
+          options: {
+            format: "git2",
+            no_renames: true,
+            all_branches: true
+          }
+        },
+        "git-legacy" => {
+          description: "Legacy format for git parser",
+          options: {
+            format: "legacy",
+            no_renames: true,
+            all_branches: false
+          }
+        },
+        "recent-activity" => {
+          description: "Last 3 months of activity",
+          options: {
+            format: "git2",
+            since: (Date.today - 90).strftime("%Y-%m-%d"),
+            no_renames: true,
+            all_branches: true
+          }
+        },
+        "last-year" => {
+          description: "Last 12 months of activity",
+          options: {
+            format: "git2",
+            since: (Date.today - 365).strftime("%Y-%m-%d"),
+            no_renames: true,
+            all_branches: true
+          }
+        },
+        "full-history" => {
+          description: "Complete repository history (may be large)",
+          options: {
+            format: "git2",
+            no_renames: true,
+            all_branches: true
+          }
+        },
+        "pr-coupling" => {
+          description: "Format with parent hashes for PR-level coupling analysis (use with --group-by-merge)",
+          options: {
+            format: "git2-parents",
+            no_renames: true,
+            all_branches: true
+          }
+        }
+      }.freeze
+
+      def available_presets
+        PRESETS
+      end
+
+      protected
+
+      def validate_repository!
+        super
+
+        git_dir = File.join(@repository_path, ".git")
+        unless Dir.exist?(git_dir) || File.exist?(git_dir)
+          raise ArgumentError, "Not a Git repository: #{@repository_path}"
+        end
+      end
+
+      def build_command(options)
+        format = options[:format] || "git2"
+
+        case format
+        when "git2"
+          build_git2_command(options)
+        when "git2-parents"
+          build_git2_parents_command(options)
+        when "legacy"
+          build_legacy_command(options)
+        else
+          raise ArgumentError, "Unknown Git format: #{format}"
+        end
+      end
+
+      def gather_vcs_specific_options(options)
+        super
+
+        puts "\nGit-specific options:"
+
+        # Format selection
+        puts "Output formats:"
+        puts "  1. git2 (recommended, faster parsing)"
+        puts "  2. git2-parents (git2 with parent hashes, for --group-by-merge)"
+        puts "  3. legacy (backward compatibility)"
+
+        format_choice = ask_integer("Choose format", 1, 3)
+        formats = {1 => "git2", 2 => "git2-parents", 3 => "legacy"}
+        options[:format] = formats[format_choice]
+
+        # Branch selection
+        options[:all_branches] = ask_yes_no("Include all branches?", options[:all_branches])
+
+        # Rename detection
+        options[:no_renames] = ask_yes_no("Disable rename detection? (recommended for performance)",
+          options.fetch(:no_renames, true))
+
+        # Author filtering
+        author = ask_string("Filter by author (empty for all)")
+        options[:author] = author unless author.empty?
+
+        # Path filtering
+        path = ask_string("Filter by path pattern (empty for all files)")
+        options[:path] = path unless path.empty?
+
+        options
+      end
+
+      private
+
+      def build_git2_command(options)
+        parts = ["git", "log"]
+
+        # Core git2 format options
+        parts << "--all" if options[:all_branches]
+        parts << "--numstat"
+        parts << "--date=short"
+        parts << "--pretty=format:'--%h--%ad--%aN--%s'"
+        parts << "--no-renames" if options[:no_renames]
+
+        # Date filtering (with validation and shell escaping)
+        parts << "--after=#{shell_escape(validate_date(options[:since]))}" if options[:since]
+        parts << "--before=#{shell_escape(validate_date(options[:until]))}" if options[:until]
+
+        # Author filtering (with shell escaping)
+        parts << "--author=#{shell_escape(options[:author])}" if options[:author]
+
+        # Add path at the end if specified (with shell escaping)
+        parts << "--" << shell_escape(options[:path]) if options[:path]
+
+        parts.join(" ")
+      end
+
+      def build_git2_parents_command(options)
+        parts = ["git", "log"]
+
+        parts << "--all" if options[:all_branches]
+        parts << "--numstat"
+        parts << "--date=short"
+        parts << "--pretty=format:'--%h--%p--%ad--%aN--%s'"
+        parts << "--no-renames" if options[:no_renames]
+
+        parts << "--after=#{shell_escape(validate_date(options[:since]))}" if options[:since]
+        parts << "--before=#{shell_escape(validate_date(options[:until]))}" if options[:until]
+
+        parts << "--author=#{shell_escape(options[:author])}" if options[:author]
+
+        parts << "--" << shell_escape(options[:path]) if options[:path]
+
+        parts.join(" ")
+      end
+
+      def build_legacy_command(options)
+        parts = ["git", "log"]
+
+        # Core legacy format options
+        parts << "--all" if options[:all_branches]
+        parts << "--pretty=format:'[%h] %aN %ad %s'"
+        parts << "--date=short"
+        parts << "--numstat"
+        parts << "--no-renames" if options[:no_renames]
+
+        # Date filtering (with validation and shell escaping)
+        parts << "--after=#{shell_escape(validate_date(options[:since]))}" if options[:since]
+        parts << "--before=#{shell_escape(validate_date(options[:until]))}" if options[:until]
+
+        # Author filtering (with shell escaping)
+        parts << "--author=#{shell_escape(options[:author])}" if options[:author]
+
+        # Add path at the end if specified (with shell escaping)
+        parts << "--" << shell_escape(options[:path]) if options[:path]
+
+        parts.join(" ")
+      end
+
+      # Security methods to prevent command injection
+      def shell_escape(value)
+        return value unless value.is_a?(String)
+        # Use Shellwords.escape for proper shell escaping
+        require "shellwords"
+        Shellwords.escape(value)
+      end
+
+      def validate_date(date)
+        # Validate date format and prevent injection
+        return date if date.to_s.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        raise ArgumentError, "Invalid date format: #{date}"
+      end
+    end
+  end
+end

data/lib/ruby_maat/generators/svn_generator.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "base_generator"
+
+module RubyMaat
+  module Generators
+    class SvnGenerator < BaseGenerator
+      PRESETS = {
+        "standard" => {
+          description: "Standard SVN XML log format",
+          options: {
+            verbose: true,
+            xml: true
+          }
+        },
+        "recent-activity" => {
+          description: "Last 3 months of activity",
+          options: {
+            verbose: true,
+            xml: true,
+            since: (Date.today - 90).strftime("%Y%m%d")
+          }
+        },
+        "last-year" => {
+          description: "Last 12 months of activity",
+          options: {
+            verbose: true,
+            xml: true,
+            since: (Date.today - 365).strftime("%Y%m%d")
+          }
+        },
+        "date-range" => {
+          description: "Custom date range",
+          options: {
+            verbose: true,
+            xml: true
+          }
+        },
+        "revision-range" => {
+          description: "Specific revision range",
+          options: {
+            verbose: true,
+            xml: true
+          }
+        }
+      }.freeze
+
+      def available_presets
+        PRESETS
+      end
+
+      protected
+
+      def validate_repository!
+        super
+
+        svn_dir = File.join(@repository_path, ".svn")
+        unless Dir.exist?(svn_dir)
+          # Check if we're in an SVN working copy by running svn info
+          begin
+            `cd "#{@repository_path}" && svn info 2>/dev/null`
+            if $?.exitstatus != 0
+              raise ArgumentError, "Not an SVN working copy: #{@repository_path}"
+            end
+          rescue
+            raise ArgumentError, "SVN not available or not an SVN working copy: #{@repository_path}"
+          end
+        end
+      end
+
+      def build_command(options)
+        parts = ["svn", "log"]
+
+        # Core options
+        parts << "-v" if options[:verbose]
+        parts << "--xml" if options[:xml]
+
+        # Revision range (with validation and escaping)
+        if options[:revision_start] && options[:revision_end]
+          parts << "-r"
+          parts << "#{validate_revision(options[:revision_start])}:#{validate_revision(options[:revision_end])}"
+        elsif options[:revision_start]
+          parts << "-r"
+          parts << "#{validate_revision(options[:revision_start])}:HEAD"
+        elsif options[:since] || options[:until]
+          # Date-based revision range
+          revision_range = build_date_revision_range(options)
+          if revision_range
+            parts << "-r"
+            parts << revision_range
+          end
+        end
+
+        # Limit
+        parts << "-l"
+        parts << options[:limit].to_s if options[:limit]
+
+        # URL (if specified, otherwise use current directory) (with shell escaping)
+        parts << shell_escape(options[:url]) if options[:url]
+
+        parts.join(" ")
+      end
+
+      def gather_vcs_specific_options(options)
+        super
+
+        puts "\nSVN-specific options:"
+
+        # Verbose output
+        options[:verbose] = ask_yes_no("Include file paths? (verbose mode)",
+          options.fetch(:verbose, true))
+
+        # XML format
+        options[:xml] = ask_yes_no("Use XML output format? (recommended)",
+          options.fetch(:xml, true))
+
+        # Revision range vs date range
+        puts "\nRange selection:"
+        puts "  1. Date range"
+        puts "  2. Revision range"
+        puts "  3. No range (full history)"
+
+        range_choice = ask_integer("Choose range type", 1, 3)
+
+        case range_choice
+        when 1
+          # Date range already handled by base class
+        when 2
+          rev_start = ask_string("Start revision (empty for beginning)")
+          options[:revision_start] = rev_start unless rev_start.empty?
+
+          rev_end = ask_string("End revision (empty for HEAD)")
+          options[:revision_end] = rev_end unless rev_end.empty?
+
+          # Clear date options if revision range is specified
+          options.delete(:since)
+          options.delete(:until)
+        when 3
+          # Clear all range options
+          options.delete(:since)
+          options.delete(:until)
+          options.delete(:revision_start)
+          options.delete(:revision_end)
+        end
+
+        # Limit
+        limit = ask_string("Limit number of entries (empty for no limit)")
+        options[:limit] = limit.to_i unless limit.empty?
+
+        # URL
+        url = ask_string("SVN URL (empty to use current working copy)")
+        options[:url] = url unless url.empty?
+
+        options
+      end
+
+      def supports_date_filtering?
+        true
+      end
+
+      private
+
+      def build_date_revision_range(options)
+        if options[:since] && options[:until]
+          "{#{validate_date(options[:since])}}:{#{validate_date(options[:until])}}"
+        elsif options[:since]
+          "{#{validate_date(options[:since])}}:HEAD"
+        elsif options[:until]
+          "1:{#{validate_date(options[:until])}}"
+        end
+      end
+
+      def format_date_for_svn(date_str)
+        # Convert YYYY-MM-DD to YYYYMMDD for SVN
+        Date.parse(date_str).strftime("%Y%m%d")
+      rescue Date::Error
+        date_str
+      end
+
+      # Security methods to prevent command injection
+      def shell_escape(value)
+        return value unless value.is_a?(String)
+        require "shellwords"
+        Shellwords.escape(value)
+      end
+
+      def validate_revision(revision)
+        # Only allow alphanumeric characters, dots, and basic revision keywords
+        return revision if revision.to_s.match?(/\A[a-zA-Z0-9._-]+\z/)
+        raise ArgumentError, "Invalid revision format: #{revision}"
+      end
+
+      def validate_date(date)
+        # Validate date format and prevent injection
+        return date if date.to_s.match?(/\A\d{4}-?\d{2}-?\d{2}\z/)
+        raise ArgumentError, "Invalid date format: #{date}"
+      end
+    end
+  end
+end

data/lib/ruby_maat/groupers/merge_commit_grouper.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# NOTE: Set has been a built-in class (autoloaded without require) since
+# Ruby 3.2, which is this project's minimum version (see gemspec:
+# required_ruby_version >= "3.2.0").  An explicit `require "set"` is
+# unnecessary and triggers RuboCop's Lint/RedundantRequireStatement cop.
+
+module RubyMaat
+  module Groupers
+    # Groups commits by their merge commit to enable PR-level coupling analysis.
+    #
+    # When Git uses a merge-based workflow (e.g., GitHub PRs), individual commits
+    # on feature branches are combined into merge commits on the main branch.
+    # This grouper identifies merge commits and rewrites the revision of child
+    # commits so that all commits belonging to a merge share the same revision.
+    #
+    # This allows the coupling analysis to treat all files changed in a PR as
+    # co-changing, giving more meaningful coupling results.
+    #
+    # Requires log data generated with parent hashes:
+    #   git log --all --numstat --date=short --pretty=format:'--%h--%p--%ad--%aN--%s' --no-renames
+    class MergeCommitGrouper
+      def group(change_records)
+        commit_info = build_commit_info(change_records)
+        merge_map = build_merge_map(commit_info)
+
+        return change_records if merge_map.empty?
+
+        merge_dates = build_merge_dates(commit_info)
+        rewrite_records(change_records, merge_map, merge_dates)
+      end
+
+      private
+
+      def build_commit_info(records)
+        commits = {}
+        records.each do |record|
+          rev = record.revision
+          commits[rev] ||= {parents: record.parent_revisions || [], merge: false, date: record.date}
+          commits[rev][:merge] = true if record.merge_commit?
+        end
+        commits
+      end
+
+      def build_merge_map(commits)
+        merge_map = {}
+        merges = commits.select { |_, info| info[:merge] }
+
+        merges.each do |merge_rev, info|
+          parents = info[:parents] || []
+          mainline_parent = parents[0]
+          # Skip this merge if it does not have a valid mainline parent present
+          # in the commit set, or if it is not a true merge (single parent).
+          next unless mainline_parent && parents.length > 1 && commits.key?(mainline_parent)
+
+          # Compute mainline ancestors once per merge commit and reuse across
+          # all feature parents, avoiding repeated graph walks for octopus merges.
+          mainline_ancestors = collect_ancestors(mainline_parent, commits)
+          # If we cannot determine any ancestors for the mainline parent (for
+          # example due to a filtered log), skip grouping for this merge to
+          # avoid incorrect rewrites with an incomplete graph.
+          next if mainline_ancestors.empty?
+
+          feature_parents = parents[1..].compact
+          feature_parents.each do |feature_parent|
+            feature_commits = find_feature_commits(feature_parent, mainline_ancestors, commits)
+            feature_commits.each { |rev| merge_map[rev] = merge_rev }
+          end
+        end
+
+        merge_map
+      end
+
+      # Walk backward from the feature branch tip, collecting commits that belong
+      # to this merge. Excludes any commits reachable from the mainline parent so
+      # that intermediate merges from main into the feature branch don't pull in
+      # unrelated mainline history.
+      #
+      # +mainline_ancestors+ is a pre-computed Set of commits reachable from the
+      # mainline parent, passed in to avoid redundant graph walks when a merge
+      # has multiple feature parents (octopus merges).
+      def find_feature_commits(start, mainline_ancestors, commits)
+        visited = Set.new
+        queue = [start]
+        head = 0
+
+        while head < queue.length
+          current = queue[head]
+          head += 1
+          next if mainline_ancestors.include?(current) || visited.include?(current) || !commits.key?(current)
+
+          visited << current
+
+          parents = commits[current][:parents]
+          parents&.each { |p| queue << p }
+        end
+
+        visited
+      end
+
+      # Collect all ancestors reachable from a given commit (inclusive).
+      def collect_ancestors(start, commits)
+        ancestors = Set.new
+        queue = [start]
+        head = 0
+
+        while head < queue.length
+          current = queue[head]
+          head += 1
+          next if ancestors.include?(current) || !commits.key?(current)
+
+          ancestors << current
+
+          parents = commits[current][:parents]
+          parents&.each { |p| queue << p }
+        end
+
+        ancestors
+      end
+
+      # Build a lookup from merge revision to its date, used to align
+      # rewritten feature-branch records with the merge commit's date.
+      def build_merge_dates(commits)
+        dates = {}
+        commits.each do |rev, info|
+          dates[rev] = info[:date] if info[:merge]
+        end
+        dates
+      end
+
+      def rewrite_records(records, merge_map, merge_dates)
+        records.map do |record|
+          merge_rev = merge_map[record.revision]
+          if merge_rev
+            ChangeRecord.new(
+              entity: record.entity,
+              author: record.author,
+              date: merge_dates[merge_rev] || record.date,
+              revision: merge_rev,
+              message: record.message,
+              loc_added: record.loc_added,
+              loc_deleted: record.loc_deleted,
+              parent_revisions: record.parent_revisions
+            )
+          else
+            record
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_maat/parsers/git2_parser.rb

@@ -5,18 +5,28 @@ module RubyMaat
   module Parsers
     # Git2 parser - preferred Git parser (more tolerant and faster)
     #
-    # Input: git log --all --numstat --date=short --pretty=format:'--%h--%ad--%aN' --no-renames --after=YYYY-MM-DD
+    # Supports two formats:
     #
-    # Sample format:
-    # --586b4eb--2015-06-15--Adam Tornhill
+    # Standard format (without parent info):
+    #   git log --all --numstat --date=short --pretty=format:'--%h--%ad--%aN--%s' --no-renames
+    #
+    # Format with parent hashes (for --group-by-merge / PR-level coupling):
+    #   git log --all --numstat --date=short --pretty=format:'--%h--%p--%ad--%aN--%s' --no-renames
+    #   This format is generated by the "pr-coupling" preset.
+    #
+    # Sample standard format:
+    # --586b4eb--2015-06-15--Adam Tornhill--Add new feature
     # 35      0       src/code_maat/mining/vcs.clj
-    # 2       1       test/file.rb
     #
-    # --abc123--2015-06-16--Jane Doe
+    # Sample parent-hash format (merge commit has multiple parent hashes):
+    # --abc123--def456 ghi789--2015-06-16--Jane Doe--Merge pull request #42
     # 10      5       lib/example.rb
     class Git2Parser < BaseParser
-      COMMIT_SEPARATOR = /^--([a-z0-9]+)--(\d{4}-\d{2}-\d{2})--(.+)$/
-      CHANGE_PATTERN = /^(-|\d+)\s+(-|\d+)\s+(.*)$/
+      # Format with parent hashes: --hash--parent1 parent2--date--author--message
+      COMMIT_WITH_PARENTS = /^--([a-z0-9]+)--([a-z0-9 ]*)--(\d{4}-\d{2}-\d{2})--([^\r\n]+?)--([^\r\n]*)$/
+      # Standard format: --hash--date--author--message
+      COMMIT_SEPARATOR = /^--([a-z0-9]+)--(\d{4}-\d{2}-\d{2})--([^\r\n]+?)--([^\r\n]*)$/
+      CHANGE_PATTERN = /^(-|\d+)[\t ]{1,10}(-|\d+)[\t ]{1,10}([^\r\n]*)$/
 
       protected
 
@@ -28,11 +38,22 @@ module RubyMaat
           line.strip!
           next if line.empty?
 
-          if (commit_match = line.match(COMMIT_SEPARATOR))
+          if (commit_match = line.match(COMMIT_WITH_PARENTS))
+            parents_str = commit_match[2].strip
+            current_commit = {
+              revision: commit_match[1],
+              parent_revisions: parents_str.empty? ? [] : parents_str.split,
+              date: parse_date(commit_match[3]),
+              author: commit_match[4].strip,
+              message: commit_match[5].strip
+            }
+          elsif (commit_match = line.match(COMMIT_SEPARATOR))
             current_commit = {
               revision: commit_match[1],
+              parent_revisions: nil,
               date: parse_date(commit_match[2]),
-              author: commit_match[3].strip
+              author: commit_match[3].strip,
+              message: commit_match[4].strip
             }
           elsif current_commit && (change_match = line.match(CHANGE_PATTERN))
             added = clean_numstat(change_match[1])
@@ -47,8 +68,10 @@ module RubyMaat
               author: current_commit[:author],
               date: current_commit[:date],
               revision: current_commit[:revision],
+              message: current_commit[:message],
               loc_added: added,
-              loc_deleted: deleted
+              loc_deleted: deleted,
+              parent_revisions: current_commit[:parent_revisions]
             )
           end
         end

data/lib/ruby_maat/parsers/git_parser.rb

@@ -14,8 +14,8 @@ module RubyMaat
     # [abc123] Jane Doe 2015-06-16 Fix bug in parser
     # 10      5       lib/example.rb
     class GitParser < BaseParser
-      COMMIT_PATTERN = /^\[([a-f0-9]+)\]\s+(.+?)\s+(\d{4}-\d{2}-\d{2})\s+(.*)$/
-      CHANGE_PATTERN = /^(\d+|-)\s+(\d+|-)\s+(.+)$/
+      COMMIT_PATTERN = /^\[([a-f0-9]+)\] ([^0-9][^\t]*?) (\d{4}-\d{2}-\d{2}) ([^\r\n]*)$/
+      CHANGE_PATTERN = /^(\d+|-)\t(\d+|-)\t([^\r\n]+)$/
 
       protected
 

data/lib/ruby_maat/parsers/mercurial_parser.rb

@@ -14,7 +14,7 @@ module RubyMaat
     # rev: 124 author: Jane Smith date: 2015-06-16 files:
     # lib/helper.py
     class MercurialParser < BaseParser
-      ENTRY_PATTERN = /^rev:\s+(\d+)\s+author:\s+(.+?)\s+date:\s+(\d{4}-\d{2}-\d{2})\s+files:$/
+      ENTRY_PATTERN = /^rev: (\d+) author: ([^0-9][^:]*?) date: (\d{4}-\d{2}-\d{2}) files:$/
 
       protected
 

data/lib/ruby_maat/parsers/perforce_parser.rb

@@ -16,8 +16,8 @@ module RubyMaat
     # ... //depot/project/src/main.java#2 edit
     # ... //depot/project/test/test.java#1 add
     class PerforceParser < BaseParser
-      CHANGE_PATTERN = %r{^Change\s+(\d+)\s+by\s+([^@]+)@\S+\s+on\s+(\d{4}/\d{2}/\d{2})}
-      FILE_PATTERN = /^\.\.\.\s+(.+?)#\d+\s+(\w+)/
+      CHANGE_PATTERN = %r{^Change (\d+) by ([^@]*?)@\S+ on (\d{4}/\d{2}/\d{2})}
+      FILE_PATTERN = /^\.\.\. ([^#]*?)#\d+ (\w+)/
 
       protected
 

data/lib/ruby_maat/parsers/tfs_parser.rb

@@ -19,9 +19,9 @@ module RubyMaat
     #   add $/Project/test/test.cs
     class TfsParser < BaseParser
       CHANGESET_PATTERN = /^Changeset:\s+(\d+)/
-      USER_PATTERN = /^User:\s+(.+)/
-      DATE_PATTERN = /^Date:\s+(.+)/
-      ITEM_PATTERN = /^\s+(edit|add|delete)\s+(\S.+)/
+      USER_PATTERN = /^User:\s+([^\r\n]+)/
+      DATE_PATTERN = /^Date:\s+([^\r\n]+)/
+      ITEM_PATTERN = /^\s+(edit|add|delete)\s+(\S[^\r\n]*)/
 
       protected