railsforge 1.0.0

data/lib/railsforge/generators/devops_generator.rb

@@ -0,0 +1,287 @@
+# DevOps generator for RailsForge
+# Generates Dockerfile, docker-compose, and CI/CD configs
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # DevOps generator
+    class DevopsGenerator < BaseGenerator
+      # Initialize the generator
+      def initialize(name = "app", options = {})
+        super(name, options)
+        @docker_image = options[:docker_image] || "railsforge/#{name}"
+        @ci_provider = options[:ci_provider] || "github"
+        @ruby_version = options[:ruby_version] || "3.2.0"
+        @node_version = options[:node_version] || "18"
+      end
+
+      # Generate DevOps files
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << create_dockerfile
+        results << create_docker_compose
+        results << create_dockerignore
+        results << create_github_workflow if @ci_provider == "github"
+        results << create_gitlab_ci if @ci_provider == "gitlab"
+
+        results.join("\n")
+      end
+
+      private
+
+      # Create Dockerfile
+      def create_dockerfile
+        dockerfile_path = File.join(@base_path, "Dockerfile")
+        return "Skipping Dockerfile (already exists)" if File.exist?(dockerfile_path)
+
+        content = <<~DOCKERFILE
+          # Ruby version
+          FROM ruby:#{@ruby_version}-slim
+
+          # Install system dependencies
+          RUN apt-get update && apt-get install -y \\
+              build-essential \\
+              libpq-dev \\
+              curl \\
+              git \\
+              nodejs \\
+              npm \\
+              && rm -rf /var/lib/apt/lists/*
+
+          # Set working directory
+          WORKDIR /app
+
+          # Copy Gemfile
+          COPY Gemfile Gemfile.lock ./
+
+          # Install gems
+          RUN bundle install --jobs 4 --retry 3
+
+          # Copy package.json for assets
+          COPY package.json package-lock.json ./
+          RUN npm install --production
+
+          # Copy application code
+          COPY . .
+
+          # Precompile assets
+          RUN RAILS_ENV=production SECRET_KEY_BASE=dummy bundle exec rails assets:precompile
+
+          # Expose port
+          EXPOSE 3000
+
+          # Start server
+          CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0"]
+        DOCKERFILE
+
+        File.write(dockerfile_path, content)
+        "Created Dockerfile"
+      end
+
+      # Create docker-compose.yml
+      def create_docker_compose
+        compose_path = File.join(@base_path, "docker-compose.yml")
+        return "Skipping docker-compose.yml (already exists)" if File.exist?(compose_path)
+
+        content = <<~YAML
+          version: '3.8'
+
+          services:
+            app:
+              build: .
+              ports:
+                - "3000:3000"
+              environment:
+                - RAILS_ENV=development
+                - DATABASE_HOST=postgres
+                - REDIS_HOST=redis
+              depends_on:
+                - postgres
+                - redis
+              volumes:
+                - .:/app
+
+            postgres:
+              image: postgres:15-alpine
+              environment:
+                - POSTGRES_USER=rails
+                - POSTGRES_PASSWORD=password
+                - POSTGRES_DB=app_development
+              ports:
+                - "5432:5432"
+              volumes:
+                - postgres_data:/var/lib/postgresql/data
+
+            redis:
+              image: redis:7-alpine
+              ports:
+                - "6379:6379"
+
+            sidekiq:
+              build: .
+              command: bundle exec sidekiq
+              environment:
+                - RAILS_ENV=development
+                - DATABASE_HOST=postgres
+                - REDIS_HOST=redis
+              depends_on:
+                - postgres
+                - redis
+              volumes:
+                - .:/app
+
+          volumes:
+            postgres_data:
+        YAML
+
+        File.write(compose_path, content)
+        "Created docker-compose.yml"
+      end
+
+      # Create .dockerignore
+      def create_dockerignore
+        ignore_path = File.join(@base_path, ".dockerignore")
+        return "Skipping .dockerignore (already exists)" if File.exist?(ignore_path)
+
+        content = <<~IGNORE
+          .git
+          .github
+          .gitignore
+          log/*.log
+          tmp/
+          .bundle/
+          node_modules/
+          public/assets/
+          .DS_Store
+          *.swp
+          *.swo
+        IGNORE
+
+        File.write(ignore_path, content)
+        "Created .dockerignore"
+      end
+
+      # Create GitHub Actions workflow
+      def create_github_workflow
+        workflow_dir = File.join(@base_path, ".github", "workflows")
+        FileUtils.mkdir_p(workflow_dir)
+
+        workflow_path = File.join(workflow_dir, "ci.yml")
+        return "Skipping GitHub workflow (already exists)" if File.exist?(workflow_path)
+
+        content = <<~YAML
+          name: CI
+
+          on:
+            push:
+              branches: [main, develop]
+            pull_request:
+              branches: [main, develop]
+
+          jobs:
+            test:
+              runs-on: ubuntu-latest
+              services:
+                postgres:
+                  image: postgres:15-alpine
+                  env:
+                    POSTGRES_USER: rails
+                    POSTGRES_PASSWORD: password
+                    POSTGRES_DB: app_test
+                  ports:
+                    - 5432:5432
+                redis:
+                  image: redis:7-alpine
+                  ports:
+                    - 6379:6379
+
+              steps:
+                - uses: actions/checkout@v3
+                - name: Set up Ruby
+                  uses: ruby/setup-ruby@v1
+                  with:
+                    ruby-version: #{@ruby_version}
+                    bundler-cache: true
+                - name: Install dependencies
+                  run: |
+                    bundle install
+                    npm install
+                - name: Setup database
+                  env:
+                    RAILS_ENV: test
+                    POSTGRES_HOST: localhost
+                    POSTGRES_USER: rails
+                    POSTGRES_PASSWORD: password
+                    POSTGRES_DB: app_test
+                  run: bundle exec rails db:create db:schema:load
+                - name: Run tests
+                  env:
+                    RAILS_ENV: test
+                    POSTGRES_HOST: localhost
+                    POSTGRES_USER: rails
+                    POSTGRES_PASSWORD: password
+                    POSTGRES_DB: app_test
+                  run: bundle exec rspec
+                - name: Run linter
+                  run: bundle exec rubocop
+        YAML
+
+        File.write(workflow_path, content)
+        "Created GitHub Actions workflow"
+      end
+
+      # Create GitLab CI config
+      def create_gitlab_ci
+        ci_path = File.join(@base_path, ".gitlab-ci.yml")
+        return "Skipping .gitlab-ci.yml (already exists)" if File.exist?(ci_path)
+
+        content = <<~YAML
+          stages:
+            - test
+            - lint
+            - deploy
+
+          variables:
+            RUBY_VERSION: #{@ruby_version}
+            POSTGRES_DB: app_test
+            POSTGRES_USER: rails
+            POSTGRES_PASSWORD: password
+
+          test:
+            stage: test
+            image: ruby:#{@ruby_version}
+            services:
+              - postgres:15-alpine
+              - redis:7-alpine
+            before_script:
+              - apt-get update -qq && apt-get install -y -qq nodejs npm
+              - bundle install
+              - npm install
+            script:
+              - RAILS_ENV=test bundle exec rails db:create db:schema:load
+              - bundle exec rspec
+            only:
+              - main
+              - develop
+
+          rubocop:
+            stage: lint
+            image: ruby:#{@ruby_version}
+            before_script:
+              - bundle install
+            script:
+              - bundle exec rubocop
+            only:
+              - main
+              - develop
+        YAML
+
+        File.write(ci_path, content)
+        "Created GitLab CI config"
+      end
+    end
+  end
+end

data/lib/railsforge/generators/monitoring_generator.rb

@@ -0,0 +1,134 @@
+# Monitoring generator for RailsForge
+# Generates Sentry and Lograge configurations
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # Monitoring generator
+    class MonitoringGenerator < BaseGenerator
+      # Initialize the generator
+      def initialize(name = "monitoring", options = {})
+        super(name, options)
+        @sentry_dsn = options[:sentry_dsn] || ""
+        @environment = options[:environment] || (defined?(Rails) && Rails.env) || 'development'
+      end
+
+      # Generate monitoring configs
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << create_sentry_initializer
+        results << create_lograge_config
+        results << create_log_formatter
+        results << create_environments_config
+
+        results.join("\n")
+      end
+
+      private
+
+      # Create Sentry initializer
+      def create_sentry_initializer
+        init_dir = File.join(@base_path, "config", "initializers")
+        FileUtils.mkdir_p(init_dir)
+
+        sentry_path = File.join(init_dir, "sentry.rb")
+        return "Skipping Sentry initializer (already exists)" if File.exist?(sentry_path)
+
+        content = <<~RUBY
+          # Sentry error tracking configuration
+          # Install sentry-ruby and add to Gemfile: gem 'sentry-ruby', '~> 4.0'
+          Sentry.init do |config|
+            config.dsn = ENV.fetch('SENTRY_DSN', '#{@sentry_dsn}')
+            config.breadcrumb_logger = :active_support
+            config.environments = %w[staging production]
+            config.traces_sample_rate = 0.1
+            config.before_send = lambda do |event, hint|
+              # Filter out specific errors
+              if hint[:exception]
+                # Add custom filtering logic here
+              end
+              event
+            end
+          end
+        RUBY
+
+        File.write(sentry_path, content)
+        "Created config/initializers/sentry.rb"
+      end
+
+      # Create Lograge configuration
+      def create_lograge_config
+        init_dir = File.join(@base_path, "config", "initializers")
+        FileUtils.mkdir_p(init_dir)
+
+        lograge_path = File.join(init_dir, "lograge.rb")
+        return "Skipping Lograge initializer (already exists)" if File.exist?(lograge_path)
+
+        content = <<~RUBY
+          # Lograge configuration for structured logging
+          # Add to Gemfile: gem 'lograge'
+          Rails.application.configure do
+            config.lograge.enabled = true
+            config.lograge.base_controller_class = 'ActionController::API'
+            config.lograge.custom_options = lambda do |event|
+              {
+                # Add custom data to logs
+                host: Socket.gethostname,
+                pid: Process.pid,
+                # Add timing data
+                request_id: event.payload[:request_id],
+                user_id: event.payload[:user_id]
+              }
+            end
+            config.lograge.formatter = Lograge::Formatters::Json.new
+          end
+        RUBY
+
+        File.write(lograge_path, content)
+        "Created config/initializers/lograge.rb"
+      end
+
+      # Create log formatter
+      def create_log_formatter
+        config_path = File.join(@base_path, "config")
+        
+        # Check if application.rb exists
+        app_rb = File.join(config_path, "application.rb")
+        return "Not a Rails app" unless File.exist?(app_rb)
+
+        content = File.read(app_rb)
+        
+        unless content.include?("config.log_formatter")
+          # Add log formatter to application.rb
+          File.write(app_rb, content.gsub(/class Application < Rails::Application/,
+            "class Application < Rails::Application\n    config.log_formatter = proc { |severity, datetime, progname, msg| \"#{datetime.utc_iso8601} #{severity}: #{msg}\\n\" }"))
+        end
+
+        "Updated application.rb with custom log formatter"
+      end
+
+      # Create environment-specific configs
+      def create_environments_config
+        env_dir = File.join(@base_path, "config", "environments")
+        return "Not a Rails app" unless Dir.exist?(env_dir)
+
+        results = []
+
+        # Production config
+        prod_path = File.join(env_dir, "production.rb")
+        if File.exist?(prod_path)
+          content = File.read(prod_path)
+          unless content.include?("Lograge") || content.include?("Sentry")
+            File.write(prod_path, content + "\n\n# Monitoring\nconfig.lograge.enabled = true\n")
+            results << "Updated production.rb"
+          end
+        end
+
+        results.any? ? results.join("\n") : "No environment updates needed"
+      end
+    end
+  end
+end

data/lib/railsforge/generators/service_generator.rb

@@ -0,0 +1,122 @@
+# Service generator for RailsForge
+# Generates service objects
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # ServiceGenerator creates service objects
+    class ServiceGenerator < BaseGenerator
+      # Error class for invalid service names
+      class InvalidServiceNameError < StandardError; end
+
+      # Validates the service name
+      # @param name [String] Service name to validate
+      def validate_name!(name)
+        super(name, /\A[A-Z][a-zA-Z0-9]*\z/, InvalidServiceNameError)
+      end
+
+      # Generate service file and optionally spec
+      # @return [String] Success message
+      def generate
+        validate_name!(@name)
+
+        unless @base_path
+          raise "Not in a Rails application directory"
+        end
+
+        service_file_path = generate_service_file
+
+        if @options[:with_spec] != false
+          generate_spec_file
+        end
+
+        "Service '#{@name}' generated successfully!"
+      end
+
+      # Generate the service file
+      # @return [String] Path to generated file
+      def generate_service_file
+        service_dir = File.join(@base_path, "app", "services")
+        FileUtils.mkdir_p(service_dir)
+
+        file_name = "#{underscore}.rb"
+        file_path = File.join(service_dir, file_name)
+
+        if File.exist?(file_path)
+          puts "  Skipping service (already exists)"
+          return file_path
+        end
+
+        File.write(file_path, service_template)
+        puts "  Created app/services/#{file_name}"
+        file_path
+      end
+
+      # Generate the spec file
+      # @return [String] Path to generated spec
+      def generate_spec_file
+        spec_dir = File.join(@base_path, "spec", "services")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_spec.rb"
+        file_path = File.join(spec_dir, file_name)
+
+        if File.exist?(file_path)
+          puts "  Skipping spec (already exists)"
+          return file_path
+        end
+
+        File.write(file_path, spec_template)
+        puts "  Created spec/services/#{file_name}"
+        file_path
+      end
+
+      # Service template
+      # @return [String] Template content
+      def service_template
+        <<~RUBY
+          # Service class for #{underscore}
+          # Encapsulates business logic related to #{underscore}
+          class #{@name}
+            def initialize(**args)
+              @args = args
+            end
+
+            def call
+              # TODO: Implement service logic here
+            end
+
+            def self.call(**args)
+              new(**args).call
+            end
+
+            private
+          end
+        RUBY
+      end
+
+      # Spec template
+      # @return [String] Spec template content
+      def spec_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          RSpec.describe #{@name} do
+            describe '#call' do
+              it 'returns expected result' do
+                result = described_class.call
+                expect(result).to be_nil
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Class method for CLI
+      def self.generate(service_name, with_spec: true, template_version: "v1")
+        new(service_name, with_spec: with_spec, template_version: template_version).generate
+      end
+    end
+  end
+end

data/lib/railsforge/generators/stimulus_controller_generator.rb

@@ -0,0 +1,129 @@
+# Stimulus controller generator for RailsForge
+# Generates Stimulus JavaScript controllers
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # Stimulus controller generator
+    class StimulusControllerGenerator < BaseGenerator
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Controller name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        validate_name!
+      end
+
+      # Generate Stimulus controller files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << generate_controller
+        results << generate_spec if with_spec?
+
+        results.join("\n")
+      end
+
+      private
+
+      # Validate controller name
+      def validate_name!
+        validate_name!(@name, /\A[A-Z][a-zA-Z0-9]*\z/, InvalidNameError)
+      end
+
+      # Check if should generate spec
+      def with_spec?
+        @options[:spec] != false
+      end
+
+      # Generate the JavaScript controller file
+      def generate_controller
+        controller_dir = File.join(@base_path, "app", "javascript", "controllers")
+        FileUtils.mkdir_p(controller_dir)
+
+        file_name = "#{underscore}_controller.js"
+        file_path = File.join(controller_dir, file_name)
+
+        return "Skipping controller (already exists)" if File.exist?(file_path)
+
+        # Try to load template
+        template_content = load_template
+        content = apply_template(template_content)
+
+        File.write(file_path, content)
+        "Created app/javascript/controllers/#{file_name}"
+      end
+
+      # Generate the controller spec
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "javascripts", "controllers")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_controller_spec.js"
+        file_path = File.join(spec_dir, file_name)
+
+        return "Skipping spec (already exists)" if File.exist?(file_path)
+
+        content = <<~JS
+          import { Application } from "@hotwired/stimulus"
+          import #{camelize}Controller from "../../../app/javascript/controllers/#{underscore}_controller"
+
+          describe("#{camelize}Controller", () => {
+            beforeEach(() => {
+              this.application = new Application()
+              this.application.register("#{underscore}", #{camelize}Controller)
+            })
+          })
+        JS
+
+        File.write(file_path, content)
+        "Created spec/javascripts/controllers/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          template_version,
+          "stimulus_controller",
+          "template.rb"
+        )
+
+        if File.exist?(template_path)
+          File.read(template_path)
+        else
+          default_template
+        end
+      end
+
+      # Default template content
+      def default_template
+        <<~JS
+          // Stimulus controller: <%= class_name %>
+          import { Controller } from "@hotwired/stimulus"
+
+          export default class <%= class_name %> extends Controller {
+            connect() {
+              console.log("<%= class_name %> connected")
+            }
+          }
+        JS
+      end
+
+      # Apply template variables
+      def apply_template(content)
+        content
+          .gsub("<%= class_name %>", camelize)
+          .gsub("<%= underscore_name %>", underscore)
+      end
+    end
+  end
+end