railsforge 1.0.2 → 2.1.0

data/lib/railsforge/generators/base_generator.rb

@@ -1,75 +0,0 @@
-# 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
-        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
-      def generate
-        raise NotImplementedError, "Subclasses must implement #generate"
-      end
-    end
-  end
-end

data/lib/railsforge/generators/demo_generator.rb

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

data/lib/railsforge/generators/devops_generator.rb

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