railsforge 1.0.2 → 2.0.0

data/lib/railsforge/generators/form_generator.rb

@@ -1,180 +0,0 @@
-# Form generator for RailsForge
-# Generates form object files
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # FormGenerator creates form files
-    class FormGenerator < BaseGenerator
-      # Error class for invalid form names
-      class InvalidFormNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Form name
-      # @param options [Hash] Generator options
-      def initialize(name, options = {})
-        super(name, options)
-        @template_version = options[:template_version] || TEMPLATE_VERSION
-        @with_spec = options.fetch(:with_spec, true)
-      end
-
-      # Generate form files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_form
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Form '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(form_name, with_spec: true, template_version: "v1")
-        new(form_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate form name
-      def validate_name!(name)
-        raise InvalidFormNameError, "Form name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidFormNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate form file
-      def generate_form
-        form_dir = File.join(@base_path, "app", "forms")
-        FileUtils.mkdir_p(form_dir)
-
-        file_name = "#{underscore}_form.rb"
-        file_path = File.join(form_dir, file_name)
-
-        return "  Skipping form (already exists)" if File.exist?(file_path)
-
-        content = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/forms/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "forms")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_form_spec.rb"
-        file_path = File.join(spec_dir, file_name)
-
-        return "  Skipping spec (already exists)" if File.exist?(file_path)
-
-        content = load_spec_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created spec/forms/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "form",
-          "template.rb"
-        )
-
-        if File.exist?(template_path)
-          File.read(template_path)
-        else
-          default_template
-        end
-      end
-
-      # Load spec template
-      def load_spec_template
-        spec_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "form",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Form class for #{underscore}
-          # Encapsulates form validation and processing
-          class #{camelize}Form
-            include ActiveModel::Model
-
-            attr_accessor :name, :email
-
-            validates :name, presence: true
-            validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
-
-            def save
-              return false unless valid?
-
-              # TODO: Implement save logic
-              true
-            end
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize}Form do
-            describe 'validations' do
-              it 'validates presence of name' do
-                form = described_class.new(name: nil, email: 'test@example.com')
-                expect(form).not_to be_valid
-                expect(form.errors[:name]).to be_present
-              end
-
-              it 'validates email format' do
-                form = described_class.new(name: 'Test', email: 'invalid')
-                expect(form).not_to be_valid
-                expect(form.errors[:email]).to be_present
-              end
-            end
-          end
-        RUBY
-      end
-
-      # Apply template variables
-      def apply_template(content)
-        content
-          .gsub("<%= name %>", @name)
-          .gsub("<%= name.camelize %>", camelize)
-          .gsub("<%= name.underscore %>", underscore)
-      end
-    end
-  end
-end

data/lib/railsforge/generators/job_generator.rb

@@ -1,176 +0,0 @@
-# Job generator for RailsForge
-# Generates background job files
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # JobGenerator creates job files
-    class JobGenerator < BaseGenerator
-      # Error class for invalid job names
-      class InvalidJobNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Job name
-      # @param options [Hash] Generator options
-      def initialize(name, options = {})
-        super(name, options)
-        @template_version = options[:template_version] || TEMPLATE_VERSION
-        @with_spec = options.fetch(:with_spec, true)
-      end
-
-      # Generate job files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_job
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Job '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(job_name, with_spec: true, template_version: "v1")
-        new(job_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate job name
-      def validate_name!(name)
-        raise InvalidJobNameError, "Job name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidJobNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate job file
-      def generate_job
-        job_dir = File.join(@base_path, "app", "jobs")
-        FileUtils.mkdir_p(job_dir)
-
-        file_name = "#{underscore}_job.rb"
-        file_path = File.join(job_dir, file_name)
-
-        return "  Skipping job (already exists)" if File.exist?(file_path)
-
-        content = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/jobs/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "jobs")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_job_spec.rb"
-        file_path = File.join(spec_dir, file_name)
-
-        return "  Skipping spec (already exists)" if File.exist?(file_path)
-
-        content = load_spec_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created spec/jobs/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "job",
-          "template.rb"
-        )
-
-        if File.exist?(template_path)
-          File.read(template_path)
-        else
-          default_template
-        end
-      end
-
-      # Load spec template
-      def load_spec_template
-        spec_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "job",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Background job for #{underscore}
-          # Handles async processing
-          #
-          # Usage:
-          #   #{camelize}Job.perform_later(record)
-          #   #{camelize}Job.perform_now(record)
-          class #{camelize}Job < ApplicationJob
-            queue_as :default
-
-            def perform(*args)
-              # TODO: Implement job logic
-            end
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize}Job do
-            let(:args) { [] }
-
-            it 'enqueues the job' do
-              expect {
-                described_class.perform_later(*args)
-              }.to have_enqueued_job(described_class)
-            end
-
-            describe '#perform' do
-              it 'performs the job' do
-                expect { subject.perform(*args) }.not_to raise_error
-              end
-            end
-          end
-        RUBY
-      end
-
-      # Apply template variables
-      def apply_template(content)
-        content
-          .gsub("<%= name %>", @name)
-          .gsub("<%= name.camelize %>", camelize)
-          .gsub("<%= name.underscore %>", underscore)
-      end
-    end
-  end
-end

data/lib/railsforge/generators/monitoring_generator.rb

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

@@ -1,220 +0,0 @@
-# Policy generator for RailsForge
-# Generates policy object files (for Pundit)
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # PolicyGenerator creates policy files
-    class PolicyGenerator < BaseGenerator
-      # Error class for invalid policy names
-      class InvalidPolicyNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Policy name
-      # @param options [Hash] Generator options
-      def initialize(name, options = {})
-        super(name, options)
-        @template_version = options[:template_version] || TEMPLATE_VERSION
-        @with_spec = options.fetch(:with_spec, true)
-      end
-
-      # Generate policy files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_policy
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Policy '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(policy_name, with_spec: true, template_version: "v1")
-        new(policy_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate policy name
-      def validate_name!(name)
-        raise InvalidPolicyNameError, "Policy name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidPolicyNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate policy file
-      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 = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/policies/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "policies")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_policy_spec.rb"
-        file_path = File.join(spec_dir, file_name)
-
-        return "  Skipping spec (already exists)" if File.exist?(file_path)
-
-        content = load_spec_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created spec/policies/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "policy",
-          "template.rb"
-        )
-
-        if File.exist?(template_path)
-          File.read(template_path)
-        else
-          default_template
-        end
-      end
-
-      # Load spec template
-      def load_spec_template
-        spec_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "policy",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Policy class for #{underscore}
-          # Defines authorization rules using Pundit
-          class #{camelize}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 new?
-              create?
-            end
-
-            def update?
-              user.present? && record.user == user
-            end
-
-            def edit?
-              update?
-            end
-
-            def destroy?
-              user.present? && record.user == user
-            end
-
-            class Scope
-              def initialize(user, scope)
-                @user = user
-                @scope = scope
-              end
-
-              def resolve
-                scope.all
-              end
-            end
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize}Policy do
-            let(:user) { User.new }
-            let(:record) { #{camelize}.new }
-
-            subject { described_class.new(user, record) }
-
-            it { should permit(:index) }
-            it { should permit(:show) }
-            it { should permit(:new) }
-            it { should permit(:create) }
-
-            context 'when user is the owner' do
-              let(:user) { record.user }
-
-              it { should permit(:update) }
-              it { should permit(:destroy) }
-            end
-
-            context 'when user is not the owner' do
-              it { should_not permit(:update) }
-              it { should_not permit(:destroy) }
-            end
-          end
-        RUBY
-      end
-
-      # Apply template variables
-      def apply_template(content)
-        content
-          .gsub("<%= name %>", @name)
-          .gsub("<%= name.camelize %>", camelize)
-          .gsub("<%= name.underscore %>", underscore)
-      end
-    end
-  end
-end