wallaby-core 0.1.2 → 0.2.3

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

data/lib/services/wallaby/prefixes_builder.rb

@@ -3,64 +3,30 @@
 module Wallaby
   # To extend prefixes to provide more possibility
   class PrefixesBuilder
-    # @param origin_prefixes [Array<string>] a list of all the origin prefixes
-    # @param action_name [String] action name
-    # @param resources_name [String] resources name
-    # @param script_name [String] script name
-    # @param theme_name [String] theme name
-    def self.build(origin_prefixes:, action_name:, resources_name:, script_name:, theme_name:)
-      new(
-        origin_prefixes: origin_prefixes,
-        action_name: action_name,
-        resources_name: resources_name,
-        script_name: script_name,
-        theme_name: theme_name
-      ).send :build
-    end
+    include ActiveModel::Model
 
-    private
+    attr_accessor :prefixes
+    attr_accessor :resources_name
+    attr_accessor :script_name
 
-    # Constructor
-    def initialize(origin_prefixes:, action_name:, resources_name:, script_name:, theme_name:)
-      @origin_prefixes = origin_prefixes
-      @action_name = action_name
-      @resources_name = resources_name
-      @script_name = script_name
-      @theme_name = theme_name
-    end
+    def execute
+      return if prefixes.include? resources_path
 
-    # @return [Array<String>] prefixes
-    def build
-      prefixes = minimal_prefixes
-      prefixes.unshift mounted_prefix unless prefixes.include? resources_path
-      prefixes.uniq.compact.each_with_object([]) do |prefix, result|
-        result << "#{prefix}/#{suffix}" << prefix
-      end
-    end
+      full_prefix = [script_path, resources_path].compact.join(SLASH)
 
-    # @return [Array<String>] prefixes starting from wallaby controller path
-    def minimal_prefixes
-      index = @origin_prefixes.index ResourcesController.controller_path
-      @origin_prefixes.slice(0..index).tap do |prefixes|
-        insert_index = prefixes.length > 1 ? -2 : 0
-        prefixes.insert insert_index, @theme_name if @theme_name.present?
-      end
-    end
+      return if prefixes.include? full_prefix
 
-    # @return [String] a prefix of the mouted path
-    def mounted_prefix
-      prefix = (@script_name || '').sub(%r{^/}, '')
-      prefix << SLASH if prefix.present?
-      prefix << resources_path if resources_path
+      prefixes.insert 0, full_prefix
     end
 
-    # @return [String]
-    def suffix
-      @suffix ||= CellUtils.to_action_prefix @action_name
-    end
+    private
 
     def resources_path
-      @resources_path ||= @resources_name.try :gsub, COLONS, SLASH
+      @resources_path ||= resources_name.try :gsub, COLONS, SLASH
+    end
+
+    def script_path
+      @script_path ||= script_name.try :[], 1..-1
     end
   end
 end

data/lib/services/wallaby/type_renderer.rb

@@ -23,28 +23,18 @@ module Wallaby
       # @raise [ArgumentError] if field_name is not provided
       # @raise [ArgumentError] if object is not decorated
       def check(locals)
-        raise ArgumentError, I18n.t('errors.required', subject: 'form') if locals.key?(:form) && locals[:form].blank?
-        raise ArgumentError, I18n.t('errors.required', subject: 'field_name') if locals[:field_name].blank?
+        raise ArgumentError, Locale.t('errors.required', subject: 'form') if locals.key?(:form) && locals[:form].blank?
+        raise ArgumentError, Locale.t('errors.required', subject: 'field_name') if locals[:field_name].blank?
         raise ArgumentError, 'Object is not decorated.' unless locals[:object].is_a? ResourceDecorator
       end
 
       # @param locals [Hash]
       # @param action [String]
       def complete(locals, action)
-        action_name = CellUtils.to_action_prefix action
+        action_name = FORM_ACTIONS[action] || action
         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/locale.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Locale related
+  module Locale
+    class << self
+      # Extend translation just for Wallaby
+      # so that translation can be prefixed with `wallaby.`
+      # @param key [String, Symbol, Array]
+      # @param options [Hash] the rest of the arguments
+      # @return [String] translation
+      def t(key, options = {})
+        translator = options.delete(:translator) || I18n.method(:t)
+        return translator.call(key, options) unless key.is_a?(String) || key.is_a?(Symbol)
+
+        new_key, new_defaults = normalize key, options.delete(:default)
+
+        translator.call(new_key, { default: new_defaults }.merge(options))
+      end
+
+      private
+
+      # @param key [String, Symbol, Array]
+      # @param defaults [String, Symbol, Array]
+      # @return [Array]
+      def normalize(key, defaults)
+        *keys, default = *defaults
+
+        # default will NOT be considered as one of the key
+        # if it is not set or if it is a String (since String means translation for I18n.t)
+        unless default.nil? || default.is_a?(String)
+          keys << default
+          default = nil
+        end
+
+        new_defaults = prefix_defaults_from keys.unshift(key)
+        new_key = new_defaults.shift
+        new_defaults << default if default
+        [new_key, new_defaults]
+      end
+
+      # Duplicate and prefix the keys respectively
+      # @param keys [Array]
+      # @return [Array] new_keys
+      def prefix_defaults_from(keys)
+        keys.each_with_object([]) do |k, result|
+          result << :"wallaby.#{k}" unless k.to_s.start_with? 'wallaby.'
+          result << k.to_sym
+        end
+      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
-        Rails.logger.warn I18n.t('errors.not_found.model', model: class_name)
-        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/module_utils.rb

@@ -32,7 +32,7 @@ module Wallaby
         return unless child && parent
         return if child < parent
 
-        raise ::ArgumentError, I18n.t('errors.invalid.inheritance', klass: child, parent: parent)
+        raise ::ArgumentError, Locale.t('errors.invalid.inheritance', klass: child, parent: parent)
       end
 
       # If block is given, run the block. Otherwise, return subject

data/lib/utils/wallaby/utils.rb

@@ -3,25 +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 I18n.t(key, options.merge(from: caller[0]))
-    end
-
-    # @deprecated Use {Wallaby::FilterUtils.filter_name_by} instead. It will be removed from 5.3.*
-    def self.find_filter_name(filter_name, filters)
-      deprecate 'deprecation.find_filter_name', caller: caller
-      FilterUtils.filter_name_by filter_name, filters
-    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))
+      object.try(:deep_dup) || 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

data/lib/wallaby/class_array.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # This is a constant-safe array that stores Class value as String.
+  class ClassArray
+    include Classifier
+
+    # @param [Array] array
+    def initialize(array = [])
+      @internal = array || []
+      return if @internal.blank?
+
+      @internal.map!(&method(:to_class_name)).compact!
+    end
+
+    # @!attribute [r] internal
+    # @return [Array] The array to store Class values as String.
+    attr_reader :internal
+
+    # @!attribute [r] origin
+    # @return [Array] The original array.
+    def origin
+      # NOTE: DO NOT cache it by using instance variable!
+      @internal.map(&method(:to_class)).compact
+    end
+
+    # Save the value to the {#internal} array at the given index, and convert the Class value to String
+    def []=(index, value)
+      @internal[index] = to_class_name value
+    end
+
+    # Return the value for the given index
+    def [](index)
+      to_class @internal[index]
+    end
+
+    # @param other [Array]
+    # @return [Wallaby::ClassArray] new Class array
+    def concat(other)
+      self.class.new origin.concat(other.try(:origin) || other)
+    end
+
+    # @param other [Array]
+    # @return [Wallaby::ClassArray] new Class array
+    def -(other)
+      self.class.new origin - (other.try(:origin) || other)
+    end
+
+    # @return [Wallaby::ClassArray] self
+    def each(&block)
+      origin.each(&block)
+      self
+    end
+
+    # @!method ==(other)
+    # Compare #{origin} with other.
+    delegate :==, to: :origin
+
+    # @!method blank?
+    delegate :blank?, to: :internal
+
+    # @!method each_with_object(object)
+    delegate :each_with_object, to: :origin
+
+    # @!method to_sentence
+    delegate :to_sentence, to: :origin
+
+    # Ensure to freeze the {#internal}
+    # @return [Wallaby::ClassArray] self
+    def freeze
+      @internal.freeze
+      super
+    end
+  end
+end