wallaby-core 0.2.0 → 0.2.4

data/lib/services/wallaby/type_renderer.rb

@@ -23,8 +23,8 @@ 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
 
@@ -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/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,19 +3,33 @@
 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
-
     # @see http://stackoverflow.com/a/8710663/1326499
     # @param object [Object]
     # @return [Object] a clone object
     def self.clone(object)
-      ::Marshal.load(::Marshal.dump(object))
+      # NOTE: Neither marshal/deep_dup/dup achieves real and correct deep copy,
+      # so here we need a custom solution below:
+      case object
+      when Hash
+        object.each_with_object(object.class.new) { |(key, value), hash| hash[key] = clone(value) }
+      when Array
+        object.each_with_object(object.class.new) { |value, array| array << clone(value) }
+      when Class
+        # NOTE: `Class.dup` will turn the duplicate class into anonymous class
+        # therefore, we just return the Class itself here
+        object
+      else
+        object.dup
+      end
+    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

data/lib/wallaby/class_hash.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # This is a constant-safe hash that stores Class key/value as String
+  # and returns value as Class if it was a Class.
+  #
+  # It can be used for global methods (e.g. {Wallaby::Map.mode_map}) which cache the computed result,
+  # so that when Rails reloads, it won't complain that old Class constants still exist in
+  # ObjectSpace (see https://github.com/wallaby-rails/wallaby/issues/181).
+  #
+  # ```
+  # A copy of SupportAdmin::ApplicationAuthorizer has been removed from the module tree but is still active!
+  # ```
+  #
+  # As there won't be any Class constants being stored, they will converted to String in {#internal} Hash.
+  class ClassHash
+    # @!attribute [r] internal
+    # @return [Hash] The hash to store Class keys/values as String.
+    attr_reader :internal
+
+    # @param [Hash] hash
+    def initialize(hash = {})
+      @internal =
+        (hash || {})
+        .transform_keys(&method(:to_class_name))
+        .transform_values(&method(:to_class_name))
+    end
+
+    # @!attribute [r] origin
+    # @return [Hash] The original hash.
+    def origin
+      # NOTE: DO NOT cache it by using instance variable!
+      @internal
+        .transform_keys(&method(:to_class))
+        .transform_values(&method(:to_class))
+        .reject { |k, v| k.nil? || v.nil? }
+    end
+
+    # @!method keys
+    # Return the keys of {#origin}.
+    delegate :keys, to: :origin
+
+    # @!method values
+    # Return the values of {#origin}.
+    delegate :values, to: :origin
+
+    # @!method ==(other)
+    # Compare #{origin} with other.
+    delegate :==, to: :origin
+
+    # Save the key/value to the {#internal} hash, and convert the Class key/value to String
+    def []=(key, value)
+      @internal[to_class_name(key)] = to_class_name(value)
+    end
+
+    # Return the value for the given key, and convert the value back to Class if it was a Class
+    def [](key)
+      to_class @internal[to_class_name(key)]
+    end
+
+    # @param other [Hash]
+    # @return [Wallaby::ClassHash] new Class hash
+    def merge(other)
+      self.class.new origin.merge(other.try(:origin) || other)
+    end
+
+    # @return [Wallaby::ClassHash] new Class hash
+    def select(&block)
+      self.class.new origin.select(&block)
+    end
+
+    # Ensure to freeze the {#internal}
+    # @return [Wallaby::ClassHash] self
+    def freeze
+      @internal.freeze
+      super
+    end
+
+    protected
+
+    # Convert to Class name
+    def to_class_name(klass)
+      klass.is_a?(Class) ? [klass.name, true] : [klass, false]
+    end
+
+    # Convert to Class
+    def to_class(pair)
+      val, is_class = pair
+      is_class ? val.constantize : val
+    rescue NameError
+      Logger.error "`#{val}` is not a valid Class name."
+    end
+  end
+end

data/lib/wallaby/classifier.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Concern to handle the conversion between Class and String
+  module Classifier
+    # Convert Class to String. If not Class, unchanged.
+    # @param klass [Object]
+    # @return [String] if klass is a Class
+    # @return [Object] if klass is not a Class
+    def to_class_name(klass)
+      klass.try(:name) || klass || nil
+    end
+
+    # Convert String to Class. If not String, unchanged.
+    # @param name [Object]
+    # @return [Class] if name is a Class
+    # @return [Object] if name is not a String
+    # @return [nil] if class cannot be found
+    def to_class(name)
+      return name unless name.is_a? String
+
+      # NOTE: DO NOT try to use const_defined? and const_get EVER.
+      # This is Rails, use constantize
+      name.constantize
+    rescue NameError
+      Logger.error "`#{name}` is not a valid Class name."
+    end
+  end
+end

data/lib/wallaby/configuration/mapping.rb

@@ -3,10 +3,14 @@
 module Wallaby
   class Configuration
     # Configuration used in {Wallaby::Map}
-    # @since 5.1.6
+    # @since wallaby-5.1.6
     class Mapping
+      include Classifier
+
       # @!attribute [w] resources_controller
-      attr_writer :resources_controller
+      def resources_controller=(resources_controller)
+        @resources_controller = to_class_name resources_controller
+      end
 
       # @!attribute [r] resources_controller
       # To globally configure the resources controller.
@@ -21,17 +25,19 @@ module Wallaby
       #     config.mapping.resources_controller = ::GlobalResourcesController
       #   end
       # @return [Class] resources controller class
-      # @since 5.1.6
+      # @since wallaby-5.1.6
       def resources_controller
         @resources_controller ||=
           defined?(::Admin::ApplicationController) \
             && ::Admin::ApplicationController < ::Wallaby::ResourcesController \
-            && ::Admin::ApplicationController
-        @resources_controller ||= ResourcesController
+            && 'Admin::ApplicationController'
+        to_class @resources_controller ||= 'Wallaby::ResourcesController'
       end
 
       # @!attribute [w] resource_decorator
-      attr_writer :resource_decorator
+      def resource_decorator=(resource_decorator)
+        @resource_decorator = to_class_name resource_decorator
+      end
 
       # @!attribute [r] resource_decorator
       # To globally configure the resource decorator.
@@ -46,17 +52,19 @@ module Wallaby
       #     config.mapping.resource_decorator = ::GlobalResourceDecorator
       #   end
       # @return [Class] resource decorator class
-      # @since 5.1.6
+      # @since wallaby-5.1.6
       def resource_decorator
         @resource_decorator ||=
           defined?(::Admin::ApplicationDecorator) \
             && ::Admin::ApplicationDecorator < ::Wallaby::ResourceDecorator \
-            && ::Admin::ApplicationDecorator
-        @resource_decorator ||= ResourceDecorator
+            && 'Admin::ApplicationDecorator'
+        to_class @resource_decorator ||= 'Wallaby::ResourceDecorator'
       end
 
       # @!attribute [w] model_servicer
-      attr_writer :model_servicer
+      def model_servicer=(model_servicer)
+        @model_servicer = to_class_name model_servicer
+      end
 
       # @!attribute [r] model_servicer
       # To globally configure the model servicer.
@@ -71,17 +79,19 @@ module Wallaby
       #     config.mapping.model_servicer = ::GlobalModelServicer
       #   end
       # @return [Class] model servicer class
-      # @since 5.1.6
+      # @since wallaby-5.1.6
       def model_servicer
         @model_servicer ||=
           defined?(::Admin::ApplicationServicer) \
             && ::Admin::ApplicationServicer < ::Wallaby::ModelServicer \
-            && ::Admin::ApplicationServicer
-        @model_servicer ||= ModelServicer
+            && 'Admin::ApplicationServicer'
+        to_class @model_servicer ||= 'Wallaby::ModelServicer'
       end
 
       # @!attribute [w] model_authorizer
-      attr_writer :model_authorizer
+      def model_authorizer=(model_authorizer)
+        @model_authorizer = to_class_name model_authorizer
+      end
 
       # @!attribute [r] model_authorizer
       # To globally configure the model authorizer.
@@ -96,17 +106,19 @@ module Wallaby
       #     config.mapping.model_authorizer = ::GlobalModelAuthorizer
       #   end
       # @return [Class] model authorizer class
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def model_authorizer
         @model_authorizer ||=
           defined?(::Admin::ApplicationAuthorizer) \
             && ::Admin::ApplicationAuthorizer < ::Wallaby::ModelAuthorizer \
-            && ::Admin::ApplicationAuthorizer
-        @model_authorizer ||= ModelAuthorizer
+            && 'Admin::ApplicationAuthorizer'
+        to_class @model_authorizer ||= 'Wallaby::ModelAuthorizer'
       end
 
       # @!attribute [w] model_paginator
-      attr_writer :model_paginator
+      def model_paginator=(model_paginator)
+        @model_paginator = to_class_name model_paginator
+      end
 
       # @!attribute [r] model_paginator
       # To globally configure the resource paginator.
@@ -121,13 +133,13 @@ module Wallaby
       #     config.mapping.model_paginator = ::GlobalModelPaginator
       #   end
       # @return [Class] resource paginator class
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def model_paginator
         @model_paginator ||=
           defined?(::Admin::ApplicationPaginator) \
             && ::Admin::ApplicationPaginator < ::Wallaby::ModelPaginator \
-            && ::Admin::ApplicationPaginator
-        @model_paginator ||= ModelPaginator
+            && 'Admin::ApplicationPaginator'
+        to_class @model_paginator ||= 'Wallaby::ModelPaginator'
       end
     end
   end

data/lib/wallaby/configuration/metadata.rb

@@ -14,7 +14,7 @@ module Wallaby
       #     config.metadata.max = 50
       #   end
       # @return [Integer] max number of characters to truncate, default to 20
-      # @since 5.1.6
+      # @since wallaby-5.1.6
       def max
         @max ||= DEFAULT_MAX
       end

data/lib/wallaby/configuration/models.rb

@@ -2,11 +2,7 @@
 
 module Wallaby
   class Configuration
-    # @note In `development` environment, Rails recreates module/class constants on reload event.
-    #   If constants are cached/stored, they will become stale and Rails will raise conflicts.
-    #
-    #   Hence, class name strings should be stored instead.
-    #   When classes are requested, strings will be constantized into classes.
+    # @deprecated will move this configuration to {Wallaby::ResourcesController} from 6.2
     # Models configuration to specify the model classes that Wallaby should handle.
     class Models
       # @note If models are whitelisted, models exclusion will NOT be applied.
@@ -17,12 +13,12 @@ module Wallaby
       #   end
       # @param models [Array<Class, String>]
       def set(*models)
-        @models = Array(models).flatten.map(&:to_s)
+        @models = ClassArray.new(models.flatten)
       end
 
       # @return [Array<Class>] the models configured
       def presence
-        (@models ||= []).map(&:constantize)
+        @models ||= ClassArray.new # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       # @note If models are whitelisted using {#set}, models exclusion will NOT be applied.
@@ -33,13 +29,13 @@ module Wallaby
       #   end
       # @param models [Array<Class, String>]
       def exclude(*models)
-        @excludes = Array(models).flatten.map(&:to_s)
+        @excludes = ClassArray.new(models.flatten)
       end
 
       # @return [Array<Class>] the list of models to exclude.
       #   By default, `ActiveRecord::SchemaMigration` is excluded.
       def excludes
-        (@excludes ||= ['ActiveRecord::SchemaMigration']).map(&:constantize)
+        @excludes ||= ClassArray.new ['ActiveRecord::SchemaMigration']
       end
     end
   end

data/lib/wallaby/configuration/security.rb

@@ -3,6 +3,7 @@
 module Wallaby
   class Configuration
     # Security configuration
+    # TODO: remove this from 6.2
     class Security
       # Default block to return nil for current user
       DEFAULT_CURRENT_USER = -> { nil }
@@ -20,7 +21,7 @@ module Wallaby
       #   Wallaby.config do |config|
       #     config.security.logout_path = 'logout_path'
       #   end
-      # @since 5.1.4
+      # @since wallaby-5.1.4
       attr_accessor :logout_path
 
       # @!attribute logout_method
@@ -34,7 +35,7 @@ module Wallaby
       #   Wallaby.config do |config|
       #     config.security.logout_method = 'post'
       #   end
-      # @since 5.1.4
+      # @since wallaby-5.1.4
       attr_accessor :logout_method
 
       # @!attribute email_method
@@ -45,7 +46,7 @@ module Wallaby
       #   Wallaby.config do |config|
       #     config.security.email_method = 'email_address'
       #   end
-      # @since 5.1.4
+      # @since wallaby-5.1.4
       attr_accessor :email_method
 
       # To globally configure how to get user object.
@@ -57,6 +58,7 @@ module Wallaby
       #   end
       # @yield A block to get user object. All application controller methods can be used in the block.
       def current_user(&block)
+        Logger.deprecated 'Wallaby will remove security.current_user? from 6.2.'
         if block_given?
           @current_user = block
         else
@@ -81,6 +83,7 @@ module Wallaby
       #   end
       # @yield A block to authenticate user. All application controller methods can be used in the block.
       def authenticate(&block)
+        Logger.deprecated 'Wallaby will remove security.authenticate from 6.2.'
         if block_given?
           @authenticate = block
         else

data/lib/wallaby/configuration/sorting.rb

@@ -3,7 +3,7 @@
 module Wallaby
   class Configuration
     # Sorting global configuration
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     class Sorting
       # @!attribute [w] strategy
       attr_writer :strategy

data/lib/wallaby/configuration.rb

@@ -4,8 +4,37 @@
 module Wallaby
   # Global configuration
   class Configuration
+    include Classifier
+
+    # @!attribute [w] model_paths
+    def model_paths=(*model_paths)
+      @model_paths =
+        model_paths.flatten.compact.presence.try do |paths|
+          next paths if paths.all? { |p| p.is_a?(String) }
+
+          raise(
+            ArgumentError,
+            'Please provide a list of string paths, e.g. `["app/models", "app/core"]`'
+          )
+        end
+    end
+
+    # @!attribute [r] model_paths
+    # To configure the model folders that {Wallaby::Preloader} needs to load before everything else.
+    # @example To set the model paths
+    #   Wallaby.config do |config|
+    #     config.model_paths = ["app/models", "app/core"]
+    #   end
+    # @return [Array<String>] model paths
+    # @since 0.2.2
+    def model_paths
+      @model_paths ||= %w(app/models)
+    end
+
     # @!attribute [w] base_controller
-    attr_writer :base_controller
+    def base_controller=(base_controller)
+      @base_controller = to_class_name base_controller
+    end
 
     # @!attribute [r] base_controller
     # To globally configure the base controller class that {Wallaby::ApplicationController} should inherit from.
@@ -18,7 +47,7 @@ module Wallaby
     #   end
     # @return [Class] base controller class
     def base_controller
-      @base_controller ||= ::ApplicationController
+      to_class @base_controller ||= '::ApplicationController'
     end
 
     # @return [Wallaby::Configuration::Models] models configuration for custom mode

data/lib/wallaby/core/version.rb

@@ -2,6 +2,6 @@
 
 module Wallaby
   module Core
-    VERSION = '0.2.0' # :nodoc:
+    VERSION = '0.2.4' # :nodoc:
   end
 end