wallaby-core 0.2.11 → 0.3.0.beta2

data/lib/utils/wallaby/locale.rb

@@ -11,11 +11,11 @@ module Wallaby
       # @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)
+        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))
+        translator.call(new_key, default: new_defaults, **options)
       end
 
       private

data/lib/utils/wallaby/module_utils.rb

@@ -4,16 +4,9 @@ module Wallaby
   # Utils for module and class
   module ModuleUtils
     class << self
-      # A helper method to check if subject responds to given method and to return the result if so
-      # @param subject [Object]
-      # @param method_id [String, Symbol]
-      # @param args [Array] a list of arguments
-      # @return [Object] result from executing given method on subject
-      # @return [nil] if subject doesn't respond to given method
-      def try_to(subject, method_id, *args, &block)
-        return if method_id.blank?
-
-        subject.respond_to?(method_id) && subject.public_send(method_id, *args, &block) || nil
+      # @deprecated
+      def try_to(_subject, _method_id, *_args)
+        Deprecator.alert method(__callee__), from: '0.3.0'
       end
 
       # Check whether a class is anonymous or not

data/lib/utils/wallaby/utils.rb

@@ -1,24 +1,20 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Utils
-  module Utils
-    # @see http://stackoverflow.com/a/8710663/1326499
+  module Utils # :nodoc:
     # @param object [Object]
-    # @return [Object] a clone object
+    # @return [Object] a cloned object
     def self.clone(object)
-      # NOTE: Neither marshal/deep_dup/dup are able to achieve real and correct deep copy,
-      # so here we need a custom solution below:
+      # NOTE: Neither marshal/deep_dup/dup is able to make a correct deep copy,
+      # therefore, this is our solution:
       case object
       when Hash
-        object
-          .each_with_object(object.class.new) { |(key, value), hash| hash[key] = clone(value) }
-          .tap { |hash| hash.default = object.default }
+        HashCloner.execute(object)
       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
+        # NOTE: `Class.dup` turns the origin Class object into an anonymous clone.
+        # therefore, the Class object itself should be returned instead
         object
       else
         object.dup
@@ -28,10 +24,21 @@ module Wallaby
     # @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
+      return 'nil' if object.nil?
+      return "#{object.class}##{object.try(:id)}" if object.is_a?(::ActiveRecord::Base)
+
+      object.inspect
+    end
 
-      "#{object.class}##{object.id}"
+    # Service object to clone Hash
+    class HashCloner
+      def self.execute(object)
+        # NOTE: `default`/`default_proc` should be cloned as well
+        default_method = object.default_proc ? :default_proc : :default
+        object
+          .each_with_object(object.class.new) { |(key, value), hash| hash[key] = Utils.clone(value) }
+          .tap { |hash| hash.try("#{default_method}=", object.try(default_method)) }
+      end
     end
   end
 end

data/lib/wallaby/class_array.rb

@@ -6,11 +6,11 @@ module Wallaby
     include Classifier
 
     # @param [Array] array
-    def initialize(array = [])
-      @internal = array || []
+    def initialize(*array)
+      @internal = (array || []).flatten
       return if @internal.blank?
 
-      @internal.map!(&method(:to_class_name)).compact!
+      @internal.map! { |klass| class_name_of(klass) }.compact!
     end
 
     # @!attribute [r] internal
@@ -20,13 +20,13 @@ module Wallaby
     # @!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
+      # NOTE: DO NOT cache it using instance variable!
+      @internal.map { |klass| to_class(klass) }.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
+      @internal[index] = class_name_of value
     end
 
     # Return the value for the given index
@@ -35,18 +35,19 @@ module Wallaby
     end
 
     # @param other [Array]
-    # @return [Wallaby::ClassArray] new Class array
+    # @return [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)
+    # @param item [Class, String]
+    # @return [ClassArray] self
+    def <<(item)
+      @internal << class_name_of(item)
+      self
     end
 
-    # @return [Wallaby::ClassArray] self
+    # @return [ClassArray] self
     def each(&block)
       origin.each(&block)
       self
@@ -56,6 +57,10 @@ module Wallaby
     # Compare #{origin} with other.
     delegate :==, to: :origin
 
+    # @!method to_a
+    # Get the array of #{origin}.
+    delegate :to_a, to: :origin
+
     # @!method blank?
     delegate :blank?, to: :internal
 
@@ -66,7 +71,7 @@ module Wallaby
     delegate :to_sentence, to: :origin
 
     # Ensure to freeze the {#internal}
-    # @return [Wallaby::ClassArray] self
+    # @return [ClassArray] self
     def freeze
       @internal.freeze
       super

data/lib/wallaby/class_hash.rb

@@ -4,7 +4,7 @@ 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,
+  # It can be used for global methods (e.g. {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).
   #
@@ -22,8 +22,8 @@ module Wallaby
     def initialize(hash = {})
       @internal =
         (hash || {})
-        .transform_keys(&method(:to_class_name))
-        .transform_values(&method(:to_class_name))
+        .transform_keys { |klass| class_name_of(klass) }
+        .transform_values { |klass| class_name_of(klass) }
     end
 
     # @!attribute [r] origin
@@ -31,11 +31,15 @@ module Wallaby
     def origin
       # NOTE: DO NOT cache it by using instance variable!
       @internal
-        .transform_keys(&method(:to_class))
-        .transform_values(&method(:to_class))
+        .transform_keys { |klass| to_class(klass) }
+        .transform_values { |klass| to_class(klass) }
         .reject { |k, v| k.nil? || v.nil? }
     end
 
+    # @!method key?
+    # Return if {#origin} has the given key.
+    delegate :key?, to: :origin
+
     # @!method keys
     # Return the keys of {#origin}.
     delegate :keys, to: :origin
@@ -50,27 +54,27 @@ module Wallaby
 
     # 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)
+      @internal[class_name_of(key)] = class_name_of(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)]
+      to_class @internal[class_name_of(key)]
     end
 
     # @param other [Hash]
-    # @return [Wallaby::ClassHash] new Class hash
+    # @return [ClassHash] new Class hash
     def merge(other)
       self.class.new origin.merge(other.try(:origin) || other)
     end
 
-    # @return [Wallaby::ClassHash] new Class hash
+    # @return [ClassHash] new Class hash
     def select(&block)
       self.class.new origin.select(&block)
     end
 
     # Ensure to freeze the {#internal}
-    # @return [Wallaby::ClassHash] self
+    # @return [ClassHash] self
     def freeze
       @internal.freeze
       super
@@ -79,16 +83,14 @@ module Wallaby
     protected
 
     # Convert to Class name
-    def to_class_name(klass)
+    def class_name_of(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."
+      is_class ? Classifier.to_class(val) : val
     end
   end
 end

data/lib/wallaby/classifier.rb

@@ -3,11 +3,13 @@
 module Wallaby
   # Concern to handle the conversion between Class and String
   module Classifier
+    extend self
+
     # 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)
+    def class_name_of(klass)
       klass.try(:name) || klass || nil
     end
 
@@ -23,7 +25,7 @@ module Wallaby
       # This is Rails, use constantize
       name.constantize
     rescue NameError
-      Logger.error "`#{name}` is not a valid Class name."
+      yield(name) if block_given?
     end
   end
 end

data/lib/wallaby/configuration/features.rb

@@ -5,7 +5,9 @@ module Wallaby
     # Features global configuration
     class Features
       # @!attribute [w] turbolinks_enabled
-      attr_writer :turbolinks_enabled
+      def turbolinks_enabled=(_turbolinks_enabled)
+        Deprecator.alert 'config.features.turbolinks_enabled=', from: '0.3.0'
+      end
 
       # @!attribute [r] turbolinks_enabled
       # To globally configure whether to use turbolinks or not.
@@ -17,7 +19,11 @@ module Wallaby
       #   end
       # @return [Boolean] a feture flag of turbolinks, default to false.
       def turbolinks_enabled
-        @turbolinks_enabled ||= false
+        Deprecator.alert method(__callee__), from: '0.3.0', alternative: <<~INSTRUCTION
+          If Turbolinks is included, it will be used by Wallaby. If you want to disable it,
+          you can either take `turbolinks` gem out from your Gemfile
+          or override the `frontend` partial by taking it out.
+        INSTRUCTION
       end
     end
   end

data/lib/wallaby/configuration/mapping.rb

@@ -2,144 +2,98 @@
 
 module Wallaby
   class Configuration
-    # Configuration used in {Wallaby::Map}
-    # @since wallaby-5.1.6
+    # @deprecated
     class Mapping
       include Classifier
 
-      # @!attribute [w] resources_controller
-      def resources_controller=(resources_controller)
-        @resources_controller = to_class_name resources_controller
+      # @deprecated
+      def resources_controller=(_resources_controller)
+        Deprecator.alert 'config.mapping.resources_controller=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set #resources_controller= from the config instead, for example:
+
+            Wallaby.config do |config|
+              config.resources_controller = ::GlobalResourcesController
+            end
+        INSTRUCTION
       end
 
-      # @!attribute [r] resources_controller
-      # To globally configure the resources controller.
-      #
-      # If no configuration is given, Wallaby will look up from the following controller classes
-      # and use the first available one:
-      #
-      # - ::Admin::ApplicationController (only when it inherits from {Wallaby::ResourcesController})
-      # - {Wallaby::ResourcesController}
-      # @example To update the resources controller to `GlobalResourcesController` in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.mapping.resources_controller = ::GlobalResourcesController
-      #   end
-      # @return [Class] resources controller class
-      # @since wallaby-5.1.6
+      # @deprecated
       def resources_controller
-        @resources_controller ||=
-          defined?(::Admin::ApplicationController) \
-            && ::Admin::ApplicationController < ::Wallaby::ResourcesController \
-            && 'Admin::ApplicationController'
-        to_class @resources_controller ||= 'Wallaby::ResourcesController'
+        Deprecator.alert 'config.mapping.resources_controller', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use config.resources_controller instead.
+        INSTRUCTION
       end
 
-      # @!attribute [w] resource_decorator
-      def resource_decorator=(resource_decorator)
-        @resource_decorator = to_class_name resource_decorator
+      # @deprecated
+      def resource_decorator=(_resource_decorator)
+        Deprecator.alert 'config.mapping.resource_decorator=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set .application_decorator= from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.application_decorator = ::GlobalModelDecorator
+            end
+        INSTRUCTION
       end
 
-      # @!attribute [r] resource_decorator
-      # To globally configure the resource decorator.
-      #
-      # If no configuration is given, Wallaby will look up from the following decorator classes
-      # and use the first available one:
-      #
-      # - ::Admin::ApplicationDecorator (only when it inherits from {Wallaby::ResourceDecorator})
-      # - {Wallaby::ResourceDecorator}
-      # @example To update the resource decorator to `GlobalResourceDecorator` in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.mapping.resource_decorator = ::GlobalResourceDecorator
-      #   end
-      # @return [Class] resource decorator class
-      # @since wallaby-5.1.6
+      # @deprecated
       def resource_decorator
-        @resource_decorator ||=
-          defined?(::Admin::ApplicationDecorator) \
-            && ::Admin::ApplicationDecorator < ::Wallaby::ResourceDecorator \
-            && 'Admin::ApplicationDecorator'
-        to_class @resource_decorator ||= 'Wallaby::ResourceDecorator'
+        Deprecator.alert 'config.mapping.resource_decorator', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.application_decorator.
+        INSTRUCTION
       end
 
-      # @!attribute [w] model_servicer
-      def model_servicer=(model_servicer)
-        @model_servicer = to_class_name model_servicer
+      # @deprecated
+      def model_servicer=(_model_servicer)
+        Deprecator.alert 'config.mapping.model_servicer=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set .application_servicer= from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.application_servicer = ::GlobalModelServicer
+            end
+        INSTRUCTION
       end
 
-      # @!attribute [r] model_servicer
-      # To globally configure the model servicer.
-      #
-      # If no configuration is given, Wallaby will look up from the following servicer classes
-      # and use the first available one:
-      #
-      # - ::Admin::ApplicationServicer (only when it inherits from {Wallaby::ModelServicer})
-      # - {Wallaby::ModelServicer}
-      # @example To update the model servicer to `GlobalModelServicer` in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.mapping.model_servicer = ::GlobalModelServicer
-      #   end
-      # @return [Class] model servicer class
-      # @since wallaby-5.1.6
+      # @deprecated
       def model_servicer
-        @model_servicer ||=
-          defined?(::Admin::ApplicationServicer) \
-            && ::Admin::ApplicationServicer < ::Wallaby::ModelServicer \
-            && 'Admin::ApplicationServicer'
-        to_class @model_servicer ||= 'Wallaby::ModelServicer'
+        Deprecator.alert 'config.mapping.model_servicer', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.application_servicer.
+        INSTRUCTION
       end
 
-      # @!attribute [w] model_authorizer
-      def model_authorizer=(model_authorizer)
-        @model_authorizer = to_class_name model_authorizer
+      # @deprecated
+      def model_authorizer=(_model_authorizer)
+        Deprecator.alert 'config.mapping.model_authorizer=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set .application_authorizer= from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.application_authorizer = ::GlobalModelAuthorizer
+            end
+        INSTRUCTION
       end
 
-      # @!attribute [r] model_authorizer
-      # To globally configure the model authorizer.
-      #
-      # If no configuration is given, Wallaby will look up from the following authorizer classes
-      # and use the first available one:
-      #
-      # - ::Admin::ApplicationAuthorizer (only when it inherits from {Wallaby::ModelAuthorizer})
-      # - {Wallaby::ModelAuthorizer}
-      # @example To update the model authorizer to `GlobalModelAuthorizer` in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.mapping.model_authorizer = ::GlobalModelAuthorizer
-      #   end
-      # @return [Class] model authorizer class
-      # @since wallaby-5.2.0
+      # @deprecated
       def model_authorizer
-        @model_authorizer ||=
-          defined?(::Admin::ApplicationAuthorizer) \
-            && ::Admin::ApplicationAuthorizer < ::Wallaby::ModelAuthorizer \
-            && 'Admin::ApplicationAuthorizer'
-        to_class @model_authorizer ||= 'Wallaby::ModelAuthorizer'
+        Deprecator.alert 'config.mapping.model_authorizer', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.application_authorizer.
+        INSTRUCTION
       end
 
-      # @!attribute [w] model_paginator
-      def model_paginator=(model_paginator)
-        @model_paginator = to_class_name model_paginator
+      # @deprecated
+      def model_paginator=(_model_paginator)
+        Deprecator.alert 'config.mapping.model_paginator=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set .application_paginator= from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.application_paginator = ::GlobalModelPaginator
+            end
+        INSTRUCTION
       end
 
-      # @!attribute [r] model_paginator
-      # To globally configure the resource paginator.
-      #
-      # If no configuration is given, Wallaby will look up from the following paginator classes
-      # and use the first available one:
-      #
-      # - ::Admin::ApplicationPaginator (only when it inherits from {Wallaby::ModelPaginator})
-      # - {Wallaby::ModelPaginator}
-      # @example To update the resource paginator to `GlobalModelPaginator` in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.mapping.model_paginator = ::GlobalModelPaginator
-      #   end
-      # @return [Class] resource paginator class
-      # @since wallaby-5.2.0
+      # @deprecated
       def model_paginator
-        @model_paginator ||=
-          defined?(::Admin::ApplicationPaginator) \
-            && ::Admin::ApplicationPaginator < ::Wallaby::ModelPaginator \
-            && 'Admin::ApplicationPaginator'
-        to_class @model_paginator ||= 'Wallaby::ModelPaginator'
+        Deprecator.alert 'config.mapping.model_paginator', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.application_paginator.
+        INSTRUCTION
       end
     end
   end

data/lib/wallaby/configuration/metadata.rb

@@ -2,21 +2,24 @@
 
 module Wallaby
   class Configuration
-    # Metadata configuration
+    # @deprecated
     class Metadata
-      # @!attribute [w] max
-      attr_writer :max
+      # @deprecated
+      def max=(_max)
+        Deprecator.alert 'config.metadata.max=', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set .max_text_length= from the controller instead, for example:
 
-      # @!attribute [r] resources_controller
-      # To globally configure max number of characters to truncate.
-      # @example To update max number of characters to truncate to 50 in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.metadata.max = 50
-      #   end
-      # @return [Integer] max number of characters to truncate, default to 20
-      # @since wallaby-5.1.6
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.max_text_length = 50
+            end
+        INSTRUCTION
+      end
+
+      # @deprecated
       def max
-        @max ||= DEFAULT_MAX
+        Deprecator.alert 'config.metadata.max', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.max_text_length instead.
+        INSTRUCTION
       end
     end
   end

data/lib/wallaby/configuration/models.rb

@@ -2,40 +2,42 @@
 
 module Wallaby
   class Configuration
-    # @deprecated will move this configuration to {Wallaby::ResourcesController} from 6.2
-    # Models configuration to specify the model classes that Wallaby should handle.
+    # @deprecated
     class Models
-      # @note If models are whitelisted, models exclusion will NOT be applied.
-      # To globally configure what model classes that Wallaby should handle.
-      # @example To whitelist the model classes in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.models = [Product, Order]
-      #   end
-      # @param models [Array<Class, String>]
-      def set(*models)
-        @models = ClassArray.new(models.flatten)
+      # @deprecated
+      def set(*_models)
+        Deprecator.alert 'config.models.set', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set #models= from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.models = User, 'Product'
+            end
+        INSTRUCTION
       end
 
-      # @return [Array<Class>] the models configured
+      # @deprecated
       def presence
-        @models ||= ClassArray.new # rubocop:disable Naming/MemoizedInstanceVariableName
+        Deprecator.alert 'config.models.presence', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.models instead.
+        INSTRUCTION
       end
 
-      # @note If models are whitelisted using {#set}, models exclusion will NOT be applied.
-      # To globally configure what model classes to exclude.
-      # @example To exclude models in `config/initializers/wallaby.rb`
-      #   Wallaby.config do |config|
-      #     config.models.exclude Product, Order
-      #   end
-      # @param models [Array<Class, String>]
-      def exclude(*models)
-        @excludes = ClassArray.new(models.flatten)
+      # @deprecated
+      def exclude(*_models)
+        Deprecator.alert 'config.models.exclude', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please set #models_to_exclude from the controller instead, for example:
+
+            class Admin::ApplicationController < Wallaby::ResourcesController
+              self.models_to_exclude User, 'Product'
+            end
+        INSTRUCTION
       end
 
-      # @return [Array<Class>] the list of models to exclude.
-      #   By default, `ActiveRecord::SchemaMigration` is excluded.
+      # @deprecated
       def excludes
-        @excludes ||= ClassArray.new ['ActiveRecord::SchemaMigration']
+        Deprecator.alert 'config.models.excludes', from: '0.3.0', alternative: <<~INSTRUCTION
+          Please use controller_class.models_to_exclude instead.
+        INSTRUCTION
       end
     end
   end