wallaby-core 0.2.11 → 0.3.0.beta1

data/lib/routes/wallaby/engines/engine_route.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Engines
+    # The general route of {Engine} looks like as follow:
+    #
+    #     /admin/order::items
+    #
+    # Therefore, to override this route, dev needs to define a resources as below
+    # before mounting {Engine}:
+    #
+    #     namespace :admin do
+    #       # NOTE: in order for the route to work properly,
+    #       # the colon before words need to be escaped in the path option
+    #       resources :items, path: 'order:\:item', module: :order
+    #     end
+    #     wallaby_mount at: '/admin'
+    #
+    # So to find out if any route has been overriden with current request, e.g. `/admin/order::items/1/edit`,
+    # we will look into the following conditions:
+    #
+    # - begins with `/admin`
+    # - same **action** as the given **action**
+    # - default **controller** exists (as {ResourcesRouter} does not define static **controller**)
+    #
+    # Then we use this route's params and pass it to the origin `url_for`.
+    class EngineRoute < BaseRoute
+      # A constant to map actions to its corresponding path helper methods
+      # defined in {Engine}'s routes.
+      # @see https://github.com/wallaby-rails/wallaby-core/blob/master/config/routes.rb
+      ACTION_TO_URL_HELPER_MAP =
+        Wallaby::ERRORS.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |error, map|
+          map[error] = :"#{error}_path"
+        end.merge(
+          home: :root_path,
+          # for resourceful actions
+          index: :resources_path,
+          new: :new_resource_path,
+          show: :resource_path,
+          edit: :edit_resource_path
+        ).freeze
+
+      def url
+        # NOTE: require to use `url_helper` here.
+        # otherwise, {Engine} will raise **ActionController::UrlGenerationError**.
+        engine_params = params_for(route)
+        Engine.routes.url_helpers.try(engine_action_url_helper, engine_params)
+      end
+
+      protected
+
+      # @return [ActionDispatch::Journey::Route]
+      #   the application route that overrides the route handled by {Engine}
+      def route
+        @route ||=
+          Engine.routes.routes.find do |route|
+            route.requirements[:action] == action_name
+          end
+      end
+
+      # @return [Symbol] the URL helper for given action
+      def engine_action_url_helper
+        ACTION_TO_URL_HELPER_MAP[action_name.try(:to_sym)]
+      end
+
+      # @return [Hash]
+      def complete_params
+        @complete_params ||=
+          normalize_params(
+            { script_name: context.script_name },
+            with_query_params,
+            params
+          )
+      end
+    end
+  end
+end

data/lib/routes/wallaby/resources_router.rb

@@ -1,68 +1,123 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # This is the core of wallaby that dynamically dispatches request to appropriate controller and action.
+  # This is the core of {Wallaby} as it dynamically dispatches request to appropriate controller and action.
+  #
+  # Assume that:
+  #
+  # - {Wallaby} is mounted at `/admin`
+  # - current request path is `/admin/order::items`, then the resources name is `order::items`
+  #
+  # {ResourcesRouter} will try to find out which controller to dispatch to by:
+  #
+  # - check if the controller name `Admin::Order::ItemsController` exists
+  #   (converted from the mount path and resources name)
+  # - check if the `:resources_controller` defaults is set when mounting {Wallaby}, for example:
+  #
+  #   ```
+  #   wallaby_mount at: '/admin', defaults: { resources_controller: CoreController }
+  #   ```
+  #
+  # - fall back to default resources controller from
+  #   {Configuration#resources_controller Wallaby.configuration.resources_controller}
+  # @see http://edgeguides.rubyonrails.org/routing.html#routing-to-rack-applications
   class ResourcesRouter
-    # @see http://edgeguides.rubyonrails.org/routing.html#routing-to-rack-applications
-    # It tries to find out the controller that has the same model class from converted resources name.
-    # Otherwise, it falls back to base resources controller which will come from the following sources:
-    #
-    # 1. `:resources_controller` parameter
-    # 2. resources_controller mapping configuration,
-    #   e.g. `Admin::ApplicationController` if defined or `Wallaby::ResourcesController`
-    # @param env [Hash] @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
+    # It dispatches the request to corresponding controller and action.
+    # @param env [Hash] (see https://github.com/rack/rack/blob/master/SPEC.rdoc)
+    # @return [void]
     def call(env)
-      params = env[ActionDispatch::Http::Parameters::PARAMETERS_KEY]
-      controller = find_controller_by params
-      controller.action(params[:action]).call env
+      options = get_options_from(env)
+      validate_model_by(options[:resources])
+      controller_class = find_controller_class_by(options)
+      controller_class.action(options[:action]).call(env)
     rescue ::AbstractController::ActionNotFound, ModelNotFound => e
-      set_message_for e, env
-      default_controller(params).action(:not_found).call env
+      set_flash_error_for(e, env)
+      default_controller(options).action(:not_found).call(env)
     rescue UnprocessableEntity => e
-      set_message_for e, env
-      default_controller(params).action(:unprocessable_entity).call env
+      set_flash_error_for(e, env)
+      default_controller(options).action(:unprocessable_entity).call(env)
     end
 
-    private
+    protected
 
-    # Find controller class
-    # @param params [Hash]
-    # @return [Class] controller class
-    def find_controller_by(params)
-      model_class = find_model_class_by params
-      Map.controller_map(model_class, params[:resources_controller]) || default_controller(params)
+    # @param env [Hash] (see https://github.com/rack/rack/blob/master/SPEC.rdoc)
+    # @return [Hash] options, which contains params and script name
+    def get_options_from(env)
+      env[ActionDispatch::Http::Parameters::PARAMETERS_KEY].merge(
+        script_name: env[SCRIPT_NAME]
+      )
     end
 
-    # Default controller class sources from:
+    # Assume that:
+    #
+    # - {Wallaby} is mounted at `/admin`
+    # - current request path is `/admin/order::items`, then the resources name is `order::items`
     #
-    # 1. `:resources_controller` parameter
-    # 2. resources_controller mapping configuration,
-    # @param params [Hash]
+    # Then it expects to return the first controller from the following list:
+    #
+    # - Admin::Order::ItemsController
+    # - `:resources_controller` defaults
+    # - default controller set by
+    #   {Configuration#resources_controller Wallaby.configuration.resources_controller}
+    # @param options [Hash]
     # @return [Class] controller class
-    def default_controller(params)
-      params[:resources_controller] || Wallaby.configuration.mapping.resources_controller
-    end
+    def find_controller_class_by(options)
+      return default_controller(options) unless options[:resources]
+
+      Classifier.to_class(
+        Inflector.to_controller_name(options[:script_name], options[:resources])
+      ) do |controller_name|
+        Logger.hint(
+          :customize_controller,
+          <<~INSTRUCTION
+            HINT: To customize the controller for resources `#{options[:resources]}`,
+            create the following controller:
 
-    # Find out the model class
-    # @param params [Hash]
-    # @return [Class]
-    # @raise [Wallaby::ModelNotFound] when model class is not found
-    # @raise [Wallaby::UnprocessableEntity] when there is no corresponding mode found for model class
-    def find_model_class_by(params)
-      model_class = Map.model_class_map params[:resources]
-      return model_class unless MODEL_ACTIONS.include? params[:action].to_sym
-      raise ModelNotFound, params[:resources] unless model_class
-      unless Map.mode_map[model_class]
-        raise UnprocessableEntity, Locale.t('errors.unprocessable_entity.model', model: model_class)
+              class #{controller_name} < #{default_controller(options)}
+                def #{options[:action]}
+                  # it's possible to re-use what's implemented by calling `#{options[:action]}!`
+                  # or `super` if bang version does not exist
+                  #{options[:action]}!
+                end
+              end
+          INSTRUCTION
+        )
+
+        default_controller(options)
       end
+    end
+
+    # @param options [Hash]
+    # @return [Class] default controller class
+    def default_controller(options)
+      options[:resources_controller] || Wallaby.configuration.resources_controller
+    end
+
+    # @param resources_name [String]
+    # @raise [ModelNotFound] when model class can not be not found
+    # @raise [UnprocessableEntity]
+    #   when there is no corresponding {Mode} found for model class
+    #   (which means {Wallaby})
+    # @return [void]
+    def validate_model_by(resources_name)
+      return unless resources_name # maybe it's for landing page or error page
+
+      # now this is for our lovely resourceful actions
+      model_name = Inflector.to_model_name(resources_name)
+      model_class = Classifier.to_class(model_name)
+      raise ModelNotFound, model_name unless model_class
+      return if Map.mode_map[model_class]
 
-      model_class
+      Wallaby::Logger.warn <<~MESSAGE
+        Cannot find the mode for #{model_name} and don't know how to handle it.
+      MESSAGE
+      raise UnprocessableEntity, Locale.t('errors.unprocessable_entity.model', model: model_class)
     end
 
-    # Set flash error message
     # @param exception [Exception]
-    # @param env [Hash] @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
-    def set_message_for(exception, env)
+    # @param env [Hash] (see https://github.com/rack/rack/blob/master/SPEC.rdoc)
+    # @return [void]
+    def set_flash_error_for(exception, env)
       session = env[ActionDispatch::Request::Session::ENV_SESSION_KEY] || {}
       env[ActionDispatch::Flash::KEY] ||= ActionDispatch::Flash::FlashHash.from_session_value session['flash']
       flash = env[ActionDispatch::Flash::KEY]

data/lib/servicers/wallaby/model_servicer.rb

@@ -20,17 +20,17 @@ module Wallaby
     attr_reader :model_class
 
     # @!attribute [r] model_decorator
-    # @return [Wallaby::ModelDecorator]
+    # @return [ModelDecorator]
     # @since wallaby-5.2.0
     attr_reader :model_decorator
 
     # @!attribute [r] authorizer
-    # @return [Wallaby::ModelAuthorizer]
+    # @return [ModelAuthorizer]
     # @since wallaby-5.2.0
     attr_reader :authorizer
 
     # @!attribute [r] provider
-    # @return [Wallaby::ModelServiceProvider] the instance that does the job
+    # @return [ModelServiceProvider] the instance that does the job
     # @since wallaby-5.2.0
     attr_reader :provider
 
@@ -40,21 +40,21 @@ module Wallaby
     delegate :user, to: :authorizer
 
     # @param model_class [Class]
-    # @param authorizer [Wallaby::ModelAuthorizer]
-    # @param model_decorator [Wallaby::ModelDecorator]
+    # @param authorizer [ModelAuthorizer]
+    # @param model_decorator [ModelDecorator]
     # @raise [ArgumentError] if model_class is blank
-    def initialize(model_class, authorizer, model_decorator = nil)
+    def initialize(model_class, authorizer, model_decorator)
       @model_class = model_class || self.class.model_class
       raise ArgumentError, 'Please provide a `model_class`.' unless @model_class
 
-      @model_decorator = model_decorator || Map.model_decorator_map(model_class)
+      @model_decorator = model_decorator
       @authorizer = authorizer
       @provider = Map.service_provider_map(@model_class).new(@model_class, @model_decorator)
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # Whitelist parameters for mass assignment.
-    # @param params [ActionController::Parameters, Hash]
+    # Allowlist parameters for mass assignment.
+    # @param params [Hash, ActionController::Parameters]
     # @param action [String, Symbol, nil]
     # @return [ActionController::Parameters] permitted params
     def permit(params, action = nil)
@@ -63,7 +63,7 @@ module Wallaby
 
     # @note This is a template method that can be overridden by subclasses.
     # Return a collection by querying the datasource (e.g. database, REST API).
-    # @param params [ActionController::Parameters, Hash]
+    # @param params [Hash, ActionController::Parameters]
     # @return [Enumerable] list of resources
     def collection(params)
       provider.collection params, authorizer
@@ -81,7 +81,7 @@ module Wallaby
     # Initialize an instance of the model class.
     # @param params [ActionController::Parameters]
     # @return [Object] initialized resource
-    def new(params)
+    def new(params = {})
       provider.new params, authorizer
     end
 
@@ -90,7 +90,7 @@ module Wallaby
     # @param id [Object]
     # @param params [ActionController::Parameters]
     # @return [Object] found resource
-    def find(id, params)
+    def find(id, params = {})
       provider.find id, params, authorizer
     end
 
@@ -117,7 +117,7 @@ module Wallaby
     # @param resource [Object]
     # @param params [ActionController::Parameters]
     # @return [Object] resource
-    def destroy(resource, params)
+    def destroy(resource, params = {})
       provider.destroy resource, params, authorizer
     end
   end

data/lib/services/wallaby/authorizer_finder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # (see #execute)
+  class AuthorizerFinder < DecoratorFinder
+    # Find authorizer class by script name and model class from the following places:
+    #
+    # - {#controller_class #controller_class}'s {Configurable::ClassMethods#model_authorizer #model_authorizer}
+    # - possible authorizer class built from script name and model class,
+    #   e.g. **/admin** and **Order::Item** will give us the possible authorizers:
+    #   - Admin::Order::ItemAuthorizer
+    #   - Order::ItemAuthorizer
+    #   - ItemAuthorizer
+    # - {#controller_class #controller_class}'s default
+    #   {Configurable::ClassMethods#application_authorizer #application_authorizer}
+    # @return [Class] authorizer class
+    def execute
+      controller_class.model_authorizer ||
+        possible_default_class ||
+        controller_class.application_authorizer
+    end
+  end
+end

data/lib/services/wallaby/class_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Base class to find out the class for given {#script_name}, {#model_class}, {#current_controller_class}
+  class ClassFinder
+    include ActiveModel::Model
+
+    # @!attribute script_name
+    # @return [String]
+    attr_accessor :script_name
+    # @!attribute model_class
+    # @return [Class]
+    attr_accessor :model_class
+    # @!attribute current_controller_class
+    # @return [Class]
+    attr_accessor :current_controller_class
+
+    protected
+
+    # @return [Class]
+    def possible_default_class
+      Guesser.possible_class_from(possible_class_name, denamespace: denamespace?)
+    end
+
+    # @return [String] class name
+    def possible_class_name
+      @possible_class_name ||= Inflector.try(:"to_#{type}_name", script_name, model_class)
+    end
+
+    # This attribute will determine if the {#possible_default_class}
+    # should keep removing the namespaces one by one when looking up the class
+    # @return [Boolean]
+    def denamespace?
+      true
+    end
+
+    # @return [String] type for the finder
+    def type
+      self.class.name.demodulize.sub(FINDER, EMPTY_STRING).underscore
+    end
+  end
+end

data/lib/services/wallaby/controller_finder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # (see #execute)
+  class ControllerFinder < ClassFinder
+    # Find controller class by script name and model class from the following places:
+    #
+    # - {ClassFinder#current_controller_class #current_controller_class}
+    #   if {ClassFinder#current_controller_class #current_controller_class}'s model is the same as given
+    #   {ClassFinder#model_class #model_class}
+    # - possible controller class built from script name and model class,
+    #   e.g. **/admin** and **Order::Item** will give us the possible controller `Admin::Order::ItemsController`
+    # - {ClassFinder#current_controller_class #current_controller_class}'s default
+    #   {Configurable::ClassMethods#application_controller #application_controller}
+    # @return [Class] controller class
+    def execute
+      return current_controller_class if model_class == current_controller_class.try(:model_class)
+
+      possible_default_class || current_controller_class.try(:application_controller)
+    end
+
+    protected
+
+    # (see ClassFinder#denamespace?)
+    def denamespace?
+      false
+    end
+  end
+end

data/lib/services/wallaby/decorator_finder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # (see #execute)
+  class DecoratorFinder < ClassFinder
+    # Find decorator class by script name and model class from the following places:
+    #
+    # - {#controller_class}'s {Configurable::ClassMethods#resource_decorator #resource_decorator}
+    # - possible decorator class built from script name and model class,
+    #   e.g. **/admin** and **Order::Item** will give us the possible decorators:
+    #   - Admin::Order::ItemDecorator
+    #   - Order::ItemDecorator
+    #   - ItemDecorator
+    # - {#controller_class}'s default
+    #   {Configurable::ClassMethods#application_decorator #application_decorator}
+    # @return [Class] decorator class
+    def execute
+      controller_class.resource_decorator ||
+        possible_default_class ||
+        controller_class.application_decorator
+    end
+
+    protected
+
+    # (see ControllerFinder#execute)
+    def controller_class
+      @controller_class ||= ControllerFinder.new(
+        script_name: script_name,
+        model_class: model_class,
+        current_controller_class: current_controller_class
+      ).execute
+    end
+  end
+end

data/lib/services/wallaby/default_models_excluder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # see {.execute}
+  class DefaultModelsExcluder
+    class << self
+      # {Wallaby} excludes the following model classes by default.
+      #
+      # - ActiveRecord::SchemaMigration
+      # - ActiveRecord::InternalMetadata
+      # @return [ClassArray] a list of model classes
+      def execute
+        ClassArray.new(
+          [].tap do |list|
+            list << active_record_schema_migration_class
+            list << active_record_internal_metadata_class
+          end.compact
+        )
+      end
+
+      private
+
+      # @return [Class] if Wallaby knows about `ActiveRecord::SchemaMigration`
+      # @return [nil] otherwise
+      def active_record_schema_migration_class
+        exists =
+          defined?(::ActiveRecord::SchemaMigration) \
+            && Map.mode_map.key?(::ActiveRecord::SchemaMigration)
+
+        exists ? ::ActiveRecord::SchemaMigration : nil
+      end
+
+      # NOTE: `ActiveRecord::InternalMetadata` exists since Rails 6.0
+      # @return [Class] if Wallaby knows about `ActiveRecord::InternalMetadata`
+      # @return [nil] otherwise
+      def active_record_internal_metadata_class
+        exists =
+          defined?(::ActiveRecord::InternalMetadata) \
+            && Map.mode_map.key?(::ActiveRecord::InternalMetadata)
+
+        exists ? ::ActiveRecord::InternalMetadata : nil
+      end
+    end
+  end
+end

data/lib/services/wallaby/engine_name_finder.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Service object to find the engine name by given request environment variables.
+  # Find out the engine routing proxy name
   class EngineNameFinder
     class << self
-      # Use script name to find out the corresponding named route and its engine name.
+      # Go through all the routes and find out the engine routing proxy name
+      # for the given request path.
       #
-      # When it can't find the engine name, it will return empty string. Reason is to prevent it from being run again.
-      # @param env [Hash, String] request env or script name
-      # @return [String] engine name or empty string if not found
-      def find(env)
-        script_name = env[SCRIPT_NAME] || env[PATH_INFO] if env.is_a? Hash
-        script_name = env if env.is_a? String
-        return EMPTY_STRING if script_name.blank?
+      # When it can't find the engine name, it will return empty string
+      # to prevent it from being run again.
+      # @param request_path [String] request path
+      # @return [String] engine name if found
+      # @return [String] empty string "" if not found
+      def execute(request_path)
+        named_routes =
+          Rails.application.routes.routes.find do |route|
+            route.path.match(request_path) && route.app.app == Wallaby::Engine
+          end
 
-        named_route = Rails.application.routes.routes.find { |route| route.path.match(script_name) }
-        named_route.try(:name) || EMPTY_STRING
+        named_routes.try(:name) || EMPTY_STRING
       end
     end
   end