indulgence 0.0.3 → 0.0.4

data/README.rdoc

@@ -17,7 +17,7 @@ succinctly within a single file.
 
 == Defining indulgent permissions
 
-Indulgence is added to a class via acts_as_indulgent:
+Indulgence can be added to a class via acts_as_indulgent:
 
     class Thing < ActiveRecord::Base
       acts_as_indulgent
@@ -59,11 +59,11 @@ So typically, these objects could look like this:
       validates :name, :uniqueness => true
     end
     
-    role = Role.create(:name => 'pleb')
+    pleb = Role.create(:name => 'pleb')
     user = User.create(
       :first_name => 'Joe', 
       :last_name => 'Blogs',
-      :role_id => role.id
+      :role => pleb
     ) 
 
 == Compare single item: indulge?
@@ -101,7 +101,7 @@ give Emperors the right to see and do anything by first creating an emperor
     caesar = User.create(
       :first_name => 'Julius', 
       :last_name => 'Ceasar',
-      :role_id => emperor.id
+      :role => emperor
     )
 
 And then defining what they can do by adding these two methods to ThingPermission:
@@ -184,26 +184,28 @@ permissions. This can be done by adding this method to ThingPermission:
 
 This will create an Ability object with the following methods:
 
-[name]           Allows abilities of the same kind to be matched
+[name]           Allows abilities of the same kind to be matched and cached
 [compare_single] Used by :indulge?
 [filter_many]    Used by :indulgence 
 
-==== Compare single
+Alternatively, you can achieve the same result by defining lambdas for the
+ability methods :compare_single and :filter_many. If you use lambdas, you must
+also define a name.
 
-_compare_single_ should be a lambda that is passed the object being tested and
-the entity it is to be tested against. The lambda returns _true_ if permission 
-should be given. Otherwise _false_ should be returned.
+Alternatively you can define the ability like this:
 
-Alternatively, instead of a lambda, any object can be used that returns _true_
-or _false_ when it _call_ method is passed the object and the entity.
-
-==== Filter many
+  def things_they_wrote
+    define_ability(:author)
+  end
 
-In this example: 
+This will use :author to define attributes of an ability object. :author could
+be an association or an attribute that return either the entity or the entity.id.
 
-    Thing.indulgence(user, :read) == Thing.where(:author_id => user.id)
+So this also works:
 
-if the :read ability is matched to *things_they_wrote*
+  def things_they_wrote
+    define_ability(:author_id)
+  end
 
 Once *things_they_wrote* has been defined, we can use it to define a new set
 of abilities:
@@ -227,11 +229,10 @@ With that done:
     cicero = User.create(
       :first_name => 'Marcus', 
       :last_name => 'Cicero', 
-      :role_id => author.id
+      :role => author
     )
 
-    thing.author = cicero
-    thing.save
+    thing.update_attribute :author, cicero
 
     thing.indulge?(cicero, :create) == true
     thing.indulge?(cicero, :read)   == true
@@ -304,6 +305,7 @@ If only ThingPermission is affected, the attributes that stores the _role_method
 and _role_name_method_ could be overwritten:
 
     class ThingPermission < Indulgence::Permission
+
       def self.role_method
         :position
       end
@@ -342,4 +344,18 @@ With this used to define indulgence in Thing, we can do this:
 == Examples
 
 For some examples, have a look at the tests. In particular, look at the object
-definitions in test/lib. 
+definitions in test/lib. 
+
+== Playing with Indulgence
+
+This app has a set of tests associated with it. The test suite includes the
+configuration for a sqlite3 test database, with migrations and fixtures. If you
+wish to play with, and/or modify Indulgence: fork the project and clone a local
+copy. Run bundler to install the necessary gems. Then use this command to
+create the test database:
+
+    rake db:migrate RAILS_ENV=test
+
+If this raises no errors, you should then be able to run the tests with:
+
+    rake test

data/lib/indulgence/ability.rb

@@ -1,17 +1,19 @@
 
 module Indulgence
   class Ability
-    attr_reader :name, :compare_single, :filter_many
+    attr_reader :name, :relationship, :args
     
     def initialize(args = {})
       @name = args[:name]
       @compare_single = args[:compare_single]
       @filter_many = args[:filter_many]
+      @relationship = args[:relationship]
+      @args = args
       valid?
     end
     
     def ==(another_ability)
-      [:name, :compare_single, :filter_many].each do |method|
+      [:name, :args].each do |method|
         return false if send(method) != another_ability.send(method)
       end
       return true
@@ -19,8 +21,27 @@ module Indulgence
     
     def valid?
       must_be_name
-      must_respond_to_call :compare_single
-      must_respond_to_call :filter_many
+      unless relationship
+        must_respond_to_call @compare_single
+        must_respond_to_call @filter_many
+      end
+    end
+    
+    def compare_single(thing, entity)
+      return @compare_single.call thing, entity if @compare_single
+      
+      identifier = thing.send(relationship)    
+      identifier == entity.id || identifier == entity     
+    end
+    
+    def filter_many(things, entity)
+      return @filter_many.call things, entity if @filter_many
+      
+      if things.reflect_on_association(relationship)
+        things.joins(relationship).where(entity.class.table_name => {:id => entity.id})
+      else
+        things.where(relationship => entity.id)
+      end
     end
     
     private
@@ -30,9 +51,9 @@ module Indulgence
       end
     end
     
-    def must_respond_to_call(method)
-      unless send(method).respond_to? :call
-        raise AbilityConfigurationError, "ability.#{method} must respond to call"
+    def must_respond_to_call(item)
+      unless item.respond_to? :call
+        raise AbilityConfigurationError, "item must respond to call: #{item.inspect}"
       end
     end
     

data/lib/indulgence/permission.rb

@@ -18,13 +18,11 @@ module Indulgence
     end
     
     def filter_many(things)
-      check_method_can_be_called(:filter_many)
-      ability.filter_many.call things, entity
+      ability.filter_many things, entity
     end
     
     def compare_single(thing)
-      check_method_can_be_called(:compare_single)
-      ability.compare_single.call thing, entity
+      ability.compare_single thing, entity
     end
     
     @@role_method = :role
@@ -64,7 +62,7 @@ module Indulgence
     end
     
     def self.define_ability(args)
-      raise AbilityConfigurationError, "A name is required for each ability" unless args[:name]
+      args = generate_ability_args(args)
       ability_cache[args[:name].to_sym] ||= Ability.new args
     end
     
@@ -103,8 +101,19 @@ module Indulgence
       @ability_cache ||= {}
     end
     
-    def check_method_can_be_called(name)
-      raise AbilityConfigurationError, "#{name} method must respond to call" unless ability.send(name).respond_to? :call
+    def self.generate_ability_args(args)
+      unless args.kind_of? Hash
+        args = {:relationship => args.to_sym}
+      end
+      args[:name] = generate_ability_name(args)
+      return args
+    end
+    
+    def self.generate_ability_name(args)
+      return args[:name] if args[:name]
+      return args.to_s if args[:relationship]
+      raise AbilityConfigurationError, "A name is required for each ability"
     end
+    
   end
 end

data/lib/indulgence/version.rb

@@ -1,14 +1,19 @@
 module Indulgence
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end
 
 # History
 # =======
 # 
+# 0.0.4   Simplifies defining abilities
+# 
+#         Allows and ability to be defined by passing in the name of the 
+#         association that it refers to.
+# 
 # 0.0.3   Updated to use latest version of standalone_migrations
 # 
-#         standalone_migrations main has been updated to use branch this app
-#         has been using. So config in .standalone_migrations now works without
+#         Branch this app has been using has been merged into standalone_migrations
+#         main. So config in .standalone_migrations now works without
 #         using a specific clone branch.
 # 
 # 0.0.2   Rebuild with lessons learnt from first usage in host app

data/test/lib/thing_permission.rb

@@ -5,7 +5,9 @@ class ThingPermission < Indulgence::Permission
   def abilities
     {
       god: default.merge(god),
-      demigod: default.merge(demigod)
+      demigod: default.merge(demigod),
+      thief: default.merge(thief),
+      friend: default.merge(friend)
     }
   end
   
@@ -35,12 +37,32 @@ class ThingPermission < Indulgence::Permission
     }
   end
   
+  def thief
+    {
+      update: things_they_stole
+    }
+  end
+  
+  def friend
+    {
+      update: things_they_borrow
+    }
+  end
+  
   def things_they_own
     define_ability(
-      :name => :things_they_own,
-      :compare_single => lambda {|thing, user| thing.owner_id == user.id},
-      :filter_many => lambda {|things, user| things.where(:owner_id => user.id)}
+      name: :things_they_own,
+      compare_single: lambda {|thing, user| thing.owner_id == user.id},
+      filter_many: lambda {|things, user| things.where(:owner_id => user.id)}
     )
   end
   
+  def things_they_stole
+    define_ability(:owner_id)
+  end
+  
+  def things_they_borrow
+    define_ability(:owner)
+  end
+  
 end

data/test/units/indulgence/ability_test.rb

@@ -2,44 +2,7 @@ require_relative '../../test_helper'
 require 'ability'
 require 'exceptions'
 
-module Indulgence
-  class AbilityTest < Test::Unit::TestCase
-    
-    def setup
-      @attributes = {
-        name: :foo, 
-        compare_single: lambda {|thing, entity| true},
-        filter_many: lambda {|entity| nil}
-      }
-    end
-    
-    def test_equality
-      ability = Ability.new(@attributes)
-      other_ability = Ability.new(@attributes)
-      assert(ability == other_ability, "#{ability} == #{other_ability} should return true")
-      assert_equal(ability, other_ability)
-    end
-    
-    def test_name_absence_raises_error
-      @attributes.delete(:name)
-      assert_initiation_raises_error
-    end
-    
-    def test_indulge_must_respond_to_call
-      @attributes[:compare_single] = true
-      assert_initiation_raises_error
-    end
-    
-    def test_indulgence_must_respond_to_call
-      @attributes[:filter_many] = true
-      assert_initiation_raises_error
-    end
-    
-    def assert_initiation_raises_error
-      assert_raise AbilityConfigurationError do
-        Ability.new(@attributes)
-      end
-    end
-    
-  end
-end
+require_relative 'ability_tests/with_lambdas'
+require_relative 'ability_tests/method_only'
+
+

data/test/units/indulgence/ability_tests/method_only.rb

@@ -0,0 +1,38 @@
+
+module Indulgence
+  module AbilityTests
+    class MethodOnly < Test::Unit::TestCase
+
+      def setup
+        @attributes = {
+          name: :foo, 
+          relationship: :author
+        }
+      end
+
+      def test_equality
+        ability = Ability.new(@attributes)
+        other_ability = Ability.new(@attributes)
+        assert(ability == other_ability, "#{ability} == #{other_ability} should return true")
+        assert_equal(ability, other_ability)
+      end
+
+      def test_name_absence_raises_error
+        @attributes.delete :name
+        assert_initiation_raises_error
+      end
+
+      def test_lack_of_entity_id_method
+        @attributes.delete :relationship
+        assert_initiation_raises_error
+      end
+      
+      def assert_initiation_raises_error
+        assert_raise AbilityConfigurationError do
+          Ability.new(@attributes)
+        end
+      end
+
+    end
+  end
+end

data/test/units/indulgence/ability_tests/with_lambdas.rb

@@ -0,0 +1,45 @@
+
+
+module Indulgence
+  module AbilityTests
+    class WithLambdas < Test::Unit::TestCase
+
+      def setup
+        @attributes = {
+          name: :foo, 
+          compare_single: lambda {|thing, entity| true},
+          filter_many: lambda {|entity| nil}
+        }
+      end
+
+      def test_equality
+        ability = Ability.new(@attributes)
+        other_ability = Ability.new(@attributes)
+        assert(ability == other_ability, "#{ability} == #{other_ability} should return true")
+        assert_equal(ability, other_ability)
+      end
+
+      def test_name_absence_raises_error
+        @attributes.delete(:name)
+        assert_initiation_raises_error
+      end
+
+      def test_indulge_must_respond_to_call
+        @attributes[:compare_single] = true
+        assert_initiation_raises_error
+      end
+
+      def test_indulgence_must_respond_to_call
+        @attributes[:filter_many] = true
+        assert_initiation_raises_error
+      end
+
+      def assert_initiation_raises_error
+        assert_raise AbilityConfigurationError do
+          Ability.new(@attributes)
+        end
+      end
+
+    end
+  end
+end

data/test/units/thing_test.rb

@@ -7,8 +7,10 @@ class ThingTest < Test::Unit::TestCase
   def setup
     @god = Role.create(:name => 'god')
     @demigod = Role.create(:name => 'demigod')
+    @thief = Role.create(:name => 'thief')
+    @friend = Role.create(:name => 'friend')
     @owner = User.create(:name => 'Mary')
-    @thing = Thing.create(:name => 'Stuff', :owner_id => @owner.id)
+    @thing = Thing.create(:name => 'Stuff', :owner => @owner)
   end
 
   
@@ -26,36 +28,51 @@ class ThingTest < Test::Unit::TestCase
   
   def test_indulge_by_god
     make_second_thing
-    @owner.update_attribute(:role_id, @god.id)
+    @owner.update_attribute(:role, @god)
     assert_equal(true, @thing.indulge?(@owner, :read))
-    @thing.indulge?(@owner, :delete)
     assert_equal(true, @thing.indulge?(@owner, :delete))
     assert_equal(true, @other_thing.indulge?(@owner, :delete))    
   end
   
   def test_indulgence_by_god
     make_second_thing
-    @owner.update_attribute(:role_id, @god.id)
+    @owner.update_attribute(:role, @god)
     assert_equal(Thing.all, Thing.indulgence(@owner, :delete))  
   end
   
   def test_indulge_by_demigod
     make_second_thing
-    @owner.update_attribute(:role_id, @demigod.id)
+    @owner.update_attribute(:role, @demigod)
     assert_equal(true, @thing.indulge?(@owner, :read))
     assert_equal(true, @thing.indulge?(@owner, :delete)) 
     assert_equal(false, @other_thing.indulge?(@owner, :delete))
   end
   
+  def test_indule_via_entity_id
+    make_second_thing
+    @owner.update_attribute(:role, @thief)
+    assert_equal(true, @thing.indulge?(@owner, :read))
+    assert_equal(true, @thing.indulge?(@owner, :update)) 
+    assert_equal(false, @thing.indulge?(@owner, :delete))
+  end
+  
+  def test_indule_via_entity_association
+    make_second_thing
+    @owner.update_attribute(:role, @friend)
+    assert_equal(true, @thing.indulge?(@owner, :read))
+    assert_equal(true, @thing.indulge?(@owner, :update)) 
+    assert_equal(false, @thing.indulge?(@owner, :delete))
+  end
+    
   def test_indulge_other_thing
-    other_thing = OtherThing.create(:name => 'Other Stuff', :owner_id => @owner.id)
+    other_thing = OtherThing.create(:name => 'Other Stuff', :owner => @owner)
     assert_equal(true, other_thing.indulge?(@owner, :read))
     assert_equal(false, other_thing.indulge?(@owner, :delete))
   end
   
   def test_indulgence
     make_second_thing
-    @owner.update_attribute(:role_id, @demigod.id)
+    @owner.update_attribute(:role, @demigod)
     assert_equal(Thing.order('id'), Thing.indulgence(@owner, :read).order('id'))
     assert_equal(Thing.order('id'), Thing.indulgence(@user, :read).order('id'))
     assert_equal([@thing], Thing.indulgence(@owner, :delete))
@@ -64,6 +81,18 @@ class ThingTest < Test::Unit::TestCase
     end
   end
   
+  def test_indulgence_via_entity_id_method
+    make_second_thing
+    @owner.update_attribute(:role, @thief)
+    assert_equal(Thing.where(:owner_id => @owner.id), Thing.indulgence(@owner, :update))
+  end
+  
+  def test_indulgence_via_entity_association
+    make_second_thing
+    @owner.update_attribute(:role, @friend)
+    assert_equal(Thing.where(:owner_id => @owner.id).all, Thing.indulgence(@owner, :update).all)
+  end
+  
   def test_indulgence_with_unspecified_ability
     assert_raise ActiveRecord::RecordNotFound do
       Thing.indulgence(@owner, :unspecified)
@@ -72,7 +101,7 @@ class ThingTest < Test::Unit::TestCase
   
   def test_find
     make_second_thing
-    @owner.update_attribute(:role_id, @demigod.id)
+    @owner.update_attribute(:role, @demigod)
     assert_equal(@thing, Thing.indulgence(@owner, :delete).find(@thing.id))
     assert_raise ActiveRecord::RecordNotFound do
       assert_equal(@thing, Thing.indulgence(@user, :delete).find(@thing.id))
@@ -88,7 +117,7 @@ class ThingTest < Test::Unit::TestCase
   
   def test_aliased_filter_many_method
     make_second_thing
-    @owner.update_attribute(:role_id, @demigod.id)
+    @owner.update_attribute(:role, @demigod)
     assert_equal(Thing.order('id'), Thing.permitted(@owner, :read).order('id'))
     assert_equal(Thing.order('id'), Thing.permitted(@user, :read).order('id'))
     assert_equal([@thing], Thing.permitted(@owner, :delete))
@@ -99,7 +128,7 @@ class ThingTest < Test::Unit::TestCase
   
   def make_second_thing
     @user = User.create(:name => 'Clive')
-    @other_thing = Thing.create(:name => 'Debris', :owner_id => @user.id)
+    @other_thing = Thing.create(:name => 'Debris', :owner => @user)
   end
   
   def teardown

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indulgence
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-15 00:00:00.000000000 Z
+date: 2013-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -79,6 +79,8 @@ files:
 - test/units/role_test.rb
 - test/units/indulgence/permission_test.rb
 - test/units/indulgence/ability_test.rb
+- test/units/indulgence/ability_tests/method_only.rb
+- test/units/indulgence/ability_tests/with_lambdas.rb
 - test/units/user_test.rb
 - test/units/thing_permission_test.rb
 - test/units/thing_test.rb
@@ -121,6 +123,8 @@ test_files:
 - test/units/role_test.rb
 - test/units/indulgence/permission_test.rb
 - test/units/indulgence/ability_test.rb
+- test/units/indulgence/ability_tests/method_only.rb
+- test/units/indulgence/ability_tests/with_lambdas.rb
 - test/units/user_test.rb
 - test/units/thing_permission_test.rb
 - test/units/thing_test.rb