rbacanable 0.2.1 → 0.2.2

data/Rakefile

@@ -1,7 +1,8 @@
 require 'rubygems'
 require 'rake'
 
-require File.dirname(__FILE__) + '/lib/canable'
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'canable'
 
 begin
   require 'jeweler'
@@ -16,6 +17,8 @@ begin
     gem.add_development_dependency "shoulda", "2.10.3"
     gem.add_development_dependency "mocha", "0.9.8"
     gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "activesupport", ">= 0"
+    
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/examples/callbacks.rb

@@ -0,0 +1,84 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rubygems'
+require 'activesupport'
+require 'canable'
+require 'terminal-table/import'
+
+module Canable::Roles
+  module BasicRole
+    include Canable::Role
+    default_response false
+
+  end
+  
+  module EmployeeRole
+    include Canable::Role
+    default_response false
+    
+    def can_destroy_article?(article)
+      article.creator == @name
+    end
+  
+    def can_update_article?(article)
+      article.creator == @name
+    end
+  end
+end
+
+class User
+  include Canable::Actor
+  attr_accessor :name
+  attr_accessor :role
+  
+  default_role Canable::Roles::BasicRole
+  after_permissions_query :after_query
+  
+  def after_query(options = {})
+    puts "After Query from Basic Role"
+  end
+  
+  def initialize(attributes = {})
+    @name = attributes[:name]
+    @role = attributes[:role]
+  end
+  
+  def to_s
+    "#{@role.to_s}: #{@name}"
+  end
+end
+
+class Article
+  include Canable::Ables
+  attr_accessor :creator
+  
+  def initialize(attributes = {})
+    @creator = attributes[:creator]
+  end
+  
+  def to_s
+    "#{@creator}'s article"
+  end
+end
+
+users = [
+  User.new(:name => "John", :role => :employee),
+  User.new(:name => "Jim")
+]
+
+posts = [
+  Article.new(:creator => "John"),
+  Article.new(:creator => "Jim"),
+  Article.new(:creator => "Harry")
+]
+
+
+user_table = table do |t|
+  t.headings = "User", "Resource", "Can View?", "Can Create?", "Can Update?", "Can Destroy?", "@role", "Included Role"
+  users.each do |user|
+    posts.each do |post|
+      t << [user.to_s, post.to_s, user.can_view?(post), user.can_create?(post), user.can_update?(post), user.can_destroy?(post), user.role, user.canable_included_role]
+    end
+  end
+end
+puts user_table

data/lib/canable.rb

@@ -1,207 +1,12 @@
-module Canable
-  Version = '0.2.1'
-
-  # Module that holds all the can_action? methods.
-  module Cans; end
-
-  # Module that holds all the [method]able_by? methods.
-  module Ables; end
-  
-  # Module that is included by a role implementation
-  module Role
-    
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-    
-    # These are applied to the actual Role module 'instance' that includes this (Canable::Role) module 
-    module ClassMethods
-      # Each role has a default query response, found in this variable
-      attr_accessor :_default_response
-      
-      
-      # Called when another Role imeplementation module tries to inherit an existing Role implementation
-      # Notice this method isn't self.included, this method becomes self.included on the module including this (Canable::Role) module
-      # This is nesscary to emulate inhertance of the default response and any other variables in the future
-      def included(base)
-        base._default_response = self._default_response
-      end
-      
-      # Called when an Actor decides its role and extends itself (an instance) with a Role implementation
-      # Creates the default instance methods for an Actor and persists the can_action? response default down
-      def extended(base)
-        base.extend(RoleEnabledCanInstanceMethods)
-        this_role = self # can't use self inside the instance eval
-        base.instance_eval { @_canable_role = this_role }
-      end
-      
-      # Methods given to an instance of an Actor
-      module RoleEnabledCanInstanceMethods
-        def _canable_default # the role default response
-          @_canable_role._default_response
-        end
-      end
-      
-      # ----------------------
-      # Role building DSL
-      # ----------------------
-      def default_response(val)
-        self._default_response = val
-      end
-    end
-  end
-  
-  module Actor
-    include Cans # each role has a distinct set of responses to all the can_action? methods
-    attr_accessor :canable_included_role
-    
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Override attr_accessor to make sure the role has been included so that we can return an accurate value
-    # "lazy" role including
-    def canable_included_role
-      self.__initialize_canable_role
-      @canable_included_role
-    end
-    
-    # Called every time a role is needed to make sure the lazy load has been completed
-    def __initialize_canable_role
-      return if @_canable_initialized == true 
-      @_canable_intialize == true
-      role_constant = self.__get_role_constant
-      if role_constant == nil
-        default_role = self.class.canable_default_role
-        self.act(default_role) unless default_role == nil
-      else
-        self.act(role_constant)
-      end
-    end
-    
-    def __get_role_constant
-      if self.class.canable_role_proc.respond_to?(:call)
-        attribute = self.class.canable_role_proc.call(self)
-      elsif self.instance_variable_get(:@role)
-        attribute = @role
-      end
-      attribute || nil
-    end
-    
-    # Sets the role of this actor by including a role module
-    def act(role)
-      unless(role.respond_to?(:included))
-        role = Canable::Roles.const_get((role.to_s.capitalize+"Role").intern)
-      end
-      self.extend role
-      self.canable_included_role = role
-    end
-    
-    
-      # ---------------
-      # RBAC Actor building DSL
-      # ---------------
-    
-    module ClassMethods
-      attr_accessor :canable_default_role
-      attr_accessor :canable_role_proc
-      
-      
-      def default_role(role)
-        self.canable_default_role = role
-      end
-      
-      def role_attribute(attribute)
-        self.canable_role_proc = Proc.new {|actor|
-          role = actor.instance_variable_get(attribute)
-        }
-      end
-      
-      def role_proc(proc)
-        self.canable_role_proc = proc
-      end
-    end
-  end
-  
-  # Holds all the different roles that an actor may assume
-  module Roles
-    # Make one default role that is false for everything
-    module Role
-      include Canable::Role
-      default_response false
-    end
-  end
-
-  # Module that holds all the enforce_[action]_permission methods for use in controllers.
-  module Enforcers
-    def self.included(controller)
-      controller.class_eval do
-        Canable.actions.each do |can, able|
-          delegate      "can_#{can}?", :to => :current_user
-          helper_method "can_#{can}?" if controller.respond_to?(:helper_method)
-          hide_action   "can_#{can}?" if controller.respond_to?(:hide_action)
-        end
-      end
-    end
-  end
-
-  # Exception that gets raised when permissions are broken for whatever reason.
-  class Transgression < StandardError; end
+require 'active_support'
+require 'canable/role'
+require 'canable/canable'
+require 'canable/cans'
+require 'canable/actor'
+require 'canable/enforcers'
 
-  # Default actions to an empty hash.
-  @actions = {}
-
-  # Returns hash of actions that have been added.
-  #   {:view => :viewable, ...}
-  def self.actions
-    @actions
-  end
-
-  # Adds an action to actions and the correct methods to can and able modules.
-  #
-  #   @param [Symbol] can_method The name of the can_[action]? method.
-  #   @param [Symbol] resource_method The name of the [resource_method]_by? method.
-  def self.add(can, able)
-    @actions[can] = able
-    add_can_method(can)
-    add_able_method(can, able)
-    add_enforcer_method(can)
-  end
-
-  private
-    def self.add_can_method(can)
-      Cans.module_eval <<-EOM
-        def can_#{can}?(resource)
-          self.__initialize_canable_role if self.class.include?(Canable::Actor)
-          method = ("can_#{can}_"+resource.class.name.gsub(/::/,"_").downcase+"?").intern
-          if self.respond_to?(method, true)
-            self.send method, resource
-          elsif self.respond_to?(:_canable_default)
-            self._canable_default
-          else
-            false
-          end
-        end
-      EOM
-    end
-
-    def self.add_able_method(can, able)
-      Ables.module_eval <<-EOM
-        def #{able}_by?(actor)
-          return false if actor.blank?
-          actor.can_#{can}?(self)
-        end
-      EOM
-    end
-
-    def self.add_enforcer_method(can)
-      Enforcers.module_eval <<-EOM
-        def enforce_#{can}_permission(resource)
-          raise Canable::Transgression unless can_#{can}?(resource)
-        end
-        private :enforce_#{can}_permission
-      EOM
-    end
+module Canable
+  Version = '0.2.2'
 end
 
 Canable.add(:view,    :viewable)

data/lib/canable/actor.rb

@@ -0,0 +1,76 @@
+module Canable
+  module Actor
+    attr_accessor :canable_included_role
+    
+    def self.included(base)
+      base.instance_eval do
+        include Canable::Cans
+      end
+      class << base
+        include ClassMethods
+      end
+    end
+
+    # Override attr_accessor to make sure the role has been included so that we can return an accurate value
+    # "lazy" role including
+    def canable_included_role
+      self.__initialize_canable_role
+      @canable_included_role
+    end
+    
+    # Called every time a role is needed to make sure the lazy load has been completed
+    def __initialize_canable_role
+      return if @_canable_initialized == true 
+      @_canable_intialize == true
+      role_constant = self.__get_role_constant
+      if role_constant == nil
+        default_role = self.class.canable_default_role
+        self.act(default_role) unless default_role == nil
+      else
+        self.act(role_constant)
+      end
+    end
+    
+    def __get_role_constant
+      if self.class.canable_role_proc.respond_to?(:call)
+        attribute = self.class.canable_role_proc.call(self)
+      elsif self.instance_variable_get(:@role)
+        attribute = @role
+      end
+      attribute || nil
+    end
+    
+    # Sets the role of this actor by including a role module
+    def act(role)
+      unless(role.respond_to?(:included))
+        role = Canable::Roles.const_get((role.to_s.capitalize+"Role").intern)
+      end
+      self.extend role
+      self.canable_included_role = role
+    end
+    
+      # ---------------
+      # RBAC Actor building DSL
+      # ---------------
+    
+    module ClassMethods
+      attr_accessor :canable_default_role
+      attr_accessor :canable_role_proc
+            
+      def default_role(role)
+        self.canable_default_role = role
+      end
+      
+      def role_attribute(attribute)
+        self.canable_role_proc = Proc.new {|actor|
+          role = actor.instance_variable_get(attribute)
+        }
+      end
+      
+      def role_proc(proc)
+        self.canable_role_proc = proc
+      end
+      
+    end
+  end
+end

data/lib/canable/canable.rb

@@ -0,0 +1,82 @@
+module Canable
+  
+  # Module that holds all the can_action? methods.
+  module Cans; end
+
+  # Module that holds all the [method]able_by? methods.
+  module Ables; end
+  
+  # Holds all the different roles that an actor may assume
+  module Roles
+    # Make one default role that is false for everything
+    module Role
+      include Canable::Role
+      default_response false
+    end
+  end
+
+  # Exception that gets raised when permissions are broken for whatever reason.
+  class Transgression < StandardError; end
+
+  # Default actions to an empty hash.
+  @actions = {}
+  
+  # Returns hash of actions that have been added.
+  #   {:view => :viewable, ...}
+  def self.actions
+    @actions
+  end
+  
+  # Adds an action to actions and the correct methods to can and able modules.
+  #
+  #   @param [Symbol] can_method The name of the can_[action]? method.
+  #   @param [Symbol] resource_method The name of the [resource_method]_by? method.
+  def self.add(can, able)
+    @actions[can] = able
+    add_can_method(can)
+    add_able_method(can, able)
+    add_enforcer_method(can)
+  end
+  
+  def self.run_callbacks(callback, options)
+    @callbacks.run_callbacks(callback, options) { |result, object| result == false }
+  end
+  
+  private
+    def self.add_can_method(can)
+      Cans.module_eval <<-EOM
+        def can_#{can}?(resource)
+          self.__initialize_canable_role if self.class.include?(Canable::Actor)
+          self.run_callback(:before_query, {:can => self, :able => resource, :permission => :#{can}})
+          method = ("can_#{can}_"+resource.class.name.gsub(/::/,"_").downcase+"?").intern
+          if self.respond_to?(method, true)
+            result = self.send method, resource
+          elsif self.respond_to?(:_canable_default)
+            result = self._canable_default
+          else
+            result = false
+          end
+          self.run_callback(:after_query, {:can => self, :able => resource, :permission => :#{can}, :result => result})
+          result
+        end
+      EOM
+    end
+
+    def self.add_able_method(can, able)
+      Ables.module_eval <<-EOM
+        def #{able}_by?(actor)
+          return false if actor.blank?
+          actor.can_#{can}?(self)
+        end
+      EOM
+    end
+
+    def self.add_enforcer_method(can)
+      Enforcers.module_eval <<-EOM
+        def enforce_#{can}_permission(resource)
+          raise Canable::Transgression unless can_#{can}?(resource)
+        end
+        private :enforce_#{can}_permission
+      EOM
+    end
+end

data/lib/canable/cans.rb

@@ -0,0 +1,38 @@
+module Canable
+  module Cans    
+    def self.included(base)
+      class << base
+        include ClassMethods
+      end
+    end
+    
+    def run_callback(name, options)
+      cs = self.class.canable_callbacks
+      self.send(cs[name], options) if cs[name]
+    end
+    
+      # ---------------
+      # RBAC Can/Actor building DSL
+      # ---------------
+    
+    module ClassMethods
+      attr_accessor :canable_callbacks
+      
+      def canable_callbacks
+        @canable_callbacks ||= {}
+      end
+      
+      def after_permissions_query(symbol)
+        c = self.canable_callbacks
+        c[:after_query] = symbol
+        self.canable_callbacks = c
+      end
+      
+      def before_permissions_query(symbol)
+        c = self.canable_callbacks
+        c[:before_query] = symbol
+        self.canable_callbacks = c
+      end
+    end
+  end
+end

data/lib/canable/enforcers.rb

@@ -0,0 +1,14 @@
+module Canable
+  # Module that holds all the enforce_[action]_permission methods for use in controllers.
+  module Enforcers
+    def self.included(controller)
+      controller.class_eval do
+        Canable.actions.each do |can, able|
+          delegate      "can_#{can}?", :to => :current_user
+          helper_method "can_#{can}?" if controller.respond_to?(:helper_method)
+          hide_action   "can_#{can}?" if controller.respond_to?(:hide_action)
+        end
+      end
+    end
+  end
+end

data/lib/canable/role.rb

@@ -0,0 +1,45 @@
+module Canable
+  # Module that is included by a role implementation
+  module Role
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    # These are applied to the actual Role module 'instance' that includes this (Canable::Role) module 
+    module ClassMethods
+      # Each role has a default query response, found in this variable
+      attr_accessor :_default_response
+      
+      
+      # Called when another Role imeplementation module tries to inherit an existing Role implementation
+      # Notice this method isn't self.included, this method becomes self.included on the module including this (Canable::Role) module
+      # This is nesscary to emulate inhertance of the default response and any other variables in the future
+      def included(base)
+        base._default_response = self._default_response
+      end
+      
+      # Called when an Actor decides its role and extends itself (an instance) with a Role implementation
+      # Creates the default instance methods for an Actor and persists the can_action? response default down
+      def extended(base)
+        base.extend(RoleEnabledCanInstanceMethods)
+        this_role = self # can't use self inside the instance eval
+        base.instance_eval { @_canable_role = this_role }
+      end
+      
+      # Methods given to an instance of an Actor
+      module RoleEnabledCanInstanceMethods
+        def _canable_default # the role default response
+          @_canable_role._default_response
+        end
+      end
+      
+      # ----------------------
+      # Role building DSL
+      # ----------------------
+      def default_response(val)
+        self._default_response = val
+      end
+    end
+  end
+end

data/rbacanable.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rbacanable}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Nunemaker", "Harry Brundage"]
+  s.date = %q{2010-04-07}
+  s.description = %q{Simple role based permissions system}
+  s.email = %q{harry.brundage@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Changes.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "examples/basic.rb",
+     "examples/callbacks.rb",
+     "examples/roles.rb",
+     "lib/canable.rb",
+     "lib/canable/actor.rb",
+     "lib/canable/canable.rb",
+     "lib/canable/cans.rb",
+     "lib/canable/enforcers.rb",
+     "lib/canable/role.rb",
+     "rbacanable.gemspec",
+     "specs.watchr",
+     "test/helper.rb",
+     "test/test_ables.rb",
+     "test/test_canable.rb",
+     "test/test_cans.rb",
+     "test/test_enforcers.rb",
+     "test/test_roles.rb"
+  ]
+  s.homepage = %q{http://github.com/hornairs/rbacanable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Simple role based permissions system}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_ables.rb",
+     "test/test_canable.rb",
+     "test/test_cans.rb",
+     "test/test_enforcers.rb",
+     "test/test_roles.rb",
+     "examples/basic.rb",
+     "examples/callbacks.rb",
+     "examples/roles.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
+      s.add_development_dependency(%q<shoulda>, ["= 2.10.3"])
+      s.add_development_dependency(%q<mocha>, ["= 0.9.8"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<activesupport>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, ["= 2.10.3"])
+      s.add_dependency(%q<mocha>, ["= 0.9.8"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, ["= 2.10.3"])
+    s.add_dependency(%q<mocha>, ["= 0.9.8"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -14,6 +14,19 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'canable'
 
 class Test::Unit::TestCase
+  
+  def self.should_set_callback_attributes(test_value)
+    should "be called" do
+      assert ! subject.blank?
+    end
+    should "return proper options" do
+      assert_equal @user, subject[:can]
+      assert_equal @resource, subject[:able]
+      assert_equal :update, subject[:permission]
+      assert_equal test_value, subject[:test]
+    end
+  end
+  
 end
 
 def Doc(name=nil, &block)

data/test/test_ables.rb

@@ -27,57 +27,101 @@ class AblesTest < Test::Unit::TestCase
          assert ! @resource.viewable_by?('')
        end
     end
+   
+   context "creatable_by?" do
+      should "be false if user cannot create" do
+        user = mock('user', :can_create? => false)
+        assert ! @resource.creatable_by?(user)
+      end
+
+      should "be true if user can create" do
+        user = mock('user', :can_create? => true)
+        assert @resource.creatable_by?(user)
+      end
+
+      should "be false if resource is blank" do
+        assert ! @resource.creatable_by?(nil)
+        assert ! @resource.creatable_by?('')
+      end
+    end
+    
+    context "updatable_by?" do
+       should "be false if user cannot update" do
+         user = mock('user', :can_update? => false)
+         assert ! @resource.updatable_by?(user)
+       end
+
+       should "be true if user can update" do
+         user = mock('user', :can_update? => true)
+         assert @resource.updatable_by?(user)
+       end
+
+       should "be false if resource is blank" do
+         assert ! @resource.updatable_by?(nil)
+         assert ! @resource.updatable_by?('')
+       end
+     end
      
-     context "creatable_by?" do
-        should "be false if user cannot create" do
-          user = mock('user', :can_create? => false)
-          assert ! @resource.creatable_by?(user)
+     context "destroyable_by?" do
+        should "be false if user cannot destroy" do
+          user = mock('user', :can_destroy? => false)
+          assert ! @resource.destroyable_by?(user)
         end
 
-        should "be true if user can create" do
-          user = mock('user', :can_create? => true)
-          assert @resource.creatable_by?(user)
+        should "be true if user can destroy" do
+          user = mock('user', :can_destroy? => true)
+          assert @resource.destroyable_by?(user)
         end
 
         should "be false if resource is blank" do
-          assert ! @resource.creatable_by?(nil)
-          assert ! @resource.creatable_by?('')
+          assert ! @resource.destroyable_by?(nil)
+          assert ! @resource.destroyable_by?('')
         end
       end
-      
-      context "updatable_by?" do
-         should "be false if user cannot update" do
-           user = mock('user', :can_update? => false)
-           assert ! @resource.updatable_by?(user)
-         end
+    end
+    context "Canable Ables with callbacks defined" do
+      setup do
+        @resource = mock('resource')
 
-         should "be true if user can update" do
-           user = mock('user', :can_update? => true)
-           assert @resource.updatable_by?(user)
-         end
+        userklass = Class.new do
+          attr_accessor :before_options
+          attr_accessor :after_options
+          include Canable::Actor          
+          before_permissions_query :before
+          after_permissions_query :after
 
-         should "be false if resource is blank" do
-           assert ! @resource.updatable_by?(nil)
-           assert ! @resource.updatable_by?('')
-         end
-       end
-       
-       context "destroyable_by?" do
-          should "be false if user cannot destroy" do
-            user = mock('user', :can_destroy? => false)
-            assert ! @resource.destroyable_by?(user)
+          def before(options = {})
+            options[:test] = 2+2
+            @before_options = options
           end
 
-          should "be true if user can destroy" do
-            user = mock('user', :can_destroy? => true)
-            assert @resource.destroyable_by?(user)
+          def after(options = {})
+            options[:test] = 2-3
+            @after_options = options
           end
+        end
 
-          should "be false if resource is blank" do
-            assert ! @resource.destroyable_by?(nil)
-            assert ! @resource.destroyable_by?('')
+        @user = userklass.new
+      end
+
+      context "and a permission query is preformed, " do
+        setup do
+          @result = @user.can_update?(@resource)
+        end
+        
+        context "before callbacks" do
+         subject {@user.before_options}
+         should_set_callback_attributes(4)
+        end
+        
+        context "after callbacks" do
+          subject{@user.after_options}
+          should_set_callback_attributes(-1)
+          
+          should "have the result in an option" do
+            assert_equal @user.after_options[:result], false
           end
         end
-  end
-  
+      end
+    end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - John Nunemaker
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-01 00:00:00 -04:00
+date: 2010-04-07 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,6 +58,18 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Simple role based permissions system
 email: harry.brundage@gmail.com
 executables: []
@@ -75,8 +87,15 @@ files:
 - README.rdoc
 - Rakefile
 - examples/basic.rb
+- examples/callbacks.rb
 - examples/roles.rb
 - lib/canable.rb
+- lib/canable/actor.rb
+- lib/canable/canable.rb
+- lib/canable/cans.rb
+- lib/canable/enforcers.rb
+- lib/canable/role.rb
+- rbacanable.gemspec
 - specs.watchr
 - test/helper.rb
 - test/test_ables.rb
@@ -122,4 +141,5 @@ test_files:
 - test/test_enforcers.rb
 - test/test_roles.rb
 - examples/basic.rb
+- examples/callbacks.rb
 - examples/roles.rb