railsforge 1.0.1 → 2.0.0

data/lib/railsforge/audit.rb

@@ -1,289 +0,0 @@
-# Audit module for RailsForge
-# Runs a comprehensive architecture health check
-
-module RailsForge
-  # Audit module combines all analyzers to produce a comprehensive report
-  module Audit
-    # Error class for audit issues
-    class AuditError < StandardError; end
-
-    # Default scoring weights for each analyzer
-    WEIGHTS = {
-      controllers: 25,
-      models: 25,
-      database: 20,
-      specs: 15,
-      metrics: 15
-    }.freeze
-
-    # Run full audit and return results
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Complete audit results
-    def self.run(base_path = nil)
-      base_path ||= find_rails_app_path
-      raise AuditError, "Not in a Rails application directory" unless base_path
-
-      results = {
-        timestamp: Time.now.iso8601,
-        base_path: base_path,
-        controllers: run_controller_analysis(base_path),
-        models: run_model_analysis(base_path),
-        database: run_database_analysis(base_path),
-        specs: run_spec_analysis(base_path),
-        metrics: run_metrics_analysis(base_path)
-      }
-
-      results[:score] = calculate_score(results)
-      results
-    end
-
-    # Run controller analysis
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Controller analysis results
-    def self.run_controller_analysis(base_path)
-      begin
-        issues = ControllerAnalyzer.analyze(base_path)
-        {
-          issues_count: issues.length,
-          issues: issues,
-          status: issues.empty? ? :pass : :warning
-        }
-      rescue => e
-        { issues_count: 0, issues: [], status: :error, error: e.message }
-      end
-    end
-
-    # Run model analysis
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Model analysis results
-    def self.run_model_analysis(base_path)
-      begin
-        issues = ModelAnalyzer.analyze(base_path)
-        {
-          issues_count: issues.length,
-          issues: issues,
-          status: issues.empty? ? :pass : :warning
-        }
-      rescue => e
-        { issues_count: 0, issues: [], status: :error, error: e.message }
-      end
-    end
-
-    # Run database analysis
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Database analysis results
-    def self.run_database_analysis(base_path)
-      begin
-        issues = DatabaseAnalyzer.analyze(base_path)
-        {
-          issues_count: issues.length,
-          issues: issues,
-          status: issues.empty? ? :pass : :warning
-        }
-      rescue => e
-        { issues_count: 0, issues: [], status: :error, error: e.message }
-      end
-    end
-
-    # Run spec analysis
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Spec analysis results
-    def self.run_spec_analysis(base_path)
-      begin
-        results = SpecAnalyzer.analyze(base_path)
-        missing_count = results.count { |r| r[:has_spec] == false }
-        {
-          issues_count: missing_count,
-          coverage: results,
-          status: missing_count == 0 ? :pass : :warning
-        }
-      rescue => e
-        { issues_count: 0, coverage: [], status: :error, error: e.message }
-      end
-    end
-
-    # Run metrics analysis
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Metrics analysis results
-    def self.run_metrics_analysis(base_path)
-      begin
-        metrics = MetricsAnalyzer.analyze(base_path)
-        {
-          metrics: metrics,
-          status: :pass
-        }
-      rescue => e
-        { metrics: {}, status: :error, error: e.message }
-      end
-    end
-
-    # Calculate overall architecture score
-    # @param results [Hash] All analysis results
-    # @return [Integer] Score out of 100
-    def self.calculate_score(results)
-      score = 100
-
-      # Deduct points for controller issues
-      controller_issues = results[:controllers][:issues_count]
-      score -= [controller_issues * 5, WEIGHTS[:controllers]].min
-
-      # Deduct points for model issues
-      model_issues = results[:models][:issues_count]
-      score -= [model_issues * 5, WEIGHTS[:models]].min
-
-      # Deduct points for database issues
-      db_issues = results[:database][:issues_count]
-      score -= [db_issues * 3, WEIGHTS[:database]].min
-
-      # Deduct points for missing specs
-      spec_issues = results[:specs][:issues_count]
-      score -= [spec_issues * 2, WEIGHTS[:specs]].min
-
-      [score, 0].max.to_i
-    end
-
-    # Format results as a readable report
-    # @param results [Hash] Audit results
-    # @return [String] Formatted report
-    def self.format_report(results)
-      score = results[:score]
-      score_color = score >= 80 ? :green : score >= 50 ? :yellow : :red
-
-      output = []
-      output << "=" * 60
-      output << "RailsForge Architecture Audit"
-      output << "=" * 60
-      output << ""
-      output << "Architecture Score: #{colorize(score, score_color)}/100"
-      output << ""
-
-      # Controllers section
-      output << "-" * 40
-      output << "Controllers:"
-      controller_issues = results[:controllers][:issues_count]
-      if controller_issues == 0
-        output << "  ✓ No issues found (#{controller_issues})"
-      else
-        output << "  ⚠ #{controller_issues} issue(s) found"
-        results[:controllers][:issues].first(5).each do |issue|
-          output << "    - #{issue[:file]}: #{issue[:issues].join(', ')}"
-        end
-        output << "    ..." if results[:controllers][:issues].count > 5
-      end
-      output << ""
-
-      # Models section
-      output << "-" * 40
-      output << "Models:"
-      model_issues = results[:models][:issues_count]
-      if model_issues == 0
-        output << "  ✓ No issues found (#{model_issues})"
-      else
-        output << "  ⚠ #{model_issues} issue(s) found"
-        results[:models][:issues].first(5).each do |issue|
-          output << "    - #{issue[:file]}: #{issue[:issues].join(', ')}"
-        end
-        output << "    ..." if results[:models][:issues].count > 5
-      end
-      output << ""
-
-      # Database section
-      output << "-" * 40
-      output << "Database:"
-      db_issues = results[:database][:issues_count]
-      if db_issues == 0
-        output << "  ✓ No issues found (#{db_issues})"
-      else
-        output << "  ⚠ #{db_issues} issue(s) found"
-        results[:database][:issues].first(5).each do |issue|
-          output << "    - #{issue[:table]}: #{issue[:issue]}"
-        end
-        output << "    ..." if results[:database][:issues].count > 5
-      end
-      output << ""
-
-      # Specs section
-      output << "-" * 40
-      output << "Specs:"
-      spec_issues = results[:specs][:issues_count]
-      if spec_issues == 0
-        output << "  ✓ All components have specs (#{spec_issues} missing)"
-      else
-        output << "  ⚠ #{spec_issues} component(s) missing specs"
-        results[:specs][:coverage].select { |r| r[:has_spec] == false }.first(5).each do |item|
-          output << "    - #{item[:type]}: #{item[:name]}"
-        end
-        output << "    ..." if results[:specs][:coverage].count { |r| r[:has_spec] == false } > 5
-      end
-      output << ""
-
-      # Metrics section
-      output << "-" * 40
-      output << "Metrics:"
-      metrics = results[:metrics][:metrics]
-      if metrics && !metrics.empty?
-        output << "  Files: #{metrics[:total_files] || 'N/A'}"
-        output << "  Lines: #{metrics[:total_lines] || 'N/A'}"
-        output << "  Services: #{metrics[:services_count] || 0}"
-        output << "  Queries: #{metrics[:queries_count] || 0}"
-        output << "  Jobs: #{metrics[:jobs_count] || 0}"
-      else
-        output << "  No metrics available"
-      end
-      output << ""
-
-      output << "=" * 60
-      output << "Audit completed at #{results[:timestamp]}"
-      output << "=" * 60
-
-      output.join("\n")
-    end
-
-    # Print results to console
-    # @param results [Hash] Audit results
-    def self.print_report(results)
-      puts format_report(results)
-    end
-
-    # Convert results to JSON
-    # @param results [Hash] Audit results
-    # @return [String] JSON string
-    def self.to_json(results)
-      require 'json'
-      # Remove non-serializable data
-      serializable = results.dup
-      serializable.delete(:timestamp)
-      JSON.pretty_generate(serializable)
-    end
-
-    # Find Rails app path
-    # @return [String, nil] Rails app root path
-    def self.find_rails_app_path
-      path = Dir.pwd
-      max_depth = 10
-
-      max_depth.times do
-        return path if File.exist?(File.join(path, "config", "application.rb"))
-        parent = File.dirname(path)
-        break if parent == path
-        path = parent
-      end
-
-      nil
-    end
-
-    # Colorize output for terminal
-    # @param text [String] Text to colorize
-    # @param color [Symbol] Color name
-    # @return [String] Colorized text
-    def self.colorize(text, color)
-      colors = {
-        green: "\e[32m",
-        yellow: "\e[33m",
-        red: "\e[31m",
-        reset: "\e[0m"
-      }
-      "#{colors[color]}#{text}#{colors[:reset]}"
-    end
-  end
-end

data/lib/railsforge/config.rb

@@ -1,181 +0,0 @@
-# Config module for RailsForge
-# Manages .railsforgerc configuration
-
-require 'yaml'
-require 'fileutils'
-
-module RailsForge
-  # Config class handles RailsForge configuration
-  class Config
-    # Default config file name
-    CONFIG_FILE = ".railsforgerc".freeze
-
-    # Default configuration
-    DEFAULT_CONFIG = {
-      "version" => "1.0",
-      "profile" => "standard",
-      "generators" => {
-        "default_template_version" => "v1",
-        "include_specs" => true
-      },
-      "analyzers" => {
-        "controller_max_lines" => 150,
-        "controller_max_methods" => 10,
-        "model_max_lines" => 200,
-        "model_max_method_lines" => 15
-      },
-      "refactor" => {
-        "min_method_lines" => 15,
-        "auto_extract" => false
-      }
-    }.freeze
-
-    # Load configuration from file
-    # @param base_path [String] Rails app root path
-    # @return [Hash] Configuration
-    def self.load(base_path = nil)
-      base_path ||= find_rails_app_path || Dir.pwd
-
-      config_file = File.join(base_path, CONFIG_FILE)
-
-      if File.exist?(config_file)
-        YAML.safe_load(File.read(config_file), permitted_classes: [], permitted_symbols: [], aliases: true) || DEFAULT_CONFIG
-      else
-        DEFAULT_CONFIG.dup
-      end
-    end
-
-    # Save configuration to file
-    # @param config [Hash] Configuration to save
-    # @param base_path [String] Rails app root path
-    def self.save(config, base_path = nil)
-      base_path ||= find_rails_app_path || Dir.pwd
-
-      config_file = File.join(base_path, CONFIG_FILE)
-
-      File.write(config_file, YAML.dump(config))
-      puts "Configuration saved to #{config_file}"
-    end
-
-    # Get a specific config value
-    # @param key [String] Configuration key (dot-notation supported)
-    # @param base_path [String] Rails app root path
-    # @return [Object] Configuration value
-    def self.get(key, base_path = nil)
-      config = load(base_path)
-
-      keys = key.split(".")
-      value = config
-
-      keys.each do |k|
-        value = value[k] if value.is_a?(Hash)
-      end
-
-      value
-    end
-
-    # Set a specific config value
-    # @param key [String] Configuration key
-    # @param value [Object] Value to set
-    # @param base_path [String] Rails app root path
-    def self.set(key, value, base_path = nil)
-      config = load(base_path)
-
-      keys = key.split(".")
-      current = config
-
-      keys[0...-1].each do |k|
-        current[k] ||= {}
-        current = current[k]
-      end
-
-      current[keys.last] = value
-      save(config, base_path)
-    end
-
-    # Initialize default config file
-    # @param base_path [String] Rails app root path
-    def self.init(base_path = nil)
-      base_path ||= find_rails_app_path || Dir.pwd
-
-      config_file = File.join(base_path, CONFIG_FILE)
-
-      if File.exist?(config_file)
-        puts "Config file already exists"
-        return false
-      end
-
-      save(DEFAULT_CONFIG.dup, base_path)
-      true
-    end
-
-    # Show current configuration
-    # @param base_path [String] Rails app root path
-    def self.show(base_path = nil)
-      config = load(base_path)
-
-      puts "RailsForge Configuration:"
-      puts ""
-
-      # Version
-      puts "  Version: #{config['version']}"
-      puts "  Profile: #{config['profile']}"
-      puts ""
-
-      # Generators
-      puts "  Generators:"
-      gens = config["generators"] || {}
-      gens.each do |key, value|
-        puts "    #{key}: #{value}"
-      end
-      puts ""
-
-      # Analyzers
-      puts "  Analyzers:"
-      analyzers = config["analyzers"] || {}
-      analyzers.each do |key, value|
-        puts "    #{key}: #{value}"
-      end
-      puts ""
-
-      # Refactor
-      puts "  Refactor:"
-      refactor = config["refactor"] || {}
-      refactor.each do |key, value|
-        puts "    #{key}: #{value}"
-      end
-    end
-
-    # Reset configuration to defaults
-    # @param base_path [String] Rails app root path
-    def self.reset(base_path = nil)
-      base_path ||= find_rails_app_path || Dir.pwd
-
-      config_file = File.join(base_path, CONFIG_FILE)
-
-      if File.exist?(config_file)
-        File.delete(config_file)
-        puts "Configuration reset to defaults"
-      else
-        puts "No configuration file to reset"
-      end
-    end
-
-    private
-
-    # Find Rails app path
-    def self.find_rails_app_path
-      path = Dir.pwd
-      max_depth = 10
-
-      max_depth.times do
-        return path if File.exist?(File.join(path, "config", "application.rb"))
-        parent = File.dirname(path)
-        break if parent == path
-        path = parent
-      end
-
-      nil
-    end
-  end
-end