wallaby-core 0.2.11 → 0.3.0.beta1

data/lib/generators/wallaby/engine/servicer/USAGE

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

data/lib/generators/wallaby/engine/servicer/servicer_generator.rb

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

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

@@ -0,0 +1,45 @@
+# @see https://github.com/wallaby-rails/wallaby/blob/master/docs/servicer.md
+class <%= base_class %> < <%= parent_base_class %>
+  # Specify the model class if Wallaby doesn't get it right
+  # self.model_class = <%= model_name %>
+
+  # Allowlist parameters for mass assignment
+  # def permit(params, action)
+  #   super # do something
+  # end
+
+  # Fetch collection by given params
+  # def collection(params)
+  #   super # do something
+  # end
+
+  # Paginate the collection
+  # def paginate(query, params)
+  #   super # do something
+  # end
+
+  # Initialize the model class using given params
+  # def new(params)
+  #   super # do something
+  # end
+
+  # Find a resource using id
+  # def find(id, params)
+  #   super # do something
+  # end
+
+  # Save the newly initialized resource
+  # def create(resource, params)
+  #   super # do something
+  # end
+
+  # Update the persisted resource
+  # def update(resource, params)
+  #   super # do something
+  # end
+
+  # Destroy the given resource
+  # def destroy(resource, params)
+  #   super # do something
+  # end
+end

data/lib/helpers/wallaby/application_helper.rb

@@ -4,71 +4,22 @@ module Wallaby
   # Wallaby application helper
   module ApplicationHelper
     include ConfigurationHelper
+    include Configurable
     include Engineable
-    include SharedHelpers
+    include Urlable
 
-    # @!method try_to(subject, method_id, *args, &block)
-    #   (see Wallaby::ModuleUtils.try_to)
-    #   @see Wallaby::ModuleUtils.try_to
-    delegate :try_to, to: ModuleUtils
-
-    # Override origin method to handle URL for Wallaby engine.
-    #
-    # As Wallaby's routes are declared in a
-    # {https://guides.rubyonrails.org/routing.html#routing-to-rack-applications Rack application} fashion, this will
-    # lead to **ActionController::RoutingError** exception when using ordinary **url_for**
-    # (e.g. `url_for action: :index`).
-    #
-    # Gotcha: Wallaby can't cope well with the following situation.
-    # It's due to the limit of route declaration and matching:
-    #
-    # ```
-    # scope path: '/prefix' do
-    #   wresources :products, controller: 'wallaby/resources'
-    # end
-    # ```
-    # @param options [String, Hash, ActionController::Parameters]
-    # @option options [Boolean]
-    #   :with_query to include `request.query_parameters` values for url generation.
-    # @option options [String]
-    #   :engine_name to specify the engine_name to use, default to {Wallaby::Engineable#current_engine_name}
-    # @return [String] URL string
-    # @see Wallaby::EngineUrlFor.handle
-    # @see https://api.rubyonrails.org/classes/ActionView/RoutingUrlFor.html#method-i-url_for
-    #   ActionView::RoutingUrlFor#url_for
-    def url_for(options = nil)
-      if options.is_a?(Hash) || try_to(options, :permitted?)
-        # merge with all current query parameters
-        options = request.query_parameters.merge(options) if options.delete(:with_query)
-        options = ParamsUtils.presence url_options, options # remove blank values
-        EngineUrlFor.handle(
-          engine_name: options.fetch(:engine_name, current_engine_name), parameters: options
-        )
-      end || super(options)
-    end
-
-    # Override origin method to add turbolinks tracking when it's enabled
-    # @param sources [Array<String>]
-    # @return [String] stylesheet link tags HTML
-    def stylesheet_link_tag(*sources)
-      default_options =
-        features.turbolinks_enabled ? { 'data-turbolinks-track' => true } : {}
-      options = default_options.merge!(sources.extract_options!.stringify_keys)
-      super(*sources, options)
-    end
-
-    # Override origin method to add turbolinks tracking when it's enabled
-    # @param sources [Array<String>]
-    # @return [String] javascript script tags HTML
-    def javascript_include_tag(*sources)
-      default_options =
-        features.turbolinks_enabled ? { 'data-turbolinks-track' => true, 'data-turbolinks-eval' => false } : {}
-      options = default_options.merge!(sources.extract_options!.stringify_keys)
-      super(*sources, options)
+    # Override original #form_for method to provide default form builder
+    # @param record [ActiveRecord::Base, String, Symbol]
+    # @param options [Hash]
+    def form_for(record, options = {}, &block)
+      options[:builder] ||= FormBuilder
+      super
     end
 
+    # I18n transaltion just for Wallaby
     # @param key
     # @param options [Hash]
+    # @return [String] transaltion for given key
     def wt(key, options = {})
       Locale.t key, { translator: method(:t) }.merge(options)
     end

data/lib/helpers/wallaby/base_helper.rb

@@ -1,24 +1,25 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # NOTE: Global helper methods should go in here
+  # Some basic helper methods
   module BaseHelper
     include StylingHelper
     include LinksHelper
 
-    # @see ModelUtils.to_model_label
     # @return [String] label for given model class
+    # @see Inflector.to_model_label
     def to_model_label(model_class)
-      ModelUtils.to_model_label model_class
+      Inflector.to_model_label(model_class)
     end
 
-    # @see Map.resources_name_map
     # @return [String] resources name for given model class
+    # @see Map.resources_name_map
     def to_resources_name(model_class)
       Map.resources_name_map model_class
     end
 
     # Generate body class from the following sources:
+    #
     # - `:action` parameter
     # - converted current resources name (e.g. `order__item` from `Order::Item`)
     # - `:custom_body_class` content
@@ -32,11 +33,10 @@ module Wallaby
       ].compact.join SPACE
     end
 
-    # Turn a list of classes into tree structure by inheritance.
+    # Turn a list of model classes into an inheritance tree.
     # @param classes [Array<Class>]
-    #   a list of all the classes that wallaby supports
-    # @return [Array<Wallaby::Node>] a tree structure of given classes
-    def model_classes(classes = Map.model_classes)
+    # @return [Array<Node>]
+    def model_classes(classes = wallaby_controller.all_models)
       nested_hash = classes.each_with_object({}) do |klass, hash|
         hash[klass] = Node.new(klass)
       end
@@ -47,11 +47,11 @@ module Wallaby
       nested_hash.values.select { |v| v.parent.nil? }
     end
 
-    # Turn the tree of classes into a nested `ul` list.
-    # @param array [Array<Wallaby::Node>] root classes
+    # Render the HTML for the given model class tree.
+    # @param array [Array<Node>] root classes
     # @return [String] HTML for the whole tree
     def model_tree(array, base_class = nil)
-      return EMPTY_STRING if array.blank?
+      return EMPTY_STRING if array.blank? || current_engine_name.blank?
 
       options = { html_options: { class: 'dropdown-item' } }
       content_tag :ul, class: 'dropdown-menu', 'aria-labelledby': base_class do

data/lib/helpers/wallaby/configuration_helper.rb

@@ -3,16 +3,48 @@
 module Wallaby
   # Configuration helper module. Provide shortcut methods to configurations.
   module ConfigurationHelper
-    delegate :models, :security, :mapping, :pagination, :features, :sorting, to: :configuration
+    delegate :max_text_length, to: :wallaby_controller
 
-    # @return [Wallaby::Configuration] shortcut method of configuration
+    # @return [Configuration] shortcut method of configuration
     def configuration
       Wallaby.configuration
     end
 
-    # @return [Wallaby::Configuration::Metadata] shortcut method of metadata
+    # @deprecated
     def default_metadata
-      configuration.metadata
+      Deprecator.alert 'default_metadata.max', from: '0.3.0', alternative: <<~INSTRUCTION
+        Please use `max_text_length` instead
+      INSTRUCTION
+    end
+
+    # @deprecated
+    def mapping
+      Deprecator.alert method(__callee__), from: '0.3.0'
+    end
+
+    # @deprecated
+    def security
+      Deprecator.alert method(__callee__), from: '0.3.0'
+    end
+
+    # @deprecated
+    def models
+      Deprecator.alert method(__callee__), from: '0.3.0'
+    end
+
+    # @deprecated
+    def pagination
+      Deprecator.alert method(__callee__), from: '0.3.0'
+    end
+
+    # @deprecated
+    def features
+      Deprecator.alert method(__callee__), from: '0.3.0'
+    end
+
+    # @deprecated
+    def sorting
+      Deprecator.alert method(__callee__), from: '0.3.0'
     end
   end
 end

data/lib/helpers/wallaby/form_helper.rb

@@ -13,7 +13,7 @@ module Wallaby
     #   the typed keyword
     # @return [String] URL for autocomplete
     def remote_url(url, model_class, wildcard = 'QUERY')
-      url || index_path(model_class, url_params: { q: wildcard, per: pagination.page_size })
+      url || index_path(model_class, url_params: { q: wildcard, per: wallaby_controller.try(:page_size) })
     end
 
     # To generate dropdown options (class => url) for polymorphic class.

data/lib/helpers/wallaby/index_helper.rb

@@ -34,7 +34,7 @@ module Wallaby
     # @param filter_name [String, Symbol]
     # @param filters [Hash]
     # @return [String] filter name
-    # @see Wallaby::FilterUtils.filter_name_by
+    # @see FilterUtils.filter_name_by
     def filter_name_by(filter_name, filters)
       FilterUtils.filter_name_by filter_name, filters
     end
@@ -45,28 +45,38 @@ module Wallaby
     # @param filters [Hash]
     # @param url_params [Hash, ActionController::Parameters]
     # @return [String] HTML anchor link
-    def filter_link(model_class, filter_name, filters: {}, url_params: {})
+    def filter_link(model_class, filter_name, filters: {}, url_params: {}, html_options: {})
       is_all = filter_name == :all
       config = filters[filter_name] || {}
       label = is_all ? all_label : filter_label(filter_name, filters)
       url_params[:filter] = config[:default] ? nil : filter_name
-      index_link(model_class, options: { url: url_for(url_params.merge(with_query: true)) }) { label }
+
+      index_link(
+        model_class,
+        url_params: url_params.merge(with_query: true), html_options: html_options
+      ) { label }
     end
 
     # @param model_class [Class]
     # @param url_params [Hash, ActionController::Parameters] extra URL params
     # @return [String] Export link for the given model_class.
-    def export_link(model_class, url_params: {})
-      index_link(model_class, url_params: { format: 'csv', page: nil, per: nil, with_query: true }.merge(url_params)) do
+    def export_link(model_class, url_params: {}, html_options: {})
+      index_link(
+        model_class,
+        url_params: url_params.merge(format: 'csv', page: nil, per: nil, with_query: true),
+        html_options: html_options
+      ) do
         wt 'links.export', ext: 'CSV'
       end
     end
 
-    # @return [Wallaby::Sorting::LinkBuilder]
-    # @see Wallaby::Sorting::LinkBuilder
-    def sort_link_builder
+    # @return [Sorting::LinkBuilder]
+    # @see Sorting::LinkBuilder
+    def sort_link_builder(sorting_strategy = wallaby_controller.sorting_strategy)
       @sort_link_builder ||=
-        Sorting::LinkBuilder.new current_model_decorator, params.slice(:sort).permit!, self, sorting.strategy
+        Sorting::LinkBuilder.new(
+          current_model_decorator, params.slice(:sort).permit!, self, sorting_strategy
+        )
     end
   end
 end

data/lib/helpers/wallaby/links_helper.rb

@@ -7,7 +7,7 @@ module Wallaby
     # @param model_class [Class]
     # @param options [Hash]
     # @option options [String] :url url/path for the link
-    # @param url_params [ActionController::Parameters, Hash]
+    # @param url_params [Hash, ActionController::Parameters]
     # @param html_options [Hash] (see
     #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
     #   ActionView::Helpers::UrlHelper#link_to})
@@ -22,7 +22,6 @@ module Wallaby
         block: -> { to_model_label model_class }
       )
 
-      url_params = request.query_parameters.merge(url_params) if url_params.delete(:with_query)
       url = options[:url] || index_path(model_class, url_params: url_params)
       link_to url, html_options, &block
     end
@@ -31,7 +30,7 @@ module Wallaby
     # @param model_class [Class]
     # @param options [Hash]
     # @option options [String] :url url/path for the link
-    # @param url_params [ActionController::Parameters, Hash]
+    # @param url_params [Hash, ActionController::Parameters]
     # @param html_options [Hash] (see
     #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
     #   ActionView::Helpers::UrlHelper#link_to})
@@ -56,8 +55,8 @@ module Wallaby
     # @param options [Hash]
     # @option options [String] :url url/path for the link
     # @option options [Boolean] :readonly readonly and therefore output the label
-    # @option options [Boolean] :is_resource to tell {#show_path} if it is a resource
-    # @param url_params [ActionController::Parameters, Hash]
+    # @option options [Boolean] :is_resource to tell {Urlable#show_path} if it is a resource
+    # @param url_params [Hash, ActionController::Parameters]
     # @param html_options [Hash] (see
     #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
     #   ActionView::Helpers::UrlHelper#link_to})
@@ -73,10 +72,10 @@ module Wallaby
         block: -> { decorate(resource).to_label.to_s }
       )
 
-      default = options[:readonly] && block.call || nil
+      default = (options[:readonly] && block.call) || nil
       return default if unauthorized? :show, extract(resource)
 
-      url = options[:url] || show_path(resource, is_resource: options[:is_resource], url_params: url_params)
+      url = options[:url] || show_path(resource, url_params: url_params)
       link_to url, html_options, &block
     end
 
@@ -85,8 +84,8 @@ module Wallaby
     # @param options [Hash]
     # @option options [String] :url url/path for the link
     # @option options [Boolean] :readonly readonly and therefore output the label
-    # @option options [Boolean] :is_resource to tell {#edit_path} if it is a resource
-    # @param url_params [ActionController::Parameters, Hash]
+    # @option options [Boolean] :is_resource to tell {Urlable#edit_path} if it is a resource
+    # @param url_params [Hash, ActionController::Parameters]
     # @param html_options [Hash] (see
     #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
     #   ActionView::Helpers::UrlHelper#link_to})
@@ -100,10 +99,10 @@ module Wallaby
         block: -> { "#{wt 'links.edit'} #{decorate(resource).to_label}" }
       )
 
-      default = options[:readonly] && block.call || nil
+      default = (options[:readonly] && block.call) || nil
       return default if unauthorized? :edit, extract(resource)
 
-      url = options[:url] || edit_path(resource, is_resource: options[:is_resource], url_params: url_params)
+      url = options[:url] || edit_path(resource, url_params: url_params)
       link_to url, html_options, &block
     end
 
@@ -111,8 +110,8 @@ module Wallaby
     # @param resource [Object, Wallaby::ResourceDecorator] model class
     # @param options [Hash]
     # @option options [String] :url url/path for the link
-    # @option options [Boolean] :is_resource to tell {#edit_path} if it is a resource
-    # @param url_params [ActionController::Parameters, Hash]
+    # @option options [Boolean] :is_resource to tell {Urlable#edit_path} if it is a resource
+    # @param url_params [Hash, ActionController::Parameters]
     # @param html_options [Hash] (see
     #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
     #   ActionView::Helpers::UrlHelper#link_to})
@@ -129,7 +128,7 @@ module Wallaby
       html_options[:method] ||= :delete
       (html_options[:data] ||= {})[:confirm] ||= wt 'links.confirm.delete'
 
-      url = options[:url] || show_path(resource, is_resource: options[:is_resource], url_params: url_params)
+      url = options[:url] || show_path(resource, url_params: url_params)
       link_to url, html_options, &block
     end
 
@@ -143,71 +142,5 @@ module Wallaby
       block ||= -> { wt 'links.cancel' }
       link_to 'javascript:history.back()', html_options, &block
     end
-
-    # @param model_class [Class]
-    # @param url_params [Hash]
-    # @return [String] index page path
-    def index_path(model_class, url_params: {})
-      hash = ParamsUtils.presence(
-        { action: :index },
-        default_path_params(resources: to_resources_name(model_class)),
-        url_params.to_h
-      )
-      current_engine.try(:resources_path, hash) || url_for(hash)
-    end
-
-    # @param model_class [Class]
-    # @param url_params [Hash]
-    # @return [String] new page path
-    def new_path(model_class, url_params: {})
-      hash = ParamsUtils.presence(
-        { action: :new },
-        default_path_params(resources: to_resources_name(model_class)),
-        url_params.to_h
-      )
-      current_engine.try(:new_resource_path, hash) || url_for(hash)
-    end
-
-    # @param resource [Object]
-    # @param is_resource [Boolean]
-    # @param url_params [Hash]
-    # @return [String] show page path
-    def show_path(resource, is_resource: false, url_params: {})
-      decorated = decorate resource
-      return unless is_resource || decorated.primary_key_value
-
-      hash = ParamsUtils.presence(
-        { action: :show, id: decorated.primary_key_value },
-        default_path_params(resources: decorated.resources_name),
-        url_params.to_h
-      )
-
-      current_engine.try(:resource_path, hash) || url_for(hash)
-    end
-
-    # @param resource [Object]
-    # @param is_resource [Boolean]
-    # @param url_params [Hash]
-    # @return [String] edit page path
-    def edit_path(resource, is_resource: false, url_params: {})
-      decorated = decorate resource
-      return unless is_resource || decorated.primary_key_value
-
-      hash = ParamsUtils.presence(
-        { action: :edit, id: decorated.primary_key_value },
-        default_path_params(resources: decorated.resources_name),
-        url_params.to_h
-      )
-
-      current_engine.try(:edit_resource_path, hash) || url_for(hash)
-    end
-
-    # @return [Hash] default path params
-    def default_path_params(resources: nil)
-      { script_name: request.env[SCRIPT_NAME] }.tap do |default|
-        default[:resources] = resources if current_engine || resources
-        default[:only_path] = true unless default.key?(:only_path)
-      end
-    end
   end
 end

data/lib/helpers/wallaby/resources_helper.rb

@@ -16,18 +16,50 @@ module Wallaby
     include Resourcable
     include Servicable
 
-    # Render type cell/partial
-    # @param partial_name [String]
-    # @param locals [Hash]
-    def type_render(partial_name = '', locals = {}, &block)
-      TypeRenderer.render self, partial_name, locals, &block
+    # @deprecated
+    def type_render(_partial_name = '', _locals = {})
+      Deprecator.alert method(__callee__), from: '0.3.0', alternative: <<~INSTRUCTION
+        If it's for index type partils, please follow below example:
+
+          render(
+            field_name,
+            object: decorated,
+            field_name: field_name,
+            value: decorated.try(field_name),
+            metadata: decorated.index_metadata_of(field_name)
+          )
+
+        If it's for show type partils, please follow below example:
+
+          render(
+            field_name,
+            object: decorated,
+            field_name: field_name,
+            value: decorated.try(field_name),
+            metadata: decorated.show_metadata_of(field_name)
+          )
+
+        If it's for new/create/edit/update/destroy type partils, please follow below example:
+
+          render(
+            field_name,
+            form: form,
+            object: decorated,
+            field_name: field_name,
+            value: decorated.try(field_name),
+            metadata: decorated.form_metadata_of(field_name)
+          )
+
+      INSTRUCTION
     end
 
     # Title for show page of given resource
-    # @param decorated [Wallaby::ResourceDecorator]
+    # @param decorated [ResourceDecorator]
     # @return [String]
     def show_title(decorated)
-      raise ::ArgumentError unless decorated.is_a? ResourceDecorator
+      unless decorated.is_a? ResourceDecorator
+        raise ::ArgumentError, 'Please provide a resource wrapped by a decorator.'
+      end
 
       [
         to_model_label(decorated.model_class), decorated.to_label

data/lib/helpers/wallaby/secure_helper.rb

@@ -8,42 +8,43 @@ module Wallaby
     # - if email is present, a gravatar image tag will be returned
     # - otherwise, an user icon will be returned
     # @param user [Object]
+    # @param method_name [Symbol, String]
     # @return [String] IMG or I element
-    def user_portrait(user = wallaby_user)
-      email_method = security.email_method || :email
-      email = try_to user, email_method
-      if email.present?
-        https = "http#{request.ssl? ? 's' : EMPTY_STRING}"
-        email_md5 = ::Digest::MD5.hexdigest email.downcase
-        image_source = "#{https}://www.gravatar.com/avatar/#{email_md5}"
-        image_tag image_source, class: 'user'
-      else
-        fa_icon 'user'
-      end
+    def user_portrait(user: wallaby_user, method_name: wallaby_controller.email_method)
+      method_name ||= user.methods.grep(/email/i).min || :email
+      email = user.try method_name
+      return fa_icon 'user' if email.blank?
+
+      image_tag(
+        "#{request.protocol}www.gravatar.com/avatar/#{::Digest::MD5.hexdigest email.downcase}", # rubocop:disable Fips/MD5
+        class: 'user'
+      )
     end
 
     # Logout path for given user
-    # @see Wallaby::Configuration::Security#logout_path
+    # @see Configuration::Security#logout_path
     # @param user [Object]
     # @param app [Object]
+    # @param method_name [Symbol, String]
     # @return [String] URL to log out
-    def logout_path(user = wallaby_user, app = main_app)
-      path = security.logout_path
-      path ||=
+    def logout_path(user: wallaby_user, app: main_app, method_name: wallaby_controller.logout_path)
+      method_name ||=
         if defined? ::Devise
           scope = ::Devise::Mapping.find_scope! user
           "destroy_#{scope}_session_path"
         end
-      try_to app, path
+
+      app.try method_name if method_name
     end
 
     # Logout method for given user
-    # @see Wallaby::Configuration::Security#logout_method
+    # @see Configuration::Security#logout_method
     # @param user [Object]
+    # @param http_method [Symbol, String]
     # @return [String, Symbol] http method to log out
-    def logout_method(user = wallaby_user)
-      http_method = security.logout_method
+    def logout_method(user: wallaby_user, http_method: wallaby_controller.logout_method)
       http_method ||
+
         if defined? ::Devise
           scope = ::Devise::Mapping.find_scope! user
           mapping = ::Devise.mappings[scope]