wallaby-core 0.2.0 → 0.2.4

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,19 +26,25 @@ 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'
 
 require 'utils/wallaby/field_utils'
 require 'utils/wallaby/filter_utils'
+require 'utils/wallaby/locale'
 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'
 
+require 'concerns/wallaby/application_concern'
+require 'concerns/wallaby/authentication_concern'
+require 'concerns/wallaby/resources_concern'
+
 require 'concerns/wallaby/authorizable'
 require 'concerns/wallaby/baseable'
 require 'concerns/wallaby/decoratable'
@@ -45,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'
@@ -55,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'
@@ -95,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/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
-          Rails.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
-      Rails.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
-        Rails.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]
-          Rails.logger.warn I18n.t('wallaby.map.missing_mode_for_model_class', model: model_class.name)
+          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.0
+  version: 0.2.4
 platform: ruby
 authors:
 - Tian Chen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-15 00:00:00.000000000 Z
+date: 2022-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -117,9 +117,7 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- app/controllers/wallaby/application_controller.rb
 - app/controllers/wallaby/resources_controller.rb
-- app/controllers/wallaby/secure_controller.rb
 - app/security/ability.rb
 - config/locales/wallaby.en.yml
 - config/locales/wallaby_class.en.yml
@@ -134,6 +132,8 @@ files:
 - lib/authorizers/wallaby/default_authorization_provider.rb
 - lib/authorizers/wallaby/model_authorizer.rb
 - lib/authorizers/wallaby/pundit_authorization_provider.rb
+- lib/concerns/wallaby/application_concern.rb
+- lib/concerns/wallaby/authentication_concern.rb
 - lib/concerns/wallaby/authorizable.rb
 - lib/concerns/wallaby/baseable.rb
 - lib/concerns/wallaby/decoratable.rb
@@ -143,9 +143,11 @@ files:
 - lib/concerns/wallaby/paginatable.rb
 - lib/concerns/wallaby/prefixable.rb
 - lib/concerns/wallaby/resourcable.rb
+- lib/concerns/wallaby/resources_concern.rb
 - 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
@@ -193,12 +195,15 @@ files:
 - lib/tree/wallaby/node.rb
 - lib/utils/wallaby/field_utils.rb
 - lib/utils/wallaby/filter_utils.rb
+- lib/utils/wallaby/locale.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
@@ -211,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
@@ -219,7 +226,7 @@ metadata:
   homepage_uri: https://github.com/wallaby-rails/wallaby-core
   source_code_uri: https://github.com/wallaby-rails/wallaby-core
   changelog_uri: https://github.com/wallaby-rails/wallaby-core/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -234,8 +241,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: The core of Wallaby
 test_files: []

data/app/controllers/wallaby/application_controller.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Like ordinary Rails application, it's the base controller that
-  # other Wallaby controllers inherit from.
-  #
-  # However, the difference is that the controller class that {Wallaby::ApplicationController} inherits from
-  # can be configured via {Wallaby::Configuration#base_controller}
-  #
-  # Here, it provides the most basic functions e.g. error handling for common 4xx HTTP status, helpers method,
-  # and URL handling.
-  class ApplicationController < configuration.base_controller
-    extend Engineable::ClassMethods
-    include Engineable
-    include SharedHelpers
-    helper ApplicationHelper
-
-    rescue_from NotFound, with: :not_found
-    rescue_from ::ActionController::ParameterMissing, with: :bad_request
-    rescue_from ::ActiveRecord::StatementInvalid, with: :unprocessable_entity
-    rescue_from NotImplemented, with: :not_implemented
-    rescue_from UnprocessableEntity, with: :unprocessable_entity
-
-    delegate(*ConfigurationHelper.instance_methods(false), :url_for, to: :helpers)
-
-    # Health check page for e.g. NewRelic
-    def healthy
-      render plain: 'healthy'
-    end
-
-    # Not found page
-    # @param exception [Exception] comes from **rescue_from**
-    def not_found(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # Bad request page
-    # @param exception [Exception] comes from **rescue_from**
-    def bad_request(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # Unprocessable entity page
-    # @param exception [Exception] comes from **rescue_from**
-    def unprocessable_entity(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # Internal server error page
-    # @param exception [Exception] comes from **rescue_from**
-    def internal_server_error(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # Not implemented
-    # @param exception [Exception] comes from **rescue_from**
-    def not_implemented(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # {https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers helpers}
-    # exists since Rails 5.0, need to mimic this to support Rails 4.2.
-    # @see https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers
-    #   ActionController::Helpers#helpers
-    # @see https://github.com/rails/rails/blob/5-0-stable/actionpack/lib/action_controller/metal/helpers.rb#L118
-    def helpers
-      @helpers ||= defined?(super) ? super : view_context
-    end
-
-    protected
-
-    # Capture exceptions and display the error using error template.
-    # @param exception [Exception]
-    # @param symbol [Symbol] http status symbol
-    def render_error(exception, symbol)
-      Rails.logger.error exception
-
-      @exception = exception
-      @symbol = symbol
-      @code = Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol].to_i
-      respond_with @exception, status: @code, template: ERROR_PATH, prefixes: _prefixes
-    end
-  end
-end

data/app/controllers/wallaby/secure_controller.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # This is the controller with only authentication logics.
-  class SecureController < ::Wallaby::ApplicationController
-    helper SecureHelper
-    helper_method :current_user
-
-    rescue_from NotAuthenticated, with: :unauthorized
-    rescue_from Forbidden, with: :forbidden
-
-    # Unauthorized page.
-    # @param exception [Exception] exception comes from `rescue_from`
-    def unauthorized(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # Forbidden page.
-    # @param exception [Exception] exception comes from `rescue_from`
-    def forbidden(exception = nil)
-      render_error exception, __callee__
-    end
-
-    # @note This is a template method that can be overridden by subclasses
-    # This {current_user} method will try to looking up the actual implementation from the following
-    # places from high precedence to low:
-    #
-    # - {Wallaby::Configuration::Security#current_user}
-    # - `super`
-    # - do nothing
-    #
-    # It can be replaced completely in subclasses:
-    #
-    # ```
-    # def current_user
-    #   # NOTE: please ensure `@current_user` is assigned, for instance:
-    #   @current_user ||= User.new params.slice(:email)
-    # end
-    # ```
-    # @return [Object] a user object
-    def current_user
-      @current_user ||=
-        if security.current_user? || !defined? super
-          instance_exec(&security.current_user)
-        else
-          super
-        end
-    end
-
-    # @note This is a template method that can be overridden by subclasses
-    # This {authenticate_user!} method will try to looking up the actual implementation from the following
-    # places from high precedence to low:
-    #
-    # - {Wallaby::Configuration::Security#authenticate}
-    # - `super`
-    # - do nothing
-    #
-    # It can be replaced completely in subclasses:
-    #
-    # ```
-    # def authenticate_user!
-    #   authenticate_or_request_with_http_basic do |username, password|
-    #     username == 'too_simple' && password == 'too_naive'
-    #   end
-    # end
-    # ```
-    # @return [true] when user is authenticated successfully
-    # @raise [Wallaby::NotAuthenticated] when user fails to authenticate
-    def authenticate_user!
-      authenticated =
-        if security.authenticate? || !defined? super
-          instance_exec(&security.authenticate)
-        else
-          super
-        end
-      raise NotAuthenticated unless authenticated
-
-      true
-    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