much-rails 0.0.1 → 0.2.0

data/lib/much-rails/action/controller.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "much-rails/action/router"
+require "much-rails/mixin"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::Controller defines the behaviors for controllers processing
+# MuchRails::Actions.
+module MuchRails::Action::Controller
+  DEFAULT_ACTION_CLASS_FORMAT = :any
+
+  include MuchRails::Mixin
+
+  mixin_included do
+    attr_reader :much_rails_action_class
+
+    before_action(
+      :require_much_rails_action_class,
+      only: MuchRails::Action::Router::CONTROLLER_CALL_ACTION_METHOD_NAME,
+    )
+    before_action :permit_all_much_rails_action_params
+  end
+
+  mixin_instance_methods do
+    define_method(
+      MuchRails::Action::Router::CONTROLLER_CALL_ACTION_METHOD_NAME,
+    ) do
+      respond_to do |format|
+        format.public_send(much_rails_action_class_format) do
+          result =
+            much_rails_action_class.call(
+              params: much_rails_action_params,
+              current_user: current_user,
+              request: request,
+            )
+          instance_exec(result, &result.execute_block)
+        end
+      end
+    end
+
+    define_method(
+      MuchRails::Action::Router::CONTROLLER_NOT_FOUND_METHOD_NAME,
+    ) do
+      respond_to do |format|
+        format.html do
+          head :not_found
+        end
+      end
+    end
+
+    def much_rails_action_class_name
+      "::#{params[MuchRails::Action::Router::ACTION_CLASS_PARAM_NAME]}"
+    end
+
+    def much_rails_action_class_format
+      much_rails_action_class.format || DEFAULT_ACTION_CLASS_FORMAT
+    end
+
+    def much_rails_action_params
+      # If a `params_root` value is specified, pull the params from that key and
+      # merge them into the base params.
+      Array
+        .wrap(much_rails_action_class&.params_root)
+        .reduce(
+          params
+            .to_h
+            .except(
+              MuchRails::Action::Router::ACTION_CLASS_PARAM_NAME,
+              :controller,
+              :action,
+            ),
+        ) do |acc, root|
+          acc.merge(acc[root].to_h)
+        end
+    end
+
+    def require_much_rails_action_class
+      begin
+        @much_rails_action_class = much_rails_action_class_name.constantize
+      rescue NameError => ex
+        if MuchRails.config.action.raise_response_exceptions?
+          raise(
+            MuchRails::Action::ActionError,
+            "No Action class defined for "\
+            "#{much_rails_action_class_name.inspect}.",
+            cause: ex,
+          )
+        else
+          head(:not_found)
+        end
+      end
+    end
+
+    def permit_all_much_rails_action_params
+      params.permit!
+    end
+  end
+end

data/lib/much-rails/action/head_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_command_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Views::HeadResult is a command result for the `head` controller
+# response command.
+class MuchRails::Action::HeadResult < MuchRails::Action::BaseCommandResult
+  def initialize(*head_args)
+    super(:head, *head_args)
+  end
+
+  def head_args
+    command_args
+  end
+end

data/lib/much-rails/action/redirect_to_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_command_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::RedirectToResult is a command result for the
+# `redirect_to` controller response command.
+class MuchRails::Action::RedirectToResult < MuchRails::Action::BaseCommandResult
+  def initialize(*redirect_to_args)
+    super(:redirect_to, *redirect_to_args)
+  end
+
+  def redirect_to_args
+    command_args
+  end
+end

data/lib/much-rails/action/render_result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::RenderResult is a result returned by calling a view
+# action that directs the controller to render a response.
+class MuchRails::Action::RenderResult < MuchRails::Action::BaseResult
+  attr_reader :render_view_model, :render_kargs
+
+  def initialize(render_view_model, **render_kargs)
+    @render_view_model = render_view_model
+    @render_kargs = render_kargs
+  end
+
+  # This block is called using `instance_exec` in the scope of the controller
+  def execute_block
+    ->(result){
+      @view = result.render_view_model
+      render(**result.render_kargs)
+    }
+  end
+end

data/lib/much-rails/action/router.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_router"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+class MuchRails::Action::Router < MuchRails::Action::BaseRouter
+  DEFAULT_CONTROLLER_NAME = "application"
+  CONTROLLER_CALL_ACTION_METHOD_NAME = :much_rails_call_action
+  CONTROLLER_NOT_FOUND_METHOD_NAME = :much_rails_not_found
+  ACTION_CLASS_PARAM_NAME = :much_rails_action_class_name
+
+  def self.url_class
+    MuchRails::Action::Router::URL
+  end
+
+  def self.load(routes_file_name, controller_name: nil)
+    if routes_file_name.to_s.strip.empty?
+      raise(
+        ArgumentError,
+        "expected a routes file name, given `#{routes_file_name.inspect}`.",
+      )
+    end
+
+    file_path = ::Rails.root.join("config/routes/#{routes_file_name}.rb")
+    unless file_path.exist?
+      raise ArgumentError, "routes file `#{file_path.inspect}` does not exist."
+    end
+
+    new(routes_file_name, controller_name: controller_name) do
+      instance_eval(File.read(file_path), file_path.to_s, 1)
+    end
+  end
+
+  attr_reader :controller_name
+
+  def initialize(name = nil, controller_name: nil, &block)
+    super(name, &block)
+
+    @controller_name = controller_name || DEFAULT_CONTROLLER_NAME
+  end
+
+  # Example:
+  #   MyRouter = MuchRails::Action::Router.new { ... }
+  #   Rails.application.routes.draw do
+  #     root "/"
+  #     MyRouter.draw(self)
+  #   end
+  def apply_to(application_routes_draw_scope)
+    validate!
+    draw_url_to   = "#{controller_name}##{CONTROLLER_NOT_FOUND_METHOD_NAME}"
+    draw_route_to = "#{controller_name}##{CONTROLLER_CALL_ACTION_METHOD_NAME}"
+
+    definitions.each do |definition|
+      definition.request_type_actions.each do |request_type_action|
+        application_routes_draw_scope.public_send(
+          definition.http_method,
+          definition.path,
+          to: draw_route_to,
+          as: definition.name,
+          defaults:
+            definition.default_params.merge({
+              ACTION_CLASS_PARAM_NAME => request_type_action.class_name,
+            }),
+          constraints: request_type_action.constraints_lambda,
+        )
+      end
+
+      next unless definition.has_default_action_class_name?
+
+      application_routes_draw_scope.public_send(
+        definition.http_method,
+        definition.path,
+        to: draw_route_to,
+        as: definition.name,
+        defaults:
+          definition.default_params.merge({
+            ACTION_CLASS_PARAM_NAME => definition.default_action_class_name,
+          }),
+      )
+    end
+
+    # Draw each URL that doesn't have a route definition so that we can generate
+    # them using MuchRails::RailsRoutes.
+    unrouted_urls.each do |url|
+      application_routes_draw_scope.get(url.path, to: draw_url_to, as: url.name)
+    end
+  end
+  alias_method :draw, :apply_to
+
+  class URL < MuchRails::Action::BaseRouter::BaseURL
+    def path_for(*args)
+      MuchRails::RailsRoutes.instance.public_send("#{name}_path", *args)
+    end
+
+    def url_for(*args)
+      MuchRails::RailsRoutes.instance.public_send("#{name}_url", *args)
+    end
+  end
+end

data/lib/much-rails/action/send_data_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_command_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::SendDataResult is a command result for the `send_data`
+# controller response command.
+class MuchRails::Action::SendDataResult < MuchRails::Action::BaseCommandResult
+  def initialize(*send_data_args)
+    super(:send_data, *send_data_args)
+  end
+
+  def send_data_args
+    command_args
+  end
+end

data/lib/much-rails/action/send_file_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_command_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::SendFileResult is a command result for the `send_file`
+# controller response command.
+class MuchRails::Action::SendFileResult < MuchRails::Action::BaseCommandResult
+  def initialize(*send_file_args)
+    super(:send_file, *send_file_args)
+  end
+
+  def send_file_args
+    command_args
+  end
+end

data/lib/much-rails/action/unprocessable_entity_result.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "much-rails/action/base_result"
+
+module MuchRails; end
+module MuchRails::Action; end
+
+# MuchRails::Action::UnprocessableEntityResult is a result returned by
+# calling a view action that is not valid. It returns JSON with the validation
+# details.
+#
+# This result is only returned if, after validating the action, there are
+# errors. Most commonly this occurs when validating form submission params.
+class MuchRails::Action::UnprocessableEntityResult <
+        MuchRails::Action::BaseResult
+  attr_reader :errors
+
+  def initialize(errors)
+    @errors = errors
+  end
+
+  # This block is called using `instance_exec` in the scope of the controller
+  def execute_block
+    ->(result){
+      errors =
+        Array
+          .wrap(much_rails_action_class&.params_root)
+          .reduce(result.errors) do |acc, root|
+            acc.merge(
+              acc.transform_keys{ |error_key| "#{root}[#{error_key}]" },
+            )
+          end
+
+      render(json: errors, status: :unprocessable_entity)
+    }
+  end
+end

data/lib/much-rails/assets.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "dassets"
+require "dassets/server"
+require "dassets-erubi"
+require "dassets-sass"
+
+module MuchRails
+  Assets = Dassets
+end
+
+module MuchRails::Assets
+  def self.configure_for_rails(rails)
+    MuchRails::Assets.configure do |config|
+      # Cache fingerprints in memory for performance gains.
+      config.fingerprint_cache MuchRails::Assets::MemCache.new
+
+      # Cache compiled content in memory in development/test for performance
+      # gains since we aren't caching to the file system. Otherwise, don't
+      # cache in memory as we are caching to the file system and won't benefit
+      # from the in memory cache.
+      much_rails_content_cache =
+        if rails.env.development? || rails.env.test?
+          MuchRails::Assets::MemCache.new
+        else
+          MuchRails::Assets::NoCache.new
+        end
+      config.content_cache much_rails_content_cache
+
+      # Cache out compiled file content to the public folder in non
+      # development/test environments.
+      if !rails.env.development? && !rails.env.test?
+        config.file_store rails.root.join("public")
+      end
+
+      # Look for asset files in the app/assets folder. Support ERB processing
+      # on all .js and .scss files. Support compilation of .scss files.
+      config.source rails.root.join("app", "assets") do |s|
+        # Reject SCSS partials
+        s.filter do |paths|
+          paths.reject{ |p| File.basename(p) =~ /^_.*\.scss$/ }
+        end
+
+        s.engine "js",   MuchRails::Assets::Erubi::Engine
+        s.engine "scss", MuchRails::Assets::Erubi::Engine
+        s.engine "scss", MuchRails::Assets::Sass::Engine, {
+          syntax: "scss",
+          output_style: "compressed",
+        }
+      end
+    end
+    MuchRails::Assets.init
+  end
+end

data/lib/much-rails/boolean.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-boolean"
+
+module MuchRails
+  Boolean = MuchBoolean
+end

data/lib/much-rails/call_method.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+
+module MuchRails; end
+
+# MuchRails::CallMethod is a mix-in to implement the `call`
+# class/instance method pattern.
+module MuchRails::CallMethod
+  include MuchRails::Mixin
+
+  mixin_class_methods do
+    def call(*args, &block)
+      new(*args, &block).call
+    end
+  end
+
+  mixin_instance_methods do
+    def call
+      on_call
+    end
+
+    def on_call
+      raise NotImplementedError
+    end
+  end
+end

data/lib/much-rails/call_method_callbacks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "much-rails/call_method"
+require "much-rails/config"
+require "much-rails/mixin"
+
+module MuchRails; end
+
+# MuchRails::CallMethodCallbacks is a common mix-in for adding before/after
+# callback support to MuchRails::CallMethod. This is separate from the
+# MuchRails::CallMethod mix-in as it adds a bit of overhead (e.g. the
+# `much_rails_call_callbacks_config`) that may not be desired by things
+# just wanting to use the basic `MuchRails::CallMethod`. This allows opting-in
+# to callback support as needed.
+module MuchRails::CallMethodCallbacks
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::CallMethod
+    include MuchRails::Config
+
+    add_config :much_rails_call_callbacks
+  end
+
+  mixin_class_methods do
+    def before_call(&block)
+      much_rails_call_callbacks_config.before_callbacks.append(block) if block
+    end
+
+    def prepend_before_call(&block)
+      much_rails_call_callbacks_config.before_callbacks.prepend(block) if block
+    end
+
+    def after_call(&block)
+      much_rails_call_callbacks_config.after_callbacks.append(block) if block
+    end
+
+    def prepend_after_call(&block)
+      much_rails_call_callbacks_config.after_callbacks.prepend(block) if block
+    end
+
+    def around_call(&block)
+      much_rails_call_callbacks_config.around_callbacks.append(block) if block
+    end
+
+    def prepend_around_call(&block)
+      much_rails_call_callbacks_config.around_callbacks.prepend(block) if block
+    end
+  end
+
+  mixin_instance_methods do
+    def call
+      set_the_return_value_for_the_call_method(nil)
+
+      execute_before_callbacks
+      execute_around_callbacks do
+        set_the_return_value_for_the_call_method(on_call)
+      end
+      execute_after_callbacks
+
+      the_return_value_for_the_call_method
+    end
+
+    # Do nothing by default - override as needed. Prefer this approach over
+    # e.g. `raise NotImplementedError` as it allows any callbacks that have been
+    # attached to run even if the actual `on_call` method was never overridden.
+    def on_call
+    end
+
+    def set_the_return_value_for_the_call_method(value)
+      @the_return_value_for_the_call_method = value
+    end
+
+    def the_return_value_for_the_call_method
+      @the_return_value_for_the_call_method
+    end
+
+    private
+
+    def execute_before_callbacks
+      self
+        .class
+        .much_rails_call_callbacks_config
+        .before_callbacks
+        .each do |callback|
+          instance_exec(&callback)
+        end
+    end
+
+    def execute_around_callbacks(&on_call_block)
+      self
+        .class
+        .much_rails_call_callbacks_config
+        .around_callbacks
+        .reverse
+        .reduce(on_call_block){ |acc_proc, callback_proc|
+          ->{ instance_exec(acc_proc, &callback_proc) }
+        }
+        .call
+    end
+
+    def execute_after_callbacks
+      self
+        .class
+        .much_rails_call_callbacks_config
+        .after_callbacks
+        .each do |callback|
+          instance_exec(&callback)
+        end
+    end
+  end
+
+  class MuchRailsCallCallbacksConfig
+    attr_accessor :before_callbacks, :after_callbacks, :around_callbacks
+
+    def initialize
+      @before_callbacks = []
+      @after_callbacks = []
+      @around_callbacks = []
+    end
+  end
+end