authority 2.7.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3bb0dcfadb29c3e61cf717eca48de2be68259b9
-  data.tar.gz: 5d8299cf62e1c9adabcc1c86bde6706592af9433
+  metadata.gz: 9206ed88d49590c996639a19863a6d31dfd96717
+  data.tar.gz: e17aef04639c0fab82bcb7b221167f5b066eb12d
 SHA512:
-  metadata.gz: 9543396964cdc739ba4b41929cf5cde18de52e65c2c392f132c9b2f880c27469ceeeb6ccc6c622c4724d6458023baa981cb668440a6d3c3cab3dc7627aeadff8
-  data.tar.gz: 9a73e9a4dee9d62b0a5a2ec4597ad3ec15293fec5eeef1379d5e2830513960b9af7729da0f8a0f46e0471662f179e1ca6b27799b753ebf811e9202753256fad2
+  metadata.gz: d6fb759f6188d224fe7a7a7a029a605bbe595f8ad344c9e3705d9e7d0e460b86ee5d0fb20e4d529cf22f3685f1f0c477e309301acdbde5456d9dcad5f4a32584
+  data.tar.gz: e762ecc99ebd2632b01a45b88ffacc19196af9eb90acb72b6063b5cef08122ae74e7d17b3921098f13cede871a6f01e2dec174aeb9e608dc0c080d37a88b6297

data/.travis.yml

@@ -14,7 +14,6 @@ gemfile:
   - gemfiles/3.1.gemfile
   - gemfiles/3.2.gemfile
   - gemfiles/4.0.gemfile
-  - Gemfile
 
 matrix:
   exclude:

data/CHANGELOG.markdown

@@ -2,6 +2,10 @@
 
 Authority does its best to use [semantic versioning](http://semver.org).
 
+## v2.8.0
+
+New controller method `ensure_authorization_performed`, thanks to [Igor Davydov](https://github.com/div).
+
 ## 2.7.0
 
 Allows setting authorizer by class (`authorizer = FooAuthorizer`) as well as by name (`authorizer_name = 'FooAuthorizer'`), thanks to [mguymon](https://github.com/mguymon)

data/CONTRIBUTING.markdown

@@ -0,0 +1,27 @@
+# Contributing
+
+## I love you
+
+Thanks so much for wanting to contribute to Authority! You are wonderful and I love you.
+
+## New feature? Probably not.
+
+Authority's default answer to new features is "no".
+
+Every feature increases the complexity of Authority. It will need documentation, tests, and maintenance. Its interactions with other features will forever need to be considered. More code means more chances for bugs.
+
+Every feature makes Authority harder to understand for users and maintainers.
+
+A feature **must clearly benefit most users** to justify these costs.
+
+It's hard to reject pull requests. It feels like rejecting the requester personally. But the silent participants in the conversation must be considered, too: all the other users and maintainers. Every user of Authority has entrusted us to put code into their system. **We owe it to them not to add needless complexity**.
+
+If your feature seems worth the tradeoff, great! But be aware that the bar is high.
+
+## Bugfixes welcome
+
+Bugfixes, updating deprecated method calls, etc are always welcome.
+
+## Tests and readability
+
+No untested code will be accepted. No confusing code will be accepted. (Yes, that's subjective.) Make it as readable as you possibly can.

data/README.markdown

@@ -6,8 +6,10 @@ Authority will work fine with a standalone app or a single sign-on system. You c
 
 If you're using it with Rails controllers, it requires that you already have some kind of user object in your application, accessible via a method like `current_user` (configurable).
 
+[![Gem Version](https://badge.fury.io/rb/authority.png)](https://rubygems.org/gems/searchlight)
 [![Build Status](https://secure.travis-ci.org/nathanl/authority.png?branch=master)](http://travis-ci.org/nathanl/authority)
 [![Code Climate](https://codeclimate.com/github/nathanl/authority.png)](https://codeclimate.com/github/nathanl/authority)
+[![Dependency Status](https://gemnasium.com/nathanl/authority.png)](https://gemnasium.com/nathanl/authority)
 
 ## Contents
 
@@ -380,7 +382,7 @@ class LlamasController < ApplicationController
 end
 ```
 
-Finally, note that if you have a controller that dynamically determines the class it's working with, you can pass the name of a controller instance method to `authorize_actions_for` instead of a class, and the class will be looked up when a request is made.
+If you have a controller that dynamically determines the class it's working with, you can pass the name of a controller instance method to `authorize_actions_for` instead of a class, and the class will be looked up when a request is made.
 
 ```ruby
 class LlamasController < ApplicationController
@@ -388,11 +390,29 @@ class LlamasController < ApplicationController
   authorize_actions_for :llama_class
 
   def llama_class
+    # In a real application, you would choose your llama class
+    # much more carefully
     [StandardLlama, LludicrousLlama].sample
   end
 end
 ```
 
+Finally, you can enforce that every controller action runs an authorization check using the class method `ensure_authorization_performed`, which sets up an `after_filter` to raise an exception if it wasn't. Any `only` or `except` arguments will be passed to `after_filter`. You can also use `if` or `unless` to specify the name of a controller method which determines whether it's necessary.
+
+Since this runs in an `after_filter`, it obviously doesn't prevent the action, it just alerts you that no authorization was performed. Therefore, it's most useful in development. An example usage might be:
+
+```ruby
+class ApplicationController < ActionController::Base
+  ensure_authorization_performed :except => [:index, :search], :if => :auditing_security?, :unless => :devise_controller?
+
+  def auditing_security?
+    Rails.env != 'production'
+  end
+end
+```
+
+If you want a skippable filter, you can roll your own using the instance method, also called `ensure_authorization_performed`.
+
 <a name="views">
 ### Views
 

data/gemfiles/4.0.gemfile

@@ -1,6 +1,6 @@
 source "http://rubygems.org"
 
-gem "rails", ">= 4.0.0.rc", "< 4.1"
-gem 'rspec', '>= 2.8.0'
+gem "rails", "~> 4.0"
+gem 'rspec', '~> 2.14'
 
 gemspec :path=>"../"

data/lib/authority.rb

@@ -1,6 +1,7 @@
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/rescuable'
 require 'forwardable'

data/lib/authority/controller.rb

@@ -7,7 +7,7 @@ module Authority
 
     def self.security_violation_callback
       Proc.new do |exception|
-        # Through the magic of ActiveSupport's `Proc#bind`, `ActionController::Base#rescue_from`
+        # Through the magic of `instance_exec` `ActionController::Base#rescue_from`
         # can call this proc and make `self` the actual controller instance
         self.send(Authority.configuration.security_violation_handler, exception)
       end
@@ -18,6 +18,19 @@ module Authority
       class_attribute :authority_resource, :instance_reader => false
     end
 
+    attr_writer :authorization_performed
+
+    def authorization_performed?
+      !!@authorization_performed
+    end
+
+    def ensure_authorization_performed(options = {})
+      return if authorization_performed?
+      return if options[:if]     && !send(options[:if])
+      return if options[:unless] && send(options[:unless])
+      raise AuthorizationNotPerformed, "No authorization was performed for #{self.class.to_s}##{self.action_name}"
+    end
+
     module ClassMethods
 
       # Sets up before_filter to ensure user is allowed to perform a given controller action
@@ -49,6 +62,13 @@ module Authority
         authority_actions(action_map)
       end
 
+      # Convenience wrapper for instance method
+      def ensure_authorization_performed(options = {})
+        after_filter(options.slice(:only, :except)) do |controller_instance|
+          controller_instance.ensure_authorization_performed(options)
+        end
+      end
+
       # The controller action to authority action map used for determining
       # which Rails actions map to which authority actions (ex: index to read)
       #
@@ -74,7 +94,9 @@ module Authority
       if authority_action.nil?
         raise MissingAction.new("No authority action defined for #{action_name}")
       end
+
       Authority.enforce(authority_action, authority_resource, authority_user, *options)
+      self.authorization_performed = true
     end
 
     # Renders a static file to minimize the chances of further errors.
@@ -112,7 +134,8 @@ module Authority
       send(Authority.configuration.user_method)
     end
 
-    class MissingAction   < StandardError ; end
-    class MissingResource < StandardError ; end
+    class MissingAction             < StandardError ; end
+    class MissingResource           < StandardError ; end
+    class AuthorizationNotPerformed < StandardError ; end
   end
 end

data/lib/authority/version.rb

@@ -1,3 +1,3 @@
 module Authority
-  VERSION = "2.7.0"
+  VERSION = "2.8.0"
 end

data/spec/authority/controller_spec.rb

@@ -49,15 +49,15 @@ describe Authority::Controller do
         controller_instance = controller_class.new
         # If a callback is passed to a controller's `rescue_from` method as the value for
         # the `with` option (like `SomeController.rescue_from FooException, :with => some_callback`),
-        # Rails will use ActiveSupport's `Proc#bind` to ensure that when the proc refers to
+        # Rails will use `instance_exec` to ensure that when the proc refers to
         # `self`, it will be the controller, not the proc itself.
         # I need this callback's `self` to be the controller for the purposes of
         # this test, so I'm stealing that behavior.
-        callback = Authority::Controller.security_violation_callback.bind(controller_instance)
 
         Authority.configuration.security_violation_handler = :fire_ze_missiles
         controller_instance.should_receive(:fire_ze_missiles).with(fake_exception)
-        callback.call(fake_exception)
+        controller_instance.instance_exec(fake_exception, &Authority::Controller.security_violation_callback)
+
       end
     end
 
@@ -155,6 +155,61 @@ describe Authority::Controller do
 
       end
 
+      describe "ensure_authorization_performed" do
+
+        let(:controller_instance) { controller_class.new }
+
+        before(:each) do
+          controller_instance.stub(:class).and_return("FooController")
+          controller_instance.stub(:action_name).and_return(:bar)
+        end
+
+        it "sets up an after_filter, passing the options it was given" do
+          filter_options = {:only => [:show, :edit, :update]}
+          controller_class.should_receive(:after_filter).with(filter_options)
+          controller_class.ensure_authorization_performed(filter_options)
+        end
+
+        it "triggers AuthorizationNotPerformed in after filter" do
+          controller_class.stub(:after_filter).and_yield(controller_instance)
+          lambda {
+            controller_class.ensure_authorization_performed
+          }.should raise_error(Authority::Controller::AuthorizationNotPerformed)
+        end
+
+        it "AuthorizationNotPerformed error has meaningful message" do
+          controller_class.stub(:after_filter).and_yield(controller_instance)
+          lambda {
+            controller_class.ensure_authorization_performed
+          }.should raise_error("No authorization was performed for FooController#bar")
+        end
+
+        it "does not trigger AuthorizationNotPerformed when :if is false" do
+          controller_instance.stub(:authorize?) { false }
+          controller_class.stub(:after_filter).with({}).and_yield(controller_instance)
+          lambda {
+            controller_class.ensure_authorization_performed(:if => :authorize?)
+          }.should_not raise_error()
+        end
+
+        it "does not trigger AuthorizationNotPerformed when :unless is true" do
+          controller_instance.stub(:skip_authorization?) { true }
+          controller_class.stub(:after_filter).with({}).and_yield(controller_instance)
+          lambda {
+            controller_class.ensure_authorization_performed(:unless => :skip_authorization?)
+          }.should_not raise_error()
+        end
+
+        it "does not raise error when #authorization_performed is true" do
+          controller_instance.authorization_performed = true
+          controller_class.stub(:after_filter).with({}).and_yield(controller_instance)
+          lambda {
+            controller_class.ensure_authorization_performed
+          }.should_not raise_error()
+        end
+
+      end
+
     end
 
     describe "instance methods" do
@@ -244,6 +299,12 @@ describe Authority::Controller do
           controller_instance.send(:authorize_action_for, resource_class, options)
         end
 
+        it "sets correct authorization flag" do
+          Authority.stub(:enforce)
+          controller_instance.send(:authorize_action_for, resource_class)
+          controller_instance.authorization_performed?.should be_true
+        end
+
       end
 
       describe "authority_user" do
@@ -257,7 +318,7 @@ describe Authority::Controller do
 
       describe "authority_forbidden action" do
 
-        let(:mock_error) { mock(:message => 'oh noes! an error!') }
+        let(:mock_error) { double(:message => 'oh noes! an error!') }
 
         it "logs an error" do
           Authority.logger.should_receive(:warn)

data/spec/authority_spec.rb

@@ -66,7 +66,7 @@ describe Authority do
     end
 
     it "doesn't raise a SecurityViolation if the action is authorized" do
-      expect { Authority.enforce(:read, resource_class, user) }.not_to raise_error(Authority::SecurityViolation)
+      expect { Authority.enforce(:read, resource_class, user) }.not_to raise_error()
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: authority
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Nathan Long
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-10 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,6 +53,7 @@ files:
 - .rspec
 - .travis.yml
 - CHANGELOG.markdown
+- CONTRIBUTING.markdown
 - Gemfile
 - LICENSE
 - README.markdown