railsforge 1.0.0

data/lib/railsforge/generator.rb

@@ -0,0 +1,313 @@
+# 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/base_generator.rb

@@ -0,0 +1,70 @@
+# Base generator class for RailsForge
+# All generators inherit from this class
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # Base class for all generators
+    class BaseGenerator
+      # Error class for invalid names
+      class InvalidNameError < StandardError; end
+
+      # Default template version
+      TEMPLATE_VERSION = "v1".freeze
+
+      # Initialize generator
+      # @param name [String] Name for the generated object
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+        @base_path = find_rails_app_path
+      end
+
+      # Find Rails app path
+      # @return [String, nil] Rails app root 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
+
+      # Validate name
+      # @param name [String] Name to validate
+      # @param pattern [Regexp] Pattern to match
+      # @param error_class [Class] Error class to raise
+      def validate_name!(name, pattern, error_class)
+        raise error_class, "#{self.class.name.split('::').last} name cannot be empty" if name.nil? || name.strip.empty?
+        raise error_class, "Name must match pattern: #{pattern}" unless name =~ pattern
+      end
+
+      # Convert to underscore
+      # @return [String] Underscored name
+      def underscore
+        @name.to_s.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+      end
+
+      # Convert to camelize
+      # @return [String] Camelized name
+      def camelize
+        @name.to_s.split('_').map(&:capitalize).join
+      end
+
+      # Generate the file
+      def generate
+        raise NotImplementedError, "Subclasses must implement #generate"
+      end
+    end
+  end
+end

data/lib/railsforge/generators/demo_generator.rb

@@ -0,0 +1,307 @@
+# Demo project generator for RailsForge
+# Creates a complete demo Rails project
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # Demo generator creates a sample Rails project
+    class DemoGenerator < BaseGenerator
+      # Initialize the generator
+      def initialize(name, options = {})
+        super(name, options)
+      end
+
+      # Generate demo project
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << create_readme
+        results << create_sample_services
+        results << create_sample_queries
+        results << create_sample_jobs
+        results << create_sample_serializers
+        results << create_sample_policies
+        results << create_sample_forms
+
+        results.join("\n")
+      end
+
+      private
+
+      # Create README.md
+      def create_readme
+        readme_path = File.join(@base_path, "README.md")
+        return "Skipping README (already exists)" if File.exist?(readme_path)
+
+        content = <<~MD
+          # #{@name.titleize}
+
+          Generated with RailsForge
+
+          ## Setup
+
+          ```bash
+          bundle install
+          rails db:create db:migrate
+          rails server
+          ```
+
+          ## Available Generators
+
+          Run `railsforge generate --help` to see all available generators.
+
+          ### Services
+          ```bash
+          railsforge generate service UserService
+          ```
+
+          ### Queries
+          ```bash
+          railsforge generate query FindUsers
+          ```
+
+          ### Jobs
+          ```bash
+          railsforge generate job ProcessData
+          ```
+
+          ## Analyzers
+
+          Run code analysis:
+          ```bash
+          railsforge analyze
+          railsforge analyze security
+          railsforge analyze performance
+          ```
+
+          ## Project Structure
+
+          - `app/services/` - Service objects
+          - `app/queries/` - Query objects
+          - `app/jobs/` - Background jobs
+          - `app/policies/` - Policy objects
+          - `app/forms/` - Form objects
+          - `app/serializers/` - JSON serializers
+        MD
+
+        File.write(readme_path, content)
+        "Created README.md"
+      end
+
+      # Create sample services
+      def create_sample_services
+        service_dir = File.join(@base_path, "app", "services")
+        FileUtils.mkdir_p(service_dir)
+
+        samples = %w[user_service notification_service payment_service]
+        created = []
+
+        samples.each do |name|
+          path = File.join(service_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, service_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample services" : "Services already exist"
+      end
+
+      # Create sample queries
+      def create_sample_queries
+        query_dir = File.join(@base_path, "app", "queries")
+        FileUtils.mkdir_p(query_dir)
+
+        samples = %w[find_active_users find_recent_orders]
+        created = []
+
+        samples.each do |name|
+          path = File.join(query_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, query_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample queries" : "Queries already exist"
+      end
+
+      # Create sample jobs
+      def create_sample_jobs
+        job_dir = File.join(@base_path, "app", "jobs")
+        FileUtils.mkdir_p(job_dir)
+
+        samples = %w[process_order_job send_email_job]
+        created = []
+
+        samples.each do |name|
+          path = File.join(job_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, job_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample jobs" : "Jobs already exist"
+      end
+
+      # Create sample serializers
+      def create_sample_serializers
+        serializer_dir = File.join(@base_path, "app", "serializers")
+        FileUtils.mkdir_p(serializer_dir)
+
+        samples = %w[user_serializer article_serializer]
+        created = []
+
+        samples.each do |name|
+          path = File.join(serializer_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, serializer_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample serializers" : "Serializers already exist"
+      end
+
+      # Create sample policies
+      def create_sample_policies
+        policy_dir = File.join(@base_path, "app", "policies")
+        FileUtils.mkdir_p(policy_dir)
+
+        samples = %w[user_policy article_policy]
+        created = []
+
+        samples.each do |name|
+          path = File.join(policy_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, policy_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample policies" : "Policies already exist"
+      end
+
+      # Create sample forms
+      def create_sample_forms
+        form_dir = File.join(@base_path, "app", "forms")
+        FileUtils.mkdir_p(form_dir)
+
+        samples = %w[contact_form signup_form]
+        created = []
+
+        samples.each do |name|
+          path = File.join(form_dir, "#{name}.rb")
+          next if File.exist?(path)
+
+          File.write(path, form_template(name.classify))
+          created << name
+        end
+
+        created.any? ? "Created #{created.count} sample forms" : "Forms already exist"
+      end
+
+      # Templates
+      def service_template(name)
+        <<~RUBY
+          class #{name}
+            def initialize(params = {})
+              @params = params
+            end
+
+            def call
+              # TODO: Implement service logic
+              { success: true }
+            end
+
+            def self.call(params = {})
+              new(params).call
+            end
+          end
+        RUBY
+      end
+
+      def query_template(name)
+        <<~RUBY
+          class #{name}
+            def initialize(relation = nil)
+              @relation = relation || default_scope
+            end
+
+            def call
+              @relation
+            end
+
+            private
+
+            def default_scope
+              # TODO: Replace with actual model
+              OpenStruct.all
+            end
+          end
+        RUBY
+      end
+
+      def job_template(name)
+        <<~RUBY
+          class #{name} < ApplicationJob
+            queue_as :default
+
+            def perform(*args)
+              # TODO: Implement job logic
+            end
+          end
+        RUBY
+      end
+
+      def serializer_template(name)
+        <<~RUBY
+          class #{name} < ActiveModel::Serializer
+            attributes :id, :created_at
+
+            # TODO: Add attributes
+          end
+        RUBY
+      end
+
+      def policy_template(name)
+        <<~RUBY
+          class #{name} < ApplicationPolicy
+            def index?
+              true
+            end
+
+            def show?
+              true
+            end
+
+            def create?
+              user.present?
+            end
+          end
+        RUBY
+      end
+
+      def form_template(name)
+        <<~RUBY
+          class #{name} < ApplicationForm
+            attr_accessor :name, :email
+
+            validates :name, presence: true
+            validates :email, presence: true
+
+            def save
+              return false unless valid?
+
+              # TODO: Implement save logic
+              true
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end