role_model 0.1.1 → 0.2.0

data/README.rdoc

@@ -10,7 +10,10 @@ are done.
 Assigned roles will be stored as a bitmask in an configurable attribute
 (default: <tt>roles_mask</tt>). Here's everything you need to know:
 
-  # given an User class with a roles_mask attribute
+  # given a User class with a roles_mask attribute
+  require 'rubygems'
+  require 'role_model'
+
   class User
     attr_accessor :roles_mask # in real life this would be an persisted attribute / DB-column
     
@@ -43,10 +46,14 @@ Assigned roles will be stored as a bitmask in an configurable attribute
   => 1
 
 Once you have included RoleModel, your model is perfectly fit to be used
-together with an role-based authorization solution, such as
+together with a role-based authorization solution, such as
 http://github.com/ryanb/cancan or
 http://github.com/stffn/declarative_authorization .
 
+== Installation
+
+  gem install role_model
+
 == Reasoning
 
 Whenever I introduce a role-based authorization scheme into a project, the

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/role_model.rb

@@ -1,33 +1,56 @@
 module RoleModel
-  def self.included(base) # :nodoc:
 
-    # add class methods
-    base.instance_eval do
-      def roles_attribute(name)
-        @@roles_attribute = name.to_sym
+  INHERITABLE_CLASS_ATTRIBUTES = [:roles_attribute_name, :valid_roles]
+
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+    base.class_eval do
+      class << self
+        attr_accessor *::RoleModel::INHERITABLE_CLASS_ATTRIBUTES
       end
       roles_attribute :roles_mask
+    end
 
-      def roles(*roles)
-        @@valid_roles = Array[*roles].flatten.map { |r| r.to_sym }
-      end
+    # assign roles
+    def roles=(*roles)
+      self.send("#{self.class.roles_attribute_name}=", (Array[*roles].flatten.map { |r| r.to_sym } & self.class.valid_roles).map { |r| 2**self.class.valid_roles.index(r) }.inject { |sum, bitvalue| sum + bitvalue })
     end
 
-    # add instance methods
-    base.class_eval do
-      def roles=(*roles)
-        self.send("#{@@roles_attribute}=", (Array[*roles].flatten.map { |r| r.to_sym } & @@valid_roles).map { |r| 2**@@valid_roles.index(r) }.inject { |sum, bitvalue| sum + bitvalue })
-      end
+    # query assigned roles
+    def roles
+      self.class.valid_roles.reject { |r| ((self.send(self.class.roles_attribute_name) || 0) & 2**self.class.valid_roles.index(r)).zero? }
+    end
+    alias role_symbols roles
 
-      def roles
-        @@valid_roles.reject { |r| ((self.send(@@roles_attribute) || 0) & 2**@@valid_roles.index(r)).zero? }
-      end
-      alias_method :role_symbols, :roles
+    # check if a given role has been assigned
+    def has_role?(role)
+      roles.include?(role.to_sym)
+    end
+  end
 
-      def has_role?(role)
-        roles.include?(role.to_sym)
+  module ClassMethods
+    def inherited(subclass) # :nodoc:
+      ::RoleModel::INHERITABLE_CLASS_ATTRIBUTES.each do |attribute|
+        instance_var = "@#{attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
       end
+      super
+    end
+
+    # set the bitmask attribute role assignment will be stored in
+    def roles_attribute(name)
+      self.roles_attribute = name
     end
 
+    # alternative method signature: set the bitmask attribute role assignment will be stored in
+    def roles_attribute=(name)
+      self.roles_attribute_name = name.to_sym
+    end
+
+    # declare valid roles
+    def roles(*roles)
+      self.valid_roles = Array[*roles].flatten.map { |r| r.to_sym }
+    end
   end
+
 end

data/role_model.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{role_model}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Martin Rehfeld"]

data/spec/role_model_spec.rb

@@ -13,19 +13,21 @@ describe RoleModel do
     end
   end
 
-  describe ".roles_attribute" do
-    before(:each) do
-      model_class.instance_eval do
-        roles_attribute :custom_roles_mask
-        roles :sample
+  [:roles_attribute, :roles_attribute=].each do |roles_attribute_setter_method|
+    describe ".#{roles_attribute_setter_method}" do
+      before(:each) do
+        model_class.instance_eval do
+          send(roles_attribute_setter_method, :custom_roles_mask)
+          roles :sample
+        end
       end
-    end
-    subject { model_class.new }
+      subject { model_class.new }
 
-    it "should change the bitmask attribute used to store the assigned roles" do
-      subject.roles = [:sample]
-      subject.roles_mask.should be_nil
-      subject.custom_roles_mask.should == 1
+      it "should change the bitmask attribute used to store the assigned roles" do
+        subject.roles = [:sample]
+        subject.roles_mask.should be_nil
+        subject.custom_roles_mask.should == 1
+      end
     end
   end
 
@@ -34,8 +36,7 @@ describe RoleModel do
 
     it "should define the valid roles" do
       subject.roles = %w(foo bar baz)
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
+      subject.roles.should include(:foo, :bar)
       subject.roles.should_not include(:baz)
     end
 
@@ -47,26 +48,19 @@ describe RoleModel do
     end
   end
 
-  describe "#roles" do
-    subject { model_class.new }
+  [:roles, :role_symbols].each do |role_query_method|
+    describe "##{role_query_method}" do
+      subject { model_class.new }
 
-    it "should return the assigned roles as symbols" do
-      subject.roles = [:foo, :bar]
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
-      subject.roles.should have(2).elements
-    end
-
-    it "should return an empty array when no roles have been assigned" do
-      subject.roles.should be_empty
-    end
-  end
-
-  describe "#role_symbols" do
-    subject { model_class.new }
+      it "should return the assigned roles as symbols" do
+        subject.roles = [:foo, :bar]
+        subject.send(role_query_method).should include(:foo, :bar)
+        subject.send(role_query_method).should have(2).elements
+      end
 
-    it "should be an alias to roles" do
-      subject.method(:role_symbols).should == subject.method(:roles)
+      it "should return an empty array when no roles have been assigned" do
+        subject.send(role_query_method).should be_empty
+      end
     end
   end
 
@@ -75,48 +69,44 @@ describe RoleModel do
 
     it "should accept an array of symbols" do
       subject.roles = [:foo, :bar]
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
-      subject.roles.should have(2).elements
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
       subject.roles = [:bar]
       subject.roles.should include(:bar)
-      subject.roles.should have(1).element
+      subject.should have(1).roles
     end
 
     it "should accept an array of strings" do
       subject.roles = %w(foo bar)
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
-      subject.roles.should have(2).elements
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
       subject.roles = ['bar']
       subject.roles.should include(:bar)
-      subject.roles.should have(1).element
+      subject.should have(1).roles
     end
 
     it "should accept a single symbol" do
       subject.roles = :foo
       subject.roles.should include(:foo)
-      subject.roles.should have(1).element
+      subject.should have(1).roles
     end
 
     it "should accept a single string" do
       subject.roles = 'foo'
       subject.roles.should include(:foo)
-      subject.roles.should have(1).element
+      subject.should have(1).roles
     end
 
     it "should accept multiple arguments as symbols" do
       subject.send(:roles=, :foo, :bar)
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
-      subject.roles.should have(2).elements
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
     end
 
     it "should accept multiple arguments as strings" do
       subject.send(:roles=, 'foo', 'bar')
-      subject.roles.should include(:foo)
-      subject.roles.should include(:bar)
-      subject.roles.should have(2).elements
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
     end
 
     it "should silently ignore undefined roles" do
@@ -148,4 +138,76 @@ describe RoleModel do
     end
   end
 
+  context "inheritance" do
+    let(:superclass_instance) {  model_class.new }
+    let(:inherited_model_class) { Class.new(model_class) }
+    subject { inherited_model_class.new }
+
+    it "should not alter the superclass behaviour" do
+      inherited_model_class.instance_eval do
+        roles :quux, :quuux
+      end
+      superclass_instance.roles = [:foo, :bar, :quux, :quuux]
+      superclass_instance.roles.should include(:foo, :bar)
+      superclass_instance.roles.should have(2).roles
+    end
+
+    it "should inherit the valid roles" do
+      subject.roles = [:foo, :bar, :quux, :quuux]
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
+    end
+
+    it "should not inherit the assigned roles" do
+      subject.roles.should be_empty
+    end
+
+    it "should allow overriding the valid roles for the inherited class" do
+      inherited_model_class.instance_eval do
+        roles :quux, :quuux
+      end
+      subject.roles = [:foo, :bar, :quux, :quuux]
+      subject.roles.should include(:quux, :quuux)
+      subject.should have(2).roles
+      subject.roles_mask.should == 3
+    end
+
+    it "should allow overriding the attribute to store the roles for the inherited class" do
+      inherited_model_class.instance_eval do
+        roles_attribute :custom_roles_mask
+      end
+      subject.roles = [:foo, :bar, :quux, :quuux]
+      subject.roles.should include(:foo, :bar)
+      subject.should have(2).roles
+      subject.custom_roles_mask.should == 3
+    end
+  end
+
+  context "independent usage" do
+    let(:model_instance) {  model_class.new }
+    let(:other_model_class) { Class.new }
+    before(:each) do
+      other_model_class.instance_eval do
+        attr_accessor :roles_mask
+        include RoleModel
+        roles :quux, :quuux
+      end
+    end
+    subject { other_model_class.new }
+
+    it "should not alter the behaviour of other classes" do
+      model_instance.roles = [:foo, :bar, :quux, :quuux]
+      model_instance.roles.should include(:foo)
+      model_instance.roles.should include(:bar)
+      model_instance.should have(2).roles
+    end
+
+    it "should allow using different roles in other models" do
+      subject.roles = [:foo, :bar, :quux, :quuux]
+      subject.roles.should include(:quux)
+      subject.roles.should include(:quuux)
+      subject.should have(2).roles
+    end
+  end
+
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Martin Rehfeld