railsforge 1.0.2 → 2.0.0

data/lib/railsforge/analyzers/refactor_analyzer.rb

@@ -1,20 +1,22 @@
 # Refactor analyzer for RailsForge
 # Provides refactoring suggestions
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # RefactorAnalyzer provides refactoring suggestions
     class RefactorAnalyzer < BaseAnalyzer
       class RefactorError < StandardError; end
 
-      CONTROLLER_MAX_LINES = 150
+      CONTROLLER_MAX_LINES   = 150
       CONTROLLER_MAX_METHODS = 10
-      MODEL_MAX_LINES = 200
+      MODEL_MAX_LINES        = 200
       MODEL_MAX_METHOD_LINES = 15
 
-      # Analyze controllers
+      def self.analyze(base_path = nil)
+        analyze_controllers(base_path) + analyze_models(base_path)
+      end
+
       def self.analyze_controllers(base_path = nil)
         base_path ||= find_rails_app_path
         raise RefactorError, "Not in a Rails app" unless base_path
@@ -22,15 +24,13 @@ module RailsForge
         controllers_dir = File.join(base_path, "app", "controllers")
         return [] unless Dir.exist?(controllers_dir)
 
-        results = []
+        issues = []
         Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
-          result = analyze_file(file, :controller)
-          results << result if result[:needs_refactoring]
+          issues.concat(analyze_file(file, :controller))
         end
-        results
+        issues
       end
 
-      # Analyze models
       def self.analyze_models(base_path = nil)
         base_path ||= find_rails_app_path
         raise RefactorError, "Not in a Rails app" unless base_path
@@ -38,81 +38,101 @@ module RailsForge
         models_dir = File.join(base_path, "app", "models")
         return [] unless Dir.exist?(models_dir)
 
-        results = []
+        issues = []
         Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
-          next if file.end_with?("_application.rb")
-          result = analyze_file(file, :model)
-          results << result if result[:needs_refactoring]
+          next if File.basename(file) == "application_record.rb"
+          issues.concat(analyze_file(file, :model))
         end
-        results
+        issues
       end
 
       def self.analyze_file(file_path, type)
-        content = File.read(file_path)
-        lines = content.lines.count
-        methods = extract_methods(content)
-
-        issues = []
-        suggestions = []
+        content  = File.read(file_path)
+        lines    = content.lines.count
+        methods  = extract_methods(content)
+        basename = File.basename(file_path)
+        issues   = []
 
         if type == :controller
-          issues << "Exceeds #{CONTROLLER_MAX_LINES} lines" if lines > CONTROLLER_MAX_LINES
-          issues << "Has #{methods.count} methods" if methods.count > CONTROLLER_MAX_METHODS
-          suggestions << "Consider moving business logic to Service object" if lines > CONTROLLER_MAX_LINES
+          if lines > CONTROLLER_MAX_LINES
+            issues << RailsForge::Issue.new(
+              analyzer:   :refactor,
+              type:       :oversized_controller,
+              severity:   "medium",
+              file:       basename,
+              line:       nil,
+              message:    "#{basename} has #{lines} lines (max #{CONTROLLER_MAX_LINES})",
+              suggestion: "Extract business logic to Service objects"
+            )
+          end
+
+          if methods.count > CONTROLLER_MAX_METHODS
+            issues << RailsForge::Issue.new(
+              analyzer:   :refactor,
+              type:       :too_many_methods,
+              severity:   "low",
+              file:       basename,
+              line:       nil,
+              message:    "#{basename} has #{methods.count} methods (max #{CONTROLLER_MAX_METHODS})",
+              suggestion: "Consider splitting into focused controllers"
+            )
+          end
         else
-          issues << "Exceeds #{MODEL_MAX_LINES} lines" if lines > MODEL_MAX_LINES
+          if lines > MODEL_MAX_LINES
+            issues << RailsForge::Issue.new(
+              analyzer:   :refactor,
+              type:       :oversized_model,
+              severity:   "medium",
+              file:       basename,
+              line:       nil,
+              message:    "#{basename} has #{lines} lines (max #{MODEL_MAX_LINES})",
+              suggestion: "Consider extracting concerns or service objects"
+            )
+          end
         end
 
         methods.each do |method|
-          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting" if method[:lines] > MODEL_MAX_METHOD_LINES
+          next unless method[:lines] > MODEL_MAX_METHOD_LINES
+
+          issues << RailsForge::Issue.new(
+            analyzer:   :refactor,
+            type:       :long_method,
+            severity:   "info",
+            file:       basename,
+            line:       nil,
+            message:    "Method `#{method[:name]}` has #{method[:lines]} lines",
+            suggestion: "Consider extracting to a private method or service"
+          )
         end
 
-        {
-          type: type,
-          file: File.basename(file_path),
-          path: file_path,
-          lines: lines,
-          methods: methods,
-          issues: issues,
-          suggestions: suggestions,
-          needs_refactoring: issues.any? || suggestions.any?
-        }
+        issues
       end
 
       def self.extract_methods(content)
-        methods = []
-        in_method = false
+        methods      = []
+        in_method    = false
+        method_name  = nil
         method_lines = []
 
         content.lines.each do |line|
           if line =~ /\bdef\s+(\w+)/
-            methods << { name: $1, lines: method_lines.count } if in_method
-            in_method = true
+            methods << { name: method_name, lines: method_lines.count } if in_method && method_name
+            in_method    = true
+            method_name  = $1
             method_lines = [line]
           elsif in_method
             method_lines << line
-            methods << { name: methods.last[:name], lines: method_lines.count } if line.strip == "end" && method_lines.count > 1
+            if line.strip == "end" && method_lines.count > 1
+              methods << { name: method_name, lines: method_lines.count }
+              in_method    = false
+              method_name  = nil
+              method_lines = []
+            end
           end
         end
 
         methods
       end
-
-      def self.print_report(results)
-        puts "\nRefactoring Suggestions"
-        puts "-" * 40
-
-        if results.empty?
-          puts "✓ No refactoring needed"
-          return
-        end
-
-        results.each do |result|
-          puts "⚠ #{result[:file]}"
-          result[:issues].each { |i| puts "  - #{i}" }
-          result[:suggestions].each { |s| puts "  → #{s}" }
-        end
-      end
     end
   end
 end

data/lib/railsforge/analyzers/security_analyzer.rb

@@ -1,25 +1,29 @@
 # Security analyzer for RailsForge
 # Checks for common security vulnerabilities
 
-require 'fileutils'
+require "fileutils"
 
 module RailsForge
   module Analyzers
-    # SecurityAnalyzer scans code for security issues
     class SecurityAnalyzer < BaseAnalyzer
-      # Security issue types
       ISSUE_TYPES = {
-        sql_injection: "SQL Injection",
-        mass_assignment: "Unsafe Mass Assignment",
-        xss: "Cross-Site Scripting (XSS)",
-        sensitive_data: "Sensitive Data Exposure",
-        weak_crypto: "Weak Cryptography",
+        sql_injection:    "SQL Injection",
+        mass_assignment:  "Unsafe Mass Assignment",
+        xss:              "Cross-Site Scripting (XSS)",
+        sensitive_data:   "Sensitive Data Exposure",
+        weak_crypto:      "Weak Cryptography",
         command_injection: "Command Injection"
       }.freeze
 
-      # Analyze Rails app for security issues
-      # @param base_path [String] Rails app root path
-      # @return [Array<Hash>] Security issues found
+      SUGGESTIONS = {
+        sql_injection:    "Use parameterized queries: Model.where(column: value)",
+        mass_assignment:  "Use strong parameters with permit() instead of attr_accessible",
+        xss:              "Avoid raw/html_safe; use Rails' built-in escaping",
+        sensitive_data:   "Move secrets to environment variables or Rails credentials",
+        weak_crypto:      "Use bcrypt for passwords; SHA-256 or better for hashing",
+        command_injection: "Avoid shell interpolation; use array form of system()"
+      }.freeze
+
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
@@ -27,141 +31,80 @@ module RailsForge
         new(base_path).find_issues
       end
 
-      # Initialize analyzer
-      # @param base_path [String] Rails app root path
       def initialize(base_path)
         @base_path = base_path
         @issues = []
       end
 
-      # Find all security issues
-      # @return [Array<Hash>] Issues found
       def find_issues
         check_sql_injection
         check_mass_assignment
         check_xss
         check_sensitive_data
         check_weak_crypto
-
         @issues
       end
 
-      # Print security report
-      # @param issues [Array<Hash>] Issues to print
-      def self.print_report(issues)
-        puts "Security Analysis"
-        puts "=" * 50
-
-        if issues.empty?
-          puts "✓ No security issues found"
-          return
-        end
-
-        puts "Found #{issues.count} security issue(s):"
-        puts ""
-
-        issues.each do |issue|
-          puts "⚠ #{issue[:type]}"
-          puts "  File: #{issue[:file]}"
-          puts "  Line: #{issue[:line]}"
-          puts "  Issue: #{issue[:message]}"
-          puts ""
-        end
-      end
-
       private
 
-      # Check for SQL injection vulnerabilities
       def check_sql_injection
         patterns = [
           /\.where\s*\(\s*params\./,
           /find_by\(.*\#\{.*\}/,
           /execute\s*\(.*\#\{.*\}/
         ]
-
         scan_files("app/models/**/*.rb", patterns, :sql_injection)
         scan_files("app/controllers/**/*.rb", patterns, :sql_injection)
       end
 
-      # Check for unsafe mass assignment
       def check_mass_assignment
-        patterns = [
-          /attr_accessible/,
-          /attr_protected/
-        ]
-
+        patterns = [/attr_accessible/, /attr_protected/]
         scan_files("app/models/**/*.rb", patterns, :mass_assignment)
       end
 
-      # Check for XSS vulnerabilities
       def check_xss
-        patterns = [
-          /raw\s*\(/,
-          /html_safe\s*$/,
-          /\<\%=\s*[^>]+without/
-        ]
-
+        patterns = [/raw\s*\(/, /html_safe\s*$/, /\<\%=\s*[^>]+without/]
         scan_files("app/views/**/*.erb", patterns, :xss)
         scan_files("app/helpers/**/*.rb", patterns, :xss)
       end
 
-      # Check for sensitive data exposure
       def check_sensitive_data
-        patterns = [
-          /password/,
-          /secret/,
-          /token/,
-          /api_key/,
-          /private_key/
-        ]
-
+        patterns = [/password/, /secret/, /token/, /api_key/, /private_key/]
         scan_files("app/models/**/*.rb", patterns, :sensitive_data)
         scan_files("config/**/*.rb", patterns, :sensitive_data)
       end
 
-      # Check for weak cryptography
       def check_weak_crypto
-        patterns = [
-          /MD5/,
-          /SHA1/,
-          /DES\.encrypt/,
-          /\.encrypt\s+[^:]+$/
-        ]
-
+        patterns = [/MD5/, /SHA1/, /DES\.encrypt/, /\.encrypt\s+[^:]+$/]
         scan_files("app/**/*.rb", patterns, :weak_crypto)
       end
 
-      # Scan files for patterns
       def scan_files(glob, patterns, issue_type)
         Dir.glob(File.join(@base_path, glob)).each do |file|
-          content = File.read(file)
-          lines = content.lines
-
+          lines = File.read(file).lines
           lines.each_with_index do |line, index|
             patterns.each do |pattern|
-              if line =~ pattern
-                @issues << {
-                  type: ISSUE_TYPES[issue_type],
-                  file: file.gsub(@base_path, ""),
-                  line: index + 1,
-                  message: line.strip,
-                  severity: severity_for(issue_type)
-                }
-              end
+              next unless line =~ pattern
+
+              @issues << RailsForge::Issue.new(
+                analyzer:   :security,
+                type:       issue_type,
+                severity:   severity_for(issue_type),
+                file:       file.delete_prefix("#{@base_path}/"),
+                line:       index + 1,
+                message:    "#{ISSUE_TYPES[issue_type]}: #{line.strip}",
+                suggestion: SUGGESTIONS[issue_type]
+              )
             end
           end
         end
       end
 
-      # Get severity for issue type
       def severity_for(issue_type)
         case issue_type
-        when :sql_injection, :command_injection
-          "high"
-        when :mass_assignment, :xss
-          "medium"
-        else
-          "low"
+        when :sql_injection, :command_injection then "high"
+        when :mass_assignment, :xss             then "medium"
+        else                                         "low"
         end
       end
     end

data/lib/railsforge/analyzers/spec_analyzer.rb

@@ -1,57 +1,43 @@
 # Spec analyzer for RailsForge
 # Checks for missing spec files
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # SpecAnalyzer checks spec coverage
     class SpecAnalyzer < BaseAnalyzer
       GENERATOR_TYPES = %w[services queries jobs forms presenters policies serializers].freeze
 
-      # Analyze spec coverage
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
 
-        results = []
-        GENERATOR_TYPES.each do |type|
-          app_folder = "app/#{type.chop}"
-          spec_folder = "spec/#{type}"
+        issues = []
 
-          app_path = File.join(base_path, app_folder)
-          spec_path = File.join(base_path, spec_folder)
+        GENERATOR_TYPES.each do |type|
+          singular   = type.chop
+          app_path   = File.join(base_path, "app", singular)
+          spec_path  = File.join(base_path, "spec", type)
 
           next unless Dir.exist?(app_path)
 
-          app_files = Dir.glob(File.join(app_path, "**", "*.rb")).map { |f| File.basename(f, ".rb") }
+          app_files  = Dir.glob(File.join(app_path, "**", "*.rb")).map { |f| File.basename(f, ".rb") }
           spec_files = Dir.exist?(spec_path) ? Dir.glob(File.join(spec_path, "**", "*_spec.rb")).map { |f| File.basename(f, "_spec.rb") } : []
 
           (app_files - spec_files).each do |missing|
-            results << {
-              type: type.chop,
-              name: missing,
-              has_spec: false
-            }
+            issues << RailsForge::Issue.new(
+              analyzer:   :spec,
+              type:       :missing_spec,
+              severity:   "low",
+              file:       "app/#{singular}/#{missing}.rb",
+              line:       nil,
+              message:    "#{singular.capitalize} `#{missing}` has no spec",
+              suggestion: "Create spec/#{type}/#{missing}_spec.rb"
+            )
           end
         end
 
-        results
-      end
-
-      def self.print_results(results)
-        puts "\nSpec Coverage Analysis"
-        puts "-" * 40
-
-        if results.empty?
-          puts "✓ All components have specs"
-          return
-        end
-
-        puts "⚠ #{results.count} missing specs:"
-        results.first(10).each do |result|
-          puts "  - #{result[:type]}: #{result[:name]}"
-        end
+        issues
       end
     end
   end