wallaby-core 0.2.1 → 0.2.2

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

@@ -7,10 +7,15 @@ require 'wallaby/view'
 
 require 'wallaby/core/version'
 require 'wallaby/constants'
+require 'wallaby/logger'
+require 'wallaby/preloader'
 require 'wallaby/engine'
 
-require 'support/action_dispatch/routing/mapper'
-
+# Global class attributes that holds the most important configuration/information
+# NOTE: DO NOT store any Class in both configuration and map
+require 'wallaby/classifier'
+require 'wallaby/class_array'
+require 'wallaby/class_hash'
 require 'wallaby/configuration'
 require 'wallaby/configuration/features'
 require 'wallaby/configuration/mapping'
@@ -21,6 +26,8 @@ require 'wallaby/configuration/security'
 require 'wallaby/configuration/sorting'
 require 'wallaby/map'
 
+require 'support/action_dispatch/routing/mapper'
+
 require 'routes/wallaby/resources_router'
 require 'tree/wallaby/node'
 require 'parsers/wallaby/parser'
@@ -28,11 +35,9 @@ require 'parsers/wallaby/parser'
 require 'utils/wallaby/field_utils'
 require 'utils/wallaby/filter_utils'
 require 'utils/wallaby/locale'
-require 'utils/wallaby/logger'
 require 'utils/wallaby/model_utils'
 require 'utils/wallaby/module_utils'
 require 'utils/wallaby/params_utils'
-require 'utils/wallaby/preload_utils'
 require 'utils/wallaby/test_utils'
 require 'utils/wallaby/utils'
 
@@ -51,7 +56,6 @@ require 'concerns/wallaby/prefixable'
 require 'concerns/wallaby/resourcable'
 require 'concerns/wallaby/servicable'
 require 'concerns/wallaby/shared_helpers'
-# require 'concerns/wallaby/themeable'
 
 require 'interfaces/wallaby/mode'
 require 'interfaces/wallaby/model_decorator'
@@ -61,6 +65,8 @@ require 'interfaces/wallaby/model_pagination_provider'
 require 'interfaces/wallaby/model_authorization_provider'
 
 require 'errors/wallaby/general_error'
+
+require 'errors/wallaby/class_not_found'
 require 'errors/wallaby/invalid_error'
 require 'errors/wallaby/not_implemented'
 require 'errors/wallaby/not_found'
@@ -101,9 +107,9 @@ require 'helpers/wallaby/links_helper'
 require 'helpers/wallaby/styling_helper'
 
 require 'helpers/wallaby/base_helper'
-require 'helpers/wallaby/resources_helper'
-require 'helpers/wallaby/secure_helper'
 require 'helpers/wallaby/application_helper'
+require 'helpers/wallaby/secure_helper'
+require 'helpers/wallaby/resources_helper'
 
 require 'responders/wallaby/resources_responder'
 require 'responders/wallaby/json_api_responder'

data/lib/wallaby/core/version.rb

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

data/lib/wallaby/engine.rb

@@ -3,40 +3,29 @@
 module Wallaby
   # Wallaby engine
   class Engine < ::Rails::Engine
-    initializer 'wallaby.autoload_paths', before: :set_load_path do |_|
-      # NOTE: this needs to be run before `set_load_path`
-      # so that files under `app/views` can be eager loaded
-      # and therefore, Wallaby's renderer can function properly
-      [Rails.configuration].each do |conf|
-        next if conf.paths['app/views'].eager_load?
-
-        conf.paths.add 'app/views', eager_load: true
-      end
-    end
-
     initializer 'wallaby.development.reload' do |_|
       # NOTE: Rails reload! will hit here
       # @see http://rmosolgo.github.io/blog/2017/04/12/watching-files-during-rails-development/
       config.to_prepare do
         if Rails.env.development? || Rails.configuration.eager_load
-          Logger.debug '  [WALLABY] Reloading...'
-          ::Wallaby::Map.clear
-          ::Wallaby::PreloadUtils.require_all
+          Logger.debug 'Reloading after Rails\' reload...', sourcing: false
+          Map.clear
+          Preloader.require_all
         end
       end
     end
 
     config.before_eager_load do
-      # NOTE: We need to ensure that the core models are loaded before anything else
-      Logger.debug '  [WALLABY] Preload all model files.'
-      ::Wallaby::PreloadUtils.require_one 'app/models'
+      # NOTE: The models must be loaded before everything else
+      Logger.debug 'Preload all `app/models` files.', sourcing: false
+      Preloader.require_models
     end
 
-    # Preload the rest files
     config.after_initialize do
+      # Load the rest files
       unless Rails.env.development? || Rails.configuration.eager_load
-        Logger.debug '  [WALLABY] Preload files after initialize.'
-        ::Wallaby::PreloadUtils.require_all
+        Logger.debug 'Preload all other eager load files after initialize.', sourcing: false
+        Preloader.require_all
       end
     end
   end

data/lib/wallaby/logger.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Custom logger
+  module Logger
+    class << self
+      %i(unknown fatal error warn info debug deprecated).each do |method_id|
+        define_method method_id do |message, replacements = {}|
+          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,
+            "#{heading}#{method_id.to_s.upcase}: #{format new_message, replacements}#{from}"
+          )
+          nil
+        end
+      end
+
+      protected
+
+      # @param message [Object]
+      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")}"]
+        end
+      end
+    end
+  end
+end

data/lib/wallaby/map.rb

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Global storage to hold all the information that Wallaby needs to look up.
+  # All the lookups that Wallaby needs.
   class Map
     class << self
-      # To store modes
+      include Classifier
+
+      # @!attribute [w] modes
       attr_writer :modes
 
-      # @return [Array<Class>] descendants of Mode
+      # @!attribute [r] modes
+      # @return [Array<String>] all {Wallaby::Mode}s
       def modes
-        @modes ||= Mode.descendants
+        @modes ||= ClassArray.new Mode.descendants
       end
 
-      # @return [Hash] { model => mode }
+      # @return [Wallaby::ClassHash] { Model Class => {Wallaby::Mode} }
       def mode_map
-        @mode_map ||= ModeMapper.new(modes).map.freeze
+        @mode_map ||= ModeMapper.execute(modes).freeze
       end
 
       # TODO: remove this method
       # @return [Array] [ model classes ]
       def model_classes
-        @model_classes ||= ModelClassCollector.new(configuration, mode_map.keys).collect.freeze
+        ModelClassCollector.new(configuration, mode_map.keys).collect
       end
 
       # { model => resources name }
@@ -30,7 +33,7 @@ module Wallaby
       # @param value [String, nil] resources name
       # @return [String] resources name
       def resources_name_map(model_class, value = nil)
-        @resources_name_map ||= {}
+        @resources_name_map ||= ClassHash.new
         @resources_name_map[model_class] ||= value || ModelUtils.to_resources_name(model_class)
       end
 
@@ -40,7 +43,7 @@ module Wallaby
       # @param resources_name [String]
       # @return [Class]
       def model_class_map(resources_name, value = nil)
-        @model_class_map ||= {}
+        @model_class_map ||= ClassHash.new
         @model_class_map[resources_name] ||= value || ModelUtils.to_model_class(resources_name)
       end
     end
@@ -61,7 +64,7 @@ module Wallaby
       # @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 :@decorator_map, model_class, application_decorator
+        map_of :@resource_decorator_map, model_class, application_decorator
       end
 
       # { model => model decorator }
@@ -70,8 +73,8 @@ module Wallaby
       # @return [Wallaby::ModelDecorator] model decorator instance
       def model_decorator_map(model_class, application_decorator = nil)
         application_decorator ||= mapping.resource_decorator
-        @model_decorator_map ||= {}
-        @model_decorator_map[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
@@ -109,7 +112,7 @@ module Wallaby
       # @param model_class [Class]
       # @return [Class] model service provider instance
       def service_provider_map(model_class)
-        @service_provider_map ||= {}
+        @service_provider_map ||= ClassHash.new
         @service_provider_map[model_class] ||= mode_map[model_class].try :model_service_provider
       end
 
@@ -117,7 +120,7 @@ module Wallaby
       # @param model_class [Class]
       # @return [Class] model pagination provider class
       def pagination_provider_map(model_class)
-        @pagination_provider_map ||= {}
+        @pagination_provider_map ||= ClassHash.new
         @pagination_provider_map[model_class] ||= mode_map[model_class].try :model_pagination_provider
       end
 
@@ -125,7 +128,7 @@ module Wallaby
       # @param model_class [Class]
       # @return [Class] model authorizer provider class
       def authorizer_provider_map(model_class)
-        @authorizer_provider_map ||= {}
+        @authorizer_provider_map ||= ClassHash.new
         @authorizer_provider_map[model_class] ||= mode_map[model_class].try :model_authorization_providers
       end
     end
@@ -157,10 +160,10 @@ module Wallaby
         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
+          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) || {})
+        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

data/lib/wallaby/preloader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Preload files for eager load paths.
+  #
+  # As Wallaby is built upon the {Wallaby::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),
+  # especially the files under `app/models`, need to be loaded before everything else.
+  class Preloader
+    include ActiveModel::Model
+
+    # Require all files
+    # @see #all_file_paths
+    def self.require_all
+      new.all_file_paths.each(&method(:require_dependency))
+    end
+
+    # Require models under {Wallaby::Configuration#model_paths}
+    # @see #model_file_paths
+    def self.require_models
+      new.model_file_paths.each(&method(:require_dependency))
+    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}
+    def model_file_paths
+      sort(all_eager_load_file_paths).select(&method(:indexed))
+    end
+
+    # @!attribute [w] eager_load_paths
+    attr_writer :eager_load_paths
+
+    # @!attribute [r] eager_load_paths
+    # @return [Array<String, Pathname>]
+    def eager_load_paths # :nodoc:
+      @eager_load_paths ||= Rails.configuration.eager_load_paths
+    end
+
+    # @!attribute [w] model_paths
+    attr_writer :model_paths
+
+    # @!attribute [r] model_paths
+    # @return [Array<String>]
+    def model_paths # :nodoc:
+      @model_paths ||= Wallaby.configuration.model_paths
+    end
+
+    private
+
+    def all_eager_load_file_paths # :nodoc:
+      Dir.glob(eager_load_paths.map { |load_path| "#{load_path}/**/*.rb" })
+    end
+
+    # All files need to be sorted in the following orders:
+    # 1. {Wallaby::Configuration#model_paths} order
+    # 2. Alphabet order
+    def sort(file_paths)
+      file_paths.sort { |p1, p2| conditions_for(p1) <=> conditions_for(p2) }
+    end
+
+    # @see #sort
+    def conditions_for(path)
+      [indexed(path) || model_paths.length, path]
+    end
+
+    # Check if the path is in the {Wallaby::Configuration#model_paths}
+    def indexed(path)
+      model_paths.index(&path.method(:include?))
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wallaby-core
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Tian Chen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-22 00:00:00.000000000 Z
+date: 2020-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -147,6 +147,7 @@ files:
 - lib/concerns/wallaby/servicable.rb
 - lib/concerns/wallaby/shared_helpers.rb
 - lib/decorators/wallaby/resource_decorator.rb
+- lib/errors/wallaby/class_not_found.rb
 - lib/errors/wallaby/forbidden.rb
 - lib/errors/wallaby/general_error.rb
 - lib/errors/wallaby/invalid_error.rb
@@ -195,13 +196,14 @@ files:
 - lib/utils/wallaby/field_utils.rb
 - lib/utils/wallaby/filter_utils.rb
 - lib/utils/wallaby/locale.rb
-- lib/utils/wallaby/logger.rb
 - lib/utils/wallaby/model_utils.rb
 - lib/utils/wallaby/module_utils.rb
 - lib/utils/wallaby/params_utils.rb
-- lib/utils/wallaby/preload_utils.rb
 - lib/utils/wallaby/test_utils.rb
 - lib/utils/wallaby/utils.rb
+- lib/wallaby/class_array.rb
+- lib/wallaby/class_hash.rb
+- lib/wallaby/classifier.rb
 - lib/wallaby/configuration.rb
 - lib/wallaby/configuration/features.rb
 - lib/wallaby/configuration/mapping.rb
@@ -214,7 +216,9 @@ files:
 - lib/wallaby/core.rb
 - lib/wallaby/core/version.rb
 - lib/wallaby/engine.rb
+- lib/wallaby/logger.rb
 - lib/wallaby/map.rb
+- lib/wallaby/preloader.rb
 homepage: https://github.com/wallaby-rails/wallaby-core
 licenses:
 - MIT

data/lib/utils/wallaby/logger.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Custom logger
-  module Logger
-    class << self
-      %w(unknown fatal error warn info debug).each do |method_id|
-        define_method method_id do |message, replacements = {}|
-          message = message.inspect unless message.is_a? String
-          sourcing = replacements.delete :sourcing # sourcing can be set to false
-
-          from = "\nfrom #{caller[sourcing || 0]}" unless sourcing == false
-          Rails.logger.public_send(
-            method_id, "#{method_id.upcase}: #{format message, replacements}#{from}"
-          )
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/utils/wallaby/preload_utils.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Preload utils
-  module PreloadUtils
-    class << self
-      # Preload all files under app folder
-      def require_all
-        eager_load_paths.map(&method(:require_one))
-      end
-
-      # Require files under a load path
-      # @param load_path [String, Pathname]
-      # @see https://api.rubyonrails.org/classes/Rails/Engine.html#method-i-eager_load-21 Rails::Engine#eager_load!
-      def require_one(load_path)
-        Dir.glob("#{load_path}/**/*.rb").sort.each(&method(:load_class_for))
-      end
-
-      protected
-
-      # @return [Array<String, Pathname>] a list of sorted eager load paths which lists `app/models`
-      #   at highest precedence
-      def eager_load_paths
-        Rails.configuration.eager_load_paths.sort_by do |path|
-          - path.to_s.index(%r{/models$}).to_i
-        end
-      end
-
-      # `constantize` is used to make Rails to handle all sort of load errors
-      #
-      # NOTE: don't try to use `ActiveSupport::Dependencies::Loadable.require_dependency`.
-      # As `require_dependency` does not take care all errors raised when class/module is loaded.
-      # @param file_path [Pathname, String]
-      def load_class_for(file_path)
-        module_name = file_path[%r{app/[^/]+/(.+)\.rb}, 1].gsub('/concerns/', '/')
-        class_name = module_name.camelize
-        class_name.constantize unless Module.const_defined? class_name
-      rescue NameError, LoadError => e
-        Rails.logger.debug "  [WALLABY] Preload warning: #{e.message} from #{file_path}"
-        Rails.logger.debug e.backtrace.slice(0, 5)
-      end
-    end
-  end
-end