wallaby-core 0.2.9 → 0.3.0.beta1

data/lib/concerns/wallaby/authentication_concern.rb

@@ -5,72 +5,34 @@ 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
-    # 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
+    included do
+      try :helper_method, :wallaby_user
 
-    # @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
-    # 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
+      rescue_from NotAuthenticated, with: :unauthorized
+      rescue_from Forbidden, with: :forbidden
+
+      # # @note This is a proxy method to ensure {#current_user} exists
+      unless method_defined?(:current_user)
+        def current_user
+          defined?(super) ? super : nil
+        end
+      end
+    end
 
-    # @!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.
+    # 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
+    def wallaby_user
+      @wallaby_user ||= try :current_user
+    end
 
-    # @!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.
+    # 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!
@@ -79,84 +41,24 @@ module Wallaby
     #     end
     #   end
     # @return [true] when user is authenticated successfully
-    # @raise [Wallaby::NotAuthenticated] when user fails to authenticate
+    # @raise [NotAuthenticated] when user fails to authenticate
+    def authenticate_wallaby_user!
+      authenticated = try :authenticate_user!
+      raise NotAuthenticated if authenticated == false
+
+      true
+    end
 
-    # @!method unauthorized(exception = nil)
     # Unauthorized page.
     # @param exception [Exception] comes from **rescue_from**
+    def unauthorized(exception = nil)
+      render_error exception, __callee__
+    end
 
-    # @!method forbidden(exception = nil)
     # Forbidden page.
     # @param exception [Exception] comes from **rescue_from**
-
-    included do # rubocop:disable Metrics/BlockLength
-      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 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
-
-      # (see #unauthorized)
-      def unauthorized(exception = nil)
-        render_error exception, __callee__
-      end
-
-      # (see #forbidden)
-      def forbidden(exception = nil)
-        render_error exception, __callee__
-      end
+    def forbidden(exception = nil)
+      render_error exception, __callee__
     end
   end
 end

data/lib/concerns/wallaby/authorizable.rb

@@ -1,61 +1,15 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Authorizer related attributes
+  # Authorizer related
   module Authorizable
-    # Configurable attribute for authorizer related
-    module ClassMethods
-      # @!attribute [w] model_authorizer
-      def model_authorizer=(model_authorizer)
-        ModuleUtils.inheritance_check model_authorizer, application_authorizer
-        @model_authorizer = model_authorizer
-      end
-
-      # @!attribute [r] model_authorizer
-      # If Wallaby doesn't get it right, please specify the **model_authorizer**.
-      # @example To set model authorizer
-      #   class Admin::ProductionsController < Admin::ApplicationController
-      #     self.model_authorizer = ProductAuthorizer
-      #   end
-      # @return [Class] model authorizer
-      # @raise [ArgumentError] when **model_authorizer** doesn't inherit from **application_authorizer**
-      # @see Wallaby::ModelAuthorizer
-      # @since wallaby-5.2.0
-      attr_reader :model_authorizer
-
-      # @!attribute [w] application_authorizer
-      def application_authorizer=(application_authorizer)
-        ModuleUtils.inheritance_check model_authorizer, application_authorizer
-        @application_authorizer = application_authorizer
-      end
-
-      # @!attribute [r] application_authorizer
-      # The **application_authorizer** is as the base class of {#model_authorizer}.
-      # @example To set application decorator:
-      #   class Admin::ApplicationController < Wallaby::ResourcesController
-      #     self.application_authorizer = AnotherApplicationAuthorizer
-      #   end
-      # @return [Class] application decorator
-      # @raise [ArgumentError] when **model_authorizer** doesn't inherit from **application_authorizer**
-      # @see Wallaby::ModelAuthorizer
-      # @since wallaby-5.2.0
-      def application_authorizer
-        @application_authorizer ||= ModuleUtils.try_to superclass, :application_authorizer
-      end
-    end
-
     # Model authorizer for current modal class.
-    #
-    #  It can be configured in following class attributes:
-    #
-    # - controller configuration {Wallaby::Authorizable::ClassMethods#model_authorizer .model_authorizer}
-    # - a generic authorizer based on
-    #   {Wallaby::Authorizable::ClassMethods#application_authorizer .application_authorizer}
-    # @return [Wallaby::ModelAuthorizer] model authorizer
+    # @return [ModelAuthorizer] model authorizer
+    # @see #authorizer_of
     # @since wallaby-5.2.0
     def current_authorizer
       @current_authorizer ||=
-        authorizer_of(current_model_class, controller_to_get(:model_authorizer)).tap do |authorizer|
+        authorizer_of(current_model_class).tap do |authorizer|
           Logger.debug %(Current authorizer: #{authorizer.try(:class)}), sourcing: false
         end
     end
@@ -70,7 +24,7 @@ module Wallaby
       return false unless subject
 
       klass = subject.is_a?(Class) ? subject : subject.class
-      authorizer_of(klass).authorized? action, subject
+      authorizer_of(klass).authorized?(action, subject)
     end
 
     # Check if user is allowed to perform action on given subject
@@ -80,18 +34,21 @@ module Wallaby
     # @return [false] if allowed
     # @since wallaby-5.2.0
     def unauthorized?(action, subject)
-      !authorized? action, subject
+      !authorized?(action, subject)
     end
 
     protected
 
     # @param model_class [Class]
-    # @param authorizer_class [Class, nil]
-    # @return [Wallaby::ModelAuthorizer] model authorizer for given model
+    # @return [ModelAuthorizer] model authorizer for given model
+    # @see AuthorizerFinder#execute
     # @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.new model_class, self
+    def authorizer_of(model_class)
+      AuthorizerFinder.new(
+        script_name: script_name,
+        model_class: model_class,
+        current_controller_class: wallaby_controller
+      ).execute.create model_class, self
     end
   end
 end

data/lib/concerns/wallaby/baseable.rb

@@ -3,42 +3,7 @@
 module Wallaby
   # Abstract related class methods
   module Baseable
-    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
+    extend ActiveSupport::Concern
 
     # Configurable attributes:
     # 1. mark a class as a base class
@@ -80,37 +45,39 @@ module Wallaby
       #     end
       #   end
       # @return [Class] assigned model class or Wallaby will guess it
-      #   (see {Wallaby::Baseable.guess_associated_class_of .guess_associated_class_of})
+      #   (see {Guesser.class_for})
       # @return [nil] if current class is marked as base class
-      # @raise [Wallaby::ModelNotFound] if model class isn't found
+      # @raise [ClassNotFound] 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:
+        @model_class ||= Guesser.class_for(name) || raise(
+          ClassNotFound, <<~INSTRUCTION
+            The `model_class` hasn't been provided for Class `#{name}` and Wallaby cannot guess it right.
+            If `#{name}` is supposed to be a base class, add the following line to its class declaration:
+
+              class #{name}
+                base_class!
+              end
 
-            class ParentClass
-              base_class!
-            end
-        INSTRUCTION
+            Otherwise, please specify the `model_class` in `#{name}`'s declaration as follows:
+
+              class #{name}
+                self.model_class = CorrectModelClass
+              end
+          INSTRUCTION
+        )
       end
 
-      # @!attribute [w] namespace
-      # Used by `model_class`
-      # @since wallaby-5.2.0
-      attr_writer :namespace
+      # @deprecated
+      def namespace=(_namespace)
+        Deprecator.alert method(__callee__), from: '0.3.0'
+      end
 
-      # @!attribute [r] namespace
-      # @return [String] namespace
-      # @since wallaby-5.2.0
+      # @deprecated
       def namespace
-        @namespace ||=
-          superclass.try(:namespace) \
-            || name.deconstantize.gsub(/Wallaby(::)?/, EMPTY_STRING).presence
+        Deprecator.alert method(__callee__), from: '0.3.0'
       end
     end
   end