railsforge 1.0.0

data/lib/railsforge/api_generator.rb

@@ -0,0 +1,397 @@
+module RailsForge
+  # ApiGenerator module handles generating API resources
+  module ApiGenerator
+    # Error class for invalid resource names
+    class InvalidResourceNameError < StandardError; end
+
+    # Simple pluralize helper
+    def self.pluralize(word)
+      return word + 's' unless word.end_with?('s')
+      return word + 'es' if word.end_with?('sh') || word.end_with?('ch')
+      word + 's'
+    end
+
+    # Simple underscore helper
+    def self.underscore(word)
+      word.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .downcase
+    end
+
+    # Validates the resource name
+    def self.validate_resource_name(name)
+      if name.nil? || name.strip.empty?
+        raise InvalidResourceNameError, "Resource name cannot be empty"
+      end
+
+      unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+        raise InvalidResourceNameError, "Resource name must be in PascalCase (e.g., User)"
+      end
+    end
+
+    # Generates an API resource with all necessary files
+    def self.generate(resource_name, with_spec: true, version: "v1", namespace: "api")
+      validate_resource_name(resource_name)
+
+      base_path = find_rails_app_path
+      raise InvalidResourceNameError, "Not in a Rails application directory" unless base_path
+
+      results = []
+
+      # Generate directories
+      controller_dir = File.join(base_path, "app", "controllers", namespace, version)
+      FileUtils.mkdir_p(controller_dir)
+
+      serializer_dir = File.join(base_path, "app", "serializers")
+      FileUtils.mkdir_p(serializer_dir)
+
+      policy_dir = File.join(base_path, "app", "policies")
+      FileUtils.mkdir_p(policy_dir)
+
+      service_dir = File.join(base_path, "app", "services")
+      FileUtils.mkdir_p(service_dir)
+
+      query_dir = File.join(base_path, "app", "queries")
+      FileUtils.mkdir_p(query_dir)
+
+      results << generate_controller(base_path, resource_name, namespace, version)
+      results << generate_serializer(base_path, resource_name)
+      results << generate_policy(base_path, resource_name)
+      results << generate_service(base_path, resource_name)
+      results << generate_query(base_path, resource_name)
+
+      if with_spec
+        spec_dir = File.join(base_path, "spec", "requests", namespace, version)
+        FileUtils.mkdir_p(spec_dir)
+        results << generate_request_spec(base_path, resource_name, namespace, version)
+      end
+
+      "API resource '#{resource_name}' generated successfully with #{results.count} files!"
+    end
+
+    def self.generate_controller(base_path, resource_name, namespace, version)
+      resource_plural = pluralize(resource_name)
+      resource_underscore = underscore(resource_name)
+      resource_underscore_plural = pluralize(resource_underscore)
+
+      file_name = "#{resource_underscore}_controller.rb"
+      file_path = File.join(base_path, "app", "controllers", namespace, version, file_name)
+
+      return "  Skipping controller (already exists)" if File.exist?(file_path)
+
+      content = <<~RUBY
+        # API Controller for #{resource_name}
+        # Version: #{version}
+        # Namespace: #{namespace}
+        #
+        # Generates standard CRUD actions for REST API
+        class #{resource_plural}Controller < ApplicationController
+          before_action :set_#{resource_underscore}, only: [:show, :update, :destroy]
+          before_action :authenticate_user!, unless: :devise_controller?
+
+          # GET /#{resource_underscore_plural}
+          def index
+            @#{resource_underscore_plural} = #{resource_name}Query.call
+            render json: #{resource_name}Serializer.new(@#{resource_underscore_plural}).serializable_hash
+          end
+
+          # GET /#{resource_underscore_plural}/:id
+          def show
+            render json: #{resource_name}Serializer.new(@#{resource_underscore}).serializable_hash
+          end
+
+          # POST /#{resource_underscore_plural}
+          def create
+            @result = Create#{resource_name}Service.call(#{resource_underscore}_params)
+
+            if @result.success?
+              render json: #{resource_name}Serializer.new(@result.#{resource_underscore}).serializable_hash, status: :created
+            else
+              render json: { errors: @result.errors }, status: :unprocessable_entity
+            end
+          end
+
+          # PATCH/PUT /#{resource_underscore_plural}/:id
+          def update
+            @result = Update#{resource_name}Service.call(@#{resource_underscore}, #{resource_underscore}_params)
+
+            if @result.success?
+              render json: #{resource_name}Serializer.new(@result.#{resource_underscore}).serializable_hash
+            else
+              render json: { errors: @result.errors }, status: :unprocessable_entity
+            end
+          end
+
+          # DELETE /#{resource_underscore_plural}/:id
+          def destroy
+            @#{resource_underscore}.destroy
+            head :no_content
+          end
+
+          private
+
+          def set_#{resource_underscore}
+            @#{resource_underscore} = #{resource_name}.find(params[:id])
+          end
+
+          def #{resource_underscore}_params
+            params.require(:#{resource_underscore}).permit(:name)
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/controllers/#{namespace}/#{version}/#{file_name}"
+      file_path
+    end
+
+    def self.generate_serializer(base_path, resource_name)
+      file_name = "#{underscore(resource_name)}_serializer.rb"
+      file_path = File.join(base_path, "app", "serializers", file_name)
+
+      return "  Skipping serializer (already exists)" if File.exist?(file_path)
+
+      content = <<~RUBY
+        # Serializer for #{resource_name}
+        class #{resource_name}Serializer < ApplicationSerializer
+          attributes :id, :name, :created_at, :updated_at
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/serializers/#{file_name}"
+      file_path
+    end
+
+    def self.generate_policy(base_path, resource_name)
+      file_name = "#{underscore(resource_name)}_policy.rb"
+      file_path = File.join(base_path, "app", "policies", file_name)
+
+      return "  Skipping policy (already exists)" if File.exist?(file_path)
+
+      content = <<~RUBY
+        # Policy for #{resource_name}
+        class #{resource_name}Policy
+          attr_reader :user, :record
+
+          def initialize(user, record)
+            @user = user
+            @record = record
+          end
+
+          def index?
+            true
+          end
+
+          def show?
+            true
+          end
+
+          def create?
+            user.present?
+          end
+
+          def update?
+            user.present?
+          end
+
+          def destroy?
+            user.present?
+          end
+
+          class Scope
+            def initialize(user, scope)
+              @user = user
+              @scope = scope
+            end
+
+            def resolve
+              scope.all
+            end
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/policies/#{file_name}"
+      file_path
+    end
+
+    def self.generate_service(base_path, resource_name)
+      res_underscore = underscore(resource_name)
+
+      # Create service
+      file_name = "create_#{res_underscore}_service.rb"
+      file_path = File.join(base_path, "app", "services", file_name)
+
+      unless File.exist?(file_path)
+        content = <<~RUBY
+          # Service for creating #{resource_name}
+          class Create#{resource_name}Service
+            def initialize(params)
+              @params = params
+            end
+
+            def call
+              @#{res_underscore} = #{resource_name}.create!(@params)
+              Result.new(success: true, #{res_underscore}: @#{res_underscore})
+            rescue => e
+              Result.new(success: false, errors: e.message)
+            end
+
+            class Result
+              attr_reader :#{res_underscore}, :errors
+              def initialize(success:, #{res_underscore}: nil, errors: nil)
+                @success = success
+                @#{res_underscore} = #{res_underscore}
+                @errors = errors
+              end
+
+              def success?
+                @success
+              end
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        puts "  Created app/services/#{file_name}"
+      end
+
+      # Update service
+      file_name = "update_#{res_underscore}_service.rb"
+      file_path = File.join(base_path, "app", "services", file_name)
+
+      unless File.exist?(file_path)
+        content = <<~RUBY
+          # Service for updating #{resource_name}
+          class Update#{resource_name}Service
+            def initialize(#{res_underscore}, params)
+              @#{res_underscore} = #{res_underscore}
+              @params = params
+            end
+
+            def call
+              if @#{res_underscore}.update(@params)
+                Result.new(success: true, #{res_underscore}: @#{res_underscore})
+              else
+                Result.new(success: false, errors: @#{res_underscore}.errors.full_messages)
+              end
+            end
+
+            class Result
+              attr_reader :#{res_underscore}, :errors
+              def initialize(success:, #{res_underscore}: nil, errors: nil)
+                @success = success
+                @#{res_underscore} = #{res_underscore}
+                @errors = errors
+              end
+
+              def success?
+                @success
+              end
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        puts "  Created app/services/#{file_name}"
+      end
+
+      "services"
+    end
+
+    def self.generate_query(base_path, resource_name)
+      file_name = "find_#{underscore(resource_name)}.rb"
+      file_path = File.join(base_path, "app", "queries", file_name)
+
+      return "  Skipping query (already exists)" if File.exist?(file_path)
+
+      content = <<~RUBY
+        # Query for finding #{resource_name}
+        class Find#{resource_name}
+          def initialize(scope: nil)
+            @scope = scope || #{resource_name}.all
+          end
+
+          def call
+            @scope
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/queries/#{file_name}"
+      file_path
+    end
+
+    def self.generate_request_spec(base_path, resource_name, namespace, version)
+      resource_plural = pluralize(resource_name)
+      resource_underscore = underscore(resource_name)
+
+      file_name = "#{resource_underscore}_spec.rb"
+      file_path = File.join(base_path, "spec", "requests", namespace, version, file_name)
+
+      return "  Skipping spec (already exists)" if File.exist?(file_path)
+
+      content = <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe "#{namespace.capitalize}::#{version.capitalize}::#{resource_plural}Controller" do
+          let(:user) { User.create!(name: "Test", email: "test@example.com") }
+          let(:#{resource_underscore}) { #{resource_name}.create!(name: "Test #{resource_name}") }
+
+          before do
+            sign_in user
+          end
+
+          describe "GET /index" do
+            it "returns a success response" do
+              get :index
+              expect(response).to be_successful
+            end
+          end
+
+          describe "GET /show" do
+            it "returns a success response" do
+              get :show, params: { id: #{resource_underscore}.id }
+              expect(response).to be_successful
+            end
+          end
+
+          describe "POST /create" do
+            it "creates a new #{resource_underscore}" do
+              expect {
+                post :create, params: { #{resource_underscore}: { name: "New #{resource_name}" } }
+              }.to change(#{resource_name}, :count).by(1)
+            end
+          end
+
+          describe "DELETE /destroy" do
+            it "deletes the #{resource_underscore}" do
+              #{resource_underscore}
+              expect {
+                delete :destroy, params: { id: #{resource_underscore}.id }
+              }.to change(#{resource_name}, :count).by(-1)
+            end
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created spec/requests/#{namespace}/#{version}/#{file_name}"
+      file_path
+    end
+
+    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/audit.rb

@@ -0,0 +1,289 @@
+# 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