effective_resources 0.6.9 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 339b7dbd609cceed80ebcc1a4671e1df604a632c
-  data.tar.gz: 19c70d912b4f036fc5c032e89194808771dfcef9
+  metadata.gz: e60422542e4fd0579203430168370a0469aca1a4
+  data.tar.gz: 2768849db26e1cdb04f66a06806acd2026973113
 SHA512:
-  metadata.gz: 53837fc5daceb61b11b0b20a5a5a4b188ec06a7cb0a8393432562d9de444929ab1f7101b84ba1760ff7d73c97f65aeb3dbe6a07f02394851f92a26aed4e22c9a
-  data.tar.gz: 2f3ea295180132d429dc68c6616f26a2fcb47247bac8a3e038975399688d78f07b614c3890986e3894972b538f6105728c0249f5d41739f3fa73204f230f5385
+  metadata.gz: 21c3d13331bc4eca088ee77b9ba1f0a6ff160f64f7373f190371d90eaadd7060048f1e8f1e471c93515862ac7b7bea0f1dd4be3f10ec38d9d88dbce95ad8f56a
+  data.tar.gz: eabc01995fafbb7d4a200336964f34c292341d3b6aaf8d50cddccb0d6fb6a17c2641df45c2fae00b8853a4a7b928daf9affea1389f56ca9e44bfa6cc380136f1

data/app/controllers/concerns/effective/crud_controller.rb

@@ -61,7 +61,7 @@ module Effective
         define_method(action) do
           self.resource ||= resource_scope.find(params[:id])
 
-          EffectiveResources.authorized?(self, action, resource)
+          EffectiveResources.authorize!(self, action, resource)
 
           @page_title ||= "#{action.to_s.titleize} #{resource}"
 
@@ -81,7 +81,7 @@ module Effective
 
           self.resources ||= resource_scope.all
 
-          EffectiveResources.authorized?(self, action, resource_klass)
+          EffectiveResources.authorize!(self, action, resource_klass)
 
           @page_title ||= "#{action.to_s.titleize} #{resource_plural_name.titleize}"
 
@@ -121,7 +121,7 @@ module Effective
 
     def index
       @page_title ||= resource_plural_name.titleize
-      EffectiveResources.authorized?(self, :index, resource_klass)
+      EffectiveDatatables.authorize!(self, :index, resource_klass)
 
       self.resources ||= resource_scope.all
 
@@ -140,7 +140,7 @@ module Effective
       )
 
       @page_title ||= "New #{resource_name.titleize}"
-      EffectiveResources.authorized?(self, :new, resource)
+      EffectiveResources.authorize!(self, :new, resource)
 
       run_callbacks(:resource_render)
     end
@@ -149,10 +149,10 @@ module Effective
       self.resource ||= resource_scope.new
 
       @page_title ||= "New #{resource_name.titleize}"
-      EffectiveResources.authorized?(self, :create, resource)
+      EffectiveResources.authorize!(self, :create, resource)
 
-      action = resource_commit_action[:action]
-      EffectiveResources.authorized?(self, action, resource) unless action == :save
+      action = commit_action[:action]
+      EffectiveResources.authorize!(self, action, resource) unless action == :save
 
       resource.assign_attributes(send(resource_params_method_name))
       resource.created_by ||= current_user if resource.respond_to?(:created_by=)
@@ -170,7 +170,7 @@ module Effective
       self.resource ||= resource_scope.find(params[:id])
 
       @page_title ||= resource.to_s
-      EffectiveResources.authorized?(self, :show, resource)
+      EffectiveResources.authorize!(self, :show, resource)
 
       run_callbacks(:resource_render)
     end
@@ -179,7 +179,7 @@ module Effective
       self.resource ||= resource_scope.find(params[:id])
 
       @page_title ||= "Edit #{resource}"
-      EffectiveResources.authorized?(self, :edit, resource)
+      EffectiveResources.authorize!(self, :edit, resource)
 
       run_callbacks(:resource_render)
     end
@@ -188,10 +188,10 @@ module Effective
       self.resource ||= resource_scope.find(params[:id])
 
       @page_title = "Edit #{resource}"
-      EffectiveResources.authorized?(self, :update, resource)
+      EffectiveResources.authorize!(self, :update, resource)
 
-      action = resource_commit_action[:action]
-      EffectiveResources.authorized?(self, action, resource) unless action == :save
+      action = commit_action[:action]
+      EffectiveResources.authorize!(self, action, resource) unless action == :save
 
       resource.assign_attributes(send(resource_params_method_name))
 
@@ -208,7 +208,7 @@ module Effective
       self.resource = resource_scope.find(params[:id])
 
       @page_title ||= "Destroy #{resource}"
-      EffectiveResources.authorized?(self, :destroy, resource)
+      EffectiveResources.authorize!(self, :destroy, resource)
 
       if resource.destroy
         flash[:success] ||= flash_success(resource, :delete)
@@ -220,7 +220,7 @@ module Effective
       if referer_redirect_path && !request.referer.to_s.include?("/#{resource.to_param}/")
         redirect_to(referer_redirect_path)
       else
-        redirect_to(resource_index_path)
+        redirect_to(resource_redirect_path)
       end
     end
 
@@ -316,17 +316,15 @@ module Effective
     end
 
     def resource_redirect_path
-      if resource_commit_action[:redirect].respond_to?(:call)
-        return instance_exec(&resource_commit_action[:redirect])
-      end
+      return instance_exec(&commit_action[:redirect]) if commit_action[:redirect].respond_to?(:call)
 
-      commit_action_redirect = case resource_commit_action[:redirect]
+      commit_action_redirect = case commit_action[:redirect]
         when :index ; resource_index_path
         when :edit  ; resource_edit_path
         when :show  ; resource_show_path
         when :back  ; referer_redirect_path
         when nil    ; nil
-        else        ; resource_member_action_path(resource_commit_action[:action])
+        else        ; resource_member_action_path(commit_action[:action])
       end
 
       return commit_action_redirect if commit_action_redirect.present?
@@ -350,27 +348,27 @@ module Effective
     end
 
     def resource_index_path
-      send(effective_resource.index_path) if effective_resource.index_path(check: true)
+      effective_resource.action_path(:index)
     end
 
     def resource_new_path
-      send(effective_resource.new_path) if effective_resource.new_path(check: true)
+      effective_resource.action_path(:new)
     end
 
     def resource_edit_path
-      send(effective_resource.edit_path, resource) if effective_resource.edit_path(check: true)
+      effective_resource.action_path(:edit, resource)
     end
 
     def resource_show_path
-      send(effective_resource.show_path, resource) if effective_resource.show_path(check: true)
+      effective_resource.action_path(:show, resource)
     end
 
     def resource_destroy_path
-      send(effective_resource.destroy_path, resource) if effective_resource.destroy_path(check: true)
+      effective_resource.action_path(:destroy, resource)
     end
 
     def resource_member_action_path(action)
-      send(effective_resource.action_path(action), resource) if effective_resource.action_path(action, check: true)
+      effective_resource.action_path(action.to_sym, resource)
     end
 
     def resource # @thing
@@ -415,7 +413,7 @@ module Effective
       (action.to_s + (action.to_s.end_with?('e') ? 'd' : 'ed'))
     end
 
-    def resource_commit_action
+    def commit_action
       self.class.member_actions[params[:commit].to_s] || self.class.member_actions['Save'] || raise("expected member_actions['Save'] to be present")
     end
 

data/app/helpers/effective_resources_helper.rb

@@ -14,19 +14,25 @@ module EffectiveResourcesHelper
 
         opts
       end
-
     else
       {}.tap do |actions|
         actions['Save'] = { class: 'btn btn-primary', data: { disable_with: 'Saving...' }}
-        actions['Continue'] = { class: 'btn btn-default', data: { disable_with: 'Saving...' }} if resource.index_path(check: true)
-        actions['Add New'] = { class: 'btn btn-default', data: { disable_with: 'Saving...' }} if resource.new_path(check: true)
+
+        if resource.action_path(:index) && EffectiveResources.authorized?(controller, :index, resource.klass)
+          actions['Continue'] = { class: 'btn btn-default', data: { disable_with: 'Saving...' }}
+        end
+
+        if resource.action_path(:new) && EffectiveResources.authorized?(controller, :new, resource.klass)
+          actions['Add New'] = { class: 'btn btn-default', data: { disable_with: 'Saving...' }}
+        end
+
       end
     end
 
     wrapper_options = { class: 'form-actions' }.merge(options.delete(:wrapper_html) || {})
 
     content_tag(:div, wrapper_options) do
-      buttons = actions.group_by { |(_, args)| args[:class] }.flat_map do |_, action|
+      buttons = actions.group_by { |_, args| args[:class] }.flat_map do |_, action|
         action.map { |action| form.button(:submit, *action) } + ['']
       end
 
@@ -39,7 +45,7 @@ module EffectiveResourcesHelper
         buttons = [capture(&block), ''] + buttons
       end
 
-      result = buttons.join(' ').html_safe
+      buttons.join(' ').html_safe
     end
   end
 

data/app/models/effective/resources/actions.rb

@@ -2,30 +2,59 @@ module Effective
   module Resources
     module Actions
 
-      # This was written for the Edit actions fallback templates
-
-      def controller_routes
-        @controller_routes ||= (
-          path = controller_path
+      # This was written for the Edit actions fallback templates and Datatables
+      # Effective::Resource.new('admin/posts').routes[:index]
+      def routes
+        @_routes ||= (
+          matches = [[namespace, plural_name].compact.join('/'), [namespace, name].compact.join('/')]
 
           Rails.application.routes.routes.select do |route|
-            (route.defaults[:controller] == path) && route.defaults[:action].present?
+            matches.any? { |match| match == route.defaults[:controller] }
+          end.inject({}) do |h, route|
+            h[route.defaults[:action].to_sym] = route; h
           end
         )
       end
 
-      def controller_actions
-        controller_routes.map { |route| route.defaults[:action] }
+      # Effective::Resource.new('admin/posts').action_path_helper(:edit) => 'edit_admin_posts_path'
+      # This will return empty for create, update and destroy
+      def action_path_helper(action)
+        return unless routes[action]
+        return (routes[action].name + '_path') if routes[action].name.present?
+      end
+
+      # Effective::Resource.new('admin/posts').action_path(:edit, Post.last) => '/admin/posts/3/edit'
+      # Will work for any action. Returns the real path
+      def action_path(action, resource = nil, opts = {})
+        return unless routes[action]
+
+        # edge case: Effective::Resource.new('admin/comments').action_path(:new, @post)
+        if resource.present? && !resource.kind_of?(klass)
+          if (bt = belongs_to(resource)).present? && instance.respond_to?("#{bt.name}=")
+            return routes[action].format(klass.new(bt.name => resource)).presence
+          end
+        end
+
+        routes[action].format(resource || instance).presence
+      end
+
+      def actions
+        routes.keys
+      end
+
+      # GET actions
+      def collection_actions
+        routes.values.map { |route| route.defaults[:action].to_sym if is_get_route?(route) && !is_member_route?(route) }.compact - crud_actions
       end
 
       # GET actions
       def member_actions
-        controller_routes.map { |route| route.defaults[:action] if is_get_member?(route) }.compact - crud_actions
+        routes.values.map { |route| route.defaults[:action].to_sym if is_get_route?(route) && is_member_route?(route) }.compact - crud_actions
       end
 
       # POST/PUT/PATCH actions
       def member_post_actions
-        controller_routes.map { |route| route.defaults[:action] if is_post_member?(route) }.compact - crud_actions
+        routes.values.map { |route| route.defaults[:action].to_sym if is_post_route?(route) && is_member_route?(route) }.compact - crud_actions
       end
 
       # Same as controller_path in the view
@@ -36,15 +65,19 @@ module Effective
       private
 
       def crud_actions
-        %w(index new create show edit update destroy)
+        %i(index new create show edit update destroy)
+      end
+
+      def is_member_route?(route)
+        (route.path.required_names || []).include?('id')
       end
 
-      def is_get_member?(route)
-        route.verb.to_s.include?('GET') && route.path.required_names == ['id']
+      def is_get_route?(route)
+        route.verb.to_s.include?('GET')
       end
 
-      def is_post_member?(route)
-        ['POST', 'PUT', 'PATCH'].any? { |verb| route.verb == verb } && route.path.required_names == ['id']
+      def is_post_route?(route)
+        ['POST', 'PUT', 'PATCH'].any? { |verb| route.verb == verb }
       end
 
     end

data/app/models/effective/resources/associations.rb

@@ -37,8 +37,12 @@ module Effective
       end
 
       def belongs_to(name)
-        name = (name.to_s.end_with?('_id') ? name.to_s[0...-3] : name).to_sym
-        belong_tos.find { |ass| ass.name == name }
+        if name.kind_of?(String) || name.kind_of?(Symbol)
+          name = (name.to_s.end_with?('_id') ? name.to_s[0...-3] : name).to_sym
+          belong_tos.find { |ass| ass.name == name }
+        else
+          belong_tos.find { |ass| ass.klass == name.class }
+        end
       end
 
       def belongs_to_polymorphic(name)

data/app/models/effective/resources/paths.rb

@@ -2,64 +2,67 @@ module Effective
   module Resources
     module Paths
 
-      # Controller REST helper paths
-      def index_path(check: false)
-        path = [namespace, plural_name, 'path'].compact * '_'
-        path if (!check || path_exists?(path))
-      end
-
-      def new_path(check: false)
-        path = ['new', namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path))
-      end
-
-      def show_path(check: false)
-        path = [namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path, 1))
-      end
-
-      def destroy_path(check: false)
-        path = [namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path, 1, :delete))
-      end
-
-      def edit_path(check: false)
-        path = ['edit', namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path, 1))
-      end
-
-      def action_path(action, check: false)
-        path = [action, namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path, 1, :any))
-      end
-
-      def action_post_path(action, check: false)
-        path = [action, namespace, name, 'path'].compact * '_'
-        path if (!check || path_exists?(path, 1, :post) || path_exists?(path, 1, :put) || path_exists?(path, 1, :patch))
-      end
-
-      def path_exists?(path, param = nil, verb = :get)
-        routes = Rails.application.routes
-
-        return false unless routes.url_helpers.respond_to?(path)
-        (routes.recognize_path(routes.url_helpers.send(path, param), method: verb).present? rescue false)
-      end
-
-      # _helper methods also put in the (@thing)
-      alias_method :index_path_helper, :index_path
-      alias_method :new_path_helper, :new_path
-
-      def show_path_helper(at: true)
-        show_path + '(' + (at ? '@' : '') + name + ')'
-      end
-
-      def edit_path_helper(at: true)
-        edit_path + '(' + (at ? '@' : '') + name + ')'
-      end
-
-      def action_path_helper(action, at: true)
-        action_path(action) + '(' + (at ? '@' : '') + name + ')'
-      end
+      #
+      # TODO: Delete these. Once effective_developer is updated
+      #
+      # # Controller REST helper paths
+      # def index_path(check: false)
+      #   path = [namespace, plural_name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path))
+      # end
+
+      # def new_path(check: false)
+      #   path = ['new', namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path))
+      # end
+
+      # def show_path(check: false)
+      #   path = [namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path, 1))
+      # end
+
+      # def destroy_path(check: false)
+      #   path = [namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path, 1, :delete))
+      # end
+
+      # def edit_path(check: false)
+      #   path = ['edit', namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path, 1))
+      # end
+
+      # def action_path(action, check: false)
+      #   path = [action, namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path, 1, :any))
+      # end
+
+      # def action_post_path(action, check: false)
+      #   path = [action, namespace, name, 'path'].compact * '_'
+      #   path if (!check || path_exists?(path, 1, :post) || path_exists?(path, 1, :put) || path_exists?(path, 1, :patch))
+      # end
+
+      # def path_exists?(path, param = nil, verb = :get)
+      #   routes = Rails.application.routes
+
+      #   return false unless routes.url_helpers.respond_to?(path)
+      #   (routes.recognize_path(routes.url_helpers.send(path, param), method: verb).present? rescue false)
+      # end
+
+      # # _helper methods also put in the (@thing)
+      # alias_method :index_path_helper, :index_path
+      # alias_method :new_path_helper, :new_path
+
+      # def show_path_helper(at: true)
+      #   show_path + '(' + (at ? '@' : '') + name + ')'
+      # end
+
+      # def edit_path_helper(at: true)
+      #   edit_path + '(' + (at ? '@' : '') + name + ')'
+      # end
+
+      # def action_path_helper(action, at: true)
+      #   action_path(action) + '(' + (at ? '@' : '') + name + ')'
+      # end
 
       # Default file paths
       def model_file

data/app/models/effective/resources/sql.rb

@@ -40,24 +40,24 @@ module Effective
       def sql_type(name)
         name = name.to_s.split('.').first
 
-        if belongs_to_polymorphic(name)
-          :belongs_to_polymorphic
-        elsif belongs_to(name)
+        if belongs_to(name)
           :belongs_to
-        elsif has_and_belongs_to_many(name)
-          :has_and_belongs_to_many
+        elsif (column = column(name))
+          column.type
         elsif has_many(name)
           :has_many
         elsif has_one(name)
           :has_one
+        elsif belongs_to_polymorphic(name)
+          :belongs_to_polymorphic
+        elsif has_and_belongs_to_many(name)
+          :has_and_belongs_to_many
         elsif name == 'id' && defined?(EffectiveObfuscation) && klass.respond_to?(:deobfuscate)
           :effective_obfuscation
         elsif name == 'roles' && defined?(EffectiveRoles) && klass.respond_to?(:with_role)
           :effective_roles
         elsif (name.include?('_address') || name.include?('_addresses')) && defined?(EffectiveAddresses) && (klass.new rescue nil).respond_to?(:effective_addresses)
           :effective_addresses
-        elsif (column = column(name))
-          column.type
         elsif name.ends_with?('_id')
           :integer
         else

data/app/views/application/edit.html.haml

@@ -3,19 +3,14 @@
 
 - if @resource
   .row
-    .col-sm-6
+    .col-xs-8
       %h1= @page_title
-    .col-sm-6
-      %p.text-right
-        - resource.member_post_actions.each do |action|
-          - if EffectiveResources.authorized?(controller, action.to_sym, @resource)
-            - if resource.action_post_path(action, check: true).present?
-              = link_to action.titleize, send(resource.action_post_path(action), @resource), class: 'btn btn-primary',
-                data: { confirm: "Really #{action} #{@resource}?", method: :post }
+    .col-xs-4.text-right
+      - resource.member_post_actions.each do |action|
+        - if EffectiveResources.authorized?(controller, action, @resource) && (path = resource.action_path(action, @resource)).present?
+          = link_to action.to_s.titleize, path, class: 'btn btn-sm btn-primary', data: { confirm: "Really #{action} #{@resource}?", method: :post }
 
-        - if EffectiveResources.authorized?(controller, :destroy, @resource)
-          - if resource.destroy_path(check: true).present?
-            = link_to 'Delete', send(resource.destroy_path, @resource), class: 'btn btn-danger',
-              data: { confirm: "Really delete #{@resource}?", method: :delete }
+      - if EffectiveResources.authorized?(controller, :destroy, @resource) && (path = resource.action_path(:destroy, @resource)).present?
+        = link_to 'Delete', path, class: 'btn btn-sm btn-danger', data: { confirm: "Really delete #{@resource}?", method: :delete }
 
   = render 'form', resource.name.to_sym => @resource

data/app/views/application/index.html.haml

@@ -1,12 +1,11 @@
 - resource = (@_effective_resource || Effective::Resource.new(controller_path))
 
 .row
-  .col-sm-6
+  .col-xs-8
     %h1= @page_title
-  .col-sm-6
-    %p.text-right
-      - if can?(:new, resource.klass) && resource.new_path(check: true).present?
-        = link_to "New #{resource.human_name.titleize}", send(resource.new_path), class: 'btn btn-primary'
+  .col-xs-4.text-right
+    - if EffectiveResources.authorized?(controller, :new, resource.klass) && (path = resource.action_path(:new)).present?
+      = link_to "New #{resource.human_name.titleize}", path, class: 'btn btn-primary'
 
 - if @datatable
   = render_datatable(@datatable)

data/app/views/application/show.html.haml

@@ -3,19 +3,17 @@
 
 - if @resource
   .row
-    .col-sm-6
+    .col-xs-8
       %h1= @page_title
-    .col-sm-6
-      %p.text-right
-        - resource.member_post_actions.each do |action|
-          - if EffectiveResources.authorized?(controller, action.to_sym, @resource)
-            - if resource.action_post_path(action, check: true).present?
-              = link_to action.titleize, send(resource.action_post_path(action), @resource), class: 'btn btn-primary',
-                data: { confirm: "Really #{action} #{@resource}?", method: :post }
+    .col-xs-4.text-right
+      - resource.member_post_actions.each do |action|
+        - if EffectiveResources.authorized?(controller, action, @resource) && (path = resource.action_path(action, @resource)).present?
+          = link_to action.to_s.titleize, path, class: 'btn btn-sm btn-primary', data: { confirm: "Really #{action} #{@resource}?", method: :post }
 
-        - if EffectiveResources.authorized?(controller, :destroy, @resource)
-          - if resource.destroy_path(check: true).present?
-            = link_to 'Delete', send(resource.destroy_path, @resource), class: 'btn btn-danger',
-              data: { confirm: "Really delete #{@resource}?", method: :delete }
+      - if EffectiveResources.authorized?(controller, :destroy, @resource) && (path = resource.action_path(:destroy, @resource)).present?
+        = link_to 'Delete', path, class: 'btn btn-sm btn-danger', data: { confirm: "Really delete #{@resource}?", method: :delete }
 
   = render @resource
+
+.form-actions
+  = link_to 'Continue', (resource.action_path(:index) || root_path), class: 'btn btn-primary'

data/config/effective_resources.rb

@@ -2,21 +2,23 @@ EffectiveResources.setup do |config|
   # Authorization Method
   #
   # This method is called by all controller actions with the appropriate action and resource
-  # If the method returns false, an Effective::AccessDenied Error will be raised (see README.md for complete info)
+  # If it raises an exception or returns false, an Effective::AccessDenied Error will be raised
   #
-  # Use via Proc (and with CanCan):
-  # config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) }
+  # Use via Proc:
+  # Proc.new { |controller, action, resource| authorize!(action, resource) }       # CanCan
+  # Proc.new { |controller, action, resource| can?(action, resource) }             # CanCan with skip_authorization_check
+  # Proc.new { |controller, action, resource| authorize "#{action}?", resource }   # Pundit
+  # Proc.new { |controller, action, resource| current_user.is?(:admin) }           # Custom logic
   #
-  # Use via custom method:
-  # config.authorization_method = :my_authorization_method
-  #
-  # And then in your application_controller.rb:
+  # Use via Boolean:
+  # config.authorization_method = true  # Always authorized
+  # config.authorization_method = false # Always unauthorized
   #
-  # def my_authorization_method(action, resource)
-  #   current_user.is?(:admin)
+  # Use via Method (probably in your application_controller.rb):
+  # config.authorization_method = :my_authorization_method
+  # def my_authorization_method(resource, action)
+  #   true
   # end
-  #
-  # Or disable the check completely:
-  # config.authorization_method = false
-  config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) } # CanCanCan
+  config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) }
+
 end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '0.6.9'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/lib/effective_resources.rb

@@ -11,10 +11,20 @@ module EffectiveResources
   end
 
   def self.authorized?(controller, action, resource)
-    if authorization_method.respond_to?(:call) || authorization_method.kind_of?(Symbol)
-      raise Effective::AccessDenied.new() unless (controller || self).instance_exec(controller, action, resource, &authorization_method)
+    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
+
+    return !!authorization_method unless authorization_method.respond_to?(:call)
+    controller = controller.controller if controller.respond_to?(:controller)
+
+    begin
+      !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
+    rescue *@_exceptions
+      false
     end
-    true
+  end
+
+  def self.authorize!(controller, action, resource)
+    raise Effective::AccessDenied unless authorized?(controller, action, resource)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.7.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-08 00:00:00.000000000 Z
+date: 2017-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails