permissioner 0.2.0.beta → 1.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef2fdeee2181e2b845b4067b8955a359810b638d
-  data.tar.gz: d331ff39f167342f27d49f037ffcc8e0054d0468
+  metadata.gz: 43616baad7f73fa5bc6d9fcf2503ad69cd745143
+  data.tar.gz: 7719b023c2d20c24ee4e9851c78f60d08c6dc612
 SHA512:
-  metadata.gz: de48e7b82506ee21f857430378497d136cf02de884a8bc655dc643c315714602da4502d98a4fa3937f5e287d2c77184ece2d9bf92bbe83329d9741b884c586c1
-  data.tar.gz: 97e1f98ce1a663ff7439212d6e6419a33cf3050aab1e069d1eaf00f8ef06f000ca3484010229647617d74fb99503f6afe285fb689aee7bdc2cc5f93e069a883d
+  metadata.gz: 39fc6a0d3c6b93f56bf0c2af626f4dac11571d7c3a42a2dfe82b80294b762a01150e288f1476b4eaacaa800545274dc5858a77271d55030e06d8fef57b93fcdb
+  data.tar.gz: b323e09b04b4d0b957ff908af916f855e0afaed3cc63b2733f3a6b18a382847e48d7d6b7b72169b51ecab7f3764cef03691a69b854475289340aa2191a973ded

data/lib/permissioner/matchers/exactly_allow_attributes.rb

@@ -15,7 +15,7 @@ module Permissioner
         expected_attributes_exactly_match?
       end
 
-      def failure_message_for_should
+      def failure_message
         if @failing_attributes.empty?
           "expected to find allowed attributes for resources\n" \
           "#{all_expected_resources}, but found allowed attributes for resources\n"\
@@ -32,7 +32,7 @@ module Permissioner
         end
       end
 
-      def failure_message_for_should_not
+      def failure_message_when_negated
         'given attributes are exactly allowed although this is not expected'
       end
 
@@ -103,13 +103,13 @@ module Permissioner
       #  expected_attributs_exactly_macht? allowed_attributes_for_resource
       #end
       #
-      #def failure_message_for_should
+      #def failure_message
       #  "expected that for resource \"#{@resource}\" attributes\n"\
       #  "#{@expected_attributes} are exactly allowed, but found attributes\n"\
       #  "#{allowed_attributes_for_resource} allowed"
       #end
       #
-      #def failure_message_for_should_not
+      #def  failure_message_when_negated
       #  "expected that for resource \"#{@resource}\" attributes\n"\
       #  "#{@expected_attributes} are exactly not allowed,\n"\
       #  "but those attributes are exactly allowed\n"

data/lib/permissioner/matchers/exactly_allow_controllers.rb

@@ -11,13 +11,13 @@ module Permissioner
         controllers_exactly_match?(allowed_controllers)
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected to exactly allow controllers \n" \
           "#{@expected_controllers.sort}, but found controllers\n"\
           "#{allowed_controllers.sort} allowed"
       end
 
-      def failure_message_for_should_not
+      def  failure_message_when_negated
         "expected to exactly not allow controllers \n" \
           "#{@expected_controllers.sort}, but these controllers are exactly allowed\n"\
       end

data/lib/permissioner/matchers/exactly_allow_resources.rb

@@ -11,13 +11,13 @@ module Permissioner
         resources_exactly_match?
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected to exactly allow resources \n" \
         "#{@expected_resources.sort}, but found resources\n"\
         "#{allowed_resources.sort} allowed"
       end
 
-      def failure_message_for_should_not
+      def  failure_message_when_negated
         "expected to exactly not allow resources \n" \
         "#{@expected_resources.sort}, but these resources are exactly allowed\n"\
       end

data/lib/permissioner/matchers/exactly_expect_actions.rb

@@ -16,7 +16,7 @@ module Permissioner
         expected_actions_exactly_match?
       end
 
-      def failure_message_for_should
+      def failure_message
         if @failing_actions.empty?
           "expected to find actions for controllers \n" \
           "#{all_expected_controllers}, but found actions for controllers\n"\
@@ -33,7 +33,7 @@ module Permissioner
         end
       end
 
-      def failure_message_for_should_not
+      def  failure_message_when_negated
         'given actions are exactly match although this is not expected'
       end
 

data/lib/permissioner/version.rb

@@ -1,3 +1,3 @@
 module Permissioner
-  VERSION = "0.2.0.beta"
+  VERSION = "1.0.0.beta"
 end

data/permissioner.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency "rspec", "~>2.14.1"
-  gem.add_development_dependency "activesupport", "~>4.0.2"
-  gem.add_development_dependency "actionpack", "~>4.0.2"
-  gem.add_development_dependency "guard-rspec", "~>4.2.0"
+  gem.add_development_dependency "rspec", ">=3.0.0"
+  gem.add_development_dependency "activesupport", ">=4.1.0"
+  gem.add_development_dependency "actionpack", ">=4.1.0"
+  gem.add_development_dependency "guard-rspec", ">=4.3.0"
 end

data/spec/permissioner/configurer_spec.rb

@@ -13,24 +13,24 @@ describe Permissioner::Configurer do
     let(:permission_configurer) { permission_configurer_class.new(permission_service, 'current_user') }
 
     it 'should delegate call to allow_actions to permission_service' do
-      permission_service.should_receive(:allow_actions).with(:comments, :index)
+      expect(permission_service).to receive(:allow_actions).with(:comments, :index)
       permission_configurer.allow_actions(:comments, :index)
     end
 
     it 'should delegate call to allow_attributes to permission_service' do
-      permission_service.should_receive(:allow_attributes).with(:comment, [:user_id, :text])
+      expect(permission_service).to receive(:allow_attributes).with(:comment, [:user_id, :text])
       permission_configurer.allow_attributes(:comment, [:user_id, :text])
     end
 
     it 'should delegate call to add_filter to permission_service' do
       block = Proc.new {}
-      permission_service.should_receive(:add_filter).with(:comments, :create, &block)
+      expect(permission_service).to receive(:add_filter).with(:comments, :create, &block)
       permission_configurer.add_filter(:comments, :create, &block)
     end
 
     it 'should delegate call to clear_filter to permission_service' do
       block = Proc.new {}
-      permission_service.should_receive(:clear_filters).with(no_args)
+      expect(permission_service).to receive(:clear_filters).with(no_args)
       permission_configurer.clear_filters
     end
   end
@@ -39,11 +39,11 @@ describe Permissioner::Configurer do
     subject(:permission_configurer){ permission_configurer_class.new(nil, nil) }
 
     it 'should respond_to permission_service' do
-      should respond_to(:permission_service)
+      is_expected.to respond_to(:permission_service)
     end
 
     it 'should respond_to current_user' do
-      should respond_to(:current_user)
+      is_expected.to respond_to(:current_user)
     end
   end
 
@@ -51,16 +51,16 @@ describe Permissioner::Configurer do
 
     it 'should set permission_service' do
       permission_configurer = permission_configurer_class.new('permission_service', nil)
-      permission_configurer.permission_service.should eq 'permission_service'
+      expect(permission_configurer.permission_service).to eq 'permission_service'
     end
 
     it 'should set current_user' do
       permission_configurer = permission_configurer_class.new(nil, 'current_user')
-      permission_configurer.current_user.should eq 'current_user'
+      expect(permission_configurer.current_user).to eq 'current_user'
     end
 
     it 'should call configure_permissions current_user' do
-      permission_configurer_class.any_instance.should_receive(:configure_permissions)
+      expect_any_instance_of(permission_configurer_class).to receive(:configure_permissions)
       permission_configurer_class.new(nil, nil)
     end
   end

data/spec/permissioner/controller_additions_spec.rb

@@ -4,10 +4,10 @@ describe Permissioner::ControllerAdditions do
 
   let(:controller) do
     controller_class = Class.new
-    controller_class.stub(:helper_method)
+    allow(controller_class).to receive(:helper_method)
     controller_class.send(:include, Permissioner::ControllerAdditions)
     controller = controller_class.new
-    controller.stub(:current_user)
+    allow(controller).to receive(:current_user)
     controller
   end
 
@@ -16,13 +16,13 @@ describe Permissioner::ControllerAdditions do
     let(:clazz) { Class.new }
 
     it 'should set view helpers' do
-      clazz.should_receive(:helper_method).with(:allow_action?, :allow_attribute?, :permission_service)
+      expect(clazz).to receive(:helper_method).with(:allow_action?, :allow_attribute?, :permission_service)
       clazz.send(:include, Permissioner::ControllerAdditions)
     end
 
     it 'should delegate helper methods to permission servie' do
-      clazz.stub(:helper_method)
-      clazz.should_receive(:delegate).with(:allow_action?, :allow_attribute?, to: :permission_service)
+      allow(clazz).to receive(:helper_method)
+      expect(clazz).to receive(:delegate).with(:allow_action?, :allow_attribute?, to: :permission_service)
       clazz.send(:include, Permissioner::ControllerAdditions)
     end
   end
@@ -32,23 +32,23 @@ describe Permissioner::ControllerAdditions do
     let(:params) { {controller: 'comments', action: 'index'} }
 
     before :each do
-      controller.stub(:current_resource).and_return('resource')
-      controller.stub(:params).and_return(params)
+      allow(controller).to receive(:current_resource).and_return('resource')
+      allow(controller).to receive(:params).and_return(params)
     end
 
     it 'should call permit_params! if action allwed and filters passed' do
-      controller.permission_service.should_receive(:allow_action?).and_return(true)
-      controller.permission_service.should_receive(:permit_params!).with(params)
+      expect(controller.permission_service).to receive(:allow_action?).and_return(true)
+      expect(controller.permission_service).to receive(:permit_params!).with(params)
       controller.authorize
     end
 
     it 'should call allow_action? with correct parameters' do
-      controller.permission_service.should_receive(:allow_action?).with('comments', 'index', resource: 'resource', params: params).and_return(true)
+      expect(controller.permission_service).to receive(:allow_action?).with('comments', 'index', resource: 'resource', params: params).and_return(true)
       controller.authorize
     end
 
     it 'should raise Permissioner::NotAuthorized when action not allowed' do
-      controller.permission_service.should_receive(:allow_action?).with('comments', 'index', resource: 'resource', params: params).and_return(false)
+      expect(controller.permission_service).to receive(:allow_action?).with('comments', 'index', resource: 'resource', params: params).and_return(false)
       expect {
         controller.authorize
       }.to raise_error Permissioner::NotAuthorized
@@ -58,21 +58,21 @@ describe Permissioner::ControllerAdditions do
   describe '#permission_service' do
 
     it 'should return instance of PermissionService' do
-      controller.permission_service.class.should eq PermissionService
+      expect(controller.permission_service.class).to eq PermissionService
     end
 
     it 'should cache PermissionService instance' do
-      controller.permission_service.should be controller.permission_service
+      expect(controller.permission_service).to be controller.permission_service
     end
 
     it 'should create PermissionService by calling PermissionService::new' do
-      PermissionService.should_receive(:new)
+      expect(PermissionService).to receive(:new)
       controller.permission_service
     end
 
     it 'should pass current_user to PermissionService::initialize' do
-      controller.should_receive(:current_user).and_return('current_user')
-      PermissionService.should_receive(:new).with('current_user')
+      expect(controller).to receive(:current_user).and_return('current_user')
+      expect(PermissionService).to receive(:new).with('current_user')
       controller.permission_service
     end
   end
@@ -80,7 +80,7 @@ describe Permissioner::ControllerAdditions do
   describe '#current_resource' do
 
     it 'should return nil as default' do
-      controller.current_resource.should be_nil
+      expect(controller.current_resource).to be_nil
     end
   end
 end

data/spec/permissioner/matchers/exactly_allow_attributes_spec.rb

@@ -18,9 +18,9 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
 
     it 'should ensure that all attributes are into an array' do
       matcher = create_matcher [:resource, :attribute]
-      matcher.instance_variable_get(:@all_expected_attributes).should eq [[:resource, [:attribute]]]
+      expect(matcher.instance_variable_get(:@all_expected_attributes)).to eq [[:resource, [:attribute]]]
       matcher = create_matcher [:resource, [:attribute_1, :attribute_2]]
-      matcher.instance_variable_get(:@all_expected_attributes).should eq [[:resource, [:attribute_1, :attribute_2]]]
+      expect(matcher.instance_variable_get(:@all_expected_attributes)).to eq [[:resource, [:attribute_1, :attribute_2]]]
     end
 
     it 'should raise an exception if multiple actions not stated as array' do
@@ -40,7 +40,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             [:comment, [:user_id, :post_id, :content]],
             [:post, [:user_id, :content]]
         )
-        matcher.matches?(permission_service).should be_true
+        expect(matcher.matches?(permission_service)).to be_truthy
       end
 
       it 'should accept attributs being a hash' do
@@ -60,7 +60,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
              ]
             ]
         )
-        matcher.matches?(permission_service).should be_true
+        expect(matcher.matches?(permission_service)).to be_truthy
       end
     end
 
@@ -72,7 +72,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             [:comment, [:user_id, :post_id, :content]],
             [:account, [:user_id, :content]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
 
       it 'should return false if at least one resource is allowed but no expected' do
@@ -80,7 +80,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             [:user, [:name, :email, :phone]],
             [:comment, [:user_id, :post_id, :content]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
     end
 
@@ -92,7 +92,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             [:comment, [:user_id, :post_id, :content]],
             [:post, [:user_id, :content]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
 
       it 'should return false if at least one attribute is allowed but not expected' do
@@ -101,27 +101,27 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             [:comment, [:user_id, :post_id, :content]],
             [:post, [:user_id, :content]]
         )
-        matcher.matches?(permission_service).should be_false
+        expect(matcher.matches?(permission_service)).to be_falsey
       end
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '# failure_message_when_negated' do
 
     it 'should be available' do
       matcher = create_matcher
       expected_messages = 'given attributes are exactly allowed although this is not expected'
-      matcher.failure_message_for_should_not.should eq expected_messages
+      expect(matcher. failure_message_when_negated).to eq expected_messages
     end
 
     it 'should be available' do
       matcher = create_matcher
       matcher.matches?(PermissionService.new)
-      matcher.failure_message_for_should_not.should be_kind_of(String)
+      expect(matcher. failure_message_when_negated).to be_kind_of(String)
     end
   end
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
 
     context 'if resources did not match' do
 
@@ -136,7 +136,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             "[:comment, :post, :user]"
         #call is necessary because matches sets @permission_service
         matcher.matches?(permission_service)
-        matcher.failure_message_for_should.should eq expected_messages
+        expect(matcher.failure_message).to eq expected_messages
       end
 
       it 'should work if no controller allowed' do
@@ -147,7 +147,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
         )
         #call is necessary because matches sets @permission_service
         matcher.matches?(PermissionService.new)
-        matcher.failure_message_for_should.should be_kind_of(String)
+        expect(matcher.failure_message).to be_kind_of(String)
       end
     end
 
@@ -170,7 +170,7 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
             "[:user_id, :post_id, :content] are allowed\n"
         #call is necessary because matches sets @permission_service
         matcher.matches?(permission_service)
-        matcher.failure_message_for_should.should eq expected_messages
+        expect(matcher.failure_message).to eq expected_messages
       end
 
 
@@ -182,12 +182,12 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
         )
         #call is necessary because matches sets @permission_service
         matcher.matches?(PermissionService.new)
-        matcher.failure_message_for_should.should be_kind_of(String)
+        expect(matcher.failure_message).to be_kind_of(String)
       end
     end
   end
 
-  #describe '#failure_message_for_should' do
+  #describe '#failure_message' do
   #
   #  it 'should be available' do
   #    matcher = create_matcher :user, [:name, :email, :street]
@@ -196,17 +196,17 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
   #        "[:name, :email, :street] are exactly allowed, but found attributes\n"\
   #        "[:name, :email, :phone] allowed"
   #    matcher.matches?(permission_service)
-  #    matcher.failure_message_for_should.should eq expected_messages
+  #    matcher.failure_message.should eq expected_messages
   #  end
   #
   #  it 'should work if no controller allowed' do
   #    matcher = create_matcher :user, [:name, :email, :street]
   #    matcher.matches?(PermissionService.new)
-  #    matcher.failure_message_for_should.should be_kind_of(String)
+  #    matcher.failure_message.should be_kind_of(String)
   #  end
   #end
   #
-  #describe '#failure_message_for_should_not' do
+  #describe '# failure_message_when_negated' do
   #
   #  it 'should be available' do
   #    matcher = create_matcher :user, [:name, :email, :street]
@@ -215,13 +215,13 @@ describe Permissioner::Matchers::ExactlyAllowAttributes do
   #        "[:name, :email, :street] are exactly not allowed,\n"\
   #        "but those attributes are exactly allowed\n"
   #    matcher.matches?(permission_service)
-  #    matcher.failure_message_for_should_not.should eq expected_messages
+  #    matcher. failure_message_when_negated.should eq expected_messages
   #  end
   #
   #  it 'should work if no controller allowed' do
   #    matcher = create_matcher :user, [:name, :email, :street]
   #    matcher.matches?(PermissionService.new)
-  #    matcher.failure_message_for_should_not.should be_kind_of(String)
+  #    matcher. failure_message_when_negated.should be_kind_of(String)
   #  end
   #end
 end

data/spec/permissioner/matchers/exactly_allow_controllers_spec.rb

@@ -19,7 +19,7 @@ describe Permissioner::Matchers::ExactlyAllowControllers do
 
     it 'should transform expected_controllers to strings' do
       matcher = create_matcher(:comments, :users)
-      matcher.instance_variable_get(:@expected_controllers).should eq ['comments', 'users']
+      expect(matcher.instance_variable_get(:@expected_controllers)).to eq ['comments', 'users']
     end
   end
 
@@ -27,26 +27,26 @@ describe Permissioner::Matchers::ExactlyAllowControllers do
 
     it 'should return true if exactly all expected controllers allowed' do
       matcher = create_matcher(:comments, :users, :posts)
-      matcher.matches?(permission_service).should be_true
+      expect(matcher.matches?(permission_service)).to be_truthy
     end
 
     it 'should return false if at least one controller is not allowed' do
       matcher = create_matcher(:comments, :users, :posts, :blogs)
-      matcher.matches?(permission_service).should be_false
+      expect(matcher.matches?(permission_service)).to be_falsey
     end
 
     it 'should return true if more controllers allowed than expected' do
       matcher = create_matcher(:comments, :users)
-      matcher.matches?(permission_service).should be_false
+      expect(matcher.matches?(permission_service)).to be_falsey
     end
 
     it 'should work if no controller allowed' do
       matcher = create_matcher(:comments, :users)
-      matcher.matches?(PermissionService.new).should be_false
+      expect(matcher.matches?(PermissionService.new)).to be_falsey
     end
   end
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
 
     it 'should be available' do
       matcher = create_matcher(:comments)
@@ -56,30 +56,30 @@ describe Permissioner::Matchers::ExactlyAllowControllers do
           "[\"comments\", \"posts\", \"users\"] allowed"
       #call is necessary because matches sets @permission_service
       matcher.matches?(permission_service)
-      matcher.failure_message_for_should.should eq expected_messages
+      expect(matcher.failure_message).to eq expected_messages
     end
 
     it 'should work if no controller allowed' do
       matcher = create_matcher(:comments)
       #call is necessary because matches sets @permission_service
       matcher.matches?((PermissionService.new))
-      matcher.failure_message_for_should.should be_kind_of(String)
+      expect(matcher.failure_message).to be_kind_of(String)
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '# failure_message_when_negated' do
 
     it 'should be available' do
       matcher = create_matcher(:users, :comments)
       expected_messages =
           "expected to exactly not allow controllers \n" \
           "[\"comments\", \"users\"], but these controllers are exactly allowed\n"
-      matcher.failure_message_for_should_not.should eq expected_messages
+      expect(matcher. failure_message_when_negated).to eq expected_messages
     end
 
     it 'should work if no controller allowed' do
       matcher = create_matcher(:comments, :users)
-      matcher.failure_message_for_should_not.should be_kind_of(String)
+      expect(matcher. failure_message_when_negated).to be_kind_of(String)
     end
   end