wallaby-core 0.1.2 → 0.2.3

data/lib/helpers/wallaby/application_helper.rb

@@ -12,15 +12,6 @@ module Wallaby
     #   @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
@@ -75,5 +66,11 @@ module Wallaby
       options = default_options.merge!(sources.extract_options!.stringify_keys)
       super(*sources, options)
     end
+
+    # @param key
+    # @param options [Hash]
+    def wt(key, options = {})
+      Locale.t key, { translator: method(:t) }.merge(options)
+    end
   end
 end

data/lib/helpers/wallaby/form_helper.rb

@@ -3,12 +3,6 @@
 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
@@ -52,9 +46,8 @@ module Wallaby
       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
+      hint ||= type && wt("hints.#{type}_html", default: [:"hints.#{type}", ''])
+      return if hint.blank?
 
       content_tag :p, hint, class: 'help-block'
     end

data/lib/helpers/wallaby/index_helper.rb

@@ -3,22 +3,10 @@
 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'
+      wt 'filters.all'
     end
 
     # If `:fields` parameter is given, only display fields that is in `index_field_names`
@@ -70,7 +58,7 @@ module Wallaby
     # @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'
+        wt 'links.export', ext: 'CSV'
       end
     end
 

data/lib/helpers/wallaby/links_helper.rb

@@ -44,7 +44,7 @@ module Wallaby
       html_options, block = LinkOptionsNormalizer.normalize(
         html_options, block,
         class: 'resource__create',
-        block: -> { t 'links.new', model: to_model_label(model_class) }
+        block: -> { wt 'links.new', model: to_model_label(model_class) }
       )
 
       url = options[:url] || new_path(model_class, url_params: url_params)
@@ -97,7 +97,7 @@ module Wallaby
       html_options, block = LinkOptionsNormalizer.normalize(
         html_options, block,
         class: 'resource__update',
-        block: -> { "#{t 'links.edit'} #{decorate(resource).to_label}" }
+        block: -> { "#{wt 'links.edit'} #{decorate(resource).to_label}" }
       )
 
       default = options[:readonly] && block.call || nil
@@ -123,11 +123,11 @@ module Wallaby
       return if unauthorized? :destroy, extract(resource)
 
       html_options, block = LinkOptionsNormalizer.normalize(
-        html_options, block, class: 'resource__destroy', block: -> { t 'links.delete' }
+        html_options, block, class: 'resource__destroy', block: -> { wt 'links.delete' }
       )
 
       html_options[:method] ||= :delete
-      (html_options[:data] ||= {})[:confirm] ||= t 'links.confirm.delete'
+      (html_options[:data] ||= {})[:confirm] ||= wt 'links.confirm.delete'
 
       url = options[:url] || show_path(resource, is_resource: options[:is_resource], url_params: url_params)
       link_to url, html_options, &block
@@ -140,7 +140,7 @@ module Wallaby
     # @yield block to return the link label
     # @return [String] anchor link of cancel action
     def cancel_link(html_options: {}, &block)
-      block ||= -> { t 'links.cancel' }
+      block ||= -> { wt 'links.cancel' }
       link_to 'javascript:history.back()', html_options, &block
     end
 

data/lib/helpers/wallaby/resources_helper.rb

@@ -3,6 +3,9 @@
 module Wallaby
   # Resources helper
   module ResourcesHelper
+    include ApplicationHelper
+    include SecureHelper
+
     include BaseHelper
     include FormHelper
     include IndexHelper
@@ -12,13 +15,6 @@ module Wallaby
     include Paginatable
     include Resourcable
     include Servicable
-    include Themeable
-
-    # @deprecated Use {#type_render} instead. It will be removed from 5.3.*
-    def type_partial_render(options = {}, locals = {}, &block)
-      Utils.deprecate 'deprecation.type_partial_render', caller: caller
-      type_render options, locals, &block
-    end
 
     # Render type cell/partial
     # @param partial_name [String]

data/lib/helpers/wallaby/secure_helper.rb

@@ -9,7 +9,7 @@ module Wallaby
     # - otherwise, an user icon will be returned
     # @param user [Object]
     # @return [String] IMG or I element
-    def user_portrait(user = current_user)
+    def user_portrait(user = wallaby_user)
       email_method = security.email_method || :email
       email = try_to user, email_method
       if email.present?
@@ -27,7 +27,7 @@ module Wallaby
     # @param user [Object]
     # @param app [Object]
     # @return [String] URL to log out
-    def logout_path(user = current_user, app = main_app)
+    def logout_path(user = wallaby_user, app = main_app)
       path = security.logout_path
       path ||=
         if defined? ::Devise
@@ -41,7 +41,7 @@ module Wallaby
     # @see Wallaby::Configuration::Security#logout_method
     # @param user [Object]
     # @return [String, Symbol] http method to log out
-    def logout_method(user = current_user)
+    def logout_method(user = wallaby_user)
       http_method = security.logout_method
       http_method ||
         if defined? ::Devise

data/lib/helpers/wallaby/styling_helper.rb

@@ -3,6 +3,20 @@
 module Wallaby
   # Helper methods to build custom elements
   module StylingHelper
+    # backforward compatible with FontAwesome 4
+    # @see this fa migration document https://fontawesome.com/how-to-use/on-the-web/setup/upgrading-from-version-4
+    FONT_AWESOME_MAPPING = {
+      4 => {
+        clock: 'clock-o',
+        bars: 'navicon',
+        calendar: 'calendar-o',
+        'check-square': 'check-square-o',
+        square: 'square-o',
+        link: 'chain',
+        user: 'user-o'
+      }
+    }.with_indifferent_access.freeze
+
     # Shortcut to build up the HTML options as keyword arguments
     # @param string_or_array [String, Array<String>]
     # @param options [Hash]
@@ -54,12 +68,12 @@ module Wallaby
 
     # @return [String] grey null
     def null
-      muted t 'labels.empty'
+      muted wt 'labels.empty'
     end
 
     # @return [String] grey N/A
     def na
-      muted t 'labels.na'
+      muted wt 'labels.na'
     end
 
     # Grey text
@@ -74,7 +88,7 @@ module Wallaby
     def fa_map(name, major = nil)
       @map ||= begin
         major ||= Gem.loaded_specs['font-awesome-sass'].try(:version).try(:segments).try(:first)
-        t("fa.v#{major}").with_indifferent_access
+        FONT_AWESOME_MAPPING[major] || {}
       end
       @map[name] || name
     end

data/lib/interfaces/wallaby/mode.rb

@@ -24,14 +24,14 @@ module Wallaby
 
       # @see Wallaby::ModelPaginationProvider
       # @return [Class] pagination provider for the mode
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def model_pagination_provider
         check_and_constantize __callee__
       end
 
       # @see Wallaby::ModelPaginationProvider
       # @return [Class] pagination provider for the mode
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def default_authorization_provider
         check_and_constantize __callee__
       end
@@ -39,7 +39,7 @@ module Wallaby
       # Return a list of authorization providers for authorizer to detect which one to use.
       # @see Wallaby::ModelAuthorizationProvider
       # @return [ActiveSupport::HashWithIndifferentAccess<String, Class>] authorization provider hash
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def model_authorization_providers(classes = ModelAuthorizationProvider.descendants)
         # NOTE: make sure default provider always comes last
         @model_authorization_providers ||=
@@ -61,10 +61,10 @@ module Wallaby
         class_name.constantize.tap do |klass|
           next if klass < parent_class
 
-          raise InvalidError, I18n.t('wallaby.mode.inherit_required', klass: klass, parent: parent_class)
+          raise InvalidError, Locale.t('mode.inherit_required', klass: klass, parent: parent_class)
         end
       rescue NameError => e
-        Rails.logger.error e
+        Logger.error e
         raise NotImplemented, class_name
       end
     end

data/lib/interfaces/wallaby/model_authorization_provider.rb

@@ -2,7 +2,7 @@
 
 module Wallaby
   # Model Authorizer interface.
-  # @since 5.2.0
+  # @since wallaby-5.2.0
   class ModelAuthorizationProvider
     class << self
       # @!attribute [w] provider_name
@@ -13,34 +13,36 @@ module Wallaby
       # @see Wallaby::ModelAuthorizer.provider_name
       # @return [String/Symbol] provider name
       def provider_name
-        @provider_name || name.demodulize.gsub(/(Authorization)?Provider/, EMPTY_STRING).underscore
+        @provider_name ||= name.demodulize.gsub(/(Authorization)?Provider/, EMPTY_STRING).underscore
       end
 
       # @note Template method to check and see if current provider is in used.
-      # @param _context [ActionController::Base]
+      # @param _context [ActionController::Base, ActionView::Base]
       # @raise [Wallaby::NotImplemented]
       def available?(_context)
         raise NotImplemented
       end
-
-      # @note Template method to pull out the args required for contruction from context.
-      # @param _context [ActionController::Base]
-      # @raise [Wallaby::NotImplemented]
-      def args_from(_context)
-        raise NotImplemented
-      end
     end
 
     # @!attribute [r] context
-    # @return [ActionController::Base]
+    # @return [ActionController::Base, ActionView::Base]
     attr_reader :context
 
     # @!attribute [r] user
     # @return [Object]
     attr_reader :user
 
-    # Empty initialize that accepts all sorts of args
-    def initialize(*); end
+    # @!attribute [r] options
+    # @return [Hash]
+    attr_reader :options
+
+    # @param context [ActionController::Base, ActionView::Base]
+    # @param options [Hash]
+    def initialize(context, **options)
+      @context = context
+      @options = options
+      @user = context.try :wallaby_user
+    end
 
     # @note It can be overridden in subclasses for customization purpose.
     # This is the template method to check user's permission for given action on given subject.

data/lib/interfaces/wallaby/model_decorator.rb

@@ -157,12 +157,24 @@ module Wallaby
       field_names.unshift(primary_key.to_s).uniq
     end
 
-    # Validate presence of a type for given field name
+    # Ensure the type is present for given field name
     # @param type [String, Symbol, nil]
     # @return [String, Symbol] type
     # @raise [ArgumentError] when type is nil
-    def validate_presence_of(field_name, type)
-      type || raise(::ArgumentError, I18n.t('errors.invalid.type_required', field_name: field_name))
+    def ensure_type_is_present(field_name, type, metadata_prefix = '')
+      type || raise(::ArgumentError, <<~INSTRUCTION
+        The type for field `#{field_name}` is missing in metadata `#{metadata_prefix}_fields`.
+        The possible causes are:
+
+        1. Check type's value from metadata `#{metadata_prefix}_fields[:#{field_name}][:type]`.
+          If it is missing, specify the type as below:
+
+          #{metadata_prefix}field_name[:#{field_name}][:type] = 'string'
+
+        2. If metadata `#{metadata_prefix}_fields` is blank, maybe table hasn't be created yet
+          or there is some error in the decorator class declaration.
+      INSTRUCTION
+      )
     end
   end
 end

data/lib/paginators/wallaby/model_paginator.rb

@@ -1,72 +1,39 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Model paginator to provide support for pagination on index page
+  # This is the base paginator class to provider pagination for given collection.
+  #
+  # For best practice, please create an application paginator class (see example)
+  # to better control the functions shared between different model paginators.
+  # @example Create an application class for Admin Interface usage
+  #   class Admin::ApplicationPaginator < Wallaby::ModelPaginator
+  #     base_class!
+  #   end
   class ModelPaginator
     extend Baseable::ClassMethods
-
-    class << self
-      # @!attribute [w] model_class
-      attr_writer :model_class
-
-      # @!attribute [r] model_class
-      # Return associated model class, e.g. return **Product** for **ProductPaginator**.
-      #
-      # If Wallaby can't recognise the model class for Paginator, it's required to be configured as below example:
-      # @example To configure model class
-      #   class Admin::ProductPaginator < Admin::ApplicationPaginator
-      #     self.model_class = Product
-      #   end
-      # @example To configure model class for version below 5.2.0
-      #   class Admin::ProductPaginator < Admin::ApplicationPaginator
-      #     def self.model_class
-      #       Product
-      #     end
-      #   end
-      # @return [Class] assoicated model class
-      # @return [nil] if current class is marked as base class
-      # @return [nil] if current class is the same as the value of {Wallaby::Configuration::Mapping#model_paginator}
-      # @return [nil] if current class is {Wallaby::ModelPaginator}
-      # @return [nil] if assoicated model class is not found
-      def model_class
-        return unless self < ModelPaginator
-        return if base_class? || self == Wallaby.configuration.mapping.model_paginator
-
-        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Paginator$)/, EMPTY_STRING))
-      end
-
-      # @!attribute provider_class
-      # @return [Class] pagination provider class
-      # @since 5.2.0
-      attr_accessor :provider_class
-    end
+    base_class!
 
     # @!attribute [r] model_class
     # @return [Class]
     attr_reader :model_class
 
     # @!attribute [r] provider
-    # @return [Wallaby::ModelServiceProvider]
-    # @since 5.2.0
+    # @return [Wallaby::ModelPaginationProvider] the instance that does the job
+    # @since wallaby-5.2.0
     attr_reader :provider
 
-    # During initialization, Wallaby will assign a pagination provider for this paginator
-    # to carry out the actual execution.
-    #
-    # Therefore, all its actions can be completely replaced by user's own implemnetation.
     # @param model_class [Class]
     # @param collection [#to_a] a collection of the resources
     # @param params [ActionController::Parameters]
     def initialize(model_class, collection, params)
       @model_class = self.class.model_class || model_class
-      raise ArgumentError, I18n.t('errors.required', subject: 'model_class') unless @model_class
+      raise ArgumentError, 'Please provide a `model_class`.' unless @model_class
 
       @collection = collection
       @params = params
       @provider = Map.pagination_provider_map(@model_class).new(@collection, @params)
     end
 
-    delegate(*ModelPaginationProvider.instance_methods(false), to: :provider)
     # @!method paginatable?
     #   (see Wallaby::ModelPaginationProvider#paginatable?)
 
@@ -111,5 +78,7 @@ module Wallaby
 
     # @!method number_of_pages
     #   (see Wallaby::ModelPaginationProvider#number_of_pages)
+
+    delegate(*ModelPaginationProvider.instance_methods(false), to: :provider)
   end
 end

data/lib/parsers/wallaby/parser.rb

@@ -1,34 +1,69 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # a parser to handle colon query
+  # A parser to parse colon query string and return a hash for transformer
+  # to consume
   class Parser < Parslet::Parser
+    # @!method parse(str)
+    # Parse string into Abstract Syntax Tree for transformer to consume
+    # @param str [String]
+    # @return [Hash] Abstract Syntax Tree
+
+    # Case insensitive string match
+    # @param str [String]
+    def stri(str)
+      str.chars.map! { |c| match["#{c.upcase}#{c.downcase}"] }.reduce :>>
+    end
+
     root(:statement)
-    rule(:statement) { expression >> (space >> expression).repeat }
-    rule(:expression) { colon_query | general_keyword }
+    rule(:statement) { expression >> (spaces >> expression).repeat }
+    rule(:expression) { colon_query | quoted_string | string | any.repeat(0).as(:null) }
     rule(:colon_query) do
-      name.as(:left) >> operator.as(:op) >> keywords.as(:right)
+      name.as(:left) >> operator.as(:op) >> values.as(:right)
+    end
+
+    # colon query
+    begin
+      # name starts with letter
+      rule(:name) { letter >> ((colon | spaces).absent? >> any).repeat }
+
+      # operator starts with colon
+      rule(:operator) do
+        colon >> (
+          (colon | spaces | quote | comma | digit | letter).absent? >> any
+        ).repeat(0, 3)
+      end
+
+      # values separated by comma
+      rule(:values) { value >> (comma >> value).repeat }
+      rule(:value) { quoted_string | data }
+      rule(:data) do
+        null.as(:null) | boolean.as(:boolean) |
+          (spaces.absent? >> comma.absent? >> any).repeat.as(:string)
+      end
     end
-    rule(:name) { (space.absent? >> colon.absent? >> any).repeat(1) }
-    rule(:operator) { colon >> match('[^\s\'\"\:\,0-9a-zA-Z]').repeat(0, 3) }
-    rule(:keywords) { general_keyword >> (comma >> general_keyword).repeat }
-    rule(:general_keyword) { quoted_keyword | keyword }
 
     # basic elements
-    rule(:quoted_keyword) do
+    rule(:quoted_string) do
       open_quote >>
-        (close_quote.absent? >> any).repeat.as(:keyword) >>
+        (close_quote.absent? >> any).repeat.as(:string) >>
         close_quote
     end
-    rule(:keyword) { ((space | comma).absent? >> any).repeat.as(:keyword) }
+    rule(:string) { (spaces.absent? >> any).repeat(1).as(:string) }
 
     # atomic entities
+    rule(:null) { stri('nil') | stri('null') }
+    rule(:boolean) { stri('true') | stri('false') }
+    rule(:letter) { match['a-zA-Z'] }
+    rule(:digit) { match['0-9'] }
+    rule(:dot) { str('.') }
     rule(:comma) { str(',') }
-    rule(:space) { match('\s').repeat(1) }
+    rule(:spaces) { match['\s'].repeat(1) }
     rule(:colon) { str(':') }
+    rule(:quote) { match['\'\"'] }
 
     # open-close elements
-    rule(:open_quote) { match('[\'\"]').capture(:quote) }
-    rule(:close_quote) { dynamic { |_src, ctx| str(ctx.captures[:quote]) } }
+    rule(:open_quote) { quote.capture(:quoting) }
+    rule(:close_quote) { dynamic { |_src, ctx| str(ctx.captures[:quoting]) } }
   end
 end

data/lib/routes/wallaby/resources_router.rb

@@ -53,7 +53,7 @@ module Wallaby
       return model_class unless MODEL_ACTIONS.include? params[:action].to_sym
       raise ModelNotFound, params[:resources] unless model_class
       unless Map.mode_map[model_class]
-        raise UnprocessableEntity, I18n.t('errors.unprocessable_entity.model', model: model_class)
+        raise UnprocessableEntity, Locale.t('errors.unprocessable_entity.model', model: model_class)
       end
 
       model_class