wallaby-core 0.2.1 → 0.2.2

data/lib/authorizers/wallaby/pundit_authorization_provider.rb

@@ -1,83 +1,74 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Pundit base authorization provider
+  # @note This authorization provider DOES NOT use the
+  #   {https://github.com/varvet/pundit#customize-pundit-user pundit_user} helper.
+  #   It uses the one from {Wallaby::AuthenticationConcern#wallaby_user #wallaby_user} instead.
+  # {https://github.com/varvet/pundit Pundit} base authorization provider.
   class PunditAuthorizationProvider < ModelAuthorizationProvider
     # Detect and see if Pundit is in use.
-    # @param context [ActionController::Base]
-    # @return [true] if Pundit is in use.
-    # @return [false] if Pundit is not in use.
+    # @param context [ActionController::Base, ActionView::Base]
+    # @return [true] if Pundit is in use
+    # @return [false] otherwise
     def self.available?(context)
       defined?(Pundit) && context.respond_to?(:pundit_user)
     end
 
-    # This will pull out the args required for contruction from context
-    # @param context [ActionController::Base]
-    # @return [Hash] args for initialize
-    def self.args_from(context)
-      { user: context.pundit_user }
-    end
-
-    # @param user [Object]
-    def initialize(user:)
-      @user = user
-    end
-
     # Check user's permission for an action on given subject.
     #
-    # This method will be used in controller.
+    # This method will be mostly used in controller.
     # @param action [Symbol, String]
     # @param subject [Object, Class]
     # @raise [Wallaby::Forbidden] when user is not authorized to perform the action.
     def authorize(action, subject)
       Pundit.authorize(user, subject, normalize(action)) && subject
     rescue ::Pundit::NotAuthorizedError
-      Logger.info Locale.t('errors.unauthorized', user: user, action: action, subject: subject)
+      Logger.error <<~MESSAGE
+        #{Utils.inspect user} is forbidden to perform #{action} on #{Utils.inspect subject}
+      MESSAGE
       raise Forbidden
     end
 
     # Check and see if user is allowed to perform an action on given subject
     # @param action [Symbol, String]
     # @param subject [Object, Class]
-    # @return [Boolean]
+    # @return [true] if user is allowed to perform the action
+    # @return [false] otherwise
     def authorized?(action, subject)
       policy = Pundit.policy! user, subject
-      ModuleUtils.try_to policy, normalize(action)
+      policy.try normalize(action)
     end
 
     # Restrict user to assign certain values.
     #
     # It will do a lookup in policy's methods and pick the first available method:
     #
-    # - attributes\_for\_#\{ action \}
-    # - attributes\_for
+    # - `attributes_for_#{action}`
+    # - `attributes_for`
     # @param action [Symbol, String]
     # @param subject [Object]
     # @return [Hash] field value paired hash that user's allowed to assign
     def attributes_for(action, subject)
       policy = Pundit.policy! user, subject
-      value = ModuleUtils.try_to(policy, "attributes_for_#{action}") || ModuleUtils.try_to(policy, 'attributes_for')
-      Logger.warn Locale.t('error.pundit.not_found.attributes_for', subject: subject) unless value
-      value || {}
+      policy.try("attributes_for_#{action}") || policy.try('attributes_for') || {}
     end
 
     # Restrict user for mass assignment.
     #
     # It will do a lookup in policy's methods and pick the first available method:
     #
-    # - permitted\_attributes\_for\_#\{ action \}
-    # - permitted\_attributes
+    # - `permitted_attributes_for_#{ action }`
+    # - `permitted_attributes`
     # @param action [Symbol, String]
     # @param subject [Object]
     # @return [Array] field list that user's allowed to change.
     def permit_params(action, subject)
       policy = Pundit.policy! user, subject
       # @see https://github.com/varvet/pundit/blob/master/lib/pundit.rb#L258
-      ModuleUtils.try_to(policy, "permitted_attributes_for_#{action}") \
-        || ModuleUtils.try_to(policy, 'permitted_attributes')
+      policy.try("permitted_attributes_for_#{action}") || policy.try('permitted_attributes')
     end
 
-    private
+    protected
 
     # Convert action to pundit method name
     # @param action [Symbol, String]

data/lib/concerns/wallaby/application_concern.rb

@@ -50,7 +50,6 @@ module Wallaby
       extend Engineable::ClassMethods
       include Engineable
       include SharedHelpers
-      helper ApplicationHelper
 
       rescue_from NotFound, with: :not_found
       rescue_from ::ActionController::ParameterMissing, with: :bad_request
@@ -99,7 +98,7 @@ module Wallaby
 
       # (see #render_error)
       def render_error(exception, symbol)
-        Logger.error exception, sourcing: false
+        Logger.error exception
 
         @exception = exception
         @symbol = symbol

data/lib/concerns/wallaby/authentication_concern.rb

@@ -5,6 +5,7 @@ module Wallaby
   module AuthenticationConcern
     extend ActiveSupport::Concern
 
+    # @deprecated Use {#wallaby_user} instead
     # @!method current_user
     # @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
@@ -22,6 +23,7 @@ module Wallaby
     #   end
     # @return [Object] a user object
 
+    # @deprecated Use {#authenticate_wallaby_user!} instead
     # @!method authenticate_user!
     # @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
@@ -41,40 +43,107 @@ module Wallaby
     # @return [true] when user is authenticated successfully
     # @raise [Wallaby::NotAuthenticated] when user fails to authenticate
 
+    # @!method wallaby_user
+    # @note This is a template method that can be overridden by subclasses
+    # This method will try to call {#current_user} from superclass.
+    # @example It can be overridden in subclasses:
+    #   def wallaby_user
+    #     # NOTE: better to assign user to `@wallaby_user` for better performance:
+    #     @wallaby_user ||= User.new params.slice(:email)
+    #   end
+    # @return [Object] a user object
+
+    # @!method pundit_user
+    # @note This is a template method that can be overridden by subclasses
+    # This overridden method of {#original_pundit_user} will try to call {#wallaby_user} instead of {#current_user}.
+    # @example It can be overridden in subclasses:
+    #   def pundit_user
+    #     @pundit_user ||= User.new params.slice(:email)
+    #   end
+    # @return [Object] a user object
+
+    # @!parse alias :override_pundit_user :pundit_user
+
+    # @!method original_pundit_user
+    # This method is the original version of {#pundit_user} which calls the {#current_user}.
+    # @return [Object] a user object
+
+    # @!method authenticate_wallaby_user!
+    # @note This is a template method that can be overridden by subclasses
+    # This method will try to call {#authenticate_user!} from superclass.
+    # And it will be run as the first callback before an action.
+    # @example It can be overridden in subclasses:
+    #   def authenticate_wallaby_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
+
     # @!method unauthorized(exception = nil)
     # Unauthorized page.
-    # @param exception [Exception] exception comes from `rescue_from`
+    # @param exception [Exception] comes from **rescue_from**
 
     # @!method forbidden(exception = nil)
     # Forbidden page.
-    # @param exception [Exception] exception comes from `rescue_from`
+    # @param exception [Exception] comes from **rescue_from**
 
     included do # rubocop:disable Metrics/BlockLength
-      helper SecureHelper
-      helper_method :current_user
+      helper_method :wallaby_user
 
       rescue_from NotAuthenticated, with: :unauthorized
       rescue_from Forbidden, with: :forbidden
 
       # (see #current_user)
+      # TODO: remove this from 6.2
       def current_user
         @current_user ||=
           if security.current_user? || !defined? super
             instance_exec(&security.current_user)
           else
+            Logger.deprecated 'Wallaby will use `wallaby_user` instead of `current_user` from 6.2.'
             super
           end
       end
 
       # (see #authenticate_user!)
+      # TODO: remove this from 6.2
       def authenticate_user!
         authenticated =
           if security.authenticate? || !defined? super
             instance_exec(&security.authenticate)
           else
+            Logger.deprecated 'Wallaby will use `authenticate_wallaby_user!`' \
+              'instead of `authenticate_user!` from 6.2.'
             super
           end
-        raise NotAuthenticated unless authenticated
+        raise NotAuthenticated if authenticated == false
+
+        true
+      end
+
+      # (see #wallaby_user)
+      def wallaby_user
+        @wallaby_user ||= try :current_user
+      end
+
+      if defined?(::Pundit) && instance_methods.include?(:pundit_user)
+        # (see #override_pundit_user)
+        def override_pundit_user
+          wallaby_user
+        end
+
+        # (see #original_pundit_user)
+        alias_method :original_pundit_user, :pundit_user
+        # (see #pundit_user)
+        alias_method :pundit_user, :override_pundit_user
+      end
+
+      # (see #authenticate_wallaby_user!)
+      def authenticate_wallaby_user!
+        authenticated = try :authenticate_user!
+        raise NotAuthenticated if authenticated == false
 
         true
       end

data/lib/concerns/wallaby/authorizable.rb

@@ -20,7 +20,7 @@ module Wallaby
       # @return [Class] model authorizer
       # @raise [ArgumentError] when **model_authorizer** doesn't inherit from **application_authorizer**
       # @see Wallaby::ModelAuthorizer
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       attr_reader :model_authorizer
 
       # @!attribute [w] application_authorizer
@@ -38,7 +38,7 @@ module Wallaby
       # @return [Class] application decorator
       # @raise [ArgumentError] when **model_authorizer** doesn't inherit from **application_authorizer**
       # @see Wallaby::ModelAuthorizer
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def application_authorizer
         @application_authorizer ||= ModuleUtils.try_to superclass, :application_authorizer
       end
@@ -52,11 +52,11 @@ module Wallaby
     # - a generic authorizer based on
     #   {Wallaby::Authorizable::ClassMethods#application_authorizer .application_authorizer}
     # @return [Wallaby::ModelAuthorizer] model authorizer
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     def current_authorizer
       @current_authorizer ||=
         authorizer_of(current_model_class, controller_to_get(:model_authorizer)).tap do |authorizer|
-          Logger.debug %(Current authorizer: #{authorizer.try(:class)})
+          Logger.debug %(Current authorizer: #{authorizer.try(:class)}), sourcing: false
         end
     end
 
@@ -65,7 +65,7 @@ module Wallaby
     # @param subject [Object, Class]
     # @return [true] if allowed
     # @return [false] if not allowed
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     def authorized?(action, subject)
       return false unless subject
 
@@ -78,7 +78,7 @@ module Wallaby
     # @param subject [Object, Class]
     # @return [true] if not allowed
     # @return [false] if allowed
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     def unauthorized?(action, subject)
       !authorized? action, subject
     end
@@ -88,10 +88,10 @@ module Wallaby
     # @param model_class [Class]
     # @param authorizer_class [Class, nil]
     # @return [Wallaby::ModelAuthorizer] model authorizer for given model
-    # @since 5.2.0
+    # @since wallaby-5.2.0
     def authorizer_of(model_class, authorizer_class = nil)
       authorizer_class ||= Map.authorizer_map(model_class, controller_to_get(:application_authorizer))
-      authorizer_class.try :create, self, model_class
+      authorizer_class.new model_class, self
     end
   end
 end

data/lib/concerns/wallaby/baseable.rb

@@ -3,33 +3,114 @@
 module Wallaby
   # Abstract related class methods
   module Baseable
-    # Configurable attributes and class methods for marking a class the base class
-    # and skipping {Wallaby::Map Wallaby mapping}
+    SUFFIX = /(Controller|Decorator|Servicer|Authorizer|Paginator)$/.freeze
+    ATTR_NAME = 'model_class'
+
+    # @param class_name [String]
+    # @param attr_name [String]
+    # @param suffix [String]
+    # @param plural [String]
+    # @return [Class] found associated class
+    # @raise [Wallaby::ClassNotFound] if associated class isn't found
+    def self.guess_associated_class_of(class_name, attr_name: ATTR_NAME, suffix: EMPTY_STRING, plural: false)
+      base_name = class_name.gsub(SUFFIX, EMPTY_STRING).try(plural ? :pluralize : :singularize) << suffix
+      parts = base_name.split(COLONS)
+      parts.each_with_index do |_, index|
+        begin
+          # NOTE: DO NOT try to use const_defined? and const_get EVER.
+          # This is Rails, use constantize
+          return parts[index..-1].join(COLONS).constantize
+        rescue NameError # rubocop:disable Lint/SuppressedException
+        end
+      end
+
+      raise ClassNotFound, <<~INSTRUCTION
+        The `#{attr_name}` hasn't been provided for Class `#{class_name}` and Wallaby cannot guess it right.
+        If `#{class_name}` is supposed to be a base class, add the following line to its class declaration:
+
+          class #{class_name}
+            base_class!
+          end
+
+        Otherwise, please specify the `#{attr_name}` in `#{class_name}`'s declaration as follows:
+
+          class #{class_name}
+            self.#{attr_name} = CorrectClass
+          end
+      INSTRUCTION
+    end
+
+    # Configurable attributes:
+    # 1. mark a class as a base class
+    # 2. guess the model class if model class isn't given
     module ClassMethods
       # @return [true] if class is a base class
       # @return [false] if class is not a base class
       def base_class?
-        @base_class ||= false
+        @base_class == self
       end
 
-      # Mark class a base class
-      # @return [true]
+      # Mark the current class as the base class
       def base_class!
-        @base_class = true
+        @base_class = self
+      end
+
+      # @!attribute [r] base_class
+      # @return [Class] The base class or the one from super class
+      def base_class
+        @base_class || superclass.try(:base_class)
+      end
+
+      # @!attribute [w] model_class
+      def model_class=(model_class)
+        raise ArgumentError 'Please provide a Class for `model_class`.' unless model_class.is_a? Class
+
+        @model_class = model_class
+      end
+
+      # @!attribute [r] model_class
+      # @example To configure the model class
+      #   class Admin::ProductAuthorizer < Admin::ApplicationAuthorizer
+      #     self.model_class = Product
+      #   end
+      # @example To configure the model class for version below 5.2.0
+      #   class Admin::ProductAuthorizer < Admin::ApplicationAuthorizer
+      #     def self.model_class
+      #       Product
+      #     end
+      #   end
+      # @return [Class] assigned model class or Wallaby will guess it
+      #   (see {Wallaby::Baseable.guess_associated_class_of .guess_associated_class_of})
+      # @return [nil] if current class is marked as base class
+      # @raise [Wallaby::ModelNotFound] if model class isn't found
+      # @raise [ArgumentError] if base class is empty
+      def model_class
+        return if base_class?
+
+        @model_class ||= Baseable.guess_associated_class_of name
+      rescue TypeError
+        raise ArgumentError, <<~INSTRUCTION
+          Please specify the base class for class `#{name}`
+          by marking one of its parents `base_class!`, for example:
+
+            class ParentClass
+              base_class!
+            end
+        INSTRUCTION
       end
 
       # @!attribute [w] namespace
       # Used by `model_class`
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       attr_writer :namespace
 
       # @!attribute [r] namespace
       # @return [String] namespace
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def namespace
         @namespace ||=
-          ModuleUtils.try_to(superclass, :namespace) \
-          || name.deconstantize.gsub(/Wallaby(::)?/, EMPTY_STRING).presence
+          superclass.try(:namespace) \
+            || name.deconstantize.gsub(/Wallaby(::)?/, EMPTY_STRING).presence
       end
     end
   end

data/lib/concerns/wallaby/decoratable.rb

@@ -22,7 +22,7 @@ module Wallaby
       # @return [Class] resource decorator
       # @raise [ArgumentError] when **resource_decorator** doesn't inherit from **application_decorator**
       # @see Wallaby::ResourceDecorator
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       attr_reader :resource_decorator
 
       # @!attribute [w] application_decorator
@@ -40,7 +40,7 @@ module Wallaby
       # @raise [ArgumentError] when **resource_decorator** doesn't inherit from **application_decorator**
       # @return [Class] application decorator
       # @see Wallaby::ResourceDecorator
-      # @since 5.2.0
+      # @since wallaby-5.2.0
       def application_decorator
         @application_decorator ||= ModuleUtils.try_to superclass, :application_decorator
       end
@@ -68,7 +68,7 @@ module Wallaby
       @current_decorator ||=
         (controller_to_get(:resource_decorator) || \
         Map.resource_decorator_map(current_model_class, controller_to_get(:application_decorator))).tap do |decorator|
-          Logger.debug %(Current decorator: #{decorator})
+          Logger.debug %(Current decorator: #{decorator}), sourcing: false
         end
     end