ruby-maat 1.0.0 → 1.2.0

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/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|
@@ -158,7 +389,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 +404,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?