wallaby-core 0.2.1 → 0.2.2

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, Locale.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, Locale.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/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, Locale.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,7 +64,7 @@ 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
@@ -105,49 +74,49 @@ module Wallaby
     # 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

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

data/lib/services/wallaby/type_renderer.rb

@@ -35,16 +35,6 @@ module Wallaby
         locals[:metadata] = locals[:object].public_send :"#{action_name}_metadata_of", locals[:field_name]
         locals[:value] = locals[:object].public_send locals[:field_name]
       end
-
-      # @param options [String]
-      # @param view [ActionView]
-      # @return [String] partial path string
-      # @return [String] blank string
-      def find_partial(options, view)
-        formats = [view.request.format.to_sym]
-        lookup = view.lookup_context
-        lookup.find_template options, lookup.prefixes, true, [], formats: formats
-      end
     end
   end
 end

data/lib/utils/wallaby/model_utils.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Utils for model
+  # Model related utils
   module ModelUtils
     class << self
       # Convert model class (e.g. `Namespace::Product`) into resources name (e.g. `namespace::products`)
@@ -32,10 +32,11 @@ module Wallaby
         return if resources_name.blank?
 
         class_name = to_model_name resources_name
+        # NOTE: DO NOT try to use const_defined? and const_get EVER.
+        # This is Rails, use constantize
         class_name.constantize
       rescue NameError
-        Logger.warn Locale.t('errors.not_found.model', model: class_name), sourcing: 2
-        nil
+        Logger.warn Locale.t('errors.not_found.model', model: class_name), sourcing: 2..10
       end
 
       # Convert resources name (e.g. `namespace::products`) into model name (e.g. `Namespace::Product`)

data/lib/utils/wallaby/utils.rb

@@ -3,19 +3,20 @@
 module Wallaby
   # Utils
   module Utils
-    # Display deprecate message including the line where it's used
-    # @param key [String]
-    # @param caller [String] the line where it's called
-    # @param options [Hash]
-    def self.deprecate(key, caller:, options: {})
-      warn Locale.t(key, options.merge(from: caller[0]))
-    end
-
     # @see http://stackoverflow.com/a/8710663/1326499
     # @param object [Object]
     # @return [Object] a clone object
     def self.clone(object)
       ::Marshal.load(::Marshal.dump(object))
     end
+
+    # @param object [Object, nil]
+    # @return [String] inspection string for the given object
+    def self.inspect(object)
+      return 'nil' unless object
+      return object.name if object.is_a? Class
+
+      "#{object.class}##{object.id}"
+    end
   end
 end