wallaby-core 0.2.0 → 0.2.1

data/config/locales/wallaby_class.en.yml

@@ -1,24 +1,3 @@
-# Files in the config/locales directory are used for internationalization
-# and are automatically loaded by Rails. If you want to use locales other
-# than English, add the necessary files in this directory.
-#
-# To use the locales, use `I18n.t`:
-#
-#     I18n.t 'hello'
-#
-# In views, this is aliased to just `t`:
-#
-#     <%= t('hello') %>
-#
-# To use a different locale, set it with `I18n.locale`:
-#
-#     I18n.locale = :es
-#
-# This would use the information in config/locales/es.yml.
-#
-# To learn more, please read the Rails Internationalization guide
-# available at http://guides.rubyonrails.org/i18n.html.
-
 en:
   wallaby:
     map:

data/lib/adaptors/wallaby/custom/model_service_provider.rb

@@ -6,42 +6,42 @@ module Wallaby
     class ModelServiceProvider < ::Wallaby::ModelServiceProvider
       # @raise [Wallaby::NotImplemented]
       def permit(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def collection(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def paginate(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def new(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def find(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def create(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def update(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
 
       # @raise [Wallaby::NotImplemented]
       def destroy(*)
-        raise Wallaby::NotImplemented, I18n.t('errors.not_implemented.model_servicer', method_name: __callee__)
+        raise Wallaby::NotImplemented, Locale.t('errors.not_implemented.model_servicer', method_name: __callee__)
       end
     end
   end

data/lib/authorizers/wallaby/cancancan_authorization_provider.rb

@@ -35,7 +35,7 @@ module Wallaby
     def authorize(action, subject)
       ability.authorize! action, subject
     rescue ::CanCan::AccessDenied
-      Rails.logger.info I18n.t('errors.unauthorized', user: user, action: action, subject: subject)
+      Logger.info Locale.t('errors.unauthorized', user: user, action: action, subject: subject)
       raise Forbidden
     end
 
@@ -55,6 +55,7 @@ module Wallaby
       ModuleUtils.try_to(scope, :accessible_by, ability, action) || scope
     end
 
+    # @!method attributes_for(action, subject)
     # Restrict user to assign certain values.
     # @param action [Symbol, String]
     # @param subject [Object]

data/lib/authorizers/wallaby/pundit_authorization_provider.rb

@@ -32,7 +32,7 @@ module Wallaby
     def authorize(action, subject)
       Pundit.authorize(user, subject, normalize(action)) && subject
     rescue ::Pundit::NotAuthorizedError
-      Rails.logger.info I18n.t('errors.unauthorized', user: user, action: action, subject: subject)
+      Logger.info Locale.t('errors.unauthorized', user: user, action: action, subject: subject)
       raise Forbidden
     end
 
@@ -57,7 +57,7 @@ module Wallaby
     def attributes_for(action, subject)
       policy = Pundit.policy! user, subject
       value = ModuleUtils.try_to(policy, "attributes_for_#{action}") || ModuleUtils.try_to(policy, 'attributes_for')
-      Rails.logger.warn I18n.t('error.pundit.not_found.attributes_for', subject: subject) unless value
+      Logger.warn Locale.t('error.pundit.not_found.attributes_for', subject: subject) unless value
       value || {}
     end
 

data/lib/concerns/wallaby/application_concern.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Here, it provides the most basic functions e.g. error handling for common 4xx HTTP status, helpers method,
+  # and URL handling.
+  module ApplicationConcern
+    extend ActiveSupport::Concern
+
+    # @!parse
+    #   extend Engineable::ClassMethods
+    #   include Engineable
+    #   include SharedHelpers
+
+    # @!method healthy
+    # Health check page
+
+    # @!method not_found(exception = nil)
+    # Not found page
+    # @param exception [Exception] comes from **rescue_from**
+
+    # @!method bad_request(exception = nil)
+    # Bad request page
+    # @param exception [Exception] comes from **rescue_from**
+
+    # @!method unprocessable_entity(exception = nil)
+    # Unprocessable entity page
+    # @param exception [Exception] comes from **rescue_from**
+
+    # @!method internal_server_error(exception = nil)
+    # Internal server error page
+    # @param exception [Exception] comes from **rescue_from**
+
+    # @!method not_implemented(exception = nil)
+    # Not implemented
+    # @param exception [Exception] comes from **rescue_from**
+
+    # @!method helpers
+    # {https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers helpers}
+    # exists since Rails 5.0, need to mimic this to support Rails 4.2.
+    # @see https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers
+    #   ActionController::Helpers#helpers
+    # @see https://github.com/rails/rails/blob/5-0-stable/actionpack/lib/action_controller/metal/helpers.rb#L118
+
+    # @!method render_error(exception, symbol)
+    # Capture exceptions and display the error using error template.
+    # @param exception [Exception]
+    # @param symbol [Symbol] http status symbol
+
+    included do # rubocop:disable Metrics/BlockLength
+      extend Engineable::ClassMethods
+      include Engineable
+      include SharedHelpers
+      helper ApplicationHelper
+
+      rescue_from NotFound, with: :not_found
+      rescue_from ::ActionController::ParameterMissing, with: :bad_request
+      rescue_from ::ActiveRecord::StatementInvalid, with: :unprocessable_entity
+      rescue_from NotImplemented, with: :not_implemented
+      rescue_from UnprocessableEntity, with: :unprocessable_entity
+
+      delegate(*ConfigurationHelper.instance_methods(false), :url_for, to: :helpers)
+
+      # (see #healthy)
+      def healthy
+        render plain: 'healthy'
+      end
+
+      # (see #not_found)
+      def not_found(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #bad_request)
+      def bad_request(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #unprocessable_entity)
+      def unprocessable_entity(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #internal_server_error)
+      def internal_server_error(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #not_implemented)
+      def not_implemented(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #helpers)
+      def helpers
+        @helpers ||= defined?(super) ? super : view_context
+      end
+
+      protected
+
+      # (see #render_error)
+      def render_error(exception, symbol)
+        Logger.error exception, sourcing: false
+
+        @exception = exception
+        @symbol = symbol
+        @code = Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol].to_i
+        respond_with @exception, status: @code, template: ERROR_PATH, prefixes: _prefixes
+      end
+    end
+  end
+end

data/lib/concerns/wallaby/authentication_concern.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Authentication related functions
+  module AuthenticationConcern
+    extend ActiveSupport::Concern
+
+    # @!method current_user
+    # @note This is a template method that can be overridden by subclasses
+    # This {current_user} method will try to looking up the actual implementation from the following
+    # places from high precedence to low:
+    #
+    # - {Wallaby::Configuration::Security#current_user}
+    # - `super`
+    # - do nothing
+    #
+    # It can be replaced completely in subclasses:
+    #
+    #   def current_user
+    #     # NOTE: please ensure `@current_user` is assigned, for instance:
+    #     @current_user ||= User.new params.slice(:email)
+    #   end
+    # @return [Object] a user object
+
+    # @!method authenticate_user!
+    # @note This is a template method that can be overridden by subclasses
+    # This {authenticate_user!} method will try to looking up the actual implementation from the following
+    # places from high precedence to low:
+    #
+    # - {Wallaby::Configuration::Security#authenticate}
+    # - `super`
+    # - do nothing
+    #
+    # It can be replaced completely in subclasses:
+    #
+    #   def authenticate_user!
+    #     authenticate_or_request_with_http_basic do |username, password|
+    #       username == 'too_simple' && password == 'too_naive'
+    #     end
+    #   end
+    # @return [true] when user is authenticated successfully
+    # @raise [Wallaby::NotAuthenticated] when user fails to authenticate
+
+    # @!method unauthorized(exception = nil)
+    # Unauthorized page.
+    # @param exception [Exception] exception comes from `rescue_from`
+
+    # @!method forbidden(exception = nil)
+    # Forbidden page.
+    # @param exception [Exception] exception comes from `rescue_from`
+
+    included do # rubocop:disable Metrics/BlockLength
+      helper SecureHelper
+      helper_method :current_user
+
+      rescue_from NotAuthenticated, with: :unauthorized
+      rescue_from Forbidden, with: :forbidden
+
+      # (see #current_user)
+      def current_user
+        @current_user ||=
+          if security.current_user? || !defined? super
+            instance_exec(&security.current_user)
+          else
+            super
+          end
+      end
+
+      # (see #authenticate_user!)
+      def authenticate_user!
+        authenticated =
+          if security.authenticate? || !defined? super
+            instance_exec(&security.authenticate)
+          else
+            super
+          end
+        raise NotAuthenticated unless authenticated
+
+        true
+      end
+
+      # (see #unauthorized)
+      def unauthorized(exception = nil)
+        render_error exception, __callee__
+      end
+
+      # (see #forbidden)
+      def forbidden(exception = nil)
+        render_error exception, __callee__
+      end
+    end
+  end
+end

data/lib/concerns/wallaby/authorizable.rb

@@ -56,7 +56,7 @@ module Wallaby
     def current_authorizer
       @current_authorizer ||=
         authorizer_of(current_model_class, controller_to_get(:model_authorizer)).tap do |authorizer|
-          Rails.logger.info %(  - Current authorizer: #{authorizer.try(:class)})
+          Logger.debug %(Current authorizer: #{authorizer.try(:class)})
         end
     end
 

data/lib/concerns/wallaby/decoratable.rb

@@ -68,7 +68,7 @@ module Wallaby
       @current_decorator ||=
         (controller_to_get(:resource_decorator) || \
         Map.resource_decorator_map(current_model_class, controller_to_get(:application_decorator))).tap do |decorator|
-          Rails.logger.info %(  - Current decorator: #{decorator})
+          Logger.debug %(Current decorator: #{decorator})
         end
     end
 

data/lib/concerns/wallaby/paginatable.rb

@@ -53,7 +53,7 @@ module Wallaby
       @current_paginator ||=
         (controller_to_get(:model_paginator) \
           || Map.paginator_map(current_model_class, controller_to_get(:application_paginator))).try do |klass|
-          Rails.logger.info %(  - Current paginator: #{klass})
+          Logger.debug %(Current paginator: #{klass})
           klass.new current_model_class, collection, params
         end
     end

data/lib/concerns/wallaby/resourcable.rb

@@ -97,6 +97,8 @@ module Wallaby
         )
     end
 
+    alias 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`.
     #
@@ -145,5 +147,7 @@ module Wallaby
           &block
         )
     end
+
+    alias resource! resource
   end
 end

data/lib/concerns/wallaby/resources_concern.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resources concern
+  module ResourcesConcern
+    extend ActiveSupport::Concern
+
+    # @!parse
+    #   include ApplicationConcern
+    #   include AuthenticationConcern
+    #   extend Authorizable::ClassMethods
+    #   extend Baseable::ClassMethods
+    #   extend Decoratable::ClassMethods
+    #   extend Paginatable::ClassMethods
+    #   extend Resourcable::ClassMethods
+    #   extend Servicable::ClassMethods
+    #
+    #   include View
+    #   prepend Prefixable
+    #
+    #   include Authorizable
+    #   include Decoratable
+    #   include Defaultable
+    #   include Paginatable
+    #   include Resourcable
+    #   include Servicable
+    #
+    #   alias index! index
+    #   alias new! new
+    #   alias create! create
+    #   alias show! show
+    #   alias edit! edit
+    #   alias update! update
+    #   alias destroy! destroy
+    #   alias collection! collection
+    #   alias resource! resource
+
+    # @!method home
+    # @note This is a template method that can be overridden by subclasses.
+    # This is an action for landing page display. It does nothing more than rendering `home` template.
+    #
+    # It can be replaced completely in subclasses as below:
+    #
+    # ```
+    # def home
+    #   generate_dashboard_report
+    # end
+    # ```
+
+    # @!method index(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to list records that user can access.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # `WARN: Please keep in mind that Wallaby User Interface requires **index**
+    # action to respond to **csv** and **json** format as well.`
+    #
+    # ```
+    # def index
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   index!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # `WARN: Please keep in mind that Wallaby User Interface requires **index**
+    # action to respond to **csv** and **json** format as well.`
+    #
+    # ```
+    # def index
+    #   # NOTE: `@collection` will be used by the view, please ensure it is assigned, for example:
+    #   @collection = Product.all
+    #   respond_with @collection
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method new(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to show the form to create record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def new
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   new!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def new
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.new new_arrival: true
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method create(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to create a record that user is allowed to.
+    #
+    # If record is created successfully, user will be navigated to the record show page.
+    # Otherwise, the form will be shown again with error messages.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def create
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   create!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def create
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.new resource_params.merge(new_arrival: true)
+    #   if @resource.save
+    #     redirect_to helper.index_path(current_model_class)
+    #   else
+    #     render :new
+    #   end
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to create the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method show(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to display the record details that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def show
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   show!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def show
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method edit(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to show the form to edit record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def edit
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   edit!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def edit
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method update(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to update the record that user is allowed to.
+    #
+    # If record is updated successfully, user will be navigated to the record show page.
+    # Otherwise, the form will be shown again with error messages.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def update
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   update!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def update
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    #   @resource.assign_attributes resource_params.merge(new_arrival: true)
+    #   if @resource.save
+    #     redirect_to helper.index_path(current_model_class)
+    #   else
+    #     render :new
+    #   end
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to update the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method destroy(options = {}, &block)
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to delete the record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def destroy
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   destroy!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def destroy
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    #   @resource.destroy
+    #   redirect_to helper.index_path(current_model_class)
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to destroy the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+
+    # @!method resource_params
+    # @note This is a template method that can be overridden by subclasses.
+    # To whitelist the params for {#create} and {#update} actions.
+    #
+    # If Wallaby cannot generate the correct strong parameters, it can be replaced, for example:
+    #
+    # ```
+    # def resource_params
+    #   params.fetch(:product, {}).permit(:name, :sku)
+    # end
+    # ```
+    # @return [ActionController::Parameters] whitelisted params
+
+    included do # rubocop:disable Metrics/BlockLength
+      include ApplicationConcern
+      include AuthenticationConcern
+
+      extend Authorizable::ClassMethods
+      extend Baseable::ClassMethods
+      extend Decoratable::ClassMethods
+      extend Paginatable::ClassMethods
+      extend Resourcable::ClassMethods
+      extend Servicable::ClassMethods
+
+      include View
+      prepend Prefixable
+
+      include Authorizable
+      include Decoratable
+      include Defaultable
+      include Paginatable
+      include Resourcable
+      include Servicable
+
+      # NOTE: to ensure Wallaby's layout
+      # is not inheriting from/impacted by parent controller's layout.
+      public_send(
+        # inherit? or include?
+        self == ResourcesController ? :layout : :theme_name=,
+        ResourcesController.controller_path
+      )
+
+      self.responder = ResourcesResponder
+      respond_to :html
+      respond_to :json
+      respond_to :csv
+      helper ResourcesHelper
+      before_action :authenticate_user!
+
+      def home
+        # do nothing
+      end
+
+      def index(options = {}, &block)
+        current_authorizer.authorize :index, current_model_class
+        respond_with collection, options, &block
+      end
+
+      alias_method :index!, :index
+
+      def new(options = {}, &block)
+        current_authorizer.authorize :new, resource
+        respond_with resource, options, &block
+      end
+
+      alias_method :new!, :new
+
+      def create(options = {}, &block)
+        set_defaults_for :create, options
+        current_authorizer.authorize :create, resource
+        current_servicer.create resource, options.delete(:params)
+        respond_with resource, options, &block
+      end
+
+      alias_method :create!, :create
+
+      def show(options = {}, &block)
+        current_authorizer.authorize :show, resource
+        respond_with resource, options, &block
+      end
+
+      alias_method :show!, :show
+
+      def edit(options = {}, &block)
+        current_authorizer.authorize :edit, resource
+        respond_with resource, options, &block
+      end
+
+      alias_method :edit!, :edit
+
+      def update(options = {}, &block)
+        set_defaults_for :update, options
+        current_authorizer.authorize :update, resource
+        current_servicer.update resource, options.delete(:params)
+        respond_with resource, options, &block
+      end
+
+      alias_method :update!, :update
+
+      def destroy(options = {}, &block)
+        set_defaults_for :destroy, options
+        current_authorizer.authorize :destroy, resource
+        current_servicer.destroy resource, options.delete(:params)
+        respond_with resource, options, &block
+      end
+
+      alias_method :destroy!, :destroy
+
+      def resource_params
+        @resource_params ||= current_servicer.permit params, action_name
+      end
+    end
+  end
+end