Except

lib/ruy/conditions/except.rb

@@ -7,36 +7,21 @@ module Conditions
     # When a sub-rule is not given, Except will expect a context attribute is not equal to a given
     # value.
     class Except < CompoundCondition
-      attr_reader :attr, :value
 
       # @param value Non-expected value
       # @param attr Context attribute's name
       # @yield a block in the context of the current rule
-      def initialize(value = nil, attr = nil, &block)
+      def initialize(&block)
         super
-        @value = value
-        @attr = attr
         instance_exec(&block) if block_given?
       end
 
       def call(ctx)
-        result = true
-
-        if @attr
-          result &&= ctx.resolve(@attr) != @value
-        end
-
-        if self.conditions.any?
-          result &&= !super(ctx)
-        end
-
-        result
+        !super
       end
 
       def ==(o)
         o.kind_of?(Except) &&
-          @attr == o.attr &&
-          @value == o.value &&
           @conditions == o.conditions
       end
     end

lib/ruy/dsl.rb

@@ -55,8 +55,8 @@ def cond(&block)
     # Adds an Except condition.
     #
     # @param (see Conditions::Except#initialize)
-    def except(value = nil, attr = nil, &block)
-      self.conditions << Conditions::Except.new(value, attr, &block)
+    def except(&block)
+      self.conditions << Conditions::Except.new(&block)
     end
 
     # Adds a GreaterThan condition.

spec/lib/ruy/conditions/except_spec.rb

@@ -4,84 +4,46 @@
 
   describe '#call' do
 
-    subject(:condition) { Ruy::Conditions::Except.new(false, :enabled) }
+    subject(:condition) do
+      Ruy::Conditions::Except.new { assert :sunday }
+    end
 
-    it 'is true when enabled != false' do
-      context = Ruy::Context.new({:enabled => true})
+    it 'is true when !sunday' do
+      context = Ruy::Context.new({:sunday => false})
 
       expect(condition.call(context)).to be
     end
 
-    it 'is false when enabled = false' do
-      context = Ruy::Context.new({:enabled => false})
+    it 'is false when sunday' do
+      context = Ruy::Context.new({:sunday => true})
 
       expect(condition.call(context)).to_not be
     end
-
-    context 'when nested conditions' do
-      subject(:condition) do
-        Ruy::Conditions::Except.new(false, :enabled) do
-          assert :success
-        end
-      end
-
-      it 'is true when !success' do
-        context = Ruy::Context.new({:enabled => true, :success => false})
-
-        expect(condition.call(context)).to be
-      end
-
-      it 'is false when success' do
-        context = Ruy::Context.new({:enabled => true, :success => true})
-
-        expect(condition.call(context)).to_not be
-      end
-
-      context 'when no attribute condition' do
-        subject(:condition) do
-          Ruy::Conditions::Except.new(nil, nil) do
-            assert :success
-          end
-        end
-
-        it 'is true when !success' do
-          context = Ruy::Context.new({:enabled => true, :success => false})
-
-          expect(condition.call(context)).to be
-        end
-
-        it 'is false when success' do
-          context = Ruy::Context.new({:enabled => true, :success => true})
-
-          expect(condition.call(context)).to_not be
-        end
-      end
-    end
   end
 
   describe '#==' do
-    subject(:condition) { Ruy::Conditions::Except.new(false, :enabled) }
+    subject(:condition) { Ruy::Conditions::Except.new { assert :sunday } }
 
     context 'when comparing against self' do
       let(:other) { condition }
 
       it { should eq(other) }
     end
 
-    context 'when same condition values' do
-      let(:other) { Ruy::Conditions::Except.new(false, :enabled) }
+    context 'when same nested condition' do
+      let(:other) { Ruy::Conditions::Except.new { assert :sunday } }
 
       it { should eq(other) }
     end
 
-    context 'when different rule' do
-      let(:other) { Ruy::Conditions::All.new }
+    context 'when different nested condition' do
+      let(:other) { Ruy::Conditions::Except.new { assert :monday } }
 
       it { should_not eq(other) }
     end
 
-    context 'when different values' do
-      let(:other) { Ruy::Conditions::Except.new(true, :disabled) }
+    context 'when different rule' do
+      let(:other) { Ruy::Conditions::All.new }
 
       it { should_not eq(other) }
     end

spec/lib/ruy/dsl_spec.rb

@@ -79,7 +79,7 @@ def conditions
 
   describe '#except' do
     it 'adds an Except condition' do
-      host.except(false, :enabled)
+      host.except
 
       expect(host.conditions).to include(be_a(Ruy::Conditions::Except))
     end