walruz 0.0.7 → 0.0.8

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,14 @@
+*.sw?
+.DS_Store
+.yardoc
+coverage
+rdoc
+doc
+pkg
+tmp
+examples/rails/tmp/*
+examples/rails/log/*
+examples/rails/db/schema.rb
+examples/rails/db/*.sqlite3
+tags
+*.swp

data/CHANGELOG

@@ -0,0 +1,15 @@
+* 0.0.8 (Aug 21, 2009) The anonymous who
+* New class <tt>Walruz::Manager</tt> will handle all the authorization
+invocation that was in Walruz::Actor and Walruz::Subject before
+* New module <tt>Walruz::Memoize</tt> that provides memoization methods to
+cache the result of the <tt>can?</tt>, <tt>authorize</tt>, <tt>satisfies?</tt>
+and <tt>satisfies</tt> methods in the Actor model
+* Added the Walruz::Policy#halt method to stop execution of policies
+authorizations (even if they are in a composite policy), and return false with
+an error message.
+
+* 0.0.7 (July 23, 2009)
+* New +Array#only_authorized_for+ method for filtering arrays of _subjects_
+* Added the +satisfy+ on the +Walruz::Actor+ module
+* Changed documentation from rDoc to YARD
+* Documented all the modules of the gem

data/Rakefile

@@ -14,6 +14,11 @@ begin
   
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
+  
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "yard"
+  end
+  
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
@@ -49,28 +54,3 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-begin
-  require 'rake/contrib/sshpublisher'
-  namespace :rubyforge do
-    
-    desc "Release gem and RDoc documentation to RubyForge"
-    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
-    
-    namespace :release do
-      desc "Publish RDoc to RubyForge."
-      task :docs => [:rdoc] do
-        config = YAML.load(
-            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-        )
-
-        host = "#{config['username']}@rubyforge.org"
-        remote_dir = "/var/www/gforge-projects/walruz/"
-        local_dir = 'rdoc'
-
-        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-      end
-    end
-  end
-rescue LoadError
-  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
-end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 0
-:patch: 7
+:patch: 8

data/lib/walruz.rb

@@ -20,6 +20,9 @@ module Walruz
     
   end
   
+  class PolicyHalted < Exception 
+  end
+  
   class AuthorizationActionsNotDefined < Exception
   end
   
@@ -37,6 +40,8 @@ module Walruz
   end
   
   base_path = File.dirname(__FILE__)
+  autoload :Memoization, base_path + '/walruz/core_ext/memoization'
+  autoload :Manager, base_path + '/walruz/manager'
   autoload :Actor,   base_path + '/walruz/actor'
   autoload :Subject, base_path + '/walruz/subject'
   autoload :Policy,  base_path + '/walruz/policy'
@@ -88,4 +93,4 @@ module Walruz
 end
 
 require File.dirname(__FILE__) + '/walruz/core_ext/array'
-Array.send(:include, Walruz::CoreExt::Array)
+Array.send(:include, Walruz::CoreExt::Array)

data/lib/walruz/actor.rb

@@ -12,7 +12,9 @@ module Walruz
   # [<b><tt>satisfies(policy_label, subject)</tt></b>] Returns Either nil if the actor and subject don't satisfy the policy or a Hash with the parameters returned from the Policy.
   #
   module Actor
-    
+    include Walruz::Manager::AuthorizationQuery
+    include Walruz::Memoization
+
     # @overload can?(action, subject)
     #   Allows an <em>actor</em> to check if he can perform an <em>action</em> on a given <em>subject</em>.
     #   === Note:
@@ -32,18 +34,8 @@ module Walruz
     #   @param [Boolean] A boolean indicating if you want to reset the cached result.
     #   @return [Boolean] A boolean indicating if the <em>actor</em> is authorized to perform the <em>action</em> (or not) on the <em>subject</em>.
     #
-    def can?(*args)
-      if args.size == 2
-        (cached_values_for_can[args] ||= can_without_caching(*args))[0]
-      elsif args.size == 3 
-        if args.pop
-          (cached_values_for_can[args] = can_without_caching(*args))[0]
-        else
-          (cached_values_for_can[args] ||= can_without_caching(*args))[0]
-        end
-      else
-        raise ArgumentError.new("wrong number of arguments (%d for 2)" % args.size) 
-      end
+    def can?(action, subject)
+      super(self, action, subject)
     end
     
     
@@ -68,31 +60,10 @@ module Walruz
     # 
     #   @param [Symbol] The action as it is declared on the <tt>check_authorizations</tt> method on the <em>subject</em> class.
     #   @param [Walruz::Subject] The <em>subject</em> on which the <em>actor</em> wants to execute the <em>action</em>.
-    #   @param [Boolean] A boolean indicating if you want to reset the cached result.
+    #   @param [Symbol] A symbol with the value ":reload" indicating that you want to reset the cached result.
     #   @return [Hash] Parameters returned from the <em>policy</em>.
-    def authorize(*args)
-      if args.size == 2
-        cached_values_for_can[args] ||= can_without_caching(*args)
-        cached_values_for_can[args][0] ? cached_values_for_can[args][1] : nil
-      elsif args.size == 3 
-        if args.pop
-          cached_values_for_can[args] = can_without_caching(*args)[1]
-          cached_values_for_can[args][0] ? cached_values_for_can[args][1] : nil
-        else
-          cached_values_for_can[args] ||= can_without_caching(*args)[1]
-          cached_values_for_can[args][0] ? cached_values_for_can[args][1] : nil
-        end
-      else
-        raise ArgumentError.new("wrong number of arguments (%d for 2)" % args.size) 
-      end
-    end
-    
-    def can_without_caching(label, subject)
-      subject.can_be?(label, self)
-    end
-    
-    def cached_values_for_can
-      @_cached_values_for_can ||= {}
+    def authorize(action, subject)
+      super(self, action, subject)
     end
     
     #
@@ -108,15 +79,7 @@ module Walruz
     #
     #    
     def authorize!(label, subject)
-      result = subject.can_be?(label, self)
-      if result[0]
-        cached_values_for_can[[label, subject]] = result
-        result[1]
-      else
-        response_params = result[1]
-        error_message = response_params[:error_message] || "You are not authorized to access this content"
-        raise NotAuthorized.new(self, subject, label, error_message) 
-      end
+      super(self, label, subject)
     end
     
     #
@@ -128,12 +91,9 @@ module Walruz
     # @return [Boolean] saying if the <em>actor</em> and the <em>subject</em> satisify the <em>policy</em>.
     #
     def satisfies?(policy_label, subject)
-      policy_clz = Walruz.fetch_policy(policy_label)
-      result = policy_clz.return_policy.new.safe_authorized?(self, subject)
-      result[0]
+      super(self, policy_label, subject)
     end
     
-    
     #
     # Allows an <em>actor</em> to check if he satisfies the condition of a <em>policy</em> with a given <em>subject</em>.
     # 
@@ -143,13 +103,10 @@ module Walruz
     # @return [Hash] Hash with the parameters returned from the <em>policy</em> if the <em>actor</em> and the <em>subject</em> satisfy the <em>policy</em>, nil otherwise.
     #
     def satisfies(policy_label, subject)
-      policy_clz = Walruz.fetch_policy(policy_label)
-      result = policy_clz.return_policy.new.safe_authorized?(self, subject)
-      result[0] ? result[1] : nil
+      super(self, policy_label, subject)
     end
     
-    
-    protected :can_without_caching, :cached_values_for_can
+    walruz_memoize :can?, :authorize, :satisfies?, :satisfies 
     
   end
-end
+end

data/lib/walruz/core_ext/memoization.rb

@@ -0,0 +1,34 @@
+module Walruz
+  module Memoization
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Avoiding name clashes with Rails
+      def walruz_memoize(*methods)
+        methods.each do |method|
+          self.walruz_memoize_method(method)
+        end
+      end
+
+      def walruz_memoize_method(method)
+        memoized = {}
+        original_method = self.instance_method(method)
+        self.send(:define_method, method) do |*params|
+          bound_original_method = original_method.bind(self).to_proc
+          if params.last.kind_of?(Symbol) && params.last == :reload
+            params.pop
+            memoized[[self, params]] = bound_original_method.call(*params)
+          else
+            memoized[[self, params]] ||= bound_original_method.call(*params)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/walruz/manager.rb

@@ -0,0 +1,93 @@
+module Walruz 
+
+  # The objective of this class is to start the invocation
+  # of the authorization process, the methods of this class are used
+  # internally by the actor and subject classes.
+  #
+  class Manager
+
+    module AuthorizationQuery
+
+      def can?(actor, action, subject)
+        Walruz::Manager.check_authorization(actor, action, subject)[0]
+      end
+
+      def authorize!(actor, action, subject)
+        result = Walruz::Manager.check_authorization(actor, action, 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(self, subject, action, error_message)
+        end
+      end
+
+      def authorize(actor, action, subject)
+        result = Walruz::Manager.check_authorization(actor, action, subject)
+        result[0] ? result[1] : nil
+      end
+
+      def satisfies?(actor, policy_label, subject)
+        policy_clz = Walruz.fetch_policy(policy_label)
+        result     = policy_clz.return_policy.new.safe_authorized?(actor, subject)
+        result[0]
+      end
+
+      def satisfies(actor, policy_label, subject)
+        policy_clz = Walruz.fetch_policy(policy_label)
+        result     = policy_clz.return_policy.new.safe_authorized?(actor, subject)
+        result[0] ? result[1] : nil
+      end
+
+    end
+
+    extend AuthorizationQuery
+    class << self
+      include Memoization
+      walruz_memoize :can?, :authorize, :satisfies?, :satisfies
+    end
+
+    #
+    # core method used on all the actor methods:
+    # can?
+    # authorize!
+    # authorize
+    # :private:
+    def self.check_authorization(actor, action, subject)
+      check_authorization_action_is_declared_on_subject(subject, action)
+      action = if subject.class._walruz_policies.key?(:default)
+                subject.class._walruz_policies.key?(action) ? action : :default
+              else
+                if subject.class._walruz_policies.key?(action) 
+                  action
+                else 
+                  raise ActionNotFound.new(:subject_action, :subject => subject, 
+                                                            :action => action)
+                end
+              end
+      
+      begin
+        result = subject.class._walruz_policies[action].
+                              return_policy.
+                              new.
+                              safe_authorized?(actor, subject)
+      rescue PolicyHalted => e
+        result = [false, {:error_message => e.message}]
+      end
+      result
+    end
+
+    private
+
+    def self.check_authorization_action_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
+        BEGIN
+        raise AuthorizationActionsNotDefined.new(message)
+      end
+    end
+
+  end
+end

data/lib/walruz/policy.rb

@@ -15,7 +15,11 @@ module Walruz
         @policies[child.policy_label] = child
       end
     end
-    
+
+    def halt(msg="You are not authorized")
+      raise PolicyHalted.new(msg)
+    end
+
     
     # @see Walruz.policies
     def self.policies
@@ -188,6 +192,7 @@ module Walruz
     def params
       @params ||= {}
     end
+
     
   end
-end
+end

data/lib/walruz/subject.rb

@@ -39,36 +39,6 @@ module Walruz
       end
     end
     
-    def can_be?(action, actor) # :nodoc:
-      check_authorization_actions_are_setted(action)
-      action = if self.class._walruz_policies.key?(:default)
-                self.class._walruz_policies.key?(action) ? action : :default
-              else
-                if self.class._walruz_policies.key?(action) 
-                  action
-                else 
-                  raise ActionNotFound.new(:subject_action, :subject => self, 
-                                                            :action => action)
-                end
-              end
-      
-      result = self.class._walruz_policies[action].
-                          return_policy.
-                          new.
-                          safe_authorized?(actor, self)
-      
-      result
-    end
-    
-    def check_authorization_actions_are_setted(action) # :nodoc:
-      if self.class._walruz_policies.nil?
-        message =<<BEGIN
-You need to invoke `check_authorizations :#{action} => Policies::SomePolicy` on the #{self.class.name} class
-BEGIN
-        raise AuthorizationActionsNotDefined.new(message)
-      end
-    end
-    
     module ClassMethods
       
       #
@@ -118,4 +88,4 @@ BEGIN
     end
     
   end
-end
+end

data/spec/scenario.rb

@@ -1,3 +1,25 @@
+class Foo
+  include Walruz::Memoization
+
+  def initialize
+    @first = nil
+  end
+
+  def highcost
+    @first = @first.nil?
+    if @first
+      @first = false
+      "This is the first time"
+    else
+      "This is the second time"
+    end
+  end
+
+  walruz_memoize :highcost
+
+end
+
+
 class Beatle
   include Walruz::Actor
   include Walruz::Subject
@@ -9,8 +31,18 @@ class Beatle
   def initialize(name)
     @name = name
     @songs = []
+    @invoke_helter_skelter = nil 
     @colaborations = []
   end
+
+  def invoke_helter_skelter=(bool)
+    @invoke_helter_skellter = bool
+  end
+
+  def helter_skelter_mode?
+    !!@invoke_helter_skellter
+  end
+
   
   def sing_the_song(song)
     response = authorize!(:sing, song)
@@ -107,11 +139,23 @@ class ColaboratingWithJohnPolicy < Walruz::Policy
   
 end
 
+class HelterSkellterPolicy < Walruz::Policy
+
+  def authorized?(beatle, song)
+    if beatle == Beatle::PAUL && beatle.helter_skelter_mode?
+      halt("I wanna sing helter skellter!!! YEAAAHHH")
+    else
+      false
+    end
+  end
+
+end
+
 class Song
   include Walruz::Subject
   extend Walruz::Utils
 
-  check_authorizations :sing => any(AuthorPolicy, AuthorInColaborationPolicy),
+  check_authorizations :sing => any(HelterSkellterPolicy, AuthorPolicy, AuthorInColaborationPolicy),
                        :sell => all(AuthorPolicy, negate(AuthorInColaborationPolicy)),
                        :sing_with_john => ColaboratingWithJohnPolicy
   attr_accessor :name

data/spec/walruz/actor_spec.rb

@@ -68,18 +68,18 @@ describe 'Walruz::Actor' do
   describe '#can?' do
     
     it "should be invoked only the first time and then return a cached solution" do
-      Song::YELLOW_SUBMARINE.should_receive(:can_be?).once.and_return([true, {}])
-      Beatle::JOHN.can?(:sing, Song::YELLOW_SUBMARINE, true)
+      Walruz::Manager.should_receive(:check_authorization).once.and_return([true, {}])
+      Beatle::JOHN.can?(:sing, Song::YELLOW_SUBMARINE, :reload)
       Beatle::JOHN.can?(:sing, Song::YELLOW_SUBMARINE)
     end
     
-    it "if a boolean third parameter is received it should not use the cached result" do
-      Beatle::JOHN.stub!(:can_without_caching).and_return([true, {}])
+    it "if a :reload symbol is passed as the third parameter it should not use the cached result" do
+      Walruz::Manager.stub!(:check_authorization).and_return([true, {}])
       Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE).should be_true
       
-      Beatle::JOHN.stub!(:can_without_caching).and_return([false, {}])
+      Walruz::Manager.stub!(:check_authorization).and_return([false, {}])
       Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE).should be_true
-      Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE, true).should be_false
+      Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE, :reload).should be_false
     end
     
     it "should receive at least 2 parameters" do
@@ -90,7 +90,7 @@ describe 'Walruz::Actor' do
     
     it "should receive at most 3 parameters" do
       lambda do
-        Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE, true, false)
+        Beatle::JOHN.can?(:sing, Song::ALL_YOU_NEED_IS_LOVE, :reload, false)
       end.should raise_error(ArgumentError)
     end
     
@@ -144,4 +144,4 @@ describe 'Walruz::Actor' do
     
   end
   
-end
+end

data/spec/walruz/core_ext/memoization_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Walruz::Memoization do
+
+  before(:each) do
+    @foo = Foo.new 
+  end
+
+  it "should invoke the original method the first time" do
+    @foo.highcost.should == "This is the first time"
+  end
+
+  it "should invoke the memoized result the second time" do
+    @foo.highcost.should == "This is the first time"
+    @foo.highcost.should == "This is the first time"
+  end
+
+  it "should invoke the method once memoized if and only if the reload parameter is given" do
+    @foo.highcost.should == "This is the first time"
+    @foo.highcost(:reload).should == "This is the second time"
+  end
+
+end

data/spec/walruz/manager_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Walruz::Manager do
+
+  describe "#check_authorization" do 
+
+    it "should invoke the policies associated to an action on a subject performed by an actor" do
+      result = Walruz::Manager.check_authorization(Beatle::JOHN, :sing, Song::ALL_YOU_NEED_IS_LOVE)
+      result[0].should be_true
+    end
+
+    describe "when executing validations on an invalid subject" do
+
+      it "should raise an Walruz::AuthorizationActionsNotDefined error" do
+        lambda do
+          Walruz::Manager.check_authorization(Beatle::JOHN, :talk_with, Beatle::PAUL)
+        end.should raise_error(Walruz::AuthorizationActionsNotDefined)
+      end
+
+    end
+
+  end
+
+
+end

data/spec/walruz/policy_spec.rb

@@ -58,5 +58,35 @@ describe Walruz::Policy do
     end
   
   end
+
+  describe "when using the halt method inside a policy" do
+
+    before(:each) do
+      Beatle::PAUL.invoke_helter_skelter = true
+    end
+
+    after(:each) do
+      Beatle::PAUL.invoke_helter_skelter = false
+    end
+
+    it "should raise a PolicyHalted exception" do
+      lambda do
+        Beatle::PAUL.authorize!(:sing, Song::YESTERDAY)
+      end.should raise_error(Walruz::NotAuthorized, "I wanna sing helter skellter!!! YEAAAHHH")
+    end
+
+    describe "on composed policies" do
+
+      before(:each) do
+        AuthorPolicy.should_not_receive(:new)
+      end
+      
+      it "should not invoke any other policy" do
+        Beatle::PAUL.can?(:sing, Song::YESTERDAY)
+      end
+
+    end
+
+  end
   
-end
+end

data/spec/walruz/subject_spec.rb

@@ -2,23 +2,8 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Walruz::Subject do
   
-  it "should add a can_be? method" do
-    Song::A_DAY_IN_LIFE.should respond_to(:can_be?)
-  end
-  
   it "should add a class method called check_authorizations" do
     Song.should respond_to(:check_authorizations)
   end
   
-  
-  describe "when executing validations on an invalid subject" do
-    
-    it "should raise an Walruz::AuthorizationActionsNotDefined error" do
-      lambda do
-        Beatle::JOHN.can_be?(:talk_with, Beatle::PAUL)
-      end.should raise_error(Walruz::AuthorizationActionsNotDefined)
-    end
-    
-  end
-  
-end
+end

data/walruz.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{walruz}
+  s.version = "0.0.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roman Gonzalez"]
+  s.date = %q{2009-08-21}
+  s.email = %q{roman@noomi.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "lib/walruz.rb",
+     "lib/walruz/actor.rb",
+     "lib/walruz/core_ext/array.rb",
+     "lib/walruz/core_ext/memoization.rb",
+     "lib/walruz/manager.rb",
+     "lib/walruz/policy.rb",
+     "lib/walruz/subject.rb",
+     "lib/walruz/utils.rb",
+     "spec/scenario.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/walruz/actor_spec.rb",
+     "spec/walruz/core_ext/array_spec.rb",
+     "spec/walruz/core_ext/memoization_spec.rb",
+     "spec/walruz/manager_spec.rb",
+     "spec/walruz/policy_spec.rb",
+     "spec/walruz/subject_spec.rb",
+     "spec/walruz/utils_spec.rb",
+     "spec/walruz/walruz_spec.rb",
+     "walruz.gemspec"
+  ]
+  s.has_rdoc = %q{yard}
+  s.homepage = %q{http://github.com/noomii/walruz}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{walruz}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Walruz is a gem that provides an easy but powerful way to implement authorization policies in a system, relying on the composition of simple policies to create more complex ones.}
+  s.test_files = [
+    "spec/scenario.rb",
+     "spec/spec_helper.rb",
+     "spec/walruz/actor_spec.rb",
+     "spec/walruz/core_ext/array_spec.rb",
+     "spec/walruz/core_ext/memoization_spec.rb",
+     "spec/walruz/manager_spec.rb",
+     "spec/walruz/policy_spec.rb",
+     "spec/walruz/subject_spec.rb",
+     "spec/walruz/utils_spec.rb",
+     "spec/walruz/walruz_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: walruz
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Roman Gonzalez
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-30 00:00:00 -07:00
+date: 2009-08-21 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,9 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
+- .document
+- .gitignore
+- CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -30,6 +33,8 @@ files:
 - lib/walruz.rb
 - lib/walruz/actor.rb
 - lib/walruz/core_ext/array.rb
+- lib/walruz/core_ext/memoization.rb
+- lib/walruz/manager.rb
 - lib/walruz/policy.rb
 - lib/walruz/subject.rb
 - lib/walruz/utils.rb
@@ -38,10 +43,13 @@ files:
 - spec/spec_helper.rb
 - spec/walruz/actor_spec.rb
 - spec/walruz/core_ext/array_spec.rb
+- spec/walruz/core_ext/memoization_spec.rb
+- spec/walruz/manager_spec.rb
 - spec/walruz/policy_spec.rb
 - spec/walruz/subject_spec.rb
 - spec/walruz/utils_spec.rb
 - spec/walruz/walruz_spec.rb
+- walruz.gemspec
 has_rdoc: yard
 homepage: http://github.com/noomii/walruz
 licenses: []
@@ -66,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: walruz
-rubygems_version: 1.3.3
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Walruz is a gem that provides an easy but powerful way to implement authorization policies in a system, relying on the composition of simple policies to create more complex ones.
@@ -75,6 +83,8 @@ test_files:
 - spec/spec_helper.rb
 - spec/walruz/actor_spec.rb
 - spec/walruz/core_ext/array_spec.rb
+- spec/walruz/core_ext/memoization_spec.rb
+- spec/walruz/manager_spec.rb
 - spec/walruz/policy_spec.rb
 - spec/walruz/subject_spec.rb
 - spec/walruz/utils_spec.rb