railsforge 1.0.2 → 2.0.0

data/lib/railsforge/generators/presenter_generator.rb

@@ -1,173 +0,0 @@
-# Presenter generator for RailsForge
-# Generates presenter object files
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # PresenterGenerator creates presenter files
-    class PresenterGenerator < BaseGenerator
-      # Error class for invalid presenter names
-      class InvalidPresenterNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Presenter 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 presenter files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_presenter
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Presenter '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(presenter_name, with_spec: true, template_version: "v1")
-        new(presenter_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate presenter name
-      def validate_name!(name)
-        raise InvalidPresenterNameError, "Presenter name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidPresenterNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate presenter file
-      def generate_presenter
-        presenter_dir = File.join(@base_path, "app", "presenters")
-        FileUtils.mkdir_p(presenter_dir)
-
-        file_name = "#{underscore}_presenter.rb"
-        file_path = File.join(presenter_dir, file_name)
-
-        return "  Skipping presenter (already exists)" if File.exist?(file_path)
-
-        content = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/presenters/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "presenters")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_presenter_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/presenters/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "presenter",
-          "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,
-          "presenter",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Presenter class for #{underscore}
-          # Encapsulates view logic
-          class #{camelize}Presenter
-            def initialize(object)
-              @object = object
-            end
-
-            def title
-              @object.name.titleize
-            end
-
-            def details
-              # TODO: Add presenter logic
-            end
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize}Presenter do
-            let(:object) { double(name: 'Test Object') }
-            subject { described_class.new(object) }
-
-            describe '#title' do
-              it 'returns titleized name' do
-                expect(subject.title).to eq('Test Object')
-              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/query_generator.rb

@@ -1,174 +0,0 @@
-# Query generator for RailsForge
-# Generates query object files
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # QueryGenerator creates query files
-    class QueryGenerator < BaseGenerator
-      # Error class for invalid query names
-      class InvalidQueryNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Query 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 query files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_query
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Query '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(query_name, with_spec: true, template_version: "v1")
-        new(query_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate query name
-      def validate_name!(name)
-        raise InvalidQueryNameError, "Query name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidQueryNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate query file
-      def generate_query
-        query_dir = File.join(@base_path, "app", "queries")
-        FileUtils.mkdir_p(query_dir)
-
-        file_name = "#{underscore}.rb"
-        file_path = File.join(query_dir, file_name)
-
-        return "  Skipping query (already exists)" if File.exist?(file_path)
-
-        content = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/queries/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "queries")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_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/queries/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "query",
-          "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,
-          "query",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Query class for #{underscore}
-          # Encapsulates database queries
-          class #{camelize}
-            def initialize(scope: nil)
-              @scope = scope || default_scope
-            end
-
-            def call
-              @scope
-            end
-
-            private
-
-            def default_scope
-              # TODO: Replace with actual model scope
-              Model.all
-            end
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize} do
-            describe '#call' do
-              it 'returns scope' do
-                result = described_class.call
-                expect(result).to be_a(ActiveRecord::Relation)
-              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/serializer_generator.rb

@@ -1,166 +0,0 @@
-# Serializer generator for RailsForge
-# Generates serializer object files
-
-require_relative 'base_generator'
-
-module RailsForge
-  module Generators
-    # SerializerGenerator creates serializer files
-    class SerializerGenerator < BaseGenerator
-      # Error class for invalid serializer names
-      class InvalidSerializerNameError < StandardError; end
-
-      # Template version
-      TEMPLATE_VERSION = "v1"
-
-      # Initialize the generator
-      # @param name [String] Serializer 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 serializer files
-      # @return [String] Success message
-      def generate
-        return "Not in a Rails application directory" unless @base_path
-
-        validate_name!(@name)
-
-        results = []
-        results << generate_serializer
-
-        if @with_spec
-          results << generate_spec
-        end
-
-        "Serializer '#{@name}' generated successfully!\n" + results.join("\n")
-      end
-
-      # Class method for CLI
-      def self.generate(serializer_name, with_spec: true, template_version: "v1")
-        new(serializer_name, with_spec: with_spec, template_version: template_version).generate
-      end
-
-      private
-
-      # Validate serializer name
-      def validate_name!(name)
-        raise InvalidSerializerNameError, "Serializer name cannot be empty" if name.nil? || name.strip.empty?
-        raise InvalidSerializerNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
-      end
-
-      # Generate serializer file
-      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 = load_template
-        content = apply_template(content)
-
-        File.write(file_path, content)
-        "  Created app/serializers/#{file_name}"
-      end
-
-      # Generate spec file
-      def generate_spec
-        spec_dir = File.join(@base_path, "spec", "serializers")
-        FileUtils.mkdir_p(spec_dir)
-
-        file_name = "#{underscore}_serializer_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/serializers/#{file_name}"
-      end
-
-      # Load template content
-      def load_template
-        template_path = File.join(
-          File.dirname(__FILE__),
-          "..",
-          "templates",
-          @template_version,
-          "serializer",
-          "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,
-          "serializer",
-          "spec_template.rb"
-        )
-
-        if File.exist?(spec_path)
-          File.read(spec_path)
-        else
-          default_spec_template
-        end
-      end
-
-      # Default template
-      def default_template
-        <<~RUBY
-          # Serializer class for #{underscore}
-          # Defines JSON serialization
-          class #{camelize}Serializer < ApplicationSerializer
-            attributes :id, :name, :created_at, :updated_at
-
-            # TODO and: Add associations methods
-            # belongs_to :user
-            # has_many :items
-          end
-        RUBY
-      end
-
-      # Default spec template
-      def default_spec_template
-        <<~RUBY
-          require 'rails_helper'
-
-          RSpec.describe #{camelize}Serializer do
-            let(:resource) { #{camelize}.create!(name: 'Test') }
-            let(:serializer) { described_class.new(resource) }
-            let(:serialization) { ActiveModel::SerializableResource.new(resource).as_json }
-
-            it 'includes expected attributes' do
-              expect(serialization[:#{camelize.underscore}] [:name]).to eq('Test')
-            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/service_generator.rb

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