railsforge 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a30814a978c1f6eae732253edaf8ebde7fb49b5761ef1927f180a5480f3f7921
-  data.tar.gz: 4dfd319836fd20dcc79ac23d0c5eeb644802b9f6d480956dbae89cfeb5ef39ed
+  metadata.gz: 1ca67789d645855334565249db474d63bfde8607e031642c52a287924c55b9cf
+  data.tar.gz: 9517139f8e3224a17ebd875c6606a2ea244e183e289acc1599181eed13522f07
 SHA512:
-  metadata.gz: eb2d18edddb6280e6b1eb954efb13a7acedc9e1fc429a7257e59282cbb2225293a0c028b5c34a3b1e1c18f3e7875c1868e4472a8b39b6b90ba6d7e24cd7803b9
-  data.tar.gz: a8fee69a296ec94b93aecbd6f89223c5fcda26ff37dd6fb96081394dbc7856dd92f5c4a445ac2cd1a7f549c0159ca712f0e0680ad1987dfd166f10bf7a908d1f
+  metadata.gz: db1e954e6df040c1856be4cee40357e781201d29a550f31c1dc8924d4c3e93678daecefa42c8e651d02ddef5dc04d4ebd702cb37cac2a0731111ddf0a6e03d13
+  data.tar.gz: d7f692d25425099a0ea48499655272a70cf77f517cbfdadbe54826c517aa9e989833774feca6fb7742d36e5aa8bdc47c5c9d9760b8a0130009716ea74298e6c6

data/README.md

@@ -1,17 +1,14 @@
 # RailsForge
 
 <p align="center">
-  <a href="https://github.com/railsforge/railsforge/actions">
-    <img src="https://img.shields.io/github/actions/workflow/status/railsforge/railsforge/main.yml" alt="CI Status">
+  <a href="https://github.com/mfifth/RailsForge/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/mfifth/railsforge/main.yml?label=CI" alt="CI Status">
   </a>
   <a href="https://rubygems.org/gems/railsforge">
-    <img src="https://img.shields.io/gem/v/railsforge" alt="Gem Version">
+    <img src="https://img.shields.io/gem/v/railsforge.svg?label=rubygems" alt="Gem Version">
   </a>
-  <a href="https://rubygems.org/gems/railsforge">
-    <img src="https://img.shields.io/gem/dt/railsforge" alt="Gem Downloads">
-  </a>
-  <a href="https://github.com/railsforge/railsforge/blob/main/LICENSE">
-    <img src="https://img.shields.io/github/license/railsforge/railsforge" alt="License">
+  <a href="https://github.com/mfifth/RailsForge/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License">
   </a>
 </p>
 
@@ -41,8 +38,7 @@ RailsForge streamlines Rails development by providing automated generators and a
 
 ### Requirements
 
-- **Ruby** version 2.7 or higher
-- **Rails** version 5.0 or higher (for Rails-specific features)
+- **Ruby** version 3.0 or higher
 - **Bundler** for gem management
 
 ### Setup Steps
@@ -464,7 +460,7 @@ We welcome contributions! Please see our contributing guidelines:
 
 ```bash
 # Fork the repository
-git clone https://github.com/your-username/railsforge.git
+git clone https://github.com/mfifth/RailsForge.git
 cd railsforge
 
 # Install dependencies

data/bin/railsforge

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # CLI entrypoint for RailsForge gem
-# This file is executable from the command line
+# Uses minimal loader for fast --help and --version
 
 require_relative "../lib/railsforge"
 
-# Delegate to RailsForge::CLI
-RailsForge::CLI.start(ARGV)
+# Use minimal CLI for fast startup
+RailsForge::CLIMinimal.start(ARGV)

data/lib/railsforge/cli.rb

@@ -236,15 +236,29 @@ module RailsForge
     def self.generate_single(type, name, template_version)
       case type
       when :service
-        "Generating service: #{name}" + "\n" + RailsForge::Generators::ServiceGenerator.generate(name, with_spec: true, template_version: template_version)
+        "Generating service: #{name}\n" + RailsForge::Generators::ServiceGenerator.generate(name, with_spec: true, template_version: template_version)
       when :query
-        "Generating query: #{name}"
+        "Generating query: #{name}\n" + RailsForge::Generators::QueryGenerator.generate(name, with_spec: true, template_version: template_version)
       when :job
-        "Generating job: #{name}"
+        "Generating job: #{name}\n" + RailsForge::Generators::JobGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :form
+        "Generating form: #{name}\n" + RailsForge::Generators::FormGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :presenter
+        "Generating presenter: #{name}\n" + RailsForge::Generators::PresenterGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :policy
+        "Generating policy: #{name}\n" + RailsForge::Generators::PolicyGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :serializer
+        "Generating serializer: #{name}\n" + RailsForge::Generators::SerializerGenerator.generate(name, with_spec: true, template_version: template_version)
       when :component
-        "Generating component: #{name}" + "\n" + RailsForge::Generators::ViewComponentGenerator.new(name, template_version: template_version).generate
+        "Generating component: #{name}\n" + RailsForge::Generators::ViewComponentGenerator.new(name, template_version: template_version).generate
       when :stimulus
-        "Generating stimulus: #{name}" + "\n" + RailsForge::Generators::StimulusControllerGenerator.new(name, template_version: template_version).generate
+        "Generating stimulus: #{name}\n" + RailsForge::Generators::StimulusControllerGenerator.new(name, template_version: template_version).generate
+      when :mailer
+        "Generating mailer: #{name}\n" + RailsForge::MailerGenerator.generate(name, with_spec: true)
+      when :feature
+        "Generating feature: #{name}\n" + RailsForge::FeatureGenerator.generate(name, with_spec: true)
+      when :api
+        "Generating API: #{name}\n" + RailsForge::Generators::ApiGenerator.generate(name, with_spec: true)
       else
         "Generator for #{type} not fully implemented"
       end

data/lib/railsforge/cli_minimal.rb

@@ -0,0 +1,93 @@
+# Minimal CLI for fast --help and --version
+# This is loaded first, then full CLI is lazy-loaded when needed
+
+module RailsForge
+  class CLIMinimal
+    def self.start(args)
+      command = args.shift
+
+      case command
+      when nil, "--help", "-h"
+        display_help
+        exit 0
+      when "--version", "-v"
+        # Only load version, nothing else
+        require_relative "version"
+        puts "RailsForge #{RailsForge::VERSION}"
+        exit 0
+      else
+        # Load full CLI for other commands - this is where the slowness comes from
+        require_relative "cli"
+        require_relative "profiles"
+        require_relative "template_loader"
+        require_relative "generator"
+        
+        # Load all generators
+        require_relative "generators/base_generator"
+        require_relative "generators/service_generator"
+        require_relative "generators/view_component_generator"
+        require_relative "generators/stimulus_controller_generator"
+        require_relative "generators/demo_generator"
+        require_relative "generators/devops_generator"
+        require_relative "generators/monitoring_generator"
+        require_relative "generators/test_generator"
+        
+        # Load all analyzers
+        require_relative "analyzers/base_analyzer"
+        require_relative "analyzers/controller_analyzer"
+        require_relative "analyzers/model_analyzer"
+        require_relative "analyzers/spec_analyzer"
+        require_relative "analyzers/database_analyzer"
+        require_relative "analyzers/metrics_analyzer"
+        require_relative "analyzers/refactor_analyzer"
+        require_relative "analyzers/security_analyzer"
+        require_relative "analyzers/performance_analyzer"
+        
+        # Load refactors and plugins
+        require_relative "refactors/refactor_controller"
+        require_relative "plugins"
+        
+        # Load legacy modules
+        require_relative "mailer_generator"
+        require_relative "feature_generator"
+        require_relative "api_generator"
+        require_relative "audit"
+        require_relative "doctor"
+        require_relative "graph"
+        require_relative "wizard"
+        require_relative "wizard_tui"
+        require_relative "config"
+
+        # Dispatch to full CLI
+        CLI.start([command] + args)
+      end
+    end
+
+    def self.display_help
+      puts <<~HELP
+        RailsForge - A Rails development toolkit
+
+        Usage:
+          railsforge new <app_name>              Create a new Rails app
+          railsforge generate service <name>    Generate a service object
+          railsforge generate query <name>      Generate a query object
+          railsforge generate job <name>        Generate a job object
+          railsforge generate demo <name>       Generate a demo project
+          railsforge generate devops            Generate Docker/CI-CD configs
+          railsforge generate monitoring         Generate Sentry/Lograge configs
+          railsforge generate test <name>        Generate test files
+          railsforge analyze                    Analyze code quality
+          railsforge doctor                     Full project health check
+          railsforge audit                      Architecture audit
+          railsforge graph                      Dependency graph
+          railsforge refactor                   Refactoring suggestions
+          railsforge wizard                     Interactive project setup
+          railsforge plugins                    Plugin management
+          railsforge config                     Configuration
+          railsforge profiles                   List available profiles
+          railsforge --version, -v              Show version
+          railsforge --help, -h                 Show this help
+      HELP
+    end
+  end
+end

data/lib/railsforge/generators/api_generator.rb

@@ -0,0 +1,392 @@
+# API Generator for RailsForge
+# Generates API resources with controllers, serializers, policies, services, and queries
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # ApiGenerator creates API resources
+    class ApiGenerator < BaseGenerator
+      # Error class for invalid resource names
+      class InvalidResourceNameError < StandardError; end
+
+      # Initialize the generator
+      # @param name [String] Resource name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        @namespace = options[:namespace] || "api"
+        @version = options[:version] || "v1"
+        @with_spec = options.fetch(:with_spec, true)
+      end
+
+      # Generate API resource files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_controller
+        results << generate_serializer
+        results << generate_policy
+        results << generate_service
+        results << generate_query
+        results << generate_request_spec if @with_spec
+
+        "API resource '#{@name}' generated successfully with #{results.count} files!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(resource_name, with_spec: true, version: "v1", namespace: "api")
+        new(resource_name, with_spec: with_spec, version: version, namespace: namespace).generate
+      end
+
+      private
+
+      # Validate resource name
+      def validate_name!(name)
+        raise InvalidResourceNameError, "Resource name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidResourceNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Pluralize helper
+      def 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
+
+      # Generate controller
+      def generate_controller
+        controller_dir = File.join(@base_path, "app", "controllers", @namespace, @version)
+        FileUtils.mkdir_p(controller_dir)
+
+        resource_plural = pluralize(@name)
+        resource_underscore = underscore
+        resource_underscore_plural = pluralize(resource_underscore)
+
+        file_name = "#{resource_underscore}_controller.rb"
+        file_path = File.join(controller_dir, file_name)
+
+        return "  Skipping controller (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # API Controller for #{@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} = #{@name}Query.call
+              render json: #{@name}Serializer.new(@#{resource_underscore_plural}).serializable_hash
+            end
+
+            # GET /#{resource_underscore_plural}/:id
+            def show
+              render json: #{@name}Serializer.new(@#{resource_underscore}).serializable_hash
+            end
+
+            # POST /#{resource_underscore_plural}
+            def create
+              @result = Create#{@name}Service.call(#{resource_underscore}_params)
+
+              if @result.success?
+                render json: #{@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#{@name}Service.call(@#{resource_underscore}, #{resource_underscore}_params)
+
+              if @result.success?
+                render json: #{@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} = #{@name}.find(params[:id])
+            end
+
+            def #{resource_underscore}_params
+              params.require(:#{resource_underscore}).permit(:name)
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/controllers/#{@namespace}/#{@version}/#{file_name}"
+      end
+
+      # Generate serializer
+      def generate_serializer
+        serializer_dir = File.join(@base_path, "app", "serializers")
+        FileUtils.mkdir_p(serializer_dir)
+
+        file_name = "#{underscore}_serializer.rb"
+        file_path = File.join(serializer_dir, file_name)
+
+        return "  Skipping serializer (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # Serializer for #{@name}
+          class #{@name}Serializer < ApplicationSerializer
+            attributes :id, :name, :created_at, :updated_at
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/serializers/#{file_name}"
+      end
+
+      # Generate policy
+      def generate_policy
+        policy_dir = File.join(@base_path, "app", "policies")
+        FileUtils.mkdir_p(policy_dir)
+
+        file_name = "#{underscore}_policy.rb"
+        file_path = File.join(policy_dir, file_name)
+
+        return "  Skipping policy (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # Policy for #{@name}
+          class #{@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)
+        "  Created app/policies/#{file_name}"
+      end
+
+      # Generate service
+      def generate_service
+        service_dir = File.join(@base_path, "app", "services")
+        FileUtils.mkdir_p(service_dir)
+        res_underscore = underscore
+
+        # Create service
+        file_name = "create_#{res_underscore}_service.rb"
+        file_path = File.join(service_dir, file_name)
+
+        unless File.exist?(file_path)
+          content = <<~RUBY
+            # Service for creating #{@name}
+            class Create#{@name}Service
+              def initialize(params)
+                @params = params
+              end
+
+              def call
+                @#{res_underscore} = #{@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)
+        end
+
+        # Update service
+        file_name = "update_#{res_underscore}_service.rb"
+        file_path = File.join(service_dir, file_name)
+
+        unless File.exist?(file_path)
+          content = <<~RUBY
+            # Service for updating #{@name}
+            class Update#{@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)
+        end
+
+        "  Created app/services/create_#{res_underscore}_service.rb and update_#{res_underscore}_service.rb"
+      end
+
+      # Generate query
+      def generate_query
+        query_dir = File.join(@base_path, "app", "queries")
+        FileUtils.mkdir_p(query_dir)
+
+        file_name = "find_#{underscore}.rb"
+        file_path = File.join(query_dir, file_name)
+
+        return "  Skipping query (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # Query for finding #{@name}
+          class Find#{@name}
+            def initialize(scope: nil)
+              @scope = scope || #{@name}.all
+            end
+
+            def call
+              @scope
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/queries/#{file_name}"
+      end
+
+      # Generate request spec
+      def generate_request_spec
+        spec_dir = File.join(@base_path, "spec", "requests", @namespace, @version)
+        FileUtils.mkdir_p(spec_dir)
+
+        resource_plural = pluralize(@name)
+        resource_underscore = underscore
+
+        file_name = "#{resource_underscore}_spec.rb"
+        file_path = File.join(spec_dir, 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}) { #{@name}.create!(name: "Test #{@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 #{@name}" } }
+                }.to change(#{@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(#{@name}, :count).by(-1)
+              end
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created spec/requests/#{@namespace}/#{@version}/#{file_name}"
+      end
+    end
+  end
+end

data/lib/railsforge/generators/base_generator.rb

@@ -58,7 +58,12 @@ module RailsForge
       # Convert to camelize
       # @return [String] Camelized name
       def camelize
-        @name.to_s.split('_').map(&:capitalize).join
+        result = @name.to_s.gsub(/::/, '/')
+        result.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .split('_')
+              .map(&:capitalize)
+              .join
       end
 
       # Generate the file