wallaby-core 0.2.11 → 0.3.0.beta1

data/lib/concerns/wallaby/servicable.rb

@@ -3,57 +3,17 @@
 module Wallaby
   # Servicer related attributes
   module Servicable
-    # Configurable attribute
-    module ClassMethods
-      # @!attribute [w] model_servicer
-      def model_servicer=(model_servicer)
-        ModuleUtils.inheritance_check model_servicer, application_servicer
-        @model_servicer = model_servicer
-      end
-
-      # @!attribute [r] model_servicer
-      # If Wallaby doesn't get it right, please specify the **model_servicer**.
-      # @example To set model servicer
-      #   class Admin::ProductionsController < Admin::ApplicationController
-      #     self.model_servicer = ProductServicer
-      #   end
-      # @return [Class] model servicer
-      # @raise [ArgumentError] when **model_servicer** doesn't inherit from **application_servicer**
-      # @see Wallaby::ModelServicer
-      # @since wallaby-5.2.0
-      attr_reader :model_servicer
-
-      # @!attribute [w] application_servicer
-      def application_servicer=(application_servicer)
-        ModuleUtils.inheritance_check model_servicer, application_servicer
-        @application_servicer = application_servicer
-      end
-
-      # @!attribute [r] application_servicer
-      # The **application_servicer** is as the base class of {#model_servicer}.
-      # @example To set application decorator:
-      #   class Admin::ApplicationController < Wallaby::ResourcesController
-      #     self.application_servicer = AnotherApplicationServicer
-      #   end
-      # @return [Class] application decorator
-      # @raise [ArgumentError] when **model_servicer** doesn't inherit from **application_servicer**
-      # @see Wallaby::ModelServicer
-      # @since wallaby-5.2.0
-      def application_servicer
-        @application_servicer ||= ModuleUtils.try_to superclass, :application_servicer
-      end
-    end
-
-    # Model servicer for current modal class. It comes from:
-    #
-    # - controller configuration {Wallaby::Servicable::ClassMethods#model_servicer .model_servicer}
-    # - a generic servicer based on {Wallaby::Servicable::ClassMethods#application_servicer .application_servicer}
-    # @return [Wallaby::ModelServicer] model servicer
+    # Model servicer for current modal class.
+    # @return [ModelServicer] model servicer
+    # @see ServicerFinder#execute
     # @since wallaby-5.2.0
     def current_servicer
       @current_servicer ||=
-        (controller_to_get(:model_servicer) \
-          || Map.servicer_map(current_model_class, controller_to_get(:application_servicer))).try do |klass|
+        ServicerFinder.new(
+          script_name: script_name,
+          model_class: current_model_class,
+          current_controller_class: wallaby_controller
+        ).execute.try do |klass|
           Logger.debug %(Current servicer: #{klass}), sourcing: false
           klass.new current_model_class, current_authorizer, current_model_decorator
         end

data/lib/concerns/wallaby/urlable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # All URL helpers for {Engine}
+  module Urlable
+    # Override original method to handle URL generation **when Wallaby is mounted as Rails Engine**.
+    # @param params [String, Hash, ActionController::Parameters, nil]
+    # @param options [Hash] options only used by {EngineUrlFor}
+    # @return [String] URL string
+    # @see EngineUrlFor.execute
+    # @see https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for
+    #   ActionView::RoutingUrlFor#url_for
+    def url_for(params = nil, options = {})
+      (!options[:super] &&
+        EngineUrlFor.execute(context: self, params: params, options: options)) ||
+        super(params)
+    end
+
+    # Generate the resourceful index path for given model class.
+    # @param model_class [Class]
+    # @param url_params [Hash]
+    # @return [String] index page path
+    def index_path(model_class, url_params: {})
+      with_query = url_params.delete :with_query
+      url_for(
+        { action: :index }.merge(url_params),
+        { model_class: model_class, with_query: with_query }
+      )
+    end
+
+    # Generate the resourceful new path for given model class.
+    # @param model_class [Class]
+    # @param url_params [Hash]
+    # @return [String] new page path
+    def new_path(model_class, url_params: {})
+      with_query = url_params.delete :with_query
+      url_for(
+        { action: :new }.merge(url_params),
+        { model_class: model_class, with_query: with_query }
+      )
+    end
+
+    # Generate the resourceful show path for given resource.
+    # @param resource [Object]
+    # @param url_params [Hash]
+    # @return [String] show page path
+    def show_path(resource, url_params: {})
+      decorated = decorate resource
+      with_query = url_params.delete :with_query
+      url_for(
+        ParamsUtils.presence(action: :show, id: decorated.try(:primary_key_value)).merge(url_params),
+        { model_class: decorated.model_class, with_query: with_query }
+      )
+    end
+
+    # Generate the resourceful edit path for given resource.
+    # @param resource [Object]
+    # @param url_params [Hash]
+    # @return [String] edit page path
+    def edit_path(resource, url_params: {})
+      decorated = decorate resource
+      with_query = url_params.delete :with_query
+      url_for(
+        { action: :edit, id: decorated.primary_key_value }.merge(url_params),
+        { model_class: decorated.model_class, with_query: with_query }
+      )
+    end
+  end
+end

data/lib/decorators/wallaby/resource_decorator.rb

@@ -4,19 +4,19 @@ module Wallaby
   # Decorator base class. It's designed to be used as the decorator (AKA presenter/view object)
   # for the associated model instance (which means it should be used in the views only).
   #
-  # And it holds the following metadata information for associated model class:
+  # And it holds the following field metadata information for associated model class:
   #
-  # - {#fields}
-  # - {#field_names}
-  # - {#index_fields}
-  # - {#index_field_names}
-  # - {#show_fields}
-  # - {#show_field_names}
-  # - {#form_fields}
-  # - {#form_field_names}
+  # - {#fields} - all other `*_fields` methods origin from it. and it's frozen.
+  # - {#field_names} - all other `*_field_names` methods origin from it. and it's frozen.
+  # - {#index_fields} - field metdata used on index page
+  # - {#index_field_names} - field name list used on index page
+  # - {#show_fields} - field metdata used on show page
+  # - {#show_field_names} - field name list used on show page
+  # - {#form_fields} - field metdata used on new/create/edit/update page
+  # - {#form_field_names} - field name list used on new/create/edit/update page
   #
   # For better practice, please create an application decorator class (see example)
-  # to better control the functions shared between different resource decorators.
+  # to better control the functions shared between different decorators.
   # @example Create an application class for Admin Interface usage
   #   class Admin::ApplicationDecorator < Wallaby::ResourceDecorator
   #     base_class!
@@ -50,30 +50,66 @@ module Wallaby
     #   (see Wallaby::ModelDecorator#form_field_names)
 
     DELEGATE_METHODS =
-      ModelDecorator.public_instance_methods(false) + Fieldable.public_instance_methods(false) - %i(model_class)
+      ModelDecorator.public_instance_methods(false) + Fieldable.public_instance_methods(false) - %i[model_class]
 
     class << self
+      # @!attribute fields
+      #   (see Wallaby::ModelDecorator#fields)
+
+      # @!attribute field_names
+      #   (see Wallaby::ModelDecorator#field_names)
+
+      # @!attribute index_fields
+      #   (see Wallaby::ModelDecorator#index_fields)
+
+      # @!attribute index_field_names
+      #   (see Wallaby::ModelDecorator#index_field_names)
+
+      # @!attribute show_fields
+      #   (see Wallaby::ModelDecorator#show_fields)
+
+      # @!attribute show_field_names
+      #   (see Wallaby::ModelDecorator#show_field_names)
+
+      # @!attribute form_fields
+      #   (see Wallaby::ModelDecorator#form_fields)
+
+      # @!attribute form_field_names
+      #   (see Wallaby::ModelDecorator#form_field_names)
+
       delegate(*DELEGATE_METHODS, to: :model_decorator, allow_nil: true)
 
-      # Return associated model decorator. It is the instance that pull out all the metadata
-      # information for the associated model.
+      # Return associated {ModelDecorator model decorator}. It is the instance that pull out all the metadata
+      # information from the associated model.
       # @param model_class [Class]
-      # @return [Wallaby::ModelDecorator]
+      # @return [ModelDecorator]
       # @return [nil] if itself is a base class or the given model_class is blank
       def model_decorator(model_class = self.model_class)
         return if model_class.blank?
 
-        Map.model_decorator_map model_class, base_class
+        Map.model_decorator_map(model_class, base_class)
       end
 
       # @!attribute [w] h
       attr_writer :h
 
       # @!attribute [r] h
-      # @return [ActionView::Base]
-      #   {Wallaby::Configuration::Mapping#resources_controller resources controller}'s helpers
+      # @return [ActionView::Base] {ResourcesController}'s helpers
       def h
-        @h ||= Wallaby.configuration.mapping.resources_controller.helpers
+        @h ||= superclass.try(:h) || ResourcesController.helpers
+      end
+
+      # Delegate missing method to {.model_decorator}
+      def method_missing(method_id, *args, &block)
+        return if ModelDecorator::MISSING_METHODS_RELATED_TO_FIELDS.match?(method_id.to_s) && model_decorator.blank?
+        return super unless model_decorator.try(:respond_to?, method_id)
+
+        model_decorator.try(method_id, *args, &block)
+      end
+
+      # Delegate missing method check to {.model_decorator}
+      def respond_to_missing?(method_id, _include_private)
+        model_decorator.try(:respond_to?, method_id) || super
       end
     end
 
@@ -82,18 +118,17 @@ module Wallaby
     attr_reader :resource
 
     # @!attribute [r] model_decorator
-    # @return [Wallaby::ModelDecorator]
+    # @return [ModelDecorator]
     attr_reader :model_decorator
 
-    # @return [ActionView::Base]
-    #   {Wallaby::Configuration::Mapping#resources_controller resources controller}'s helpers
+    # @return [ActionView::Base] {ResourcesController}'s helpers
     # @see .h
     def h
       self.class.h
     end
 
     delegate(*DELEGATE_METHODS, to: :model_decorator)
-    # NOTE: this delegation is to make url helper method working properly with resource decorator instance
+    # NOTE: this delegation is to make Rails URL helper methods working properly with decorator instance
     delegate :to_s, :to_param, to: :resource
 
     # @param resource [Object]
@@ -120,8 +155,9 @@ module Wallaby
     # It falls back to primary key value when no text field is found.
     # @return [String] a label
     def to_label
-      # NOTE: `.to_s` at the end is to ensure String is returned that won't cause any
-      # issue when `#to_label` is used in a link_to block. Coz integer is ignored.
+      # NOTE: `.to_s` at the end is to ensure String is returned.
+      # There is an issue when {#to_label} returns an integer value, and it is used in a #link_to block,
+      # the #link_to will generate empty link text when integer value is given in the block.
       (model_decorator.guess_title(resource) || primary_key_value).to_s
     end
 
@@ -132,14 +168,18 @@ module Wallaby
 
     # @return [Object] primary key value
     def primary_key_value
+      return if primary_key.blank?
+
       resource.try primary_key
     end
 
+    # @note this method is for the Rails URL helper methods to recognize non-ActiveModel models
     # @return [ActiveModel::Name]
     def model_name
       resource.try(:model_name) || ActiveModel::Name.new(model_class)
     end
 
+    # @note this method is for the Rails form helper methods to recognize non-ActiveModel models
     # @return [nil] if no primary key
     # @return [Array<String>] primary key
     def to_key
@@ -149,20 +189,18 @@ module Wallaby
 
     # Delegate missing method to {#resource}
     def method_missing(method_id, *args, &block)
-      return super unless resource.respond_to? method_id
-
-      resource.try method_id, *args, &block
+      if resource.respond_to?(method_id)
+        resource.try(method_id, *args, &block)
+      elsif model_decorator.respond_to?(method_id)
+        model_decorator.try(method_id, *args, &block)
+      else
+        super
+      end
     end
 
     # Delegate missing method check to {#resource}
     def respond_to_missing?(method_id, _include_private)
-      resource.respond_to?(method_id) || super
-    end
-
-    # @see https://github.com/rails/rails/compare/v7.0.2.4..7-0-stable#diff-44b94eca66c7497711821a8e6bcdfde4684bb7b8efa15e64da6532449f03ef0bR441
-    # @note This overwritten method is a response to the above change
-    def to_model
-      self
+      [resource, model_decorator].any? { |v| v.respond_to?(method_id) } || super
     end
   end
 end

data/lib/errors/wallaby/class_not_found.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class ClassNotFound < GeneralError
-  end
+  ClassNotFound = Class.new(GeneralError)
 end

data/lib/errors/wallaby/forbidden.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class Forbidden < GeneralError
-  end
+  Forbidden = Class.new(GeneralError)
 end

data/lib/errors/wallaby/general_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class GeneralError < ::StandardError
+  class GeneralError < ::StandardError # :nodoc:
   end
 end

data/lib/errors/wallaby/invalid_error.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class InvalidError < GeneralError
-  end
+  InvalidError = Class.new(GeneralError)
 end

data/lib/errors/wallaby/method_removed.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wallaby
+  MethodRemoved = Class.new(GeneralError)
+end

data/lib/errors/wallaby/model_not_found.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Model not found error
-  class ModelNotFound < NotFound
+  class ModelNotFound < NotFound # :nodoc:
     # @return [String] not found error message
     def message
       return super if super.include? "\n"

data/lib/errors/wallaby/not_authenticated.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class NotAuthenticated < GeneralError
-  end
+  NotAuthenticated = Class.new(GeneralError)
 end

data/lib/errors/wallaby/not_found.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class NotFound < GeneralError
-  end
+  NotFound = Class.new(GeneralError)
 end

data/lib/errors/wallaby/not_implemented.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class NotImplemented < GeneralError
-  end
+  NotImplemented = Class.new(GeneralError)
 end

data/lib/errors/wallaby/resource_not_found.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Resource not found error
-  class ResourceNotFound < NotFound
+  class ResourceNotFound < NotFound # :nodoc:
     # @return [String] resource not found error message
     def message
       Locale.t 'errors.not_found.resource', resource: super

data/lib/errors/wallaby/unprocessable_entity.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Wallaby
-  class UnprocessableEntity < GeneralError
-  end
+  UnprocessableEntity = Class.new(GeneralError)
 end

data/lib/fields/wallaby/all_fields.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # A simple wrapper so that all fields (index/show/form and other fields appear before itself)
+  # can be set in one-line.
+  #
+  # @example set type for name to `'string'` in decorator
+  #   class ProductDecorator < ApplicationDecorator
+  #     some_fields[:id][:sort_disabled] = true
+  #     all_fields[:name][:type] = 'string'
+  #     # index_fields[:name][:type] => 'string'
+  #     # show_fields[:name][:type] => 'string'
+  #     # form_fields[:name][:type] => 'string'
+  #     # some_fields[:name][:type] => 'string'
+  #   end
+  class AllFields
+    def initialize(decorator)
+      @decorator = decorator
+      @keys = []
+    end
+
+    # @param key [Symbol, String]
+    # @return [AllFields] self
+    def [](key)
+      @keys << key
+      self
+    end
+
+    # Set value for given keys
+    # @param last_key [Symbol, String]
+    # @param value [Object]
+    # @return [Object] value
+    def []=(last_key, value)
+      all_fields.each do |fields_method|
+        last = @keys.reduce(@decorator.try(fields_method)) do |metadata, key|
+          metadata.try :[], key
+        end
+        last.try :[]=, last_key, value
+      end
+
+      @keys = []
+      value # rubocop:disable Lint/Void
+    end
+
+    protected
+
+    def all_fields
+      existing_fields + possible_fields_from_instance_variables
+    end
+
+    def existing_fields
+      %w[index_fields show_fields form_fields]
+    end
+
+    def possible_fields_from_instance_variables
+      @decorator
+        .model_decorator.instance_variables
+        .map(&:to_s)
+        .grep(/\A@[a-zA-Z]\w*_fields\Z/)
+        .map { |s| s[1..] }
+    end
+  end
+end

data/lib/forms/wallaby/form_builder.rb

@@ -20,7 +20,7 @@ module Wallaby
       content_tag :ul, class: 'errors' do
         errors.each do |message|
           concat content_tag :li, content_tag(
-            :small, raw(message) # rubocop:disable Rails/OutputSafety
+            :small, raw(message)
           )
         end
       end
@@ -49,7 +49,7 @@ module Wallaby
       # Delegate the method so that we don't come in here the next time
       # when same method is called
       self.class.delegate method, to: :@template
-      @template.public_send method, *args, &block
+      @template.try method, *args, &block
     end
 
     # Delegate missing method check to `@template`

data/lib/generators/wallaby/engine/application_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # base generator
+  class ApplicationGenerator < Rails::Generators::NamedBase
+    argument :name, type: :string
+    argument :parent_name, type: :string, default: nil, required: false
+
+    def install
+      template "#{base_name}.rb.erb", "app/#{base_name}s/#{name}_#{base_name}.rb"
+    end
+
+    protected
+
+    def base_class
+      "#{class_name}#{base_name.classify}"
+    end
+
+    def parent_base_class
+      return "#{parent_name.classify}#{base_name.classify}" if parent_name
+
+      application_class
+    end
+
+    def application_class
+      Wallaby.configuration.resources_controller.try "application_#{base_name}"
+    end
+
+    def model_name
+      class_name.singularize
+    end
+  end
+end

data/lib/generators/wallaby/engine/authorizer/USAGE

@@ -0,0 +1,20 @@
+Description:
+    Generate authorizer for Wallaby Engine usage by given NAME.
+    It also takes the PARENT name and makes the generated authorizer inherit from the PARENT.
+
+    For example, if 'apple' is provided as the NAME, this generator will carry out the following items:
+    - Generate AppleAuthorizer that inherits from Wallaby Engine's application authorizer.
+
+Example:
+    rails generate wallaby:engine:authorizer admin/user
+
+    This will create:
+    - app/authorizers/admin/user_authorizer.rb
+
+Example:
+    rails generate wallaby:engine:authorizer admin/user admin/application
+
+    This will create:
+    - app/authorizers/admin/user_authorizer.rb
+
+    And it makes Admin::UserAuthorizer class inherit from Admin::ApplicationAuthorizer

data/lib/generators/wallaby/engine/authorizer/authorizer_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../application_generator'
+
+module Wallaby
+  class Engine
+    # `wallaby:engine:authorizer` generator
+    # @see https://github.com/wallaby-rails/wallaby-core/blob/master/lib/generators/wallaby/engine/authorizer/USAGE
+    class AuthorizerGenerator < ApplicationGenerator
+      source_root File.expand_path('templates', __dir__)
+
+      protected
+
+      def base_name
+        'authorizer'
+      end
+    end
+  end
+end

data/lib/generators/wallaby/engine/authorizer/templates/authorizer.rb.erb

@@ -0,0 +1,35 @@
+# @see https://github.com/wallaby-rails/wallaby/blob/master/docs/authorizer.md
+class <%= base_class %> < <%= parent_base_class %>
+  # Specify the model class if Wallaby doesn't get it right
+  # self.model_class = <%= model_name %>
+
+  # Specify which provider (:cancancan, :pundit or :default) to use.
+  # :default means no authorization will be in use.
+  # self.provider_name = :cancancan
+
+  # Check user's permission for given action on given subject.
+  # Raise Wallaby::Forbidden if user doesn't have permission
+  # def authorize(action, subject)
+  #   super # do something
+  # end
+
+  # Check and see if user is allowed to perform an action on given subject.
+  # def authorized?(action, subject)
+  #   super # do something
+  # end
+
+  # Filter the scope based on user's permission.
+  # def accessible_for(action, scope)
+  #   super # do something
+  # end
+
+  # Assign the values based on user's permission.
+  # def attributes_for(action, subject)
+  #   super # do something
+  # end
+
+  # Allowlist the parameters based on user's permission.
+  # def permit_params(action, subject)
+  #   super # do something
+  # end
+end

data/lib/generators/wallaby/engine/controller/USAGE

@@ -0,0 +1,20 @@
+Description:
+    Generate controller for Wallaby Engine usage by given NAME.
+    It also takes the PARENT name and makes the generated controller inherit from the PARENT.
+
+    For example, if 'apples' is provided as the NAME, this generator will carry out the following items:
+    - Generate ApplesController that inherits from Wallaby Engine's application controller.
+
+Example:
+    rails generate wallaby:engine:controller admin/users
+
+    This will create:
+    - app/controllers/admin/users_controller.rb
+
+Example:
+    rails generate wallaby:engine:controller admin/users admin/application
+
+    This will create:
+    - app/controllers/admin/users_controller.rb
+
+    And it makes Admin::UsersController class inherit from Admin::ApplicationController

data/lib/generators/wallaby/engine/controller/controller_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../application_generator'
+
+module Wallaby
+  class Engine
+    # `wallaby:engine:controller` generator
+    # @see https://github.com/wallaby-rails/wallaby-core/blob/master/lib/generators/wallaby/engine/controller/USAGE
+    class ControllerGenerator < ApplicationGenerator
+      source_root File.expand_path('templates', __dir__)
+
+      protected
+
+      def application_class
+        Wallaby.configuration.resources_controller
+      end
+
+      def base_name
+        'controller'
+      end
+    end
+  end
+end