railsforge 1.0.2 → 2.0.0

data/lib/railsforge/refactor_analyzer.rb

@@ -1,401 +0,0 @@
-module RailsForge
-  # RefactorAnalyzer module handles refactoring suggestions and code extraction
-  module RefactorAnalyzer
-    # Error class for refactoring issues
-    class RefactorError < StandardError; end
-
-    # Configuration thresholds
-    CONTROLLER_MAX_LINES = 150
-    CONTROLLER_MAX_METHODS = 10
-    MODEL_MAX_LINES = 200
-    MODEL_MAX_METHOD_LINES = 15
-
-    # Analyzes controllers for refactoring opportunities
-    # @param base_path [String] Rails app root path
-    # @return [Array<Hash>] Array of refactoring suggestions
-    def self.analyze_controllers(base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      controllers_dir = File.join(base_path, "app", "controllers")
-      return [] unless Dir.exist?(controllers_dir)
-
-      results = []
-      Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
-        result = analyze_controller_file(file)
-        results << result if result[:needs_refactoring]
-      end
-      results
-    end
-
-    # Analyzes models for refactoring opportunities
-    # @param base_path [String] Rails app root path
-    # @return [Array<Hash>] Array of refactoring suggestions
-    def self.analyze_models(base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      models_dir = File.join(base_path, "app", "models")
-      return [] unless Dir.exist?(models_dir)
-
-      results = []
-      Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
-        next if file.end_with?("_application.rb")
-        result = analyze_model_file(file)
-        results << result if result[:needs_refactoring]
-      end
-      results
-    end
-
-    # Analyzes a controller file
-    # @param file_path [String] Path to controller file
-    # @return [Hash] Analysis results
-    def self.analyze_controller_file(file_path)
-      content = File.read(file_path)
-      lines = content.lines.count
-      methods = extract_methods(content)
-
-      issues = []
-      suggestions = []
-
-      if lines > CONTROLLER_MAX_LINES
-        issues << "Controller exceeds #{CONTROLLER_MAX_LINES} lines (currently #{lines})"
-        suggestions << "Consider moving business logic into a Service object"
-      end
-
-      if methods.count > CONTROLLER_MAX_METHODS
-        issues << "Controller has #{methods.count} methods (recommended: #{CONTROLLER_MAX_METHODS} or less)"
-        suggestions << "Consider extracting some actions into separate controllers or using a Service"
-      end
-
-      # Find long methods that could be extracted
-      methods.each do |method|
-        if method[:lines] > MODEL_MAX_METHOD_LINES
-          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting to Service"
-        end
-      end
-
-      {
-        type: :controller,
-        file: File.basename(file_path),
-        path: file_path,
-        lines: lines,
-        methods: methods,
-        issues: issues,
-        suggestions: suggestions,
-        needs_refactoring: issues.any? || suggestions.any?
-      }
-    end
-
-    # Analyzes a model file
-    # @param file_path [String] Path to model file
-    # @return [Hash] Analysis results
-    def self.analyze_model_file(file_path)
-      content = File.read(file_path)
-      lines = content.lines.count
-      methods = extract_methods(content)
-
-      issues = []
-      suggestions = []
-
-      if lines > MODEL_MAX_LINES
-        issues << "Model exceeds #{MODEL_MAX_LINES} lines (currently #{lines})"
-        suggestions << "Consider extracting scopes into Query objects or validations to a Form"
-      end
-
-      # Find long methods
-      methods.each do |method|
-        if method[:lines] > MODEL_MAX_METHOD_LINES
-          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting to a Service"
-        end
-      end
-
-      {
-        type: :model,
-        file: File.basename(file_path),
-        path: file_path,
-        lines: lines,
-        methods: methods,
-        issues: issues,
-        suggestions: suggestions,
-        needs_refactoring: issues.any? || suggestions.any?
-      }
-    end
-
-    # Extracts method names and line counts from content
-    # @param content [String] Ruby code content
-    # @return [Array<Hash>] Array of method info
-    def self.extract_methods(content)
-      methods = []
-
-      # Match def method_name or def self.method_name
-      content.scan(/def\s+(self\.)?([a-z_][a-zA-Z_]*)/) do |prefix, name|
-        methods << {
-          name: name,
-          is_class_method: prefix == "self.",
-          lines: 1  # Simplified - just mark as present
-        }
-      end
-
-      methods
-    end
-
-    # Counts lines in a method
-    # @param content [String] Ruby code content
-    # @param method_name [String] Method name
-    # @param start_line [Integer] Starting line number
-    # @return [Integer] Number of lines
-    def self.count_method_lines(content, method_name, start_line)
-      # Find the end of the method
-      lines = content.lines
-      end_pos = content.length
-
-      # Look for next def or class or end
-      rest = content.lines[start_line..-1].join
-      if rest =~ /\n\s*def\s+(self\.)?[a-z_]/i
-        end_pos = $~.begin(0)
-      elsif rest =~ /\n\s*(class|module)\s+/
-        end_pos = $~.begin(0)
-      elsif rest =~ /\n\s*end\s*$/
-        end_pos = $~.begin(0)
-      end
-
-      content[start_line..end_pos].lines.count
-    end
-
-    # Generates a service file for extracted logic
-    # @param name [String] Service name
-    # @param logic [String] Logic to extract
-    # @param base_path [String] Rails app root
-    # @return [String] Path to created file
-    def self.generate_service(name, logic, base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      service_dir = File.join(base_path, "app", "services")
-      FileUtils.mkdir_p(service_dir)
-
-      file_name = "#{name.underscore}_service.rb"
-      file_path = File.join(service_dir, file_name)
-
-      if File.exist?(file_path)
-        puts "  Skipping service (already exists)"
-        return file_path
-      end
-
-      content = <<~RUBY
-        # Service class for #{name}
-        # Extracted from controller/model logic
-        #
-        # Usage:
-        #   #{name}Service.call(params)
-        class #{name}Service
-          def initialize(**args)
-            @args = args
-          end
-
-          def call
-            # Extracted logic:
-            # #{logic.gsub("\n", "\n            # ")}
-          end
-        end
-      RUBY
-
-      File.write(file_path, content)
-      puts "  Created app/services/#{file_name}"
-      file_path
-    end
-
-    # Generates a query file for extracted logic
-    # @param name [String] Query name
-    # @param scope [String] Scope logic
-    # @param base_path [String] Rails app root
-    # @return [String] Path to created file
-    def self.generate_query(name, scope, base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      query_dir = File.join(base_path, "app", "queries")
-      FileUtils.mkdir_p(query_dir)
-
-      file_name = "find_#{name.underscore}.rb"
-      file_path = File.join(query_dir, file_name)
-
-      if File.exist?(file_path)
-        puts "  Skipping query (already exists)"
-        return file_path
-      end
-
-      content = <<~RUBY
-        # Query class for #{name}
-        # Extracted scope/query logic
-        #
-        # Usage:
-        #   Find#{name}.call
-        class Find#{name}
-          def initialize(scope: nil)
-            @scope = scope || #{name}.all
-          end
-
-          def call
-            # Extracted scope:
-            # #{scope.gsub("\n", "\n            # ")}
-            @scope
-          end
-        end
-      RUBY
-
-      File.write(file_path, content)
-      puts "  Created app/queries/#{file_name}"
-      file_path
-    end
-
-    # Generates an RSpec test for a service
-    # @param name [String] Service name
-    # @param base_path [String] Rails app root
-    # @return [String] Path to created file
-    def self.generate_service_spec(name, base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      spec_dir = File.join(base_path, "spec", "services")
-      FileUtils.mkdir_p(spec_dir)
-
-      file_name = "#{name.underscore}_service_spec.rb"
-      file_path = File.join(spec_dir, file_name)
-
-      if File.exist?(file_path)
-        puts "  Skipping spec (already exists)"
-        return file_path
-      end
-
-      content = <<~RUBY
-        require 'rails_helper'
-
-        RSpec.describe #{name}Service do
-          let(:params) { {} }
-          subject { described_class.new(params) }
-
-          describe '#call' do
-            it 'returns successful result' do
-              expect(subject.call).to be_truthy
-            end
-          end
-        end
-      RUBY
-
-      File.write(file_path, content)
-      puts "  Created spec/services/#{file_name}"
-      file_path
-    end
-
-    # Generates an RSpec test for a query
-    # @param name [String] Query name
-    # @param base_path [String] Rails app root
-    # @return [String] Path to created file
-    def self.generate_query_spec(name, base_path = nil)
-      base_path ||= find_rails_app_path
-      raise RefactorError, "Not in a Rails application directory" unless base_path
-
-      spec_dir = File.join(base_path, "spec", "queries")
-      FileUtils.mkdir_p(spec_dir)
-
-      file_name = "find_#{name.underscore}_spec.rb"
-      file_path = File.join(spec_dir, file_name)
-
-      if File.exist?(file_path)
-        puts "  Skipping spec (already exists)"
-        return file_path
-      end
-
-      content = <<~RUBY
-        require 'rails_helper'
-
-        RSpec.describe Find#{name} do
-          let(:scope) { #{name}.all }
-          subject { described_class.new(scope: scope) }
-
-          describe '#call' do
-            it 'returns scope' do
-              expect(subject.call).to eq(scope)
-            end
-          end
-        end
-      RUBY
-
-      File.write(file_path, content)
-      puts "  Created spec/queries/#{file_name}"
-      file_path
-    end
-
-    # Extracts code from a controller/model and creates a service
-    # @param file_path [String] Source file path
-    # @param method_names [Array<String>] Methods to extract
-    # @param service_name [String] Name for new service
-    # @return [Hash] Results
-    def self.extract_to_service(file_path, method_names, service_name)
-      content = File.read(file_path)
-
-      extracted_logic = []
-      method_names.each do |method_name|
-        # Find method in content
-        if content.include?("def #{method_name}")
-          # Extract method and its body
-          method_match = content.match(/def #{method_name}.*?(\n\s*end\n)/m)
-          extracted_logic << method_match[0] if method_match
-        end
-      end
-
-      base_path = find_rails_app_path
-      generate_service(service_name, extracted_logic.join("\n"), base_path)
-      generate_service_spec(service_name, base_path)
-
-      {
-        service: "app/services/#{service_name.underscore}_service.rb",
-        spec: "spec/services/#{service_name.underscore}_service_spec.rb"
-      }
-    end
-
-    # Prints refactoring report
-    # @param results [Array<Hash>] Analysis results
-    def self.print_report(results)
-      return puts "\n✓ No refactoring needed!" if results.empty?
-
-      puts "\n" + "=" * 60
-      puts "REFACTORING REPORT"
-      puts "=" * 60
-
-      results.each do |result|
-        puts "\n📁 #{result[:file]} (#{result[:type]})"
-        puts "   Lines: #{result[:lines]}"
-
-        if result[:issues].any?
-          puts "\n   ⚠️  Issues:"
-          result[:issues].each { |issue| puts "      • #{issue}" }
-        end
-
-        if result[:suggestions].any?
-          puts "\n   💡 Suggestions:"
-          result[:suggestions].each { |sug| puts "      • #{sug}" }
-        end
-      end
-
-      puts "\n" + "=" * 60
-      puts "Total files needing refactoring: #{results.count}"
-      puts "=" * 60
-    end
-
-    # Finds Rails app root path
-    # @return [String, nil] Rails app path
-    def self.find_rails_app_path
-      path = Dir.pwd
-      10.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

data/lib/railsforge/refactor_controller.rb

@@ -1,277 +0,0 @@
-# RefactorController module for RailsForge
-# Automatically refactors fat controllers by extracting service objects
-
-require 'fileutils'
-
-module RailsForge
-  # RefactorController class extracts services from fat controller methods
-  class RefactorController
-    # Minimum lines to consider a method for extraction
-    MIN_METHOD_LINES = 15
-
-    # Initialize the refactor
-    def initialize(base_path = nil)
-      @base_path = base_path || find_rails_app_path
-      raise RefactorControllerError, "Not in a Rails application directory" unless @base_path
-    end
-
-    # Refactor a specific controller
-    # @param controller_name [String] Name of controller to refactor
-    # @return [Hash] Refactoring results
-    def refactor(controller_name)
-      controller_file = find_controller_file(controller_name)
-
-      unless controller_file
-        raise RefactorControllerError, "Controller '#{controller_name}' not found"
-      end
-
-      puts "Analyzing controller: #{controller_name}"
-      puts ""
-
-      # Read controller content
-      content = File.read(controller_file)
-
-      # Find methods that can be extracted
-      long_methods = find_long_methods(content)
-
-      if long_methods.empty?
-        puts "No methods found that need extraction (min #{MIN_METHOD_LINES} lines)"
-        return { extracted: [], controller: controller_name }
-      end
-
-      puts "Found #{long_methods.count} method(s) to extract:"
-      long_methods.each do |method|
-        puts "  - #{method[:name]} (#{method[:lines]} lines)"
-      end
-      puts ""
-
-      # Extract each method to a service
-      extracted = []
-      long_methods.each do |method|
-        service = extract_method_to_service(controller_name, method)
-        if service
-          update_controller_method(controller_file, method, service)
-          extracted << service
-        end
-      end
-
-      puts "Extraction complete!"
-      puts "  Created #{extracted.count} service(s)"
-      puts ""
-
-      { extracted: extracted, controller: controller_name, methods: long_methods }
-    end
-
-    # Preview what would be extracted without making changes
-    # @param controller_name [String] Name of controller to analyze
-    # @return [Array] Methods that would be extracted
-    def preview(controller_name)
-      controller_file = find_controller_file(controller_name)
-
-      unless controller_file
-        raise RefactorControllerError, "Controller '#{controller_name}' not found"
-      end
-
-      content = File.read(controller_file)
-      find_long_methods(content)
-    end
-
-    private
-
-    # Find the controller file path
-    def 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
-
-    # Find controller file by name
-    def find_controller_file(controller_name)
-      controllers_dir = File.join(@base_path, "app", "controllers")
-
-      # Try different variations
-      [
-        "#{controller_name.underscore}_controller.rb",
-        "#{controller_name.underscore}_controller.rb"
-      ].each do |filename|
-        path = File.join(controllers_dir, filename)
-        return path if File.exist?(path)
-      end
-
-      # Search recursively
-      Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
-        return file if File.basename(file).include?(controller_name.underscore)
-      end
-
-      nil
-    end
-
-    # Find methods that exceed the line threshold
-    def find_long_methods(content)
-      methods = []
-      lines = content.lines
-
-      # Simple regex to find method definitions
-      in_method = false
-      method_start = 0
-      method_name = nil
-      method_lines = []
-
-      lines.each_with_index do |line, index|
-        # Match def method_name or def self.method_name
-        if line =~ /\bdef\s+(self\.)?(\w+)/
-          if in_method
-            # Close previous method
-            methods << {
-              name: method_name,
-              start: method_start,
-              lines: method_lines.count,
-              content: method_lines.join
-            }
-          end
-
-          in_method = true
-          method_start = index
-          method_name = $2
-          method_lines = [line]
-        elsif in_method
-          if line.strip.start_with?("end") && method_lines.last =~ /\b(end|else|elsif|when)\b/
-            # This might be the end of the method
-            method_lines << line
-
-            # Check if this is the closing end
-            depth = method_lines.join.scan(/\b(begin|class|module|def|do|if|case)\b/).count
-            end_depth = method_lines.join.scan(/\bend\b/).count
-
-            if depth == end_depth && depth > 0
-              methods << {
-                name: method_name,
-                start: method_start,
-                lines: method_lines.count,
-                content: method_lines.join
-              }
-              in_method = false
-              method_lines = []
-            end
-          else
-            method_lines << line
-          end
-        end
-      end
-
-      # Close last method if still open
-      if in_method && method_lines.any?
-        methods << {
-          name: method_name,
-          start: method_start,
-          lines: method_lines.count,
-          content: method_lines.join
-        }
-      end
-
-      # Filter to only long methods
-      methods.select { |m| m[:lines] >= MIN_METHOD_LINES }
-    end
-
-    # Extract a method to a service object
-    def extract_method_to_service(controller_name, method_info)
-      service_dir = File.join(@base_path, "app", "services", controller_name.underscore)
-      FileUtils.mkdir_p(service_dir)
-
-      service_name = "#{method_info[:name]}_service"
-      service_class_name = "#{controller_name}#{method_info[:name].camelize}Service"
-
-      service_path = File.join(service_dir, "#{service_name}.rb")
-
-      if File.exist?(service_path)
-        puts "  Skipping #{service_name} (already exists)"
-        return nil
-      end
-
-      # Generate service content
-      service_content = generate_service_content(service_class_name, method_info)
-
-      File.write(service_path, service_content)
-      puts "  Created app/services/#{controller_name.underscore}/#{service_name}.rb"
-
-      { name: service_name, class: service_class_name, path: service_path }
-    end
-
-    # Generate service object content
-    def generate_service_content(class_name, method_info)
-      <<~RUBY
-        # Service extracted from controller method: #{method_info[:name]}
-        # Original method had #{method_info[:lines]} lines
-        class #{class_name}
-          def initialize(params = {})
-            @params = params
-          end
-
-          def call
-            # TODO: Refactor extracted logic here
-            # Original method content:
-            # #{method_info[:content].lines.first(5).join('# ')}
-          end
-
-          def self.call(params = {})
-            new(params).call
-          end
-        end
-      RUBY
-    end
-
-    # Update the controller method to use the service
-    def update_controller_method(controller_file, method_info, service)
-      content = File.read(controller_file)
-
-      # Replace method body with service call
-      new_method = <<~RUBY
-        def #{method_info[:name]}
-          result = #{service[:class]}.call(params)
-        end
-      RUBY
-
-      # Simple replacement - in production would use proper parsing
-      lines = content.lines
-
-      # Find and replace the method
-      modified_lines = []
-      in_target_method = false
-      method_depth = 0
-
-      lines.each_with_index do |line, index|
-        if line =~ /\bdef\s+(self\.)?#{method_info[:name]}\b/
-          in_target_method = true
-          modified_lines << new_method
-          next
-        end
-
-        if in_target_method
-          method_depth += 1 if line =~ /\b(def|class|module|if|case|do)\b/
-          method_depth -= 1 if line =~ /\bend\b/ && method_depth > 0
-
-          if method_depth == 0
-            in_target_method = false
-          end
-          next # Skip original method lines
-        end
-
-        modified_lines << line
-      end
-
-      File.write(controller_file, modified_lines.join)
-      puts "  Updated controller method to use service"
-    end
-
-    # Error class
-    class RefactorControllerError < StandardError; end
-  end
-end