ruy 1.0.0 → 2.0.0

data/lib/ruy/conditions/less_than_or_equal.rb

@@ -1,27 +1,35 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute will be less than or equal to the given value.
+    # Expects that a context attribute will be less than or equal
+    # to the given value
+    #
     class LessThanOrEqual < Condition
-      attr_reader :attr, :value
+      attr_reader :obj
 
-      # @param attr Context attribute's name
-      # @param value
-      def initialize(value, attr)
+      # @param obj
+      # @param key
+      # @example check that :key is less than or equal to 5
+      #   LessThanOrEqual.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?(LessThanOrEqual) &&
-          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/some.rb

@@ -0,0 +1,32 @@
+module Ruy
+  module Conditions
+
+    # Iterates over an Enumerable evaluating that some value
+    # matches the set of sub-conditions
+    #
+    class Some < CompoundCondition
+
+      # @param key
+      # @example check that at least a value from :key matches the sub-conditions
+      #   Some.new(:key)
+      def initialize(*key)
+        super
+        @key = key.first if key.any?
+      end
+
+      # @see CompoundCondition#evaluate
+      def evaluate(enum)
+        enum.any? do |ctx|
+          new_ctx = Ruy::Context.new(ctx)
+
+          Ruy::Utils::Rules.evaluate_conditions(conditions, new_ctx)
+        end
+      end
+
+      def ==(o)
+        super &&
+          o.key == @key
+      end
+    end
+  end
+end

data/lib/ruy/conditions/tz.rb

@@ -1,67 +1,59 @@
 module Ruy
   module Conditions
 
-    # Evaluates a block using comparison matchers that receive time-related objects with time zone awareness.
+    # Evaluates a block using comparison matchers
+    # that receive time-related objects with time zone awareness
     #
     # @note Does not support time zone-aware matchers inside sub-blocks.
-    #       A workaround for this is always surrounding your time zone-aware matchers by a 'tz' block even in sub-blocks
-    #       already surrounded by one.
+    #   A workaround for this is always surrounding your
+    #   time zone-aware matchers by a 'tz' block even in sub-blocks
+    #   already surrounded by one.
     class TZ < CompoundCondition
-      # @param [String] tz_identifier String representing IANA's time zone identifier.
+
+      # @param tz_identifier [String]
+      #   String representing IANA's time zone identifier.
+      # @example evaluate all the sub-conditions under CST
+      #   TZ.new('CST')
       def initialize(tz_identifier)
         super
         @tz_identifier = tz_identifier
       end
 
-      # @param [Ruy::VariableContext] ctx
-      def call(ctx)
-        conditions.all? do |condition|
-          condition.call(ctx)
-        end
+      # @see Ruy::Conditions::DayOfWeek#initialize
+      def day_of_week(dow, key)
+        conditions << DayOfWeek.new(dow, key, @tz_identifier)
       end
 
-      # Adds a DayOfWeek condition
-      #
-      # @param (see Ruy::Conditions::DayOfWeek#initialize)
-      def day_of_week(dow, attr)
-        conditions << DayOfWeek.new(dow, attr, @tz_identifier)
+      # @see Ruy::Conditions::Eq#initialize
+      def eq(pattern, *key)
+        super(TimePattern.new(pattern, @tz_identifier), *key)
       end
 
-      # Intercepts an 'eq' call to the superclass and enhances its arguments
-      #
-      # @param (see Ruy::Conditions::Eq#initialize)
-      def eq(pattern, attr, &block)
-        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
-      end
 
-      # TODO Add Greater condition call here
+      # @see Ruy::Conditions::GreaterThanOrEqual#initialize
+      def greater_than(pattern, *key)
+        super(TimePattern.new(pattern, @tz_identifier), *key)
+      end
 
-      # Intercepts a 'greater_than_or_equal' call to the superclass and enhances its arguments
-      #
-      # @param (see Ruy::Conditions::GreaterThanOrEqual#initialize)
-      def greater_than_or_equal(pattern, attr, &block)
-        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
+      # @see Ruy::Conditions::GreaterThanOrEqual#initialize
+      def greater_than_or_equal(pattern, *key)
+        super(TimePattern.new(pattern, @tz_identifier), *key)
       end
 
-      # Intercepts a 'less_than' call to the superclass and enhances its arguments
-      #
-      # @param (see Ruy::Conditions::LessThan#initialize)
-      def less_than(pattern, attr, &block)
-        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
+      # @see Ruy::Conditions::LessThan#initialize
+      def less_than(pattern, *key)
+        super(TimePattern.new(pattern, @tz_identifier), *key)
       end
 
-      # Intercepts a 'less_than_or_equal' call to the superclass and enhances its arguments
-      #
-      # @param (see Ruy::Conditions::LessThanOrEqual#initialize)
-      def less_than_or_equal(pattern, attr, &block)
-        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
+      # @see Ruy::Conditions::LessThanOrEqual#initialize
+      def less_than_or_equal(pattern, *key)
+        super(TimePattern.new(pattern, @tz_identifier), *key)
       end
 
-      # Intercepts a 'between' call to the superclass and enhances its arguments
-      #
-      # @param (see Ruy::Conditions::Between#initialize)
-      def between(from, to, attr, &block)
-        super(TimePattern.new(from, @tz_identifier), TimePattern.new(to, @tz_identifier), attr, &block)
+      # @see Ruy::Conditions::Between#initialize)
+      def between(from, to, *key)
+        super(TimePattern.new(from, @tz_identifier),
+          TimePattern.new(to, @tz_identifier), *key)
       end
 
     end

data/lib/ruy/context.rb

@@ -1,28 +1,57 @@
 module Ruy
-  # Context that resolves lets and values access.
+  class UnexpectedObjectError < StandardError; end
+
+  # Wraps an evaluation object and stores lazy variables.
+  # It supports hierarchical structures that can be navigated
+  # using the #[] method.
+  #
   class Context
 
-    # @param [Hash] ctx
-    # @param [Array] lets Names of the 'let' variables
-    def initialize(ctx, lets = [])
-      @ctx = ctx
-      @lets = lets
+    attr_reader :obj
+    alias_method :object, :obj
 
+    # @param obj
+    # @param lets [Array<Symbol>]
+    # @example a Hash context
+    #   Context.new({key: 5})
+    # @example a Hash context and expected lazy variables
+    #   Context.new({key: 5}, [:lazy_a, :lazy_b])
+    # @example a Fixnum context
+    #   Context.new(5)
+    def initialize(obj, lets = [])
+      @obj = obj
+      @lets = lets
       @resolved_lets = {}
     end
 
-    # Resolve the given attr from the lets or the context.
+    # Returns true if the given key can be resolved in the current context
+    #
+    # @param key
+    #
+    # @return [Boolean]
+    def include?(key)
+      @obj.kind_of?(Hash) && @obj.include?(key)
+    end
+
+    # Resolves an attribute key to its corresponding value
     #
-    # @param [Symbol] attr
+    # @param key
     #
-    # @return [Object]
-    # @return [nil] when attribute cannot be resolved
-    def resolve(attr)
-      if @lets.include?(attr)
-        @resolved_lets[attr] ||= @ctx.instance_exec(&@ctx[attr])
+    # @return the value
+    # @return [nil] if key cannot be resolved
+    # @raise UnexpectedObjectError if object in context is not a Hash
+    def resolve(key)
+      if !@obj.kind_of?(Hash)
+        raise UnexpectedObjectError, 'Object in context is not a Hash instance'
+      end
+
+      # Lazy variables have precedence over context attributes
+      if @lets.include?(key)
+        @resolved_lets[key] ||= @obj.instance_exec(&@obj[key])
       else
-        @ctx.fetch(attr) { |key| @ctx[key.to_s] }
+        @obj[key]
       end
     end
+
   end
 end

data/lib/ruy/dsl.rb

@@ -24,29 +24,51 @@ module Ruy
     # Adds an Assert condition.
     #
     # @param (see Conditions::Assert#initialize)
-    def assert(attr)
-      self.conditions << Conditions::Assert.new(attr)
+    def assert(*attrs)
+      self.conditions << Conditions::Assert.new(*attrs)
     end
 
     # Adds a Between condition.
     #
     # @param (see Conditions::Between#initialize)
-    def between(from, to, attr, &block)
-      self.conditions << Conditions::Between.new(from, to, attr, &block)
+    def between(from, to, *attrs)
+      self.conditions << Conditions::Between.new(from, to, *attrs)
+    end
+
+    # Adds a Cond condition.
+    #
+    # @yield Evaluates the given block in the context of the new rule
+    def cond(&block)
+      cond = Conditions::Cond.new
+      cond.instance_exec(&block)
+
+      self.conditions << cond
+    end
+
+    # Adds a Dig condition.
+    #
+    # @param (see Conditions::Dig#initialize)
+    #
+    # @yield Evaluates the given block in the context of the new rule
+    def dig(*attrs, &block)
+      condition = Conditions::Dig.new(*attrs)
+      condition.instance_exec(&block)
+
+      self.conditions << condition
     end
 
     # Adds an Eq condition.
     #
     # @param (see Conditions::Eq#initialize)
-    def eq(value, attr, &block)
-      self.conditions << Conditions::Eq.new(value, attr, &block)
+    def eq(value, *attrs)
+      self.conditions << Conditions::Eq.new(value, *attrs)
     end
 
-    # Adds a Cond condition.
+    # Adds an Every condition.
     #
-    # @yield Evaluates the given block in the context of the new rule
-    def cond(&block)
-      cond = Conditions::Cond.new
+    # @param (see Conditions::Every#initialize)
+    def every(*attrs, &block)
+      cond = Conditions::Every.new(*attrs)
       cond.instance_exec(&block)
 
       self.conditions << cond
@@ -62,55 +84,65 @@ module Ruy
     # Adds a GreaterThan condition.
     #
     # @param (see Conditions::GreaterThanOrEqual#initialize)
-    def greater_than(value, attr)
-      self.conditions << Conditions::GreaterThan.new(value, attr)
+    def greater_than(value, *attrs)
+      self.conditions << Conditions::GreaterThan.new(value, *attrs)
     end
 
     # Adds a GreaterThanOrEqual condition.
     #
     # @param (see Conditions::GreaterThanOrEqual#initialize)
-    def greater_than_or_equal(value, attr)
-      self.conditions << Conditions::GreaterThanOrEqual.new(value, attr)
+    def greater_than_or_equal(value, *attrs)
+      self.conditions << Conditions::GreaterThanOrEqual.new(value, *attrs)
     end
 
     # Adds an In condition.
     #
     # @param (see Conditions::Include#initialize)
-    def in(values, attr, &block)
-      self.conditions << Conditions::In.new(values, attr, &block)
+    def in(values, *attrs)
+      self.conditions << Conditions::In.new(values, *attrs)
     end
 
     # Adds a InCyclicOrder condition.
     #
     # @param (see Conditions::InCyclicOrder#initialize)
-    def in_cyclic_order(from, to, attr, &block)
-      self.conditions << Conditions::InCyclicOrder.new(from, to, attr, &block)
+    def in_cyclic_order(from, to, *attrs)
+      self.conditions << Conditions::InCyclicOrder.new(from, to, *attrs)
     end
 
     # Adds an Include condition.
     #
     # @param (see Conditions::Included#initialize)
-    def include(value, attr, &block)
-      self.conditions << Conditions::Include.new(value, attr, &block)
+    def include(value, *attrs)
+      self.conditions << Conditions::Include.new(value, *attrs)
+    end
+
+    # Adds a LessThan condition.
+    #
+    # @param (see Conditions::LessThan#initialize)
+    def less_than(value, *attrs)
+      self.conditions << Conditions::LessThan.new(value, *attrs)
     end
 
     # Adds a LessOrEqualThan condition.
     #
     # @param (see Conditions::LessOrEqualThan#initialize)
-    def less_than_or_equal(value, attr, &block)
-      self.conditions << Conditions::LessThanOrEqual.new(value, attr)
+    def less_than_or_equal(value, *attrs)
+      self.conditions << Conditions::LessThanOrEqual.new(value, *attrs)
     end
 
-    # Adds a LessThan condition.
+    # Adds a Some condition.
     #
-    # @param (see Conditions::LessThan#initialize)
-    def less_than(value, attr)
-      self.conditions << Conditions::LessThan.new(value, attr)
+    # @param (see Conditions::Some#initialize)
+    def some(*attrs, &block)
+      cond = Conditions::Some.new(*attrs)
+      cond.instance_exec(&block)
+
+      self.conditions << cond
     end
 
     # Adds a TZ condition block
     #
-    # @param [String] tz_identifier String representing IANA's
+    # @param tz_identifier [String] String representing IANA's
     #   time zone identifier. Defaults to UTC if none passed.
     # @yield Evaluates the given block in the context of the TZ rule
     def tz(tz_identifier = 'UTC', &block)
@@ -120,7 +152,7 @@ module Ruy
       self.conditions << cond
     end
 
-    # @param [Integer] indentation Indentation level
+    # @param indentation [Integer] Indentation level
     def to_s(indentation = 0)
       rule_name = Ruy::Utils::Naming.rule_name(self)
 

data/lib/ruy/outcome.rb

@@ -1,31 +1,31 @@
 module Ruy
   # Represents a possible result (outcome) of evaluating a rule set
+  # Additionally, an outcome can be composed of rules. In that case,
+  # the outcome will evaluate to its value
+  # if all of them are evaluated successfully.
   #
-  # Additionally, an outcome can be composed of rules. In that case, the outcome will evaluate to
-  # its value if all of them are evaluated successfully.
   class Outcome
     include DSL
 
     attr_reader :value
 
-    # @param value The value of this outcome
+    # @param value
+    # @example will return true if evaluation passes
+    #   Outcome.new(true)
     def initialize(value)
       @value = value
       @root_condition = Ruy::Conditions::All.new
     end
 
-    # Returns the value of this outcome is all of the conditions succeed.
-    #
+    # Returns the value of this outcome if all of the conditions succeed.
     # It also returns the value when there's no conditions.
     #
-    # @param [Ruy::Context] ctx
+    # @param ctx [Ruy::Context]
     #
-    # @return [Object]
-    # @return [nil] If some of the conditions does not succeeds
+    # @return the value
+    # @return [nil] if conditions are not met
     def call(ctx)
-      if @root_condition.call(ctx)
-        @value
-      end
+      @value if @root_condition.call(ctx)
     end
 
     # @return [Array<Ruy::Condition>]