wallaby-core 0.1.0

data/lib/helpers/wallaby/application_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Wallaby application helper
+  module ApplicationHelper
+    include ConfigurationHelper
+    include Engineable
+    include SharedHelpers
+
+    # @!method try_to(subject, method_id, *args, &block)
+    #   (see Wallaby::ModuleUtils.try_to)
+    #   @see Wallaby::ModuleUtils.try_to
+    delegate :try_to, to: ModuleUtils
+
+    # Override the origin view_renderer to support {Wallaby::Cell} rendering
+    # @!attribute [r] view_renderer
+    #   @see Wallaby::CustomRenderer
+    def view_renderer
+      return @view_renderer if @view_renderer.is_a? CustomRenderer
+
+      @view_renderer = CustomRenderer.new @view_renderer.lookup_context
+    end
+
+    # 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)
+    end
+  end
+end

data/lib/helpers/wallaby/base_helper.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # NOTE: Global helper methods should go in here
+  module BaseHelper
+    include StylingHelper
+    include LinksHelper
+
+    # @see ModelUtils.to_model_label
+    # @return [String] label for given model class
+    def to_model_label(model_class)
+      ModelUtils.to_model_label model_class
+    end
+
+    # @see Map.resources_name_map
+    # @return [String] resources name for given model class
+    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
+    # @return [String] css classes for body tag
+    def body_class
+      [
+        params[:action],
+        controller_path.gsub(SLASH, '__'),
+        current_resources_name.try(:gsub, COLONS, '__'),
+        content_for(:custom_body_class)
+      ].compact.join SPACE
+    end
+
+    # Turn a list of classes into tree structure by inheritance.
+    # @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)
+      nested_hash = classes.each_with_object({}) do |klass, hash|
+        hash[klass] = Node.new(klass)
+      end
+      nested_hash.each do |klass, node|
+        node.parent = parent = nested_hash[klass.superclass]
+        parent.children << node if parent
+      end
+      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
+    # @return [String] HTML for the whole tree
+    def model_tree(array, base_class = nil)
+      return EMPTY_STRING if array.blank?
+
+      options = { html_options: { class: 'dropdown-item' } }
+      content_tag :ul, class: 'dropdown-menu', 'aria-labelledby': base_class do
+        array.sort_by(&:name).each do |node|
+          content = index_link(node.klass, options).try :<<, model_tree(node.children)
+          concat content_tag(:li, content)
+        end
+      end
+    end
+  end
+end

data/lib/helpers/wallaby/configuration_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Configuration helper module. Provide shortcut methods to configurations.
+  module ConfigurationHelper
+    delegate :models, :security, :mapping, :pagination, :features, :sorting, to: :configuration
+
+    # @return [Wallaby::Configuration] shortcut method of configuration
+    def configuration
+      Wallaby.configuration
+    end
+
+    # @return [Wallaby::Configuration::Metadata] shortcut method of metadata
+    def default_metadata
+      configuration.metadata
+    end
+  end
+end

data/lib/helpers/wallaby/form_helper.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Form helper
+  module FormHelper
+    # @deprecated Use {Wallaby::ResourcesHelper#type_render} instead. It will be removed from 5.3.*
+    def form_type_partial_render(options = {}, locals = {}, &block)
+      Utils.deprecate 'deprecation.form_type_partial_render', caller: caller
+      type_render options, locals, &block
+    end
+
+    # To generate remote URL for auto select plugin.
+    # @see https://github.com/reinteractive/wallaby/blob/master/app/assets/javascripts/wallaby/auto_select.js
+    #   auto_select.js
+    # @param url [String, nil]
+    #   if URL is nil, it will fall back to default remote URL
+    # @param model_class [Class]
+    # @param wildcard [String] wildcard that auto_select uses to replace with
+    #   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 })
+    end
+
+    # To generate dropdown options (class => url) for polymorphic class.
+    # @see https://github.com/reinteractive/wallaby/blob/master/app/assets/javascripts/wallaby/auto_select.js
+    #   auto_select.js
+    # This function will pull out remote URLs from `metadata[:remote_urls]`
+    # (Class => url).
+    # @see ActionView::Helpers::FormOptionsHelper#options_for_select
+    # @param metadata [Hash]
+    # @param wildcard [String] wildcard to be used in the URL
+    # @param select_options [Hash]
+    # @return [String] options HTML
+    def polymorphic_options(metadata, wildcard = 'QUERY', select_options = {})
+      urls = metadata[:remote_urls] || {}
+      options = (metadata[:polymorphic_list] || []).map do |klass|
+        [
+          klass, klass,
+          { data: { url: remote_url(urls[klass], klass, wildcard) } }
+        ]
+      end
+      options_for_select options, select_options
+    end
+
+    # To fetch the hints from the following keys:
+    # - hints.#\{ type \}_html
+    # - hints.#\{ type \}
+    # @param metadata [Hash]
+    # @return [String, nil] HTML
+    def hint_of(metadata)
+      type = metadata[:type]
+      hint = metadata[:hint]
+      # @see http://guides.rubyonrails.org/i18n.html#using-safe-html-translations
+      hint ||= type && t("hints.#{type}_html", default: '').presence
+      hint ||= type && t("hints.#{type}", default: '').presence
+      return unless hint
+
+      content_tag :p, hint, class: 'help-block'
+    end
+  end
+end

data/lib/helpers/wallaby/index_helper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Helper methods for index action
+  module IndexHelper
+    # @deprecated This method is no longer in use. It will be removed from 5.3.*
+    def index_params(parameters = params)
+      Utils.deprecate 'deprecation.index_params', caller: caller
+      parameters
+    end
+
+    # @deprecated Use {Wallaby::Paginatable#current_paginator} instead. It will be removed from 5.3.*
+    def paginator_of(_model_class, _collection, _params)
+      Utils.deprecate 'deprecation.paginator_of', caller: caller
+      current_paginator
+    end
+
+    # Just a label
+    # @return [String]
+    def all_label
+      t 'filters.all'
+    end
+
+    # If `:fields` parameter is given, only display fields that is in `index_field_names`
+    # Otherwise, `index_field_names`
+    # @param decorated_collection [Array<Wallaby::ResourceDecorator>]
+    # @param fields_from_params [Array<String>]
+    # @return [Array<String>] a list of field names for json builder
+    def json_fields_of(decorated_collection, fields_from_params = params[:fields])
+      return [] if decorated_collection.blank?
+
+      decorated = decorated_collection.first
+      index_field_names = decorated.index_field_names.map(&:to_s)
+      fields = (fields_from_params.presence || index_field_names).split(/\s*,\s*/).flatten
+      fields & index_field_names
+    end
+
+    # @param filter_name [String, Symbol]
+    # @param filters [Hash]
+    # @return [String] filter label for the given field name
+    def filter_label(filter_name, filters)
+      # TODO: use locale for filter_name label
+      filters[filter_name].try(:[], :label) || filter_name.to_s.humanize
+    end
+
+    # @param filter_name [String, Symbol]
+    # @param filters [Hash]
+    # @return [String] filter name
+    # @see Wallaby::FilterUtils.filter_name_by
+    def filter_name_by(filter_name, filters)
+      FilterUtils.filter_name_by filter_name, filters
+    end
+
+    # Link for a given model class and filter name
+    # @param model_class [Class]
+    # @param filter_name [String, Symbol]
+    # @param filters [Hash]
+    # @param url_params [Hash, ActionController::Parameters]
+    # @return [String] HTML anchor link
+    def filter_link(model_class, filter_name, filters: {}, url_params: {})
+      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 }
+    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
+        t 'links.export', ext: 'CSV'
+      end
+    end
+
+    # @return [Wallaby::Sorting::LinkBuilder]
+    # @see Wallaby::Sorting::LinkBuilder
+    def sort_link_builder
+      @sort_link_builder ||=
+        Sorting::LinkBuilder.new current_model_decorator, params.slice(:sort).permit!, self, sorting.strategy
+    end
+  end
+end

data/lib/helpers/wallaby/links_helper.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Links helper
+  module LinksHelper
+    # Return link to index page for a given model class
+    # @param model_class [Class]
+    # @param options [Hash]
+    # @option options [String] :url url/path for the link
+    # @param url_params [ActionController::Parameters, Hash]
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String] anchor link to index page for a given model class
+    # @return [nil] if user's not authorized
+    def index_link(model_class, options: {}, url_params: {}, html_options: {}, &block)
+      return if unauthorized? :index, model_class
+
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        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
+
+    # Return link to create page for a given model class
+    # @param model_class [Class]
+    # @param options [Hash]
+    # @option options [String] :url url/path for the link
+    # @param url_params [ActionController::Parameters, Hash]
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String, nil] anchor element
+    # @return [nil] if user's not authorized
+    def new_link(model_class, options: {}, url_params: {}, html_options: {}, &block)
+      return if unauthorized? :new, model_class
+
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        class: 'resource__create',
+        block: -> { t 'links.new', model: to_model_label(model_class) }
+      )
+
+      url = options[:url] || new_path(model_class, url_params: url_params)
+      link_to url, html_options, &block
+    end
+
+    # Return link to show page for a given model class.
+    # @param resource [Object, Wallaby::ResourceDecorator] model class
+    # @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]
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String] anchor element / text
+    # @return [nil] if user's not authorized
+    def show_link(resource, options: {}, url_params: {}, html_options: {}, &block)
+      # NOTE: to_s is a must
+      # if a block is returning integer (e.g. `{ 1 }`)
+      # `link_to` will render blank text note inside hyper link
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        block: -> { decorate(resource).to_label.to_s }
+      )
+
+      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)
+      link_to url, html_options, &block
+    end
+
+    # Return link to edit page for a given model class.
+    # @param resource [Object, Wallaby::ResourceDecorator] model class
+    # @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]
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String] anchor element / text
+    # @return [nil] if user's not authorized
+    def edit_link(resource, options: {}, url_params: {}, html_options: {}, &block)
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        class: 'resource__update',
+        block: -> { "#{t 'links.edit'} #{decorate(resource).to_label}" }
+      )
+
+      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)
+      link_to url, html_options, &block
+    end
+
+    # Return link to delete action for a given model class.
+    # @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]
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String, nil] anchor element
+    # @return [nil] if user's not authorized
+    def delete_link(resource, options: {}, url_params: {}, html_options: {}, &block)
+      return if unauthorized? :destroy, extract(resource)
+
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block, class: 'resource__destroy', block: -> { t 'links.delete' }
+      )
+
+      html_options[:method] ||= :delete
+      (html_options[:data] ||= {})[:confirm] ||= t 'links.confirm.delete'
+
+      url = options[:url] || show_path(resource, is_resource: options[:is_resource], url_params: url_params)
+      link_to url, html_options, &block
+    end
+
+    # Return link to cancel action
+    # @param html_options [Hash] (see
+    #   {https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to
+    #   ActionView::Helpers::UrlHelper#link_to})
+    # @yield block to return the link label
+    # @return [String] anchor link of cancel action
+    def cancel_link(html_options: {}, &block)
+      block ||= -> { t '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