rage_arch 0.1.0

data/lib/generators/rage_arch/install_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module RageArch
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Create config/initializers/rage_arch.rb, app/use_cases, app/deps, and include RageArch::Controller in ApplicationController"
+      def install
+        create_initializer
+        create_directories
+        inject_controller
+      end
+
+      private
+
+      def create_initializer
+        path = "config/initializers/rage_arch.rb"
+        full_path = File.join(destination_root, path)
+        if File.exist?(full_path)
+          say_status :skip, path, :yellow
+          return
+        end
+        template "rage.rb.tt", path
+      end
+
+      def create_directories
+        %w[app/use_cases app/deps].each do |dir|
+          full_path = File.join(destination_root, dir)
+          if File.directory?(full_path)
+            say_status :skip, dir, :yellow
+            next
+          end
+          empty_directory dir
+          create_file File.join(dir, ".keep"), ""
+        end
+      end
+
+      def inject_controller
+        path = "app/controllers/application_controller.rb"
+        full_path = File.join(destination_root, path)
+        unless File.exist?(full_path)
+          say_status :skip, path, :yellow
+          return
+        end
+        content = File.read(full_path)
+        if content.include?("RageArch::Controller")
+          say_status :skip, path, :yellow
+          return
+        end
+        injection = "  include RageArch::Controller\n"
+        if content =~ /(class\s+ApplicationController\s*<\s*\S+)/
+          content.sub!(Regexp.last_match(0), "#{Regexp.last_match(0)}\n#{injection.chomp}")
+          File.write(full_path, content)
+          say_status :inject, path, :green
+        else
+          say_status :skip, path, :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/rage_arch/scaffold_generator.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/active_record"
+
+module RageArch
+  module Generators
+    class ScaffoldGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+      class_option :skip_model, type: :boolean, default: false, desc: "Skip model and migration (use when model already exists)"
+      class_option :api, type: :boolean, default: false, desc: "Generate API-only controller (JSON responses, no views)"
+
+      desc "Generate a full Rage CRUD: model, migration, use cases (list/show/create/update/destroy), dep (AR), controller, and routes. With --api: JSON responses only, no views."
+      def create_all
+        create_model_and_migration
+        create_use_cases
+        create_dep
+        invoke_rails_scaffold_views
+        create_controller
+        add_route
+        inject_register_ar
+      end
+
+      private
+
+      def create_model_and_migration
+        return if options[:skip_model]
+        args = [name] + attributes.map(&:to_s)
+        invoke "active_record:model", args
+      end
+
+      def create_use_cases
+        dir = File.join("app/use_cases", plural_name)
+        empty_directory dir
+        template "scaffold/list.rb.tt",   File.join(dir, "list.rb")
+        template "scaffold/show.rb.tt",   File.join(dir, "show.rb")
+        template "scaffold/new.rb.tt",    File.join(dir, "new.rb")
+        template "scaffold/create.rb.tt", File.join(dir, "create.rb")
+        template "scaffold/update.rb.tt", File.join(dir, "update.rb")
+        template "scaffold/destroy.rb.tt", File.join(dir, "destroy.rb")
+      end
+
+      def create_dep
+        dep_dir = File.join("app/deps", plural_name)
+        empty_directory dep_dir
+        template "scaffold/post_repo.rb.tt", File.join(dep_dir, "#{singular_name}_repo.rb")
+      end
+
+      def create_controller
+        template_name = options[:api] ? "scaffold/api_controller.rb.tt" : "scaffold/controller.rb.tt"
+        template template_name, File.join("app/controllers", "#{plural_name}_controller.rb"), force: true
+      end
+
+      # Reuse Rails' scaffold_controller: with --api it generates API controller (no views); otherwise controller + views.
+      def invoke_rails_scaffold_views
+        args = [name] + attributes.map(&:to_s)
+        opts = { skip_routes: true }
+        opts[:api] = true if options[:api]
+        invoke "scaffold_controller", args, opts
+      end
+
+      def add_route
+        route "resources :#{plural_name}"
+      end
+
+      def inject_register_ar
+        initializer_path = File.join(destination_root, "config/initializers/rage_arch.rb")
+        return unless File.exist?(initializer_path)
+        content = File.read(initializer_path)
+        return if content.include?("register_ar(:#{repo_symbol})")
+        inject_line = "  Rage.register_ar(:#{repo_symbol}, #{model_class_name})\n"
+        content.sub!(/(Rails\.application\.config\.after_initialize do\s*\n)/m, "\\1#{inject_line}")
+        File.write(initializer_path, content)
+        say_status :inject, "config/initializers/rage_arch.rb (register_ar :#{repo_symbol})", :green
+      end
+
+      def plural_name
+        name.underscore.pluralize
+      end
+
+      def singular_name
+        name.underscore
+      end
+
+      def model_class_name
+        name.camelize
+      end
+
+      def module_name
+        plural_name.camelize
+      end
+
+      def repo_symbol
+        "#{singular_name}_repo"
+      end
+
+      def repo_class_name
+        "#{module_name}::#{singular_name.camelize}Repo"
+      end
+
+      def list_symbol
+        "#{plural_name}_list"
+      end
+
+      def show_symbol
+        "#{plural_name}_show"
+      end
+
+      def create_symbol
+        "#{plural_name}_create"
+      end
+
+      def update_symbol
+        "#{plural_name}_update"
+      end
+
+      def destroy_symbol
+        "#{plural_name}_destroy"
+      end
+
+      def new_symbol
+        "#{plural_name}_new"
+      end
+
+      def attribute_names_for_permit
+        return [] if attributes.blank?
+        attributes.map { |a| a.to_s.split(":").first.to_sym }
+      end
+    end
+  end
+end

data/lib/generators/rage_arch/templates/ar_dep.rb.tt

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Dep for :<%= symbol_name %>. Wraps the <%= model_name %> Active Record model.
+# Register in config/initializers/rage_arch.rb: Rage.register(:<%= symbol_name %>, <%= full_class_name %>.new)
+module <%= module_name %>
+  class <%= class_name %>
+    def initialize
+      @adapter = RageArch::Deps::ActiveRecord.for(<%= model_name %>)
+    end
+
+    def build(attrs = {})
+      @adapter.build(attrs)
+    end
+
+    def find(id)
+      @adapter.find(id)
+    end
+
+    def save(record)
+      @adapter.save(record)
+    end
+
+    def update(record, attrs)
+      @adapter.update(record, attrs)
+    end
+
+    def destroy(record)
+      @adapter.destroy(record)
+    end
+
+    def list(filters: {})
+      @adapter.list(filters: filters)
+    end
+<% if @extra_methods.any? -%>
+
+    # Extra methods detected from use cases — implement as needed
+<% @extra_methods.each do |method_name| -%>
+
+    def <%= method_name %>(*args, **kwargs)
+      # TODO: implement (e.g. delegate to @adapter or custom logic)
+      raise NotImplementedError, "<%= full_class_name %>#<%= method_name %>"
+    end
+<% end -%>
+<% end -%>
+  end
+end

data/lib/generators/rage_arch/templates/dep.rb.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Dep for :<%= symbol_name %>.
+# Methods detected from use cases: <%= @methods.join(', ') %>.
+# Register in config/initializers/rage_arch.rb: Rage.register(:<%= symbol_name %>, <%= full_class_name %>.new)
+module <%= module_name %>
+  class <%= class_name %>
+<% @methods.each do |method_name| -%>
+
+    def <%= method_name %>(*args, **kwargs)
+      # TODO: implement
+      raise NotImplementedError, "<%= full_class_name %>#<%= method_name %>"
+    end
+<% end -%>
+  end
+end

data/lib/generators/rage_arch/templates/rage_arch.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Register your app's deps here. Deps are grouped by module (e.g. app/deps/posts/post_repo.rb → Posts::PostRepo).
+# Use Rage.register(:symbol, ClassName.new) or Rage.register_ar(:symbol, Model) for AR-backed deps.
+
+Rails.application.config.after_initialize do
+  # Deps
+  # Rage.register(:post_repo, Posts::PostRepo.new)
+  # Rage.register_ar(:user_repo, User)
+
+  # Event publisher: use cases that declare subscribe :event_name are wired here.
+  publisher = RageArch::EventPublisher.new
+  RageArch::UseCase::Base.wire_subscriptions_to(publisher)
+  Rage.register(:event_publisher, publisher)
+end

data/lib/generators/rage_arch/templates/scaffold/api_controller.rb.tt

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class <%= module_name %>Controller < ApplicationController
+  def index
+    run :<%= list_symbol %>, {},
+      success: ->(r) { render json: r.value[:<%= singular_name %>s] },
+      failure: ->(r) { render json: { errors: r.errors }, status: :unprocessable_entity }
+  end
+
+  def show
+    run :<%= show_symbol %>, { id: params[:id] },
+      success: ->(r) { render json: r.value[:<%= singular_name %>] },
+      failure: ->(r) { render json: { errors: r.errors }, status: :not_found }
+  end
+
+  def create
+    run :<%= create_symbol %>, <%= singular_name %>_params,
+      success: ->(r) { render json: r.value[:<%= singular_name %>], status: :created },
+      failure: ->(r) { render json: { errors: r.errors }, status: :unprocessable_entity }
+  end
+
+  def update
+    run :<%= update_symbol %>, <%= singular_name %>_params.merge(id: params[:id]),
+      success: ->(r) { render json: r.value[:<%= singular_name %>] },
+      failure: ->(r) { render json: { errors: r.errors }, status: :unprocessable_entity }
+  end
+
+  def destroy
+    run :<%= destroy_symbol %>, { id: params[:id] },
+      success: ->(_r) { head :no_content },
+      failure: ->(r) { render json: { errors: r.errors }, status: :not_found }
+  end
+
+  private
+
+  def <%= singular_name %>_params
+    params.fetch(:<%= singular_name %>, params).permit(<%= attribute_names_for_permit.map { |x| ":#{x}" }.join(", ") %>)
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/controller.rb.tt

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class <%= module_name %>Controller < ApplicationController
+  def index
+    run :<%= list_symbol %>, {},
+      success: ->(r) { @<%= plural_name %> = r.value[:<%= singular_name %>s]; render :index },
+      failure: ->(r) { redirect_to root_path, alert: r.errors.join(", ") }
+  end
+
+  def show
+    run :<%= show_symbol %>, { id: params[:id] },
+      success: ->(r) { @<%= singular_name %> = r.value[:<%= singular_name %>]; render :show },
+      failure: ->(r) { redirect_to <%= plural_name %>_path, alert: r.errors.join(", ") }
+  end
+
+  def new
+    run :<%= new_symbol %>, {},
+      success: ->(r) { @<%= singular_name %> = r.value[:<%= singular_name %>]; render :new },
+      failure: ->(r) { redirect_to <%= plural_name %>_path, alert: r.errors.join(", ") }
+  end
+
+  def create
+    run :<%= create_symbol %>, <%= singular_name %>_params,
+      success: ->(r) { redirect_to <%= singular_name %>_path(r.value[:<%= singular_name %>].id), notice: "<%= model_class_name %> was successfully created." },
+      failure: ->(r) { @<%= singular_name %> = run_result(:<%= new_symbol %>, {}).value[:<%= singular_name %>]; flash_errors(r); render :new, status: :unprocessable_entity }
+  end
+
+  def edit
+    run :<%= show_symbol %>, { id: params[:id] },
+      success: ->(r) { @<%= singular_name %> = r.value[:<%= singular_name %>]; render :edit },
+      failure: ->(r) { redirect_to <%= plural_name %>_path, alert: r.errors.join(", ") }
+  end
+
+  def update
+    run :<%= update_symbol %>, <%= singular_name %>_params.merge(id: params[:id]),
+      success: ->(r) { redirect_to <%= singular_name %>_path(params[:id]), notice: "<%= model_class_name %> was successfully updated." },
+      failure: ->(r) {
+        res = run_result(:<%= show_symbol %>, id: params[:id])
+        @<%= singular_name %> = res.success? ? res.value[:<%= singular_name %>] : nil
+        flash_errors(r)
+        render :edit, status: :unprocessable_entity
+      }
+  end
+
+  def destroy
+    run :<%= destroy_symbol %>, { id: params[:id] },
+      success: ->(_r) { redirect_to <%= plural_name %>_path, notice: "<%= model_class_name %> was successfully destroyed." },
+      failure: ->(r) { redirect_to <%= plural_name %>_path, alert: r.errors.join(", ") }
+  end
+
+  private
+
+  def <%= singular_name %>_params
+    params.fetch(:<%= singular_name %>, params).permit(<%= attribute_names_for_permit.map { |x| ":#{x}" }.join(", ") %>)
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/create.rb.tt

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class Create < RageArch::UseCase::Base
+    use_case_symbol :<%= create_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(params = {})
+      item = <%= repo_symbol %>.build(params)
+      return failure(item.errors.full_messages) unless <%= repo_symbol %>.save(item)
+      success(<%= singular_name %>: item)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/destroy.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class Destroy < RageArch::UseCase::Base
+    use_case_symbol :<%= destroy_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(params = {})
+      item = <%= repo_symbol %>.find(params[:id])
+      return failure(["<%= model_class_name %> not found"]) unless item
+      <%= repo_symbol %>.destroy(item)
+      success(<%= singular_name %>: item)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/list.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class List < RageArch::UseCase::Base
+    use_case_symbol :<%= list_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(_params = {})
+      items = <%= repo_symbol %>.list
+      success(<%= singular_name %>s: items)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/new.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class New < RageArch::UseCase::Base
+    use_case_symbol :<%= new_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(_params = {})
+      item = <%= repo_symbol %>.build({})
+      success(<%= singular_name %>: item)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/post_repo.rb.tt

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Dep for :<%= repo_symbol %>. Wraps the <%= model_class_name %> Active Record model.
+# Registered by rage:scaffold in config/initializers/rage_arch.rb
+module <%= module_name %>
+  class <%= singular_name.camelize %>Repo
+    def initialize
+      @adapter = RageArch::Deps::ActiveRecord.for(<%= model_class_name %>)
+    end
+
+    def build(attrs = {})
+      @adapter.build(attrs)
+    end
+
+    def find(id)
+      @adapter.find(id)
+    end
+
+    def save(record)
+      @adapter.save(record)
+    end
+
+    def update(record, attrs)
+      @adapter.update(record, attrs)
+    end
+
+    def destroy(record)
+      @adapter.destroy(record)
+    end
+
+    def list(filters: {})
+      @adapter.list(filters: filters)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/show.rb.tt

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class Show < RageArch::UseCase::Base
+    use_case_symbol :<%= show_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(params = {})
+      item = <%= repo_symbol %>.find(params[:id])
+      return failure(["<%= model_class_name %> not found"]) unless item
+      success(<%= singular_name %>: item)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/scaffold/update.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module <%= module_name %>
+  class Update < RageArch::UseCase::Base
+    use_case_symbol :<%= update_symbol %>
+    deps :<%= repo_symbol %>
+
+    def call(params = {})
+      item = <%= repo_symbol %>.find(params[:id])
+      return failure(["<%= model_class_name %> not found"]) unless item
+      return failure(item.errors.full_messages) unless <%= repo_symbol %>.update(item, params.except(:id))
+      success(<%= singular_name %>: item)
+    end
+  end
+end

data/lib/generators/rage_arch/templates/use_case.rb.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+<%- if class_path.any? -%>
+module <%= class_path.map(&:camelize).join('::') %>
+<%- end -%>
+class <%= file_name.camelize %> < RageArch::UseCase::Base
+  use_case_symbol :<%= file_name %>
+
+  deps # e.g. :order_store, :notifications
+
+  def call(params = {})
+    # TODO: implement use case logic
+    RageArch::Result.success(params)
+  end
+end
+<%- class_path.each do -%>
+end
+<%- end -%>

data/lib/generators/rage_arch/use_case_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module RageArch
+  module Generators
+    class UseCaseGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Create a use case in app/use_cases/."
+      def create_use_case
+        template "use_case.rb.tt", File.join("app/use_cases", *class_path, "#{file_name}.rb")
+      end
+
+      def class_name_without_module
+        file_name.camelize
+      end
+
+      def symbol_name
+        file_name
+      end
+
+      def use_case_symbol
+        ":#{symbol_name}"
+      end
+
+      def module_namespace
+        return "" if class_path.empty?
+        class_path.map(&:camelize).join("::") + "::"
+      end
+    end
+  end
+end

data/lib/rage_arch/container.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RageArch
+  # Container to register and resolve dependencies by symbol.
+  # Usage: Rage.register(:order_store, MyAdapter.new); Rage.resolve(:order_store)
+  class Container
+    class << self
+      def register(symbol, implementation = nil, &block)
+        registry[symbol] = block || implementation
+      end
+
+      def resolve(symbol)
+        entry = registry[symbol]
+        raise KeyError, "Dep not registered: #{symbol.inspect}" unless entry
+
+        if entry.respond_to?(:call) && entry.is_a?(Proc)
+          entry.call
+        elsif entry.is_a?(Class)
+          entry.new
+        else
+          entry
+        end
+      end
+
+      def registered?(symbol)
+        registry.key?(symbol)
+      end
+
+      def registry
+        @registry ||= {}
+      end
+
+      def reset!
+        @registry = {}
+      end
+    end
+  end
+end

data/lib/rage_arch/controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RageArch
+  # Include in ApplicationController to get run(symbol, params, success:, failure:) and
+  # flash_errors(result). Keeps controllers thin: symbol, params, and HTTP responses only.
+  module Controller
+    private
+
+    def run(symbol, params = {}, success:, failure:)
+      result = run_result(symbol, params)
+      (result.success? ? success : failure).call(result)
+    end
+
+    def run_result(symbol, params = {})
+      RageArch::UseCase::Base.build(symbol).call(params)
+    end
+
+    def flash_errors(result)
+      flash.now[:alert] = result.errors.join(", ")
+    end
+  end
+end

data/lib/rage_arch/dep.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RageArch
+  # Convention: a "dep" is any injectable external dependency (persistence, mailer, API).
+  # Register it in RageArch::Container by symbol and resolve it in the use case with dep(:symbol).
+  # No base class required; any object can be a dep.
+  module Dep
+  end
+end