railsforge 1.0.2 → 2.0.0

data/lib/railsforge/generator.rb

@@ -1,313 +0,0 @@
-# Generator module for RailsForge
-# Handles Rails app creation and folder structure
-
-require "fileutils"
-
-module RailsForge
-  # Generator module handles Rails app creation
-  module Generator
-    # Folders to create inside the Rails app
-    FOLDERS = %w[
-      app/services
-      app/queries
-      app/policies
-      app/forms
-      app/presenters
-      app/jobs
-      app/mailers
-    ].freeze
-
-    # Error class for invalid app names
-    class InvalidAppNameError < StandardError; end
-
-    # Validates the app name to ensure it's valid for a Rails project
-    # @param name [String] The app name to validate
-    # @return [void]
-    # @raises [InvalidAppNameError] If name is invalid
-    def self.validate_app_name(name)
-      if name.nil? || name.strip.empty?
-        raise InvalidAppNameError, "App name cannot be empty"
-      end
-
-      # Check for valid Ruby/Rails naming conventions
-      unless name =~ /\A[a-z][a-z0-9_]*\z/
-        raise InvalidAppNameError, "App name must start with a lowercase letter and contain only letters, numbers, and underscores"
-      end
-
-      # Check for reserved Ruby words that would cause issues
-      reserved_words = %w[begin end if else elsif unless case when while until do for
-                          class module def unless return yield break next redo rescue
-                          require include extend raise attr attr_reader attr_writer
-                          attr_accessor lambda proc]
-      if reserved_words.include?(name)
-        raise InvalidAppNameError, "'#{name}' is a reserved Ruby word and cannot be used as an app name"
-      end
-    end
-
-    # Creates a new Rails app with the specified name
-    # @param app_name [String] The name of the Rails app to create
-    # @param options [Hash] Optional flags: auth, admin, jobs
-    # @return [String] Success message
-    def self.create_app(app_name, options = {})
-      validate_app_name(app_name)
-
-      # Load profile if specified
-      profile = nil
-      if options[:profile]
-        profile = RailsForge::Profile.load(options[:profile])
-        puts "Using profile: #{profile['name']} - #{profile['description']}"
-      end
-
-      # Check if Rails is installed
-      unless system("which rails > /dev/null 2>&1")
-        raise "Rails is not installed. Please install Rails first: gem install rails"
-      end
-
-      puts "Creating new Rails app: #{app_name}..."
-
-      # Create the Rails app using rails new command
-      rails_command = "rails new #{app_name} --skip-git --skip-test --skip-system-test"
-      unless system(rails_command)
-        raise "Failed to create Rails app. Please check your Rails installation."
-      end
-
-      # Create folders from profile or defaults
-      app_path = File.join(Dir.pwd, app_name)
-      if profile
-        RailsForge::Profile.create_folders(app_path, profile)
-      else
-        create_folders(app_path)
-      end
-
-      # Merge profile defaults with options
-      if profile
-        profile_defaults = RailsForge::Profile.defaults(profile)
-        options = profile_defaults.merge(options)
-        
-        # Auto-enable features from profile
-        profile_features = RailsForge::Profile.default_features(profile)
-        options[:auth] = "devise" if profile_features.include?("authentication") && !options[:auth]
-        options[:admin] = "activeadmin" if profile_features.include?("admin") && !options[:admin]
-        options[:jobs] = "sidekiq" if profile_features.include?("jobs") && !options[:jobs]
-      end
-
-      # Install optional features based on flags
-      results = []
-
-      if options[:auth]
-        results << install_auth(app_path, options[:auth])
-      end
-
-      if options[:admin]
-        results << install_admin(app_path, options[:admin])
-      end
-
-      if options[:jobs]
-        results << install_jobs(app_path, options[:jobs])
-      end
-
-      # Build success message
-      message = "Rails app '#{app_name}' created successfully!"
-      message += "\n\n" + results.join("\n") if results.any?
-      message
-    end
-
-    # Installs authentication (Devise)
-    # @param app_path [String] Path to the Rails app
-    # @param auth_type [String] Type of auth (devise or jwt)
-    # @return [String] Success message
-    def self.install_auth(app_path, auth_type)
-      puts "\n→ Installing authentication: #{auth_type}..."
-
-      if auth_type == "devise"
-        # Add devise to Gemfile
-        gemfile_path = File.join(app_path, "Gemfile")
-        if File.exist?(gemfile_path)
-          content = File.read(gemfile_path)
-          unless content.include?("gem 'devise'")
-            File.open(gemfile_path, "a") do |f|
-              f.puts "\n# Authentication\ngem 'devise'"
-            end
-            puts "  ✓ Added devise to Gemfile"
-          else
-            puts "  ✓ devise already in Gemfile"
-          end
-        end
-
-        # Install devise
-        Dir.chdir(app_path) do
-          system("bundle install 2>/dev/null")
-          system("rails generate devise:install 2>/dev/null")
-          system("rails generate devise User 2>/dev/null")
-          system("rails db:migrate 2>/dev/null")
-        end
-
-        "✅ Authentication (Devise) installed successfully!"
-      else
-        "⚠️  JWT authentication not implemented yet. Use --auth devise"
-      end
-    end
-
-    # Installs admin panel (ActiveAdmin)
-    # @param app_path [String] Path to the Rails app
-    # @param admin_type [String] Type of admin (activeadmin or dashboard)
-    # @return [String] Success message
-    def self.install_admin(app_path, admin_type)
-      puts "\n→ Installing admin panel: #{admin_type}..."
-
-      if admin_type == "activeadmin"
-        # Add activeadmin and its dependencies to Gemfile
-        gemfile_path = File.join(app_path, "Gemfile")
-        if File.exist?(gemfile_path)
-          content = File.read(gemfile_path)
-          unless content.include?("gem 'activeadmin'")
-            File.open(gemfile_path, "a") do |f|
-              f.puts "\n# Admin panel\ngem 'activeadmin'\ngem 'devise'"
-            end
-            puts "  ✓ Added activeadmin to Gemfile"
-          else
-            puts "  ✓ activeadmin already in Gemfile"
-          end
-        end
-
-        # Install activeadmin
-        Dir.chdir(app_path) do
-          system("bundle install 2>/dev/null")
-          system("rails generate active_admin:install 2>/dev/null")
-          system("rails db:migrate 2>/dev/null")
-        end
-
-        # Create admin user model if needed
-        admin_user_path = File.join(app_path, "app", "models", "admin_user.rb")
-        unless File.exist?(admin_user_path)
-          File.write(admin_user_path, <<~RUBY)
-            # AdminUser model for ActiveAdmin
-            class AdminUser < ApplicationRecord
-              # Include default devise modules
-              devise :database_authenticatable, :recoverable, :rememberable, :validatable
-            end
-          RUBY
-          puts "  ✓ Created AdminUser model"
-        end
-
-        "✅ Admin panel (ActiveAdmin) installed successfully!"
-      else
-        "⚠️  Dashboard admin not implemented yet. Use --admin activeadmin"
-      end
-    end
-
-    # Installs background jobs (Sidekiq + Redis)
-    # @param app_path [String] Path to the Rails app
-    # @param jobs_type [String] Type of jobs (sidekiq)
-    # @return [String] Success message
-    def self.install_jobs(app_path, jobs_type)
-      puts "\n→ Installing background jobs: #{jobs_type}..."
-
-      if jobs_type == "sidekiq"
-        # Add sidekiq to Gemfile
-        gemfile_path = File.join(app_path, "Gemfile")
-        if File.exist?(gemfile_path)
-          content = File.read(gemfile_path)
-          unless content.include?("gem 'sidekiq'")
-            File.open(gemfile_path, "a") do |f|
-              f.puts "\n# Background jobs\ngem 'sidekiq'\ngem 'redis', '~> 4.0.1'"
-            end
-            puts "  ✓ Added sidekiq to Gemfile"
-          else
-            puts "  ✓ sidekiq already in Gemfile"
-          end
-        end
-
-        # Install dependencies
-        Dir.chdir(app_path) do
-          system("bundle install 2>/dev/null")
-        end
-
-        # Create config file for sidekiq
-        config_path = File.join(app_path, "config", "sidekiq.yml")
-        unless File.exist?(config_path)
-          FileUtils.mkdir_p(File.dirname(config_path))
-          File.write(config_path, <<~YAML)
-:concurrency: 5
-:queues:
-  - default
-  - mailers
-          YAML
-          puts "  ✓ Created config/sidekiq.yml"
-        end
-
-        # Create initializers
-        init_path = File.join(app_path, "config", "initializers", "sidekiq.rb")
-        unless File.exist?(init_path)
-          File.write(init_path, <<~RUBY)
-# Sidekiq configuration
-Sidekiq.configure_server do |config|
-  config.redis = { url: ENV.fetch('REDIS_URL', 'redis://localhost:6379/1') }
-end
-
-Sidekiq.configure_client do |config|
-  config.redis = { url: ENV.fetch('REDIS_URL', 'redis://localhost:6379/1') }
-end
-          RUBY
-          puts "  ✓ Created config/initializers/sidekiq.rb"
-        end
-
-        # Update application.rb to use sidekiq for active job
-        app_rb_path = File.join(app_path, "config", "application.rb")
-        if File.exist?(app_rb_path)
-          content = File.read(app_rb_path)
-          unless content.include?("config.active_job.queue_adapter = :sidekiq")
-            content.gsub!(/config\.active_job\.queue_adapter = :.*/, "config.active_job.queue_adapter = :sidekiq")
-            File.write(app_rb_path, content)
-            puts "  ✓ Configured ActiveJob to use Sidekiq"
-          end
-        end
-
-        # Create example job
-        jobs_dir = File.join(app_path, "app", "jobs")
-        FileUtils.mkdir_p(jobs_dir)
-        example_job_path = File.join(jobs_dir, "example_job.rb")
-        unless File.exist?(example_job_path)
-          File.write(example_job_path, <<~RUBY)
-# Example job using Sidekiq
-class ExampleJob < ApplicationJob
-  queue_as :default
-
-  def perform(*args)
-    # Do something later
-  end
-end
-          RUBY
-          puts "  ✓ Created example job"
-        end
-
-        "✅ Background jobs (Sidekiq + Redis) installed successfully!"
-      else
-        "⚠️  Unknown jobs type: #{jobs_type}. Use --jobs sidekiq"
-      end
-    end
-
-    # Creates the additional folder structure inside the Rails app
-    # @param app_name [String] The name of the Rails app
-    # @return [void]
-    def self.create_folders(app_name)
-      app_path = File.join(Dir.pwd, app_name)
-
-      FOLDERS.each do |folder|
-        folder_path = File.join(app_path, folder)
-
-        if Dir.exist?(folder_path)
-          puts "  Skipping #{folder} (already exists)"
-        else
-          Dir.mkdir(folder_path)
-          puts "  Created #{folder}"
-        end
-      end
-    end
-  end
-
-  # Placeholder for gem functionality
-  def self.greet
-    "Welcome to RailsForge #{VERSION}!"
-  end
-end

data/lib/railsforge/generators/api_generator.rb

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