ruy 0.2.1 → 0.3.0

data/lib/ruy/conditions/greater_than_or_equal.rb

@@ -5,18 +5,18 @@ module Ruy
     class GreaterThanOrEqual < Ruy::Rule
       attr_reader :attr, :value
 
-      # @param attr Context attribute's name
       # @param value
+      # @param attr Context attribute's name
       # @yield a block in the context of the current rule
-      def initialize(attr, value, &block)
+      def initialize(value, attr, &block)
         super
-        @attr = attr
         @value = value
+        @attr = attr
         instance_exec(&block) if block_given?
       end
 
-      def call(var_ctx)
-        var_ctx.resolve(@attr) >= @value && super
+      def call(ctx)
+        @value <= ctx.resolve(@attr) && super
       end
 
       def ==(o)

data/lib/ruy/conditions/in.rb

@@ -0,0 +1,31 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute is included in a set of values.
+    class In < Ruy::Rule
+      attr_reader :attr, :values
+
+      # @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)
+        super
+        @values = values
+        @attr = attr
+        instance_exec(&block) if block_given?
+      end
+
+      def call(var_ctx)
+        self.values.include?(var_ctx.resolve(self.attr)) && super
+      end
+
+      def ==(o)
+        o.kind_of?(In) &&
+          self.attr == o.attr &&
+          self.values == o.values &&
+          self.conditions == o.conditions
+      end
+    end
+
+  end
+end

data/lib/ruy/conditions/in_cyclic_order.rb

@@ -0,0 +1,33 @@
+module Ruy
+  module Conditions
+    class InCyclicOrder < Ruy::Rule
+      attr_reader :from, :to, :attr
+
+      def initialize(from, to, attr, &block)
+        super
+        @from = from
+        @to = to
+        @attr = attr
+        instance_exec(&block) if block_given?
+      end
+
+      def call(ctx)
+        value = ctx.resolve(@attr)
+
+        if @from > @to
+          (@from <= value || @to >= value) && super
+        else
+          (@from <= value && @to >= value) && super
+        end
+      end
+
+      def ==(o)
+        o.kind_of?(self.class) &&
+          @from == o.from &&
+          @to   == o.to &&
+          @attr == o.attr &&
+          self.conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/include.rb

@@ -1,28 +1,28 @@
 module Ruy
   module Conditions
 
-    # Expects that a context attribute is included in a set of values.
+    # Expects that a value is included in a set of values from the context attribute.
     class Include < Ruy::Rule
-      attr_reader :attr, :values
+      attr_reader :attr, :value
 
+      # @param value Expected set of values
       # @param attr Context attribute's name
-      # @param values Expected set of values
       # @yield a block in the context of the current rule
-      def initialize(attr, values, &block)
+      def initialize(value, attr, &block)
         super
+        @value = value
         @attr = attr
-        @values = values
         instance_exec(&block) if block_given?
       end
 
-      def call(var_ctx)
-        self.values.include?(var_ctx.resolve(self.attr)) && super
+      def call(ctx)
+        ctx.resolve(self.attr).include?(self.value) && super
       end
 
       def ==(o)
         o.kind_of?(Include) &&
           self.attr == o.attr &&
-          self.values == o.values &&
+          self.value == o.value &&
           self.conditions == o.conditions
       end
     end

data/lib/ruy/conditions/included.rb

@@ -15,8 +15,8 @@ module Ruy
         instance_exec(&block) if block_given?
       end
 
-      def call(var_ctx)
-        var_ctx.resolve(self.attr).include?(self.value) && super
+      def call(ctx)
+        ctx.resolve(self.attr).include?(self.value) && super
       end
 
       def ==(o)

data/lib/ruy/conditions/less_than.rb

@@ -5,16 +5,16 @@ module Ruy
     class LessThan < Ruy::Rule
       attr_reader :attr, :value
 
-      # @param attr Context attribute's name
       # @param value
-      def initialize(attr, value)
+      # @param attr Context attribute's name
+      def initialize(value, attr)
         super
-        @attr = attr
         @value = value
+        @attr = attr
       end
 
-      def call(var_ctx)
-        var_ctx.resolve(@attr) < @value
+      def call(ctx)
+        @value > ctx.resolve(@attr)
       end
 
       def ==(o)

data/lib/ruy/conditions/less_than_or_equal.rb

@@ -7,14 +7,14 @@ module Ruy
 
       # @param attr Context attribute's name
       # @param value
-      def initialize(attr, value)
+      def initialize(value, attr)
         super
-        @attr = attr
         @value = value
+        @attr = attr
       end
 
-      def call(var_ctx)
-        var_ctx.resolve(@attr) <= @value
+      def call(ctx)
+        @value >= ctx.resolve(@attr)
       end
 
       def ==(o)

data/lib/ruy/conditions/tz.rb

@@ -2,9 +2,10 @@ module Ruy
   module Conditions
 
     # Evaluates a block using comparison matchers that receive time-related objects with time zone awareness.
-    #   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.
+    #
+    # @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.
     class TZ < Ruy::Rule
       # @param [String] tz_identifier String representing IANA's time zone identifier.
       def initialize(tz_identifier)
@@ -12,25 +13,25 @@ module Ruy
         @tz_identifier = tz_identifier
       end
 
-      # @param [Ruy::VariableContext] var_ctx
-      def call(var_ctx)
+      # @param [Ruy::VariableContext] ctx
+      def call(ctx)
         @conditions.all? do |condition|
-          condition.call(var_ctx)
+          condition.call(ctx)
         end
       end
 
       # Adds a DayOfWeek condition
       #
       # @param (see Ruy::Conditions::DayOfWeek#initialize)
-      def day_of_week(attr, dow)
-        @conditions << DayOfWeek.new(attr, dow, @tz_identifier)
+      def day_of_week(dow, attr)
+        @conditions << DayOfWeek.new(dow, attr, @tz_identifier)
       end
 
       # Intercepts an 'eq' call to the superclass and enhances its arguments
       #
       # @param (see Ruy::Conditions::Eq#initialize)
-      def eq(attr, pattern, &block)
-        super(attr, TimePattern.new(pattern, @tz_identifier), &block)
+      def eq(pattern, attr, &block)
+        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
       end
 
       # TODO Add Greater condition call here
@@ -38,29 +39,29 @@ module Ruy
       # 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(attr, pattern, &block)
-        super(attr, TimePattern.new(pattern, @tz_identifier), &block)
+      def greater_than_or_equal(pattern, attr, &block)
+        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
       end
 
       # Intercepts a 'less_than' call to the superclass and enhances its arguments
       #
       # @param (see Ruy::Conditions::LessThan#initialize)
-      def less_than(attr, pattern, &block)
-        super(attr, TimePattern.new(pattern, @tz_identifier), &block)
+      def less_than(pattern, attr, &block)
+        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
       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(attr, pattern, &block)
-        super(attr, TimePattern.new(pattern, @tz_identifier), &block)
+      def less_than_or_equal(pattern, attr, &block)
+        super(TimePattern.new(pattern, @tz_identifier), attr, &block)
       end
 
       # Intercepts a 'between' call to the superclass and enhances its arguments
       #
       # @param (see Ruy::Conditions::Between#initialize)
-      def between(attr, from, to, &block)
-        super(attr, TimePattern.new(from, @tz_identifier), TimePattern.new(to, @tz_identifier), &block)
+      def between(from, to, attr, &block)
+        super(TimePattern.new(from, @tz_identifier), TimePattern.new(to, @tz_identifier), attr, &block)
       end
 
     end

data/lib/ruy/context.rb

@@ -1,10 +1,28 @@
 module Ruy
-  class Context < Hash
-    def self.from_hash(hash)
-       ctx = Context.new
-       ctx.merge!(hash)
+  # Context that resolves lets and values access.
+  class Context
 
-       ctx
+    # @param [Hash] ctx
+    # @param [Array] lets Names of the 'let' variables
+    def initialize(ctx, lets = [])
+      @ctx = ctx
+      @lets = lets
+
+      @resolved_lets = {}
+    end
+
+    # Resolve the given attr from the lets or the context.
+    #
+    # @param [Symbol] attr
+    #
+    # @return [Object]
+    # @return [nil] when attribute cannot be resolved
+    def resolve(attr)
+      if @lets.include?(attr)
+        @resolved_lets[attr] ||= @ctx.instance_exec(&@ctx[attr])
+      else
+        @ctx.fetch(attr) { |key| @ctx[key.to_s] }
+      end
     end
   end
 end

data/lib/ruy/dsl.rb

@@ -0,0 +1,146 @@
+module Ruy
+  module DSL
+
+    # Adds an All condition.
+    #
+    # @yield Evaluates the given block in the context of the new rule
+    def all(&block)
+      cond = Conditions::All.new
+      cond.instance_exec(&block)
+
+      self.conditions << cond
+    end
+
+    # Adds an Any condition.
+    #
+    # @yield Evaluates the given block in the context of the new rule
+    def any(&block)
+      cond = Conditions::Any.new
+      cond.instance_exec(&block)
+
+      self.conditions << cond
+    end
+
+    # Adds an Assert condition.
+    #
+    # @param (see Conditions::Assert#initialize)
+    def assert(attr)
+      self.conditions << Conditions::Assert.new(attr)
+    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)
+    end
+
+    # Adds an Eq condition.
+    #
+    # @param (see Conditions::Eq#initialize)
+    def eq(value, attr, &block)
+      self.conditions << Conditions::Eq.new(value, attr, &block)
+    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 an Except condition.
+    #
+    # @param (see Conditions::Except#initialize)
+    def except(value = nil, attr = nil, &block)
+      self.conditions << Conditions::Except.new(value, attr, &block)
+    end
+
+    # Adds a GreaterThan condition.
+    #
+    # @param (see Conditions::GreaterThanOrEqual#initialize)
+    def greater_than(value, attr)
+      @conditions << Conditions::GreaterThan.new(value, attr)
+    end
+
+    # Adds a GreaterThanOrEqual condition.
+    #
+    # @param (see Conditions::GreaterThanOrEqual#initialize)
+    def greater_than_or_equal(value, attr)
+      self.conditions << Conditions::GreaterThanOrEqual.new(value, attr)
+    end
+
+    # Adds an In condition.
+    #
+    # @param (see Conditions::Include#initialize)
+    def in(values, attr, &block)
+      self.conditions << Conditions::In.new(values, attr, &block)
+    end
+
+    # Adds a InCyclicOrder condition.
+    #
+    # @param (see Conditions::InCyclicOrder#initialize)
+    def in_cyclic_order(from, to, attr, &block)
+      @conditions << Conditions::InCyclicOrder.new(from, to, attr, &block)
+    end
+
+    # Adds an Include condition.
+    #
+    # @param (see Conditions::Included#initialize)
+    def include(value, attr, &block)
+      self.conditions << Conditions::Include.new(value, attr, &block)
+    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)
+    end
+
+    # Adds a LessThan condition.
+    #
+    # @param (see Conditions::LessThan#initialize)
+    def less_than(value, attr)
+      self.conditions << Conditions::LessThan.new(value, attr)
+    end
+    
+    # Adds a TZ condition block
+    #
+    # @param [String] tz_identifier 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)
+      cond = Conditions::TZ.new(tz_identifier)
+      cond.instance_exec(&block)
+
+      self.conditions << cond
+    end
+
+    # @param [Integer] indentation Indentation level
+    def to_s(indentation = 0)
+      rule_name = Ruy::Utils::Naming.rule_name(self)
+
+      s = Ruy::Utils::Printable.indent(indentation) << rule_name
+
+      if self.params.any?
+        stringified_params = self.params.map(&:inspect)
+
+        s << ' ' << stringified_params.join(', ')
+      end
+
+      if self.conditions.empty?
+        s << "\n"
+      else
+        s << " do\n"
+        s << self.conditions.map { |c| c.to_s(indentation + 1) }.join()
+        s << Ruy::Utils::Printable.indent(indentation) + "end\n"
+      end
+
+      s
+    end
+  end
+end