moulin_rouge 0.0.1.beta1 → 0.0.1.beta2

data/lib/moulin_rouge/authorization.rb

@@ -0,0 +1,46 @@
+module MoulinRouge
+  # Creates a common scope to register roles and abilities
+  class Authorization
+    # Avoid direct initialization, just act as a singleton
+    private_class_method :new
+
+    class << self
+      # Delegates the missing method for the main ability
+      def method_missing(name, *args, &block)
+        main.send(name, *args, &block)
+      end
+
+      # The instance of the main ability
+      def main
+        @@main ||= MoulinRouge::Ability.new(:main)
+      end
+
+      # Returns an array with the name of all roles created
+      def roles
+        @@roles ||= []
+      end
+
+      # Returns an hash with all permissions defined
+      def abilities
+        @@abilities ||= {}
+      end
+
+      # Register an ability in the singleton
+      def register(instance)
+        name = instance.name
+        self.abilities[name] = instance
+        self.roles << name unless self.roles.include?(name)
+      end
+
+      # Load and initialize all authorization files in the configuration path
+      def compile!
+        Dir[MoulinRouge.configuration.path].each { |file| Kernel.load(file) }
+      end
+
+      # Reset all constants
+      def reset! #:nodoc:
+        @@main, @@roles, @@abilities = nil
+      end
+    end
+  end
+end

data/lib/moulin_rouge/cancan/ability.rb

@@ -9,14 +9,14 @@ module MoulinRouge
         model = MoulinRouge.configuration.model.new if model.nil? and not MoulinRouge.configuration.model.nil?
         # Reload all permissions if cache is disabled
         MoulinRouge.reload! unless MoulinRouge.configuration.cache
-        # Set all permissions in main
-        MoulinRouge::Permission.main.abilities.each do |ability|
+        # Set all abilities in main
+        MoulinRouge::Authorization.main.abilities.each do |ability|
           ability.send_to(self, model)
         end
-        # Set all permissions by roles
-        MoulinRouge::Permission.all.each do |role, permission|
-          permission.abilities.each do |ability|
-            ability.send_to(self, model)
+        # Set all abilities by role
+        MoulinRouge::Authorization.abilities.each do |role, ability|
+          ability.abilities.each do |cancan_ability|
+            cancan_ability.send_to(self, model)
           end if model.send(MoulinRouge.configuration.test_method, role)
         end
       end

data/lib/moulin_rouge/version.rb

@@ -1,3 +1,3 @@
 module MoulinRouge
-  VERSION = "0.0.1.beta1"
+  VERSION = "0.0.1.beta2"
 end

data/spec/fixtures/fixture_authorization.rb

@@ -0,0 +1,5 @@
+class FixtureAuthorization < MoulinRouge::Authorization
+  role(:fixture) do
+    can(:be, :used, :for, :testing)
+  end
+end

data/spec/moulin_rouge/ability_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe MoulinRouge::Ability do
+  let(:ability) { MoulinRouge::Ability.new(:name) }
+
+  describe "#initialize" do
+    it "evaluate the groups and authorizations to the class scope" do
+      ability = MoulinRouge::Ability.new(:scope) do
+        self.class.should == MoulinRouge::Ability
+        can :do, :something
+        role :for
+      end
+    end
+    
+    it "registers the ability instance into authorization" do
+      MoulinRouge::Authorization.should_receive(:register).at_least(:once)
+      MoulinRouge::Ability.new(:main) do
+        role(:one)
+      end
+    end
+
+    it "inherits all abilities from parent if this is a group" do
+      role = nil
+      MoulinRouge::Ability.new(:main) do
+        group(:group) do
+          can :do, :this
+          role = role(:role)
+        end
+      end
+      role.abilities.first.args.should include(:do, :this)
+    end
+  end
+  
+  describe "#name" do
+    it "returns the given name on class initialization" do
+      ability.name.should be(:name)
+    end
+  end
+  
+  describe "#parent" do
+    it "returns nil when for main" do
+      ability.parent.should be_nil
+    end
+    
+    it "returns a instance of the MoulinRouge::Ability" do
+      another = MoulinRouge::Ability.new(:another, :parent => ability)
+      another.parent.should be_a(MoulinRouge::Ability)
+      another.parent.should be(ability)
+    end
+  end
+
+  describe "#childrens" do
+    it "returns an array" do
+      ability.childrens.should be_an(Array)
+    end
+  end
+
+  describe "#abilities" do
+    it "returns an array" do
+      ability.abilities.should be_a(Array)
+    end
+  end
+
+  describe "#inherithed_abilities" do
+    it "returns all abilities from self and their childrens" do
+      ability.can :do, :this
+      # First nested level
+      one = ability.role(:one) do
+        can :do, :one
+      end
+      # Second nested level
+      two = one.role(:two) do
+        can :do, :two
+      end
+      ability.inherithed_abilities.should be_an(Array)
+      ability.inherithed_abilities.length.should be(3)
+      one.inherithed_abilities.length.should be(2)
+      two.inherithed_abilities.length.should be(1)
+    end
+  end
+  
+  describe "#role" do
+    it "returns a new ability with the parent setted to the class that are calling" do
+      role = ability.role(:test)
+      role.should be_a(MoulinRouge::Ability)
+      role.parent.should be(ability)
+    end
+
+    it "adds a new instance on children" do
+      ability.childrens.should be_empty
+      ability.role(:name)
+      ability.childrens.should_not be_empty
+    end
+    
+    it "appends the content if the name is already present" do
+      ability.role(:test) { can :do, :this }
+      # should create one children ...
+      ability.childrens.length.should be(1)
+      # ... and one ability
+      ability.childrens.first.abilities.length.should be(1)
+      
+      ability.role(:test) { can :do, :this }
+      # should not create other children ...
+      ability.childrens.length.should be(1)
+      # ... and append the new ability
+      ability.childrens.first.abilities.length.should be(2)
+    end
+  end
+
+  describe "#group" do
+    it "not add the group name to ability list" do
+      ability.group(:test)
+      MoulinRouge::Authorization.abilities.should_not include(:test)
+    end
+  end
+
+  describe "#group?" do
+    it "returns true if is a group and false otherwise" do
+      role = ability.role(:role)
+      group = ability.group(:group)
+      role.group?.should be_false
+      group.group?.should be_true
+    end
+  end
+  
+  describe "#role?" do
+    it "returns true if is a group and false otherwise" do
+      role = ability.role(:role)
+      group = ability.group(:group)
+      role.role?.should be_true
+      group.role?.should be_false
+    end
+  end
+
+  describe "#method_missing" do
+    let(:args) { [:one, :two] }
+    let(:proc) { Proc.new { :block } }
+
+    context "collect all cancan methods and store under abilities" do
+      MoulinRouge::Ability::CANCAN_METHODS.each do |method_name|
+        describe "##{method_name}" do
+          it "adds a new ability to this ability" do
+            ability.abilities.should be_empty
+            ability.send(method_name, *args, &proc)
+            ability.abilities.should_not be_empty
+          end
+
+          it "stores nil on block attribute when no block is given" do
+            ability.send(method_name, *args)
+            ability.abilities.first.block.should be_nil
+          end
+
+          it "stores the method" do
+            ability.abilities.should be_empty
+            ability.send(method_name, *args, &proc)
+            ability.abilities.should_not be_empty
+
+            method = ability.abilities.first
+            method.should be_a(MoulinRouge::CanCan::Method)
+            # Evaluate the class of the arguments and block
+            method.args.should be_a(Array)
+            method.block.should be_a(Proc)
+            # Just check the value
+            method.args.should eq(args)
+            method.block.call.should be(:block)
+          end
+        end
+      end
+    end
+
+    it "receives and stores in a proc calls on the model object" do
+      cancan_ability = nil
+      ability.role(:test) do
+        cancan_ability = can :do, :this, :user_id => current_user.id
+      end
+      cancan_ability.args.last[:user_id].should be_a(Proc)
+    end
+
+    it "raise an error if the method is not registered has a cancan method" do
+      lambda { ability.send(:abcdefg, *args, &proc) }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe "#find" do
+    it "returns the instance of the ability if there is children with this name and nil otherwise" do
+      role = ability.role(:test)
+      ability.find(:test).should be(role)
+      ability.find(:bad).should be_nil
+    end
+  end
+  
+  describe "#name" do
+    it "returns an symbol containing the name with the parents separeted by a underscore" do
+      first_children, second_children = nil
+      MoulinRouge::Ability.new(:main) do
+        first_children = role(:one) do
+          second_children = role(:two)
+        end
+      end
+      first_children.name.should be(:one)
+      second_children.name.should be(:one_two)
+    end
+  end
+
+  describe "#include" do
+    it "appends all childrens and abilities from one object to another" do
+      one, another = nil
+      one = ability.role(:one) do
+        role(:nested)
+        can :do, :something
+      end
+      another = ability.role(:another) do
+        include :one
+      end
+      another.childrens.should_not be_empty
+      another.abilities.should_not be_empty
+      another.childrens.first.singular_name.should be(:nested)
+      another.abilities.first.args.should include(:do, :something)
+    end
+
+    it "raises an error if could not find the requested ability" do
+      lambda {
+        ability.role(:name) do
+          include :not_found
+        end
+      }.should raise_error(MoulinRouge::RoleNotFound)
+    end
+  end
+end

data/spec/moulin_rouge/authorization_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe MoulinRouge::Authorization do
+  let(:ability) { MoulinRouge::Ability.new(:name) }
+
+  context "self" do
+    describe "#method_missing" do
+      it "delegates any missing method to the main ability class" do
+        MoulinRouge::Authorization.main.should_receive(:role).with(:test)
+        MoulinRouge::Authorization.main.should_receive(:can).with(:test)
+        MoulinRouge::Authorization.role(:test)
+        MoulinRouge::Authorization.can(:test)
+      end
+    end
+
+    describe "#main" do
+      it "returns the main MoulinRouge::Authorization instance" do
+        MoulinRouge::Authorization.main.should be_instance_of(ability.class)
+      end
+    end
+
+    describe "#roles" do
+      it "returns an array" do
+        MoulinRouge::Authorization.roles.should be_a(Array)
+      end
+    end
+
+    describe "#abilities" do
+      it "returns a hash with all registered roles with assigned abilities" do
+        MoulinRouge::Authorization.abilities.should be_a(Hash)
+      end
+
+      it "store all abilities instantiated unless the main one" do
+        hello_world = ability.role(:hello_world) do
+          can :do
+        end
+        MoulinRouge::Authorization.abilities[hello_world.name].should be(hello_world)
+      end
+    end
+
+    describe "#register" do
+      it "should append the object instance on Authorization.all and Authorization.names" do
+        object = double(:name => :foo)
+        MoulinRouge::Authorization.abilities.should_receive(:'[]=').with(object.name, object)
+        MoulinRouge::Authorization.roles.should_receive(:'<<').with(object.name)
+        MoulinRouge::Authorization.register(object)
+      end
+    end
+
+    describe "#compile!" do
+      let(:files_loaded) { [] }
+
+      it "load all files in the configuration path" do
+        Kernel.stub(:load) { |file| files_loaded << file }
+        MoulinRouge::Authorization.compile!
+        files_loaded.should include(*Dir[MoulinRouge.configuration.path])
+      end
+
+      it "should load all roles defined into the Authorization abilities" do
+        MoulinRouge::Authorization.roles.should be_empty
+        MoulinRouge::Authorization.compile!
+        MoulinRouge::Authorization.roles.should_not be_empty
+        MoulinRouge::Authorization.roles.should include(:fixture)
+      end
+      
+      it "let raise exceptions when there are syntax errors" do
+        tests = []
+        tests << %|
+          # Wrong method name
+          roe :name do
+          end
+        |
+        tests << %|
+          # Wrong method name
+          groups :name do
+          end
+        |
+        tests << %|
+          # Wrong method name
+          cn :
+        |
+        tests << %|
+          # Wrong method name
+          role do
+          end
+        |
+        # Execute them all
+        tests.each do |test|
+          create_authorization test
+          lambda { ability.import(MoulinRouge.configuration.path) }.should raise_error
+        end
+      end
+    end
+
+    describe "#reset!" do
+      it "sets to nil the main, role and abilities instance variables" do
+        # Create some
+        ability.role(:one)
+        ability.role(:two)
+        MoulinRouge::Authorization.abilities.should_not be_empty
+        MoulinRouge::Authorization.roles.should_not be_empty
+        # Apply
+        MoulinRouge::Authorization.reset!
+        # Evaluate constants
+        MoulinRouge::Authorization.class_variable_get(:'@@main').should be_nil
+        MoulinRouge::Authorization.class_variable_get(:'@@abilities').should be_nil
+        MoulinRouge::Authorization.class_variable_get(:'@@roles').should be_nil
+        # Evaluate has arrays
+        MoulinRouge::Authorization.abilities.should be_empty
+        MoulinRouge::Authorization.roles.should be_empty
+      end
+    end
+
+    describe "#new" do
+      it "raises an error because the class only act as a singleton" do
+        lambda { MoulinRouge::Authorization.new }.should raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/moulin_rouge/cancan/ability_spec.rb

@@ -4,7 +4,7 @@ describe MoulinRouge::CanCan::Ability do
   let(:test_method) { MoulinRouge.configuration.test_method.to_sym }
   let(:model)       { double("model", test_method => true) }
   let(:ability)     { MoulinRouge::CanCan::Ability.new(model) }
-  let(:permission)  { MoulinRouge::Permission.main }
+  let(:permission)  { MoulinRouge::Authorization.main }
 
   before(:each) do
     MoulinRouge::CanCan::Ability.any_instance.stub(:can) { true }
@@ -56,7 +56,7 @@ describe MoulinRouge::CanCan::Ability do
 
     it "executes the can method with exactly the same arguments and block that was stored" do
       # Concat permissions from main and from all defined classes
-      abilities = permission.abilities + MoulinRouge::Permission.all.values.map(&:abilities)
+      abilities = permission.abilities + MoulinRouge::Authorization.abilities.values.map(&:abilities)
       abilities.flatten.each do |ability|
         MoulinRouge::CanCan::Ability.any_instance.should_receive(:can).with(*ability.args, &ability.block).at_least(:once)
       end
@@ -65,7 +65,7 @@ describe MoulinRouge::CanCan::Ability do
 
     it "reloads all permissions when cache is set to false" do
       MoulinRouge.configuration.cache = false
-      MoulinRouge.should_receive(:reload!).once
+      MoulinRouge.should_receive(:reload!).twice # Here and inside spec_helpe.rb before(:each)
       ability # Execute
     end
 
@@ -79,9 +79,9 @@ describe MoulinRouge::CanCan::Ability do
     end
 
     it "executes any proc on the model object" do
-      MoulinRouge::Permission.reset!
+      MoulinRouge::Authorization.reset!
       ####
-      MoulinRouge::Permission.main.can(:do, :this, :user_id => MoulinRouge::ModelDouble.new.id)
+      MoulinRouge::Authorization.main.can(:do, :this, :user_id => MoulinRouge::ModelDouble.new.id)
       model.should_receive(:id)
       ability # Execute
     end