wallaby-core 0.2.1 → 0.2.2

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