walruz 0.0.12 → 0.0.13

data/CHANGELOG

@@ -1,3 +1,9 @@
+* 0.0.13 (Jul 21, 2011) 
+* Adding a new method to the Walruz::Manager class: satisfies!, same behaviour
+than satisfies, but raises a Walruz::NotAuthorized error if the actor and 
+subject can't satisfy the policy
+
+
 * 0.0.10 (Aug 26, 2009) Walruz wanted to be an actor too...
 * Fixed bug related to Walruz::NotAuthorized info, the actor was Walruz
 instead of the current actor, when the authorization was being called from

data/VERSION.yml

@@ -2,4 +2,4 @@
 :build: 
 :major: 0
 :minor: 0
-:patch: 12
+:patch: 13

data/lib/walruz/actor.rb

@@ -105,6 +105,10 @@ module Walruz
     def satisfies(policy_label, subject)
       super(self, policy_label, subject)
     end
+
+    def satisfies!(policy_label, subject)
+      super(self, policy_label, subject)
+    end
     
     walruz_memoize :can?, :authorize, :satisfies?, :satisfies 
     

data/lib/walruz/manager.rb

@@ -1,4 +1,4 @@
-module Walruz 
+module Walruz
 
   # The objective of this class is to start the invocation
   # of the authorization process, the methods of this class are used
@@ -24,20 +24,40 @@ module Walruz
       end
 
       def authorize(actor, action, subject)
-        result = Walruz::Manager.check_action_authorization(actor, action, subject)
+        result = Walruz::Manager.check_action_authorization(actor,
+                                                            action,
+                                                            subject)
         result[0] ? result[1] : nil
       end
 
       def satisfies?(actor, policy_label, subject)
-        result = Walruz::Manager.check_policy_authorization(actor, policy_label, subject)
+        result = Walruz::Manager.check_policy_authorization(actor,
+                                                            policy_label,
+                                                            subject)
         result[0]
       end
 
       def satisfies(actor, policy_label, subject)
-        result = Walruz::Manager.check_policy_authorization(actor, policy_label, subject)
+        result = Walruz::Manager.check_policy_authorization(actor,
+                                                            policy_label,
+                                                            subject)
         result[0] ? result[1] : nil
       end
 
+      def satisfies!(actor, policy_label, subject)
+         result = Walruz::Manager.check_policy_authorization(actor,
+                                                             policy_label,
+                                                             subject)
+         if result[0]
+           result[1]
+         else
+           response_params = result[1]
+           error_message = response_params[:error_message] ||
+            "You are not authorized to access this content"
+           raise NotAuthorized.new(actor, subject, :access, error_message)
+         end
+       end
+
     end
 
 
@@ -52,14 +72,14 @@ module Walruz
       action = if subject.class._walruz_policies.key?(:default)
                 subject.class._walruz_policies.key?(action) ? action : :default
               else
-                if subject.class._walruz_policies.key?(action) 
+                if subject.class._walruz_policies.key?(action)
                   action
-                else 
-                  raise ActionNotFound.new(:subject_action, :subject => subject, 
+                else
+                  raise ActionNotFound.new(:subject_action, :subject => subject,
                                                             :action => action)
                 end
               end
-      
+
       begin
         result = subject.class._walruz_policies[action].
                               return_policy.
@@ -74,19 +94,19 @@ module Walruz
 
     def self.check_policy_authorization(actor, policy_label, subject)
       policy_clz = Walruz.fetch_policy(policy_label)
-      
+
       begin
         result = policy_clz.return_policy.new.safe_authorized?(actor, subject)
       rescue PolicyHalted => e
         result = [false, { :error_message => e.message }]
       end
 
-      result 
+      result
     end
 
     private
 
-    def self.check_action_authorization_is_declared_on_subject(subject, action) 
+    def self.check_action_authorization_is_declared_on_subject(subject, action)
       if subject.class._walruz_policies.nil?
         message =<<-BEGIN
 You need to invoke `check_authorizations :#{action} => Policies::SomePolicy` on the #{subject.class.name} class

data/spec/scenario.rb

@@ -92,6 +92,7 @@ class Colaboration
 end
 
 class SubjectIsActorPolicy < Walruz::Policy
+  set_policy_label :subject_is_actor
   
   def authorized?(actor, subject)
     actor == subject

data/spec/walruz/manager_spec.rb

@@ -48,7 +48,40 @@ describe Walruz::Manager do
 
     end
 
+  describe "when executing the satisfies! method" do
+       
+       describe "and the actor and subject satisfy the policy" do
+ 
+         it "should return the policy hash" do
+           policy_params = Walruz.satisfies!(Beatle::RINGO, :subject_is_actor, Beatle::RINGO)
+           policy_params.should_not be_nil
+           policy_params[:subject_is_actor?].should be_true
+         end
+ 
+       end
+ 
+       describe "and the actor and subject can't satisfy the policy" do
+         
+         it "should raise a Walruz::NotAuthorized exception" do
+           lambda do
+             Walruz.satisfies!(Beatle::RINGO, :subject_is_actor, Beatle::JOHN)
+           end.should raise_error(Walruz::NotAuthorized)
+         end
+ 
+         it "should raise a Walruz::NotAuthorized exception with info about the actor, subject and access action" do
+           begin
+             Walruz.satisfies!(Beatle::RINGO, :subject_is_actor, Beatle::JOHN)
+           rescue Walruz::NotAuthorized => e
+             e.actor.should == Beatle::RINGO
+             e.subject.should == Beatle::JOHN
+             e.action.should == :access
+           end
+         end
+ 
+       end
+
   end
 
+  end
 
 end

data/walruz.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{walruz}
-  s.version = "0.0.12"
+  s.version = "0.0.13"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roman Gonzalez"]
-  s.date = %q{2011-07-12}
+  s.date = %q{2011-07-21}
   s.description = %q{
       Walruz provides an easy to use DSL to do composition of basic 
       authorization policies to create more complex ones, and then register 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: walruz
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 0
-  - 12
-  version: 0.0.12
+  - 13
+  version: 0.0.13
 platform: ruby
 authors: 
 - Roman Gonzalez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-12 00:00:00 -07:00
+date: 2011-07-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency