wallaby-core 0.2.11 → 0.3.0.beta2

data/lib/wallaby/deprecator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Deprecation log for methods
+  class Deprecator
+    include ActiveModel::Model
+
+    # @!attribute method_instance
+    # @return [Method]
+    attr_accessor :method_instance
+    # @!attribute from
+    # @return [String]
+    attr_accessor :from
+    # @!attribute mod
+    # @return [Class]
+    attr_accessor :mod
+    # @!attribute alternative
+    # @return [Method]
+    attr_accessor :alternative
+
+    # Log an warning deprecation message or raise {MethodRemoved} when the given method is obsolete.
+    # @param method_instance [Method] deprecated/obsolete method
+    # @param from [String] from/since version
+    # @param mod [Class] class name which has `VERSION` constants
+    # @param alternative [Method] method to replace the deprecated/obsolete one
+    # @see #alert
+    def self.alert(method_instance, from:, mod: Core, alternative: nil)
+      new(
+        method_instance: method_instance, from: from, mod: mod, alternative: alternative
+      ).alert
+    end
+
+    # @raise [MethodRemoved] when given method is obsolete
+    def alert
+      # if current version is larger than from version
+      already = Gem::Version.new(mod_version) >= Gem::Version.new(from)
+      raise MethodRemoved, obsolete_message if already
+
+      Logger.warn deprecated_message, sourcing: 2
+    end
+
+    protected
+
+    def obsolete_message
+      "ERROR: #{full method_instance} is removed since #{mod_name} #{from}. #{alternative_message}"
+    end
+
+    def deprecated_message
+      "DEPRECATED: #{full method_instance} will be removed from #{mod_name} #{from}. #{alternative_message}"
+    end
+
+    def alternative_message
+      return "Please use #{full alternative} instead." if alternative.is_a? Method
+
+      alternative.to_s
+    end
+
+    def mod_name
+      return mod unless mod.is_a? Module
+
+      mod.name.underscore.gsub SLASH, HYPHEN
+    end
+
+    def mod_version
+      return mod unless mod.is_a? Module
+
+      mod::VERSION
+    end
+
+    # @param method_instance [Method]
+    # @return [String] `Class.class_method` or `Class#instance_method`
+    def full(method_instance)
+      return method_instance unless method_instance.is_a? Method
+
+      owner = method_instance.owner
+      is_klass_method = owner.singleton_class?
+      klass = is_klass_method ? owner.to_s[8..-2] : owner.name
+      "#{klass}#{is_klass_method ? DOT : HASH}#{method_instance.name}"
+    end
+  end
+end

data/lib/wallaby/engine.rb

@@ -7,25 +7,8 @@ module Wallaby
       # NOTE: Rails reload! will hit here
       # @see https://rmosolgo.github.io/ruby/rails/2017/04/12/watching-files-during-rails-development.html
       config.to_prepare do
-        Map.clear
-        Preloader.clear
+        Map.clear if Rails.env.development? || Rails.configuration.eager_load
       end
     end
-
-    config.before_eager_load do
-      Logger.debug 'Preload all model files before everything else.', sourcing: false
-      Preloader.require_models
-    end
-
-    config.after_initialize do
-      # Preload will be postponed to Map when `cache_classes` is set to false
-      next unless Rails.configuration.cache_classes
-      # Models are preloaded in `before_eager_load` block,
-      # therefore, it's not essential to preload all files Since Rails will do it
-      next if Rails.configuration.eager_load
-
-      Logger.debug 'Preload all files in model first and non-model last order', sourcing: false
-      Preloader.require_all
-    end
   end
 end

data/lib/wallaby/guesser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Guess the associated class for give class
+  class Guesser
+    SUFFIX = /(Controller|Decorator|Servicer|Authorizer|Paginator)$/.freeze # :no_doc:
+
+    class << self
+      # Find out the first demodulized class constant for the give class name.
+      # For example, if given class name is **Admin::Order::ItemsController**,
+      # then it will try to constantize the following demodulized class names
+      # and return the first one that is successfully constantized:
+      #
+      # - Admin::Order::Item
+      # - Order::Item
+      # - Item
+      # @param class_name [String]
+      # @param options [Hash]
+      # @return [Class] found associated class
+      # @return [nil] if not found
+      def class_for(class_name, options = {}, &block)
+        suffix = options[:suffix] || EMPTY_STRING
+        replacement = options[:replacement] || SUFFIX
+        denamespace = options.key?(:denamespace) ? options[:denamespace] : true
+        base_name = class_name.gsub(replacement, EMPTY_STRING).singularize << suffix
+        possible_class_from(base_name, denamespace: denamespace, &block)
+      end
+
+      def possible_class_from(class_name, denamespace: false)
+        target = nil
+        parts = denamespace ? class_name.split(COLONS) : [class_name]
+        parts.each_with_index.find do |_, index|
+          klass = Classifier.to_class(parts[index..].join(COLONS))
+          next unless klass
+          # additional checking, the given block should return true to continue
+          next if block_given? && !yield(klass)
+
+          target = klass
+        end
+
+        target
+      end
+    end
+  end
+end

data/lib/wallaby/logger.rb

@@ -4,31 +4,53 @@ module Wallaby
   # Custom logger
   module Logger
     class << self
-      %i(unknown fatal error warn info debug deprecated).each do |method_id|
+      %i[unknown fatal error warn info debug].each do |method_id|
         define_method method_id do |message, replacements = {}|
-          sourcing = replacements.delete :sourcing # sourcing can be set to false
+          sourcing = replacements.delete(:sourcing) # sourcing can be set to false
           heading = replacements.delete(:heading) || 'WALLABY '
-          new_message, from = normalize message, sourcing != false && Array(caller[sourcing || 0]) || nil
-          Rails.logger.public_send(
-            method_id == :deprecated ? :warn : method_id,
+          new_message, from = normalize(
+            message, (sourcing != false && Array.wrap(caller[sourcing || 0])) || nil
+          )
+          Wallaby.configuration.logger.try(
+            method_id,
             "#{heading}#{method_id.to_s.upcase}: #{format new_message, replacements}#{from}"
           )
           nil
         end
       end
 
+      # @param key [Symbol,String]
+      # @param message_or_config [String, false]
+      # @param replacements [Hash]
+      # @example to disable a particular hint message:
+      #   Wallaby::Logger.hint(:customize_controller, false) if Wallaby::Logger.debug?
+      def hint(key, message_or_config, replacements = {})
+        @hint ||= {}
+        return @hint[key] = false if message_or_config == false
+        return if @hint[key] == false || !message_or_config.is_a?(String)
+
+        new_message = <<~MESSAGE
+          #{message_or_config}
+          This kind of debug message can be disabled in `config/initializers/wallaby.rb`:
+
+            Wallaby::Logger.hint(#{key.inspect}, false) if Wallaby::Logger.debug?
+        MESSAGE
+        debug(new_message, replacements.merge(sourcing: false))
+      end
+
       protected
 
-      # @param message [Object]
+      # @param message [String,StandardError,Object]
+      # @param sources [Array<String>] array of files
       def normalize(message, sources)
-        case message
-        when String
-          [message, sources && "\nfrom #{sources.join("     \n")}"]
-        when StandardError
-          [message.message, sources && "\n#{message.backtrace.join("\n")}"]
-        else
-          [message.inspect, sources && "\nfrom #{sources.join("     \n")}"]
+        if message.is_a?(StandardError)
+          return [
+            message.message,
+            sources && "\n#{message.backtrace.join("\n")}"
+          ]
         end
+
+        [message.to_s, sources && "\nfrom #{sources.join("     \n")}"]
       end
     end
   end

data/lib/wallaby/map.rb

@@ -10,24 +10,23 @@ module Wallaby
       attr_writer :modes
 
       # @!attribute [r] modes
-      # @return [Array<String>] all {Wallaby::Mode}s
+      # @return [Array<String>] all {Mode}s
       def modes
         @modes ||= ClassArray.new Mode.descendants
       end
 
-      # @return [Wallaby::ClassHash] { Model Class => {Wallaby::Mode} }
+      # @return [ClassHash] { Model Class => {Mode} }
       def mode_map
         @mode_map ||= begin
-          # NOTE: this is the point where all files should be required
-          Preloader.require_all
+          # NOTE: this is the point where all model files should be required
+          Preloader.require_models
           ModeMapper.execute(modes).freeze
         end
       end
 
-      # TODO: remove this method
-      # @return [Array] [ model classes ]
+      # @deprecated
       def model_classes
-        ModelClassCollector.new(configuration, mode_map.keys).collect
+        Deprecator.alert method(__callee__), from: '0.3.0'
       end
 
       # { model => resources name }
@@ -38,7 +37,7 @@ module Wallaby
       # @return [String] resources name
       def resources_name_map(model_class, value = nil)
         @resources_name_map ||= ClassHash.new
-        @resources_name_map[model_class] ||= value || ModelUtils.to_resources_name(model_class)
+        @resources_name_map[model_class] ||= value || Inflector.to_resources_name(model_class)
       end
 
       # { resources name => model }
@@ -48,67 +47,21 @@ module Wallaby
       # @return [Class]
       def model_class_map(resources_name, value = nil)
         @model_class_map ||= ClassHash.new
-        @model_class_map[resources_name] ||= value || ModelUtils.to_model_class(resources_name)
+        @model_class_map[resources_name] ||= value || Classifier.to_class(Inflector.to_model_name(resources_name))
       end
     end
 
     class << self
-      # Look up which controller to use for a given model class
-      # @param model_class [Class]
-      # @param application_controller [Class, nil]
-      # @return [Class] controller class, default to `mapping.resources_controller`
-      def controller_map(model_class, application_controller = nil)
-        application_controller ||= mapping.resources_controller
-        map_of :@controller_map, model_class, application_controller
-      end
-
-      # Look up which resource decorator to use for a given model class
-      # @param model_class [Class]
-      # @param application_decorator [Class, nil]
-      # @return [Class] resource decorator class, default to `mapping.resource_decorator`
-      def resource_decorator_map(model_class, application_decorator = nil)
-        application_decorator ||= mapping.resource_decorator
-        map_of :@resource_decorator_map, model_class, application_decorator
-      end
-
       # { model => model decorator }
       # @param model_class [Class]
-      # @param application_decorator [Class, nil]
-      # @return [Wallaby::ModelDecorator] model decorator instance
-      def model_decorator_map(model_class, application_decorator = nil)
-        application_decorator ||= mapping.resource_decorator
+      # @param application_decorator [Class]
+      # @return [ModelDecorator] model decorator instance
+      def model_decorator_map(model_class, application_decorator)
         @model_decorator_map ||= ClassHash.new
         @model_decorator_map[application_decorator] ||= ClassHash.new
         @model_decorator_map[application_decorator][model_class] ||=
           mode_map[model_class].try(:model_decorator).try :new, model_class
       end
-
-      # Look up which model servicer to use for a given model class
-      # @param model_class [Class]
-      # @param application_servicer [Class, nil]
-      # @return [Class] model servicer class, default to `mapping.model_servicer`
-      def servicer_map(model_class, application_servicer = nil)
-        application_servicer ||= mapping.model_servicer
-        map_of :@servicer_map, model_class, application_servicer
-      end
-
-      # Look up which paginator to use for a given model class
-      # @param model_class [Class]
-      # @param application_paginator [Class, nil]
-      # @return [Class] resource paginator class, default to `mapping.model_paginator`
-      def paginator_map(model_class, application_paginator = nil)
-        application_paginator ||= mapping.model_paginator
-        map_of :@paginator_map, model_class, application_paginator
-      end
-
-      # Look up which authorizer to use for a given model class
-      # @param model_class [Class]
-      # @param application_authorizer [Class, nil]
-      # @return [Class] model authorizer class, default to `mapping.model_authorizer`
-      def authorizer_map(model_class, application_authorizer = nil)
-        application_authorizer ||= mapping.model_authorizer
-        map_of :@authorizer_map, model_class, application_authorizer
-      end
     end
 
     class << self
@@ -142,36 +95,6 @@ module Wallaby
       def clear
         instance_variables.each { |name| instance_variable_set name, nil }
       end
-
-      private
-
-      # shorthand method
-      def configuration
-        ::Wallaby.configuration
-      end
-
-      # shorthand method
-      def mapping
-        configuration.mapping
-      end
-
-      # Set up the hash map for given variable name
-      # @param variable_name [Symbol] instance variable name e.g. :@decorator_map
-      # @param model_class [Class]
-      # @param application_class [Class]
-      # @return [Class]
-      def map_of(variable_name, model_class, application_class)
-        return unless model_class
-
-        unless mode_map[model_class]
-          Logger.warn Locale.t('map.missing_mode_for_model_class', model: model_class.name), sourcing: 2..5
-          return
-        end
-        instance_variable_set(variable_name, instance_variable_get(variable_name) || ClassHash.new)
-        map = instance_variable_get variable_name
-        map[application_class] ||= ModelClassMapper.map application_class.descendants
-        map[application_class][model_class] ||= application_class
-      end
     end
   end
 end

data/lib/wallaby/preloader.rb

@@ -3,7 +3,7 @@
 module Wallaby
   # Preload files for eager load paths.
   #
-  # As Wallaby is built upon the {Wallaby::Map} which will not be completed
+  # As Wallaby is built upon the {Map} which will not be completed
   # until all models and decorators/controllers/servicers/authorizers/paginators
   # are loaded. Therefore, when Rails app is initialized,
   # all files under eager load paths (mostly `app/*` folders),
@@ -12,35 +12,16 @@ module Wallaby
     include ActiveModel::Model
 
     class << self
-      def clear
-        @all_required = nil
-      end
-
-      # Require all files
-      # @see #all_file_paths
-      def require_all
-        return if @all_required
-
-        @all_required = true
-        Logger.debug 'Loading all files', sourcing: false
-        new.all_file_paths.each(&method(:require_dependency))
-      end
-
-      # Require models under {Wallaby::Configuration#model_paths}
+      # Require models under {Configuration#model_paths}
       # @see #model_file_paths
       def require_models
-        new.model_file_paths.each(&method(:require_dependency))
+        new.model_file_paths.each { |path| require_dependency(path) } # rubocop:disable Rails/RequireDependency, Lint/RedundantCopDisableDirective
       end
     end
 
-    # @return [Array<String>] all files under **Rails.configuration.eager_load_paths**
-    def all_file_paths
-      sort(all_eager_load_file_paths)
-    end
-
-    # @return [Array<String>] model files under {Wallaby::Configuration#model_paths}
+    # @return [Array<String>] model files under {Configuration#model_paths}
     def model_file_paths
-      sort(all_eager_load_file_paths).select(&method(:indexed))
+      sort(all_eager_load_file_paths).select { |path| indexed(path) }
     end
 
     # @!attribute [w] eager_load_paths
@@ -52,7 +33,6 @@ module Wallaby
       @eager_load_paths ||=
         Rails.configuration.paths['app'].expanded
           .concat(Rails.configuration.eager_load_paths)
-          .uniq
     end
 
     # @!attribute [w] model_paths
@@ -71,7 +51,7 @@ module Wallaby
     end
 
     # All files need to be sorted in the following orders:
-    # 1. {Wallaby::Configuration#model_paths} order
+    # 1. {Configuration#model_paths} order
     # 2. Alphabet order
     def sort(file_paths)
       file_paths.sort { |p1, p2| conditions_for(p1) <=> conditions_for(p2) }
@@ -82,9 +62,9 @@ module Wallaby
       [indexed(path) || model_paths.length, path]
     end
 
-    # Check if the path is in the {Wallaby::Configuration#model_paths}
+    # Check if the path is in the {Configuration#model_paths}
     def indexed(path)
-      model_paths.index(&path.method(:include?))
+      model_paths.index { |p| path.include?(p) }
     end
   end
 end