wallaby-core 0.2.0 → 0.2.4

data/lib/helpers/wallaby/index_helper.rb

@@ -6,7 +6,7 @@ module Wallaby
     # 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`
@@ -58,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

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/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

data/lib/servicers/wallaby/model_servicer.rb

@@ -1,45 +1,19 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Model servicer contains resourceful operations for Rails resourceful actions.
+  # This is the base servicer class to provider data source related operations
+  # for given/associated model. In general, it works together with {#authorizer}
+  # to ensure that all operations are legitmate.
+  #
+  # For best practice, please create an application servicer class (see example)
+  # to better control the functions shared between different model servicers.
+  # @example Create an application class for Admin Interface usage
+  #   class Admin::ApplicationServicer < Wallaby::ModelServicer
+  #     base_class!
+  #   end
   class ModelServicer
     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 **ProductServicer**.
-      #
-      # If Wallaby can't recognise the model class for Servicer, it's required to be configured as below example:
-      # @example To configure model class
-      #   class Admin::ProductServicer < Admin::ApplicationServicer
-      #     self.model_class = Product
-      #   end
-      # @example To configure model class for version below 5.2.0
-      #   class Admin::ProductServicer < Admin::ApplicationServicer
-      #     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_servicer}
-      # @return [nil] if current class is {Wallaby::ModelServicer}
-      # @return [nil] if assoicated model class is not found
-      def model_class
-        return unless self < ModelServicer
-        return if base_class? || self == Wallaby.configuration.mapping.model_servicer
-
-        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Servicer$)/, EMPTY_STRING))
-      end
-
-      # @!attribute provider_class
-      # @return [Class] service provider class
-      # @since 5.2.0
-      attr_accessor :provider_class
-    end
+    base_class!
 
     # @!attribute [r] model_class
     # @return [Class]
@@ -47,46 +21,41 @@ module Wallaby
 
     # @!attribute [r] model_decorator
     # @return [Wallaby::ModelDecorator]
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     attr_reader :model_decorator
 
     # @!attribute [r] authorizer
     # @return [Wallaby::ModelAuthorizer]
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     attr_reader :authorizer
 
     # @!attribute [r] provider
-    # @return [Wallaby::ModelServiceProvider]
-    # @since 5.2.0
+    # @return [Wallaby::ModelServiceProvider] the instance that does the job
+    # @since wallaby-5.2.0
     attr_reader :provider
 
     # @!method user
     # @return [Object]
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     delegate :user, to: :authorizer
 
-    # During initialization, Wallaby will assign a service provider for this servicer
-    # to carry out the actual execution.
-    #
-    # Therefore, all its actions can be completely replaced by user's own implemnetation.
     # @param model_class [Class]
     # @param authorizer [Wallaby::ModelAuthorizer]
     # @param model_decorator [Wallaby::ModelDecorator]
-    # @raise [ArgumentError] if param model_class is blank
+    # @raise [ArgumentError] if model_class is blank
     def initialize(model_class, authorizer, model_decorator = nil)
       @model_class = model_class || self.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
 
       @model_decorator = model_decorator || Map.model_decorator_map(model_class)
       @authorizer = authorizer
-      provider_class = self.class.provider_class || Map.service_provider_map(@model_class)
-      @provider = provider_class.new(@model_class, @model_decorator)
+      @provider = Map.service_provider_map(@model_class).new(@model_class, @model_decorator)
     end
 
     # @note This is a template method that can be overridden by subclasses.
     # Whitelist parameters for mass assignment.
     # @param params [ActionController::Parameters, Hash]
-    # @param action [String, Symbol]
+    # @param action [String, Symbol, nil]
     # @return [ActionController::Parameters] permitted params
     def permit(params, action = nil)
       provider.permit params, action, authorizer
@@ -95,58 +64,59 @@ module Wallaby
     # @note This is a template method that can be overridden by subclasses.
     # Return a collection by querying the datasource (e.g. database, REST API).
     # @param params [ActionController::Parameters, Hash]
-    # @return [Enumerable] list of records
+    # @return [Enumerable] list of resources
     def collection(params)
       provider.collection params, authorizer
     end
 
+    # @!method paginate(query, params)
     # @note This is a template method that can be overridden by subclasses.
     # Paginate given {#collection}.
     # @param query [Enumerable]
     # @param params [ActionController::Parameters]
-    # @return [Enumerable] list of records
+    # @return [Enumerable] list of resources
     delegate :paginate, to: :provider
 
     # @note This is a template method that can be overridden by subclasses.
     # Initialize an instance of the model class.
     # @param params [ActionController::Parameters]
-    # @return [Object] initialized object
+    # @return [Object] initialized resource
     def new(params)
       provider.new params, authorizer
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # To find a record.
+    # To find a resource.
     # @param id [Object]
     # @param params [ActionController::Parameters]
-    # @return [Object] resource object
+    # @return [Object] found resource
     def find(id, params)
       provider.find id, params, authorizer
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # To create a record.
+    # To create a resource.
     # @param resource [Object]
     # @param params [ActionController::Parameters]
-    # @return [Object] resource object
+    # @return [Object] created resource
     def create(resource, params)
       provider.create resource, params, authorizer
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # To update a record.
+    # To update a resource.
     # @param resource [Object]
     # @param params [ActionController::Parameters]
-    # @return [Object] resource object
+    # @return [Object] resource
     def update(resource, params)
       provider.update resource, params, authorizer
     end
 
     # @note This is a template method that can be overridden by subclasses.
-    # To delete a record.
+    # To delete a resource.
     # @param resource [Object]
     # @param params [ActionController::Parameters]
-    # @return [Object] resource object
+    # @return [Object] resource
     def destroy(resource, params)
       provider.destroy resource, params, authorizer
     end

data/lib/services/wallaby/map/mode_mapper.rb

@@ -2,23 +2,23 @@
 
 module Wallaby
   class Map
-    # To generate a hash map (`model` => `mode`).
-    # This will be used to tell if a model can be handled by Wallaby
+    # Go through each {Wallaby::Mode} (e.g. **ActiveRecord**/**Her**)
+    # and find out all the model classes respectively.
+    # Then a hash (Model => {Wallaby::Mode}) is constructed
+    # to tell {Wallaby} which {Wallaby::Mode} to use for a given model.
     class ModeMapper
-      # @param mode_classes [Array<Class>] model classes
-      def initialize(mode_classes)
-        @mode_classes = mode_classes
-      end
+      extend Classifier
 
-      # This will walk through each mode (e.g. **ActiveRecord**/**Her**) then pull out all the models,
-      # and then form a hash of (`model` => `mode`).
-      # @return [Hash] { model_class => mode }
-      def map
-        return {} if @mode_classes.blank?
+      # @param class_names [Wallaby::ClassArray] mode class names
+      # @return [WallabyClassHash]
+      def self.execute(class_names)
+        ClassHash.new.tap do |hash|
+          next if class_names.blank?
 
-        @mode_classes.each_with_object({}) do |mode_class, map|
-          mode_class.model_finder.new.all.each do |model_class|
-            map[model_class] = mode_class
+          class_names.each_with_object(hash) do |mode_name, map|
+            mode_name.model_finder.new.all.each do |model_class|
+              map[model_class] = mode_name
+            end
           end
         end
       end

data/lib/services/wallaby/map/model_class_collector.rb

@@ -8,7 +8,7 @@ module Wallaby
       # @param models [Array<Class>]
       def initialize(configuration, models = nil)
         @configuration = configuration
-        @models = models || []
+        @models = ClassArray.new(models || [])
       end
 
       # @return [Array<Class>] model class
@@ -26,7 +26,7 @@ module Wallaby
         invalid_models = configured_models - @models
         return if invalid_models.blank?
 
-        message = I18n.t 'errors.invalid.models', models: invalid_models.to_sentence
+        message = Locale.t 'errors.invalid.models', models: invalid_models.to_sentence
         raise InvalidError, message
       end
 

data/lib/services/wallaby/map/model_class_mapper.rb

@@ -2,37 +2,18 @@
 
 module Wallaby
   class Map
-    # Generate a map.
+    # Go through the class list and generate a {.map .map} that uses the class's model_class as the key.
     class ModelClassMapper
-      # Iterate all classes and generate a hash using their model classes as the key
-      # @see #map
       # @param class_array [Array<Class>]
-      # @return [Hash] model class => descendant class
-      def self.map(class_array, &block)
-        new.send :map, class_array, &block
-      end
-
-      protected
+      # @return [Wallaby::ClassHash] model class => descendant class
+      def self.map(class_array)
+        (class_array || EMPTY_ARRAY).each_with_object(ClassHash.new) do |klass, hash|
+          next if ModuleUtils.anonymous_class?(klass)
+          next if klass.try(:base_class?) || klass.model_class.blank?
 
-      # @return [Hash] model class => descendant class
-      def map(class_array)
-        (class_array || EMPTY_ARRAY).each_with_object({}) do |klass, map|
-          next if anonymous?(klass) || base_class?(klass) || !klass.model_class
-
-          map[klass.model_class] = block_given? ? yield(klass) : klass
+          hash[klass.model_class] = block_given? ? yield(klass) : klass
         end
       end
-
-      # @see Wallaby::ModuleUtils.anonymous_class?
-      def anonymous?(klass)
-        ModuleUtils.anonymous_class? klass
-      end
-
-      # @param klass [Class]
-      # @return [Boolean] whether the class is base or not
-      def base_class?(klass)
-        ModuleUtils.try_to klass, :base_class?
-      end
     end
   end
 end