wallaby-core 0.2.11 → 0.3.0.beta1

data/lib/concerns/wallaby/fieldable.rb

@@ -1,78 +1,67 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Field helper for model decorator
+  # Field helper method collection
+  # that takes care of `fields`, `field_names` related methods for model decorator
   module Fieldable
     # @param field_name [String, Symbol] field name
-    # @return [Hash] metadata information for a given field
-    def metadata_of(field_name)
-      fields[field_name] || {}
+    # @param prefix [String]
+    # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+    def metadata_of(field_name, prefix = '')
+      prefix_fields(prefix)[field_name] || {}
     end
+    alias_method :prefix_metadata_of, :metadata_of
 
     # @param field_name [String, Symbol] field name
-    # @return [String] label for a given field
-    def label_of(field_name)
-      metadata_of(field_name)[:label] || field_name.to_s.humanize
+    # @param prefix [String]
+    # @return [String] label for the given field
+    def label_of(field_name, prefix = '')
+      metadata_of(field_name, prefix)[:label] || field_name.to_s.humanize
     end
+    alias_method :prefix_label_of, :label_of
 
     # @param field_name [String, Symbol] field name
-    # @return [String, Symbol] type for a given field
-    def type_of(field_name)
-      ensure_type_is_present field_name, metadata_of(field_name)[:type]
+    # @param prefix [String]
+    # @return [String, Symbol] type for the given field
+    def type_of(field_name, prefix = '')
+      ensure_type_is_present field_name, metadata_of(field_name, prefix)[:type], prefix
     end
+    alias_method :prefix_type_of, :type_of
 
-    # @param field_name [String, Symbol] field name
-    # @return [Hash] index metadata information for a given field
-    def index_metadata_of(field_name)
-      index_fields[field_name] || {}
-    end
-
-    # @param field_name [String, Symbol] field name
-    # @return [String] index label for a given field
-    def index_label_of(field_name)
-      index_metadata_of(field_name)[:label] || field_name.to_s.humanize
-    end
-
-    # @param field_name [String, Symbol] field name
-    # @return [String, Symbol] index type for a given field
-    def index_type_of(field_name)
-      ensure_type_is_present field_name, index_metadata_of(field_name)[:type], 'index_'
+    # @param prefix [String]
+    # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+    def prefix_fields(prefix)
+      variable = "@#{prefix}fields"
+      instance_variable_get(variable) || instance_variable_set(variable, Utils.clone(fields))
     end
 
-    # @param field_name [String, Symbol] field name
-    # @return [Hash] show metadata information for a given field
-    def show_metadata_of(field_name)
-      show_fields[field_name] || {}
+    # Set metadata for the given prefix
+    # @param fields [Hash] fields metadata
+    # @param prefix [String]
+    # @return [ActiveSupport::HashWithIndifferentAccess] metadata
+    def prefix_fields=(fields, prefix)
+      variable = "@#{prefix}fields"
+      instance_variable_set(variable, FieldsRegulator.new(fields).execute)
     end
 
-    # @param field_name [String, Symbol] field name
-    # @return [String] show label for a given field
-    def show_label_of(field_name)
-      show_metadata_of(field_name)[:label] || field_name.to_s.humanize
+    # @param prefix [String]
+    # @return [Array<String>] a list of field names
+    def prefix_field_names(prefix)
+      variable = "@#{prefix}field_names"
+      instance_variable_get(variable) || \
+        instance_variable_set(variable, begin
+          fields = prefix_fields(prefix).reject { |_k, metadata| metadata[:hidden] }
+          reposition(fields.keys, primary_key)
+        end)
     end
 
-    # @param field_name [String, Symbol] field name
-    # @return [String, Symbol] show type for a given field
-    def show_type_of(field_name)
-      ensure_type_is_present field_name, show_metadata_of(field_name)[:type], 'show_'
-    end
-
-    # @param field_name [String, Symbol] field name
-    # @return [Hash] form metadata information for a given field
-    def form_metadata_of(field_name)
-      form_fields[field_name] || {}
-    end
-
-    # @param field_name [String, Symbol] field name
-    # @return [String] form label for a given field
-    def form_label_of(field_name)
-      form_metadata_of(field_name)[:label] || field_name.to_s.humanize
-    end
-
-    # @param field_name [String, Symbol] field name
-    # @return [String, Symbol] form type for a given field
-    def form_type_of(field_name)
-      ensure_type_is_present field_name, form_metadata_of(field_name)[:type], 'form_'
+    # Set field names for the given prefix
+    # @param field_names [Array<String>]
+    # @param prefix [String]
+    # @return [Array<String>] a list of field names
+    def prefix_field_names=(field_names, prefix)
+      variable = "@#{prefix}field_names"
+      instance_variable_set(variable, Array.wrap(field_names).flatten)
     end
   end
 end

data/lib/concerns/wallaby/paginatable.rb

@@ -3,58 +3,18 @@
 module Wallaby
   # Paginator related attributes
   module Paginatable
-    # Configurable attribute
-    module ClassMethods
-      # @!attribute [w] model_paginator
-      def model_paginator=(model_paginator)
-        ModuleUtils.inheritance_check model_paginator, application_paginator
-        @model_paginator = model_paginator
-      end
-
-      # @!attribute [r] model_paginator
-      # If Wallaby doesn't get it right, please specify the **model_paginator**.
-      # @example To set model paginator
-      #   class Admin::ProductionsController < Admin::ApplicationController
-      #     self.model_paginator = ProductPaginator
-      #   end
-      # @return [Class] model paginator
-      # @raise [ArgumentError] when **model_paginator** doesn't inherit from **application_paginator**
-      # @see Wallaby::ModelPaginator
-      # @since wallaby-5.2.0
-      attr_reader :model_paginator
-
-      # @!attribute [w] application_paginator
-      def application_paginator=(application_paginator)
-        ModuleUtils.inheritance_check model_paginator, application_paginator
-        @application_paginator = application_paginator
-      end
-
-      # @!attribute [r] application_paginator
-      # The **application_paginator** is as the base class of {#model_paginator}.
-      # @example To set application decorator:
-      #   class Admin::ApplicationController < Wallaby::ResourcesController
-      #     self.application_paginator = AnotherApplicationPaginator
-      #   end
-      # @return [Class] application decorator
-      # @raise [ArgumentError] when **model_paginator** doesn't inherit from **application_paginator**
-      # @see Wallaby::ModelPaginator
-      # @since wallaby-5.2.0
-      def application_paginator
-        @application_paginator ||= ModuleUtils.try_to superclass, :application_paginator
-      end
-    end
-
-    # Model paginator for current modal class. It comes from:
-    #
-    # - controller configuration {Wallaby::Paginatable::ClassMethods#model_paginator .model_paginator}
-    # - a generic paginator based on {Wallaby::Paginatable::ClassMethods#application_paginator .application_paginator}
+    # Model paginator for current modal class.
     # @return [Class] model paginator class
+    # @see PaginatorFinder#execute
     def current_paginator
       @current_paginator ||=
-        (controller_to_get(:model_paginator) \
-          || Map.paginator_map(current_model_class, controller_to_get(:application_paginator))).try do |klass|
+        PaginatorFinder.new(
+          script_name: script_name,
+          model_class: current_model_class,
+          current_controller_class: wallaby_controller
+        ).execute.try do |klass|
           Logger.debug %(Current paginator: #{klass}), sourcing: false
-          klass.new current_model_class, collection, params
+          klass.new current_model_class, collection, pagination_params_for(params)
         end
     end
 
@@ -64,9 +24,18 @@ module Wallaby
     # @param options [Hash]
     # @option options [Boolean] :paginate whether collection should be paginated
     # @return [#each]
-    # @see Wallaby::ModelServicer#paginate
-    def paginate(query, options)
-      options[:paginate] ? current_servicer.paginate(query, params) : query
+    # @see ModelServicer#paginate
+    def paginate(query, options = { paginate: true })
+      return query unless options[:paginate]
+
+      current_servicer.paginate(query, pagination_params_for(params))
+    end
+
+    # @param params [Hash, ActionController::Parameters]
+    # @return [Hash, ActionController::Parameters]
+    def pagination_params_for(params)
+      params[:per] ||= wallaby_controller.page_size
+      params
     end
   end
 end

data/lib/concerns/wallaby/prefixable.rb

@@ -3,18 +3,38 @@
 module Wallaby
   # Field helper for model decorator
   module Prefixable
+    extend ActiveSupport::Concern
+
+    MAPPING_ACTIONS = {
+      new: 'form',
+      create: 'form',
+      edit: 'form',
+      update: 'form'
+    }.freeze
+
+    module ClassMethods
+      attr_writer :mapping_actions
+
+      def mapping_actions
+        @mapping_actions || superclass.try(:mapping_actions) || MAPPING_ACTIONS
+      end
+
+      def add_mapping_actions(options)
+        @mapping_actions = mapping_actions.merge(options)
+      end
+    end
+
     # @return [Array<String>] prefixes
-    def _prefixes
+    def wallaby_prefixes
       override_prefixes(
-        options: { mapping_actions: FORM_ACTIONS }
+        options: { mapping_actions: self.class.mapping_actions }
       ) do |prefixes|
         PrefixesBuilder.new(
+          controller_class: self.class,
           prefixes: prefixes,
           resources_name: current_resources_name,
           script_name: request.env[SCRIPT_NAME]
         ).execute
-
-        prefixes[0..prefixes.index(ResourcesController.controller_path)]
       end
     end
   end

data/lib/concerns/wallaby/resourcable.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Resources related attributes
+  # Resources related attributes & helper methods
   module Resourcable
     # @return [String] resources name for current request
     def current_resources_name
       @current_resources_name ||= params[:resources]
     end
 
+    # Model class for current request.
+    #
+    # It comes from two places:
+    #
+    # - configured {Baseable::ClassMethods#model_class .model_class}
+    # - fall back to the model class converted from either the {#current_resources_name}
+    #   or
+    #   {https://edgeapi.rubyonrails.org/classes/AbstractController/Base.html#method-c-controller_path .controller_path}
     # @return [Class] model class for current request
     def current_model_class
       @current_model_class ||=
-        controller_to_get(__callee__, :model_class) || Map.model_class_map(current_resources_name || controller_path)
+        wallaby_controller.model_class || Map.model_class_map(current_resources_name || controller_path)
     end
 
     # Shorthand of params[:id]
@@ -21,98 +29,148 @@ module Wallaby
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # This is a method to return collection for index page.
+    # It's used by {#create_params} and {#update_params}.
+    #
+    # It can be replaced completely in subclasses
+    # and will impact both {#create_params} and {#update_params}:
+    #
+    #     def resource_params
+    #       params.fetch(:product, {}).permit(:name, :sku)
+    #     end
+    # @return [ActionController::Parameters] allowlisted params
+    def resource_params
+      @resource_params ||= current_servicer.permit params, action_name
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To allowlist the request params for {ResourcesConcern#create create} action.
+    #
+    # It can be replaced completely in subclasses:
+    #
+    #     def create_params
+    #       params.fetch(:product, {}).permit(:name, :sku)
+    #     end
+    # @return [ActionController::Parameters] allowlisted params
+    def create_params
+      resource_params
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To allowlist the request params for {ResourcesConcern#update update} action.
+    #
+    # It can be replaced completely in subclasses:
+    #
+    #     def update_params
+    #       params.fetch(:product, {}).permit(:name, :sku)
+    #     end
+    # @return [ActionController::Parameters] allowlisted params
+    def update_params
+      resource_params
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a method to return collection for {ResourcesConcern#index index} action and page.
     #
     # It can be customized as below in subclasses:
     #
-    # ```
-    # def collection
-    #   # do something before the origin action
-    #   options = {} # NOTE: see `options` parameter for more details
-    #   collection! options do |query| # NOTE: this is better than using `super`
-    #     # NOTE: make sure a collection is returned
-    #     query.where(active: true)
-    #   end
-    # end
-    # ```
+    #     def collection
+    #       # do something before the original action
+    #       options = {} # @see arguments for more details
+    #       # NOTE: this is better than using `super` in many ways, but choose the one that better fits your scenario
+    #       collection!(options) do |query|
+    #         # NOTE: make sure to return a collection in the block
+    #         query.where(active: true)
+    #       end
+    #     end
     #
     # Otherwise, it can be replaced completely in subclasses:
     #
-    # ```
-    # def collection
-    #   # NOTE: pagination should happen here if needed
-    #   # NOTE: make sure `@collection` and conditional assignment (the OR EQUAL) operator are used
-    #   @collection ||= paginate Product.active
-    # end
-    # ```
-    # @param options [Hash] (since 5.2.0)
-    # @option options [ActionController::Parameters, Hash] :params parameters for collection query
-    # @option options [Boolean] :paginate see {Wallaby::Paginatable#paginate}
-    # @yield [collection] (since 5.2.0) a block to run to extend collection, e.g. call chain with more queries
+    #     def collection
+    #       # NOTE: pagination should happen here if needed
+    #       # NOTE: `@collection` will be used by the view, please ensure it is assigned, for example:
+    #       @collection ||= paginate Product.active
+    #     end
+    # @param params [Hash, ActionController::Parameters] parameters for collection query, default to request parameters
+    # @param paginate [Boolean] see {Paginatable#paginate #paginate}
+    # @param paginate_options [Hash] options accepted by {Paginatable#paginate #paginate} (since 0.3.0)
+    # @yield [collection] (since wallaby-5.2.0) a block to run to extend/convert the original collection,
+    #   e.g. call chain with more queries
     # @return [#each] a collection of records
-    def collection(options = {}, &block)
+    def collection(params: self.params, paginate: true, **paginate_options, &block)
       @collection ||=
         ModuleUtils.yield_for(
-          begin
-            options[:paginate] = true unless options.key?(:paginate)
-            options[:params] ||= params
-            paginate current_servicer.collection(options.delete(:params)), options
-          end,
+          paginate(
+            current_servicer.collection(params),
+            paginate_options.merge(paginate: paginate)
+          ),
           &block
         )
     end
-
-    alias collection! collection
+    alias_method :collection!, :collection
 
     # @note This is a template method that can be overridden by subclasses.
-    # This is a method to return resource for pages except `index`.
-    #
-    # `WARN: It does not do mass assignment since 5.2.0.`
+    # This is a method to return resource for
+    # {ResourcesConcern#show show}, {ResourcesConcern#edit edit},
+    # {ResourcesConcern#update update} and {ResourcesConcern#destroy destroy} actions.
     #
     # It can be customized as below in subclasses:
     #
-    # ```
-    # def resource
-    #   # do something before the origin action
-    #   options = {} # NOTE: see `options` parameter for more details
-    #   resource! options do |object| # NOTE: this is better than using `super`
-    #     object.preload_status_from_api
-    #     # NOTE: make sure object is returned
-    #     object
-    #   end
-    # end
-    # ```
+    #     def resource
+    #       # do something before the original action
+    #       # NOTE: this is better than using `super` in many ways, but choose the one that better fits your scenario
+    #       resource! do |object|
+    #         object.preload_status_from_api
+    #         # NOTE: make sure to return an object in the block
+    #         object
+    #       end
+    #     end
     #
     # Otherwise, it can be replaced completely in subclasses:
     #
-    # ```
-    # def resource
-    #   # NOTE: make sure `@resource` and conditional assignment (the OR EQUAL) operator are used
-    #   @resource ||= resource_id.present? ? Product.find_by_slug(resource_id) : Product.new(arrival: true)
-    # end
-    # ```
-    # @param options [Hash] (since 5.2.0)
-    # @option options [Array<String>] :non_find_actions action names that shouldn't use resource find.
-    #   (Default to `%w(index new create)`)
-    # @option options [ActionController::Parameters, Hash] :find_params parameters/options for resource finding
-    # @option options [ActionController::Parameters, Hash] :new_params parameters/options for new resource
-    # @yield [resource] (since 5.2.0) a block to run to extend resource, e.g. making change to the resource.
-    #   Please make sure to return the resource at the end of block
-    # @return [Object] either persisted or unpersisted resource instance
-    # @raise [ResourceNotFound] if resource is nil
-    def resource(options = {}, &block)
+    #     def resource
+    #       # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #       @resource ||= resource_id.present? ? Product.find_by_slug(resource_id) : Product.new(arrival: true)
+    #     end
+    # @yield [resource] (since wallaby-5.2.0) a block to run to extend resource, e.g. making change to the resource.
+    #   Please make sure to return the expected resource at the end of block
+    # @return [Object] persisted resource instance
+    # @raise [ResourceNotFound] if resource is not found
+    def resource(&block)
       @resource ||=
-        ModuleUtils.yield_for(
-          # this will testify both resource and resources
-          if resource_id.present? || !(options[:non_find_actions] || NON_FIND_ACTIONS).include?(action_name)
-            current_servicer.find resource_id, options[:find_params]
-          else
-            current_servicer.new options[:new_params]
-          end,
-          &block
-        )
+        ModuleUtils.yield_for(current_servicer.find(resource_id, {}), &block)
     end
+    alias_method :resource!, :resource
 
-    alias resource! resource
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a method to return resource for
+    # {ResourcesConcern#new new} and {ResourcesConcern#create create} actions.
+    #
+    # It can be customized as below in subclasses:
+    #
+    #     def new_resource
+    #       # do something before the original action
+    #       # NOTE: this is better than using `super` in many ways, but choose the one that better fits your scenario
+    #       new_resource! do |object|
+    #         object.preload_status_from_api
+    #         # NOTE: make sure to return an object in the block
+    #         object
+    #       end
+    #     end
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    #     def new_resource
+    #       # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #       @resource ||= Product.new(arrival: true)
+    #     end
+    # @yield [resource] (since wallaby-5.2.0) a block to run to extend resource, e.g. making change to the resource.
+    #   Please make sure to return the expected resource at the end of block
+    # @return [Object] unpersisted resource instance
+    # @since 0.3.0
+    def new_resource(&block)
+      @resource ||=
+        ModuleUtils.yield_for(current_servicer.new({}), &block)
+    end
+    alias_method :new_resource!, :new_resource
   end
 end