ruby-maat 1.0.0 → 1.3.4

data/lib/ruby_maat/cli.rb

@@ -2,6 +2,10 @@
 
 require "optparse"
 require "date"
+require_relative "generators/git_generator"
+require_relative "generators/svn_generator"
+require_relative "analysis_presets"
+require_relative "vcs_detector"
 
 module RubyMaat
   # Command Line Interface - Ruby port of code-maat.cmd-line
@@ -23,8 +27,12 @@ module RubyMaat
 
       validate_required_options!
 
-      app = App.new(@options)
-      app.run
+      if @options[:generate_log] || @options[:interactive]
+        handle_log_generation
+      else
+        app = App.new(@options)
+        app.run
+      end
     rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
       warn "Error: #{e.message}"
       warn usage
@@ -41,6 +49,212 @@ module RubyMaat
 
     private
 
+    def handle_log_generation
+      if @options[:interactive]
+        handle_interactive_mode
+      else
+        generator = create_log_generator
+        output_file = @options[:save_log]
+        preset_options = get_preset_options if @options[:preset]
+
+        log_output = generator.generate_log(output_file, **(preset_options || {}))
+
+        if output_file
+          puts "Log generated: #{output_file}"
+          # If we saved to file and analysis is specified, run analysis on that file
+          if @options[:analysis] && @options[:analysis] != "authors"
+            puts "\n=== Running Analysis ==="
+            analysis_options = @options.merge(log: output_file)
+            app = App.new(analysis_options)
+            app.run
+          end
+        elsif log_output
+          # If no output file specified and we have an analysis, run it on the generated log
+          puts "\n=== Running Analysis ==="
+
+          require "tempfile"
+          temp_log = Tempfile.new(["ruby_maat", ".log"])
+          temp_log.write(log_output)
+          temp_log.close
+
+          analysis_options = @options.merge(log: temp_log.path)
+          app = App.new(analysis_options)
+          app.run
+
+          temp_log.unlink
+        end
+      end
+    end
+
+    def handle_interactive_mode
+      unless $stdin.tty?
+        raise "Interactive mode requires a terminal (TTY). Use --generate-log with presets instead."
+      end
+
+      puts "=== Ruby Maat Interactive Mode ==="
+      puts
+
+      # Step 1: Detect or choose VCS
+      vcs_type = @options[:version_control] || detect_vcs_interactive
+
+      # Step 2: Choose analysis type
+      analysis_type = @options[:analysis] || choose_analysis_interactive
+
+      # Step 3: Generate log and run analysis
+      generator = create_log_generator_for_vcs(vcs_type)
+      log_output = generator.interactive_generate_for_analysis(analysis_type, @options)
+
+      # Step 4: Run analysis if log was generated to stdout
+      if log_output && !@options[:save_log]
+        puts "\n=== Running Analysis ==="
+
+        # Create temporary log file for analysis
+        require "tempfile"
+        temp_log = Tempfile.new(["ruby_maat", ".log"])
+        temp_log.write(log_output)
+        temp_log.close
+
+        # Run analysis
+        analysis_options = @options.merge(
+          log: temp_log.path,
+          version_control: (vcs_type == "git") ? "git2" : vcs_type,
+          analysis: analysis_type
+        )
+
+        app = App.new(analysis_options)
+        app.run
+
+        temp_log.unlink
+      end
+    end
+
+    def create_log_generator
+      case @options[:version_control]
+      when "git", "git2"
+        RubyMaat::Generators::GitGenerator.new(".", @options)
+      when "svn"
+        RubyMaat::Generators::SvnGenerator.new(".", @options)
+      else
+        raise ArgumentError, "Log generation not yet supported for #{@options[:version_control]}"
+      end
+    end
+
+    def get_preset_options
+      generator = create_log_generator
+      presets = generator.available_presets
+
+      unless presets.key?(@options[:preset])
+        available = presets.keys.join(", ")
+        raise ArgumentError, "Unknown preset '#{@options[:preset]}'. Available: #{available}"
+      end
+
+      presets[@options[:preset]][:options]
+    end
+
+    def create_log_generator_for_vcs(vcs_type)
+      case vcs_type
+      when "git", "git2"
+        RubyMaat::Generators::GitGenerator.new(".", @options)
+      when "svn"
+        RubyMaat::Generators::SvnGenerator.new(".", @options)
+      else
+        raise ArgumentError, "Log generation not yet supported for #{vcs_type}"
+      end
+    end
+
+    def detect_vcs_interactive
+      detected = RubyMaat::VcsDetector.detect_vcs
+
+      if detected
+        puts "Detected VCS: #{RubyMaat::VcsDetector.vcs_description(detected)}"
+        if ask_yes_no_interactive("Use detected VCS?", true)
+          return detected
+        end
+      end
+
+      choose_vcs_interactive
+    end
+
+    def choose_vcs_interactive
+      puts "Choose version control system:"
+      vcs_options = %w[git svn hg p4 tfs]
+      vcs_options.each_with_index do |vcs, index|
+        puts "  #{index + 1}. #{RubyMaat::VcsDetector.vcs_description(vcs)}"
+      end
+
+      choice = ask_integer_interactive("Choose VCS", 1, vcs_options.length)
+      vcs_options[choice - 1]
+    end
+
+    def choose_analysis_interactive
+      analyses = RubyMaat::AnalysisPresets.available_analyses
+
+      puts "Choose analysis type:"
+      analyses.each_with_index do |analysis, index|
+        puts "  #{index + 1}. #{RubyMaat::AnalysisPresets.analysis_description(analysis)}"
+      end
+
+      choice = ask_integer_interactive("Choose analysis", 1, analyses.length)
+      analyses[choice - 1]
+    end
+
+    def ask_yes_no_interactive(prompt, default = nil)
+      default_text = case default
+      when true then " [Y/n]"
+      when false then " [y/N]"
+      else " [y/n]"
+      end
+
+      loop do
+        print "#{prompt}#{default_text}: "
+        response = $stdin.gets
+        return default if response.nil?
+        response = response.chomp.downcase
+
+        case response
+        when "y", "yes"
+          return true
+        when "n", "no"
+          return false
+        when ""
+          return default unless default.nil?
+        end
+
+        puts "Please enter 'y' or 'n'"
+      end
+    end
+
+    def ask_integer_interactive(prompt, min = nil, max = nil)
+      attempts = 0
+      max_attempts = 10
+
+      loop do
+        attempts += 1
+        if attempts > max_attempts
+          raise "Too many invalid attempts. Exiting interactive mode."
+        end
+
+        print "#{prompt}: "
+        response = $stdin.gets
+        return 1 if response.nil? # Default to first option
+
+        response = response.chomp
+
+        if response.empty?
+          puts "Please enter a valid number"
+          next
+        end
+
+        begin
+          value = Integer(response)
+          return value if (min.nil? || value >= min) && (max.nil? || value <= max)
+          puts "Please enter a number between #{min} and #{max}"
+        rescue ArgumentError
+          puts "Please enter a valid number"
+        end
+      end
+    end
+
     def build_option_parser
       OptionParser.new do |opts|
         opts.banner = usage_banner
@@ -113,6 +327,23 @@ module RubyMaat
           @options[:max_changeset_size] = max_size
         end
 
+        # Log generation options
+        opts.on("--generate-log", "Generate log file instead of running analysis") do
+          @options[:generate_log] = true
+        end
+
+        opts.on("--save-log FILENAME", "Save generated log to file") do |filename|
+          @options[:save_log] = filename
+        end
+
+        opts.on("--interactive", "Use interactive mode for log generation") do
+          @options[:interactive] = true
+        end
+
+        opts.on("--preset PRESET", "Use a preset configuration for log generation") do |preset|
+          @options[:preset] = preset
+        end
+
         # Analysis-specific options
         opts.on("-e", "--expression-to-match MATCH_EXPRESSION",
           "A regex to match against commit messages. Used with -messages analyses") do |expression|
@@ -131,6 +362,12 @@ module RubyMaat
           raise ArgumentError, "Invalid date format for --age-time-now: #{date_str}. Use YYYY-MM-dd format."
         end
 
+        opts.on("--group-by-merge",
+          "Group commits by merge commit for PR-level coupling analysis. " \
+          "Requires log generated with parent hashes (use --preset pr-coupling).") do
+          @options[:group_by_merge] = true
+        end
+
         opts.on("--verbose-results",
           "Includes additional analysis details together with the results. Only implemented for change coupling.") do
           @options[:verbose_results] = true
@@ -158,7 +395,10 @@ module RubyMaat
 
         This is Ruby Maat, a Ruby port of Code Maat - a program used to collect statistics from a VCS.
 
-        Usage: ruby-maat -l log-file -c vcs-type [options]
+        Usage: 
+          ruby-maat -l log-file -c vcs-type [options]           # Run analysis on existing log
+          ruby-maat --generate-log -c vcs-type [options]        # Generate log file
+          ruby-maat --generate-log --interactive -c vcs-type    # Interactive log generation
 
         Options:
       BANNER
@@ -170,8 +410,22 @@ module RubyMaat
 
     def validate_required_options!
       missing = []
-      missing << "log file (-l/--log)" unless @options[:log]
-      missing << "version control system (-c/--version-control)" unless @options[:version_control]
+
+      # In interactive mode, we can detect everything
+      if @options[:interactive]
+        # Interactive mode can work with no other options
+        return
+      end
+
+      # Log file is only required when not generating logs
+      unless @options[:generate_log] || @options[:log]
+        missing << "log file (-l/--log)"
+      end
+
+      # VCS is required for non-interactive modes
+      unless @options[:version_control]
+        missing << "version control system (-c/--version-control)"
+      end
 
       raise ArgumentError, "Missing required options: #{missing.join(", ")}" unless missing.empty?
 

data/lib/ruby_maat/generators/base_generator.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tempfile"
+
+module RubyMaat
+  module Generators
+    class BaseGenerator
+      attr_reader :repository_path, :options
+
+      def initialize(repository_path = ".", options = {})
+        @repository_path = File.expand_path(repository_path)
+        @options = options
+        validate_repository!
+      end
+
+      def generate_log(output_file = nil, **generation_options)
+        merged_options = @options.merge(generation_options)
+
+        if output_file
+          generate_persistent_log(output_file, merged_options)
+        else
+          generate_temporary_log(merged_options)
+        end
+      end
+
+      def available_presets
+        []
+      end
+
+      def interactive_generate
+        unless $stdin.tty?
+          raise "Interactive mode requires a terminal (TTY). Use --generate-log with presets instead."
+        end
+
+        puts "Interactive log generation for #{vcs_name}"
+        puts "Repository: #{@repository_path}"
+        puts
+
+        preset = choose_preset
+        options = gather_custom_options(preset)
+
+        save_log = ask_yes_no("Save log to file for future use?")
+
+        if save_log
+          default_filename = default_log_filename
+          filename = ask_string("Log filename", default_filename)
+          generate_log(filename, **options)
+        else
+          generate_log(nil, **options)
+        end
+      end
+
+      def interactive_generate_for_analysis(analysis_name, analysis_options = {})
+        unless $stdin.tty?
+          raise "Interactive mode requires a terminal (TTY). Use --generate-log with presets instead."
+        end
+
+        puts "Log generation for #{vcs_name}"
+        puts "Repository: #{@repository_path}"
+        puts "Analysis: #{RubyMaat::AnalysisPresets.analysis_description(analysis_name)}"
+        puts
+
+        # Get analysis-specific presets
+        presets = RubyMaat::AnalysisPresets.presets_for_analysis(analysis_name)
+
+        if presets.empty?
+          puts "No presets available for #{analysis_name}"
+          options = gather_custom_options({})
+        else
+          preset_options = choose_analysis_preset(analysis_name, presets)
+          options = gather_custom_options(preset_options)
+        end
+
+        # Merge with any analysis-specific options
+        options.merge!(analysis_options)
+
+        save_log = ask_yes_no("Save log to file for future use?", false)
+
+        if save_log
+          default_filename = "#{analysis_name}_#{default_log_filename}"
+          filename = ask_string("Log filename", default_filename)
+          generate_log(filename, **options)
+        else
+          generate_log(nil, **options)
+        end
+      end
+
+      protected
+
+      def vcs_name
+        self.class.name.split("::").last.sub("Generator", "").downcase
+      end
+
+      def validate_repository!
+        raise ArgumentError, "Repository path does not exist: #{@repository_path}" unless Dir.exist?(@repository_path)
+      end
+
+      def build_command(options)
+        raise NotImplementedError, "Subclasses must implement build_command"
+      end
+
+      def execute_command(command)
+        # Show command preview and ask for confirmation
+        show_command_preview(command)
+
+        puts "Executing: #{command}" if @options[:verbose]
+
+        # Use proper subprocess execution to prevent command injection
+        require "open3"
+
+        # Change to repository directory and execute command safely
+        result, error, status = Open3.capture3(command, chdir: @repository_path)
+        if status.exitstatus != 0
+          combined_output = result + error
+          raise "Command failed with exit code #{status.exitstatus}: #{combined_output}"
+        end
+
+        result
+      end
+
+      def default_log_filename
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        "#{vcs_name}_log_#{timestamp}.log"
+      end
+
+      private
+
+      def generate_persistent_log(output_file, options)
+        command = build_command(options)
+        output = execute_command(command)
+
+        File.write(output_file, output)
+        puts "Log generated: #{output_file}" unless @options[:quiet]
+
+        output_file
+      end
+
+      def generate_temporary_log(options)
+        command = build_command(options)
+        execute_command(command)
+      end
+
+      def choose_preset
+        presets = available_presets
+
+        if presets.empty?
+          puts "No presets available for #{vcs_name}"
+          return {}
+        end
+
+        puts "Available presets:"
+        presets.each_with_index do |(name, description), index|
+          puts "  #{index + 1}. #{name} - #{description[:description]}"
+        end
+        puts "  #{presets.length + 1}. Custom - Enter custom options"
+
+        choice = ask_integer("Choose preset", 1, presets.length + 1)
+
+        if choice <= presets.length
+          preset_name = presets.keys[choice - 1]
+          presets[preset_name][:options]
+        else
+          {}
+        end
+      end
+
+      def choose_analysis_preset(analysis_name, presets)
+        puts "Available presets for #{analysis_name}:"
+        presets.each_with_index do |(name, config), index|
+          puts "  #{index + 1}. #{name} - #{config[:description]}"
+        end
+        puts "  #{presets.length + 1}. Custom - Enter custom options"
+
+        choice = ask_integer("Choose preset", 1, presets.length + 1)
+
+        if choice <= presets.length
+          preset_name = presets.keys[choice - 1]
+          presets[preset_name]
+        else
+          {}
+        end
+      end
+
+      def gather_custom_options(base_options)
+        options = base_options.dup
+
+        puts "\nCustom options (press Enter to keep default):"
+
+        if supports_date_filtering?
+          since_date = ask_string("Since date (YYYY-MM-DD)", options[:since])
+          options[:since] = since_date unless since_date.empty?
+
+          until_date = ask_string("Until date (YYYY-MM-DD)", options[:until])
+          options[:until] = until_date unless until_date.empty?
+        end
+
+        gather_vcs_specific_options(options)
+      end
+
+      def gather_vcs_specific_options(options)
+        options
+      end
+
+      def supports_date_filtering?
+        true
+      end
+
+      def ask_string(prompt, default = nil)
+        default_text = default ? " [#{default}]" : ""
+        print "#{prompt}#{default_text}: "
+        response = $stdin.gets
+        return default || "" if response.nil?
+        response = response.chomp
+        response.empty? ? (default || "") : response
+      end
+
+      def ask_integer(prompt, min = nil, max = nil)
+        attempts = 0
+        max_attempts = 10
+
+        loop do
+          attempts += 1
+          if attempts > max_attempts
+            raise "Too many invalid attempts. Exiting interactive mode."
+          end
+
+          response = ask_string(prompt)
+
+          # Handle empty response or non-interactive mode
+          if response.nil? || response.empty?
+            puts "Please enter a valid number"
+            next
+          end
+
+          begin
+            value = Integer(response)
+            return value if (min.nil? || value >= min) && (max.nil? || value <= max)
+            puts "Please enter a number between #{min} and #{max}"
+          rescue ArgumentError
+            puts "Please enter a valid number"
+          end
+        end
+      end
+
+      def ask_yes_no(prompt, default = nil)
+        default_text = case default
+        when true then " [Y/n]"
+        when false then " [y/N]"
+        else " [y/n]"
+        end
+
+        loop do
+          response = ask_string("#{prompt}#{default_text}").downcase
+
+          case response
+          when "y", "yes"
+            return true
+          when "n", "no"
+            return false
+          when ""
+            return default unless default.nil?
+          end
+
+          puts "Please enter 'y' or 'n'"
+        end
+      end
+
+      def show_command_preview(command)
+        # Skip preview in non-interactive modes, when quiet is set, or during tests
+        return if @options[:quiet] || !$stdin.tty? || test_environment?
+
+        puts "\n" + "=" * 60
+        puts "COMMAND PREVIEW"
+        puts "=" * 60
+        puts "Repository: #{@repository_path}"
+        puts "Command:    #{command}"
+        puts "=" * 60
+        puts "\nPress Enter to execute this command..."
+        $stdin.gets
+      end
+
+      def test_environment?
+        # Check if we're in a test environment
+        !!(defined?(RSpec) || ENV["RUBY_MAAT_TEST"] == "true" || ENV["RSPEC_CORE_PID"])
+      end
+    end
+  end
+end