ruy 1.0.0 → 2.0.0

data/lib/ruy/conditions/dig.rb

@@ -0,0 +1,42 @@
+module Ruy
+  module Conditions
+
+    # Navigates into a Hash allowing to define conditions over nested attributes
+    #
+    class Dig < CompoundCondition
+      attr_reader :chain
+
+      # @param chain [Array<Object>] Sequence of keys to navigate the hash hierarchy
+      # @example navigate key -> sub_key -> sub_sub_key
+      #   Dig.new(:key, :sub_key, :sub_sub_key)
+      def initialize(*chain)
+        super
+        @chain = chain
+      end
+
+      def ==(o)
+        super &&
+          o.chain == @chain
+      end
+
+      protected
+
+      # @see CompoundCondition#evaluate
+      def evaluate(ctx)
+        ctx && Ruy::Utils::Rules.evaluate_conditions(conditions, ctx)
+      end
+
+      # @see CompoundCondition#resolve
+      def resolve(ctx)
+        @chain.reduce(ctx) do |currentctx, key|
+          if currentctx.include?(key)
+            Ruy::Context.new(currentctx.resolve(key))
+          else
+            return false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ruy/conditions/eq.rb

@@ -1,27 +1,34 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute will be equal to a given value.
+    # Expects that a context attribute will be equal to a given value
+    #
     class Eq < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param value Expected value
-      # @param attr Context attribute's name
-      def initialize(value, attr)
+      # @param obj
+      # @param key
+      # @example evaluate that :key is 5
+      #   Eq.new(5, :key)
+      def initialize(obj, *key)
         super
-        @value = value
-        @attr = attr
-      end
-
-      def call(ctx)
-        @value == ctx.resolve(@attr)
+        @obj = obj
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(Eq) &&
-          attr == o.attr &&
-          value == o.value
+          o.obj == @obj &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(value)
+        @obj == value
       end
+
     end
   end
 end

data/lib/ruy/conditions/every.rb

@@ -0,0 +1,35 @@
+module Ruy
+  module Conditions
+
+    # Iterates over an Enumerable evaluating that every value
+    # matches the set of sub-conditions
+    #
+    class Every < CompoundCondition
+
+      # @param key
+      # @example check that every element of :array matches the sub-conditions
+      #   Every.new(:array)
+      def initialize(*key)
+        super
+        @key = key.first if key.any?
+      end
+
+      def ==(o)
+        super &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see CompoundCondition#evaluate
+      def evaluate(enum)
+        enum.all? do |ctx|
+          newctx = Ruy::Context.new(ctx)
+
+          Ruy::Utils::Rules.evaluate_conditions(conditions, newctx)
+        end
+      end
+
+    end
+  end
+end

data/lib/ruy/conditions/except.rb

@@ -1,29 +1,22 @@
 module Ruy
   module Conditions
 
-    # Expects that a condition is not met.
-    #
-    # When a sub-rule is given, Except will expect an unsuccessful evaluation of that sub-rule.
-    # When a sub-rule is not given, Except will expect a context attribute is not equal to a given
-    # value.
+    # Expects that the sub-condition is not satisfied
     class Except < CompoundCondition
 
-      # @param value Non-expected value
-      # @param attr Context attribute's name
+      # @example check that :key does not contain a truthy value
+      #   Except.new { assert :key }
       # @yield a block in the context of the current rule
       def initialize(&block)
         super
         instance_exec(&block) if block_given?
       end
 
-      def call(ctx)
+      # @see CompoundCondition#evaluate
+      def evaluate(ctx)
         !super
       end
 
-      def ==(o)
-        o.kind_of?(Except) &&
-          @conditions == o.conditions
-      end
     end
   end
 end

data/lib/ruy/conditions/greater_than.rb

@@ -1,28 +1,34 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute will be greater than the given value.
+    # Expects that a context attribute will be greater than the given value
+    #
     class GreaterThan < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param value
-      # @param attr Context attribute's name
-      # @yield a block in the context of the current rule
-      def initialize(value, attr, &block)
+      # @param obj
+      # @param key
+      # @example expects that :key is greater than 5
+      #   GreaterThan.new(5, :key)
+      def initialize(obj, *key)
         super
-        @value = value
-        @attr = attr
-      end
-
-      def call(var_ctx)
-        @value < var_ctx.resolve(@attr)
+        @obj = obj
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(GreaterThan) &&
-          attr == o.attr &&
-          value == o.value
+          o.obj == @obj &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(value)
+        @obj < value
       end
+
     end
   end
 end

data/lib/ruy/conditions/greater_than_or_equal.rb

@@ -1,28 +1,35 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute will be greater than or equal to the given value.
+    # Expects that a context attribute will be greater than or
+    # equal to the given value
+    #
     class GreaterThanOrEqual < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param value
-      # @param attr Context attribute's name
-      # @yield a block in the context of the current rule
-      def initialize(value, attr, &block)
+      # @param obj
+      # @param key
+      # @example check that :key is greater than or equal to 5
+      #   GreaterThanOrEqual.new(5, :key)
+      def initialize(obj, *key)
         super
-        @value = value
-        @attr = attr
-      end
-
-      def call(ctx)
-        @value <= ctx.resolve(@attr)
+        @obj = obj
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(GreaterThanOrEqual) &&
-          attr == o.attr &&
-          value == o.value
+          o.obj == @obj &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(value)
+        @obj <= value
       end
+
     end
   end
 end

data/lib/ruy/conditions/in.rb

@@ -1,27 +1,32 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute is included in a set of values.
+    # Expects that a context attribute is included in a set of values
+    #
     class In < Condition
-      attr_reader :attr, :values
+      attr_reader :ary
 
-      # @param values Expected set of values
-      # @param attr Context attribute's name
-      # @yield a block in the context of the current rule
-      def initialize(values, attr, &block)
+      # @param ary
+      # @param key
+      # @example check that :key is included in [1,3,5]
+      #   In.new([1,3,5], :key)
+      def initialize(ary, *key)
         super
-        @values = values
-        @attr = attr
-      end
-
-      def call(var_ctx)
-        self.values.include?(var_ctx.resolve(self.attr))
+        @ary = ary
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(In) &&
-          self.attr == o.attr &&
-          self.values == o.values
+          o.ary == @ary &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(value)
+        @ary.include?(value)
       end
     end
 

data/lib/ruy/conditions/in_cyclic_order.rb

@@ -1,18 +1,34 @@
 module Ruy
   module Conditions
+
+    # Expects that a value is contained in a cyclic order
+    #
     class InCyclicOrder < Condition
-      attr_reader :from, :to, :attr
+      attr_reader :from, :to
 
-      def initialize(from, to, attr, &block)
+      # @param from left bound
+      # @param to right bound
+      # @param key
+      # @example check that :key is included in a cycle defined between 100 and -100
+      #   InCyclicOrder.new(100, -100, :key)
+      def initialize(from, to, *key)
         super
         @from = from
         @to = to
-        @attr = attr
+        @key = key.first if key.any?
+      end
+
+      def ==(o)
+        o.kind_of?(self.class) &&
+          o.from == @from &&
+          o.to   == @to &&
+          o.key == @key
       end
 
-      def call(ctx)
-        value = ctx.resolve(@attr)
+      protected
 
+      # @see Condition#evaluate
+      def evaluate(value)
         if @from > @to
           (@from <= value || @to >= value)
         else
@@ -20,12 +36,6 @@ module Ruy
         end
       end
 
-      def ==(o)
-        o.kind_of?(self.class) &&
-          @from == o.from &&
-          @to   == o.to &&
-          @attr == o.attr
-      end
     end
   end
 end

data/lib/ruy/conditions/include.rb

@@ -1,28 +1,35 @@
 module Ruy
   module Conditions
 
-    # Expects that a value is included in a set of values from the context attribute.
+    # Expects that a value is included in a set of values
+    # from the context attribute
+    #
     class Include < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param value Expected set of values
-      # @param attr Context attribute's name
-      # @yield a block in the context of the current rule
-      def initialize(value, attr, &block)
+      # @param obj
+      # @param key
+      # @example check that :key includes 5
+      #   Include.new(5, :key)
+      def initialize(obj, *key)
         super
-        @value = value
-        @attr = attr
-      end
-
-      def call(ctx)
-        ctx.resolve(self.attr).include?(self.value)
+        @obj = obj
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(Include) &&
-          self.attr == o.attr &&
-          self.value == o.value
+          o.obj == @obj &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(enum)
+        enum.include?(@obj)
       end
+
     end
   end
 end

data/lib/ruy/conditions/less_than.rb

@@ -1,25 +1,31 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute will be less than given value.
+    # Expects that a context attribute will be less than the given value
+    #
     class LessThan < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param value
-      # @param attr Context attribute's name
-      def initialize(value, attr)
-        @value = value
-        @attr = attr
-      end
-
-      def call(ctx)
-        @value > ctx.resolve(@attr)
+      # @param obj
+      # @param key
+      # @example check that :key is less than 5
+      #   LessThan.new(5, :key)
+      def initialize(obj, *key)
+        @obj = obj
+        @key = key.first if key.any?
       end
 
       def ==(o)
         o.kind_of?(LessThan) &&
-          attr == o.attr &&
-          value == o.value
+          o.obj == @obj &&
+          o.key == @key
+      end
+
+      protected
+
+      # @see Condition#evaluate
+      def evaluate(value)
+        @obj > value
       end
     end
   end