ruy 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3f59c87798c8d6d5aa92ca7639e4605f60c36c6
-  data.tar.gz: 4d51c3dd0c5e0a9d7c4a8175caf38eccb19e7763
+  metadata.gz: 062667c3bb0ac6a9796f8bbda6dded7918ec9b11
+  data.tar.gz: bd51df8ff61cab98c007849cf4a1079dc8f83956
 SHA512:
-  metadata.gz: 71e65bfa1ace338acdcefafbe9a234e5c415bdc1b8075c330fe4831e8f6cebfbd3f70a435656266c7604338c0180692f39af888d1bf7df6f64088233446b550b
-  data.tar.gz: 8c8bb8c7db01b3254d83f53fd44a41dd9257fd2544929dc513360a27ad5805d38676e4568a9d868b6946efe525c7db4f0d101128463eab98a40cfe22f624f0f2
+  metadata.gz: e48d547cdb0e47a50ede40c794d3a90eb012ab27c34e31aba0d696ae3936bcbdd0a0501887ba269833135b61e70b34d684892ff84e1e698918f54c9d9c9c7a2e
+  data.tar.gz: 78a9ecccf5c5f9f0549f7c53fa2e3515d7d900afe4695c1b52f7e5b2a019c38158e385e2daa088a7c716a396d7c31c6e3b06f70185b9d9a42b0dc756450f921a

data/README.md

@@ -4,7 +4,9 @@ Ruy is a library for defining a set of conditions and evaluating them against a
 
 ``` ruby
 # discount_day.rb
-gifter = Ruy::RuleSet.new
+gifter = Ruy::Rule.new
+
+gifter.set :name, 'Unforgettable Fridays'
 
 gifter.eq :friday, :day_of_week
 
@@ -21,7 +23,7 @@ gifter.outcome 3
 gifter.fallback 0
 ```
 
-RuleSets are evaluated against a context (the `Hash` being passed to `#call`) and return the first outcome that matches.
+Rules are evaluated against a context (the `Hash` being passed to `#call`) and return the first outcome that matches.
 
 ``` ruby
 gifter.call(day_of_week: :friday, amount: 314)
@@ -49,6 +51,13 @@ gifter.call(day_of_week: :monday, amount: 124)
 # => 0
 ```
 
+Retrieve rule attributes.
+``` ruby
+gifter.get(:name)
+
+# => 'Unforgettable Fridays'
+```
+
 ## Key concepts
 
 Ruy at its core is about evaluating a set of conditions against a context in order to return a result.
@@ -70,46 +79,28 @@ Available conditions:
  - greater_than *Tests that context value is greater than something*
  - greater_than_or_equal *Tests that context value is greater than or equal to something*
  - in *A context value must belong to a specified list of values*
- - in_cyclic_order *TBD*
+ - in_cyclic_order *Expects that a value is included in a cyclic order*
  - include *The context attribute must include a specified value*
  - less_than_or_equal *Tests that context value is less than or equal to something*
  - less_than *Tests that context value is less than something*
 
-Conditions can be nested. In such case, for the nesting condition to be met, the nested conditions must
-also be met.
-
-``` ruby
-between 0, 1_000, :amount do
-  eq :friday, :day_of_week
-end
-```
-
-is equivalent to:
-
-``` ruby
-all do
-  between 0, 1_000, :amount
-  eq :friday, :day_of_week
-end
-```
+### Rules
 
-### Rulsets
-
-A ruleset is a set of conditions that must suffice and returns a value resulting from either an
+A Rule is a set of conditions that must suffice and returns a value resulting from either an
 outcome or a fallback.
 
 ### Contexts
 
-A context is a `Hash` from which values are fetched in order to evaluate a ruleset.
+A context is a `Hash` from which values are fetched in order to evaluate a Rule.
 
 ### Lazy values
 
-Rulesets can define lazy values. The context must provide a proc which is evaluted only once the first time the value is needed. The result returned by the proc is memoized and used to evaluate subsequent conditions.
+Rules can define lazy values. The context must provide a proc which is evaluted only once the first time the value is needed. The result returned by the proc is memoized and used to evaluate subsequent conditions.
 
 
 ``` ruby
 # premium_discount_day.rb
-gifter = Ruy::RuleSet.new
+gifter = Ruy::Rule.new
 
 gifter.let :amounts_average # an expensive calculation
 
@@ -125,23 +116,23 @@ gifter.call(day_of_week: :friday, amounts_average: -> { Stats::Amounts.compute_a
 ```
 ### Outcomes
 
-An outcome is the result of a successful ruleset evaluation. An outcome can also have nested
+An outcome is the result of a successful Rule evaluation. An outcome can also have nested
 conditions, in such case, if the conditions meet, the outcome value is returned.
 
-A RuleSet can have multiple outcomes, the first matching one is returned.
+A Rule can have multiple outcomes, the first matching one is returned.
 
 ### Time Zone awareness
 
 When it comes to matching times in different time zones, Ruy is bundled with a built in `tz` block that will enable specific matchers to make time zone-aware comparisons.
 
 ```ruby
-ruleset = Ruy::RuleSet.new
+rule = Ruy::Rule.new
 
-ruleset.tz 'America/New_York' do
+rule.tz 'America/New_York' do
   eq '2015-01-01T00:00:00', :timestamp
 end
 
-ruleset.outcome 'Happy New Year, NYC!'
+rule.outcome 'Happy New Year, NYC!'
 ```
 
 For example, if the timestamp provided in the context is a Ruby Time object in UTC (zero offset from UTC), `eq` as child of a `tz` block will take the time zone passed as argument to the block (`America/New_York`) to calculate the current offset and make the comparison.
@@ -157,9 +148,9 @@ Where the time zone identifier is optional, but if you specify it, will take pre
 Inside any `tz` block, there's a matcher to look for a specific day of the week in the time zone of the block.
 
 ```ruby
-ruleset = Ruy::RuleSet.new
+rule = Ruy::Rule.new
 
-ruleset.any do
+rule.any do
   tz 'America/New_York' do
       day_of_week :saturday, :timestamp
   end
@@ -169,7 +160,7 @@ ruleset.any do
   end
 end
 
-ruleset.outcome 'Have a nice weekend, NYC!'
+rule.outcome 'Have a nice weekend, NYC!'
 ```
 
 This matcher supports both the `Symbol` and number syntax in the range `(0..6)` starting on Sunday.
@@ -183,15 +174,20 @@ You cannot use matchers inside nested blocks in a `tz` block expecting them to w
 A possible workaround for this is to use `tz` blocks inside the nested block in question:
 
 ```ruby
-ruleset = Ruy::RuleSet.new
-any do
+rule = Ruy::Rule.new
+
+rule.any do
   tz 'America/New_York' { eq '2015-01-01T00:00:00', :timestamp }
   tz 'America/New_York' { eq '2015-01-01T02:00:00zUTC', :timestamp }
 end
 
-ruleset.outcome 'Happy New Year, NYC!'
+rule.outcome 'Happy New Year, NYC!'
 ```
 
 Support for time zone awareness in nested blocks inside `tz` blocks is planned. This workaround could stop working in future versions; use it at your own risk.
 
 Ruy depends on [TZInfo](http://tzinfo.github.io/ "TZ Info website") to calculate offsets using IANA's Time Zone Database. Check their website for information about time zone identifiers.
+
+### Documentation
+
+[RubyDoc.info](http://www.rubydoc.info/github/moove-it/ruy)

data/lib/ruy.rb

@@ -1,7 +1,6 @@
 require_relative 'ruy/utils'
 require_relative 'ruy/dsl'
 require_relative 'ruy/rule'
-require_relative 'ruy/rule_set'
 require_relative 'ruy/conditions'
 require_relative 'ruy/context'
 require_relative 'ruy/outcome'

data/lib/ruy/conditions.rb

@@ -1,3 +1,5 @@
+require_relative 'conditions/condition'
+require_relative 'conditions/compound_condition'
 require_relative 'conditions/all'
 require_relative 'conditions/any'
 require_relative 'conditions/assert'

data/lib/ruy/conditions/all.rb

@@ -2,12 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that all rules will succeed.
-    class All < Ruy::Rule
-      def call(ctx)
-        @conditions.all? do |condition|
-          condition.call(ctx)
-        end
-      end
+    class All < CompoundCondition
     end
   end
 end

data/lib/ruy/conditions/any.rb

@@ -2,9 +2,9 @@ module Ruy
   module Conditions
 
     # Expects that at least one of the rules will succeed.
-    class Any < Ruy::Rule
+    class Any < CompoundCondition
       def call(ctx)
-        @conditions.any? do |condition|
+        conditions.any? do |condition|
           condition.call(ctx)
         end
       end

data/lib/ruy/conditions/assert.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Asserts that an attribute has a truth value.
-    class Assert < Ruy::Rule
+    class Assert < Condition
       attr_reader :attr
 
       # @param attr Context attribute's name

data/lib/ruy/conditions/between.rb

@@ -4,7 +4,7 @@ module Ruy
     # Expects that a context value belongs to a given range.
     #
     # Comparison formula: from <= context[attr] <= to
-    class Between < Ruy::Rule
+    class Between < Condition
       attr_reader :attr, :from, :to
 
       # @param from Range lower bound
@@ -17,20 +17,18 @@ module Ruy
         @from = from
         @to = to
         @attr = attr
-        instance_exec(&block) if block_given?
       end
 
       def call(ctx)
         value = ctx.resolve(@attr)
-        @from <= value && @to >= value && super
+        @from <= value && @to >= value
       end
 
       def ==(o)
         o.kind_of?(Between) &&
           @attr == o.attr &&
           @from == o.from &&
-          @to   == o.to &&
-          self.conditions == o.conditions
+          @to   == o.to
       end
     end
   end

data/lib/ruy/conditions/compound_condition.rb

@@ -0,0 +1,25 @@
+module Ruy
+  module Conditions
+
+    class CompoundCondition < Condition
+
+      attr_reader :conditions
+
+      def initialize(*params)
+        super
+
+        @conditions = []
+      end
+
+      # Evaluates all conditions.
+      #
+      # @return [true] When all conditions succeeds
+      # @return [false] Otherwise
+      def call(ctx)
+        @conditions.all? do |condition|
+          condition.call(ctx)
+        end
+      end
+    end
+  end
+end

data/lib/ruy/conditions/cond.rb

@@ -1,15 +1,15 @@
 module Ruy
   module Conditions
 
-    # Expects a successful evaluation of a sub-pair of rules.
+    # Expects a successful evaluation of a sub-pair of conditions.
     #
-    # Groups rules in slices of 2 rules. Then evalutes each slice until one of them succeds.
-    # If there's an even number of rules, the last slice will only one rule.
+    # Groups rules in slices of 2 conditions. Then evalutes each slice until one of them succeds.
+    # If there's an even number of conditions, the last slice will have only one condition.
     #
     # Cond is handy for mocking if/else if/else constructs.
-    class Cond < Ruy::Rule
+    class Cond < CompoundCondition
       def call(ctx)
-        clauses = @conditions.each_slice(2)
+        clauses = conditions.each_slice(2)
 
         clauses.any? do |rule_1, rule_2|
           result = rule_1.call(ctx)

data/lib/ruy/conditions/condition.rb

@@ -0,0 +1,15 @@
+module Ruy
+  module Conditions
+
+    class Condition
+      include Ruy::DSL
+
+      attr_reader :params
+
+      def initialize(*params)
+        @params = params
+      end
+
+    end
+  end
+end

data/lib/ruy/conditions/day_of_week.rb

@@ -5,7 +5,7 @@ module Ruy
   module Conditions
 
     # Expects that a Time object's date corresponds to a specified day of the week.
-    class DayOfWeek < Ruy::Rule
+    class DayOfWeek < Condition
       DAYS_INTO_WEEK = %w(sunday monday tuesday wednesday thursday friday saturday)
       attr_reader :attr, :value, :tz_identifier
 

data/lib/ruy/conditions/eq.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute will be equal to a given value.
-    class Eq < Ruy::Rule
+    class Eq < Condition
       attr_reader :attr, :value
 
       # @param value Expected value

data/lib/ruy/conditions/except.rb

@@ -6,37 +6,22 @@ module Ruy
     # 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.
-    class Except < Ruy::Rule
-      attr_reader :attr, :value
+    class Except < CompoundCondition
 
       # @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

data/lib/ruy/conditions/greater_than.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute will be greater than the given value.
-    class GreaterThan < Ruy::Rule
+    class GreaterThan < Condition
       attr_reader :attr, :value
 
       # @param value
@@ -12,18 +12,16 @@ module Ruy
         super
         @value = value
         @attr = attr
-        instance_exec(&block) if block_given?
       end
 
       def call(var_ctx)
-        @value < var_ctx.resolve(@attr) && super
+        @value < var_ctx.resolve(@attr)
       end
 
       def ==(o)
         o.kind_of?(GreaterThan) &&
           attr == o.attr &&
-          value == o.value &&
-          self.conditions == o.conditions
+          value == o.value
       end
     end
   end

data/lib/ruy/conditions/greater_than_or_equal.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute will be greater than or equal to the given value.
-    class GreaterThanOrEqual < Ruy::Rule
+    class GreaterThanOrEqual < Condition
       attr_reader :attr, :value
 
       # @param value
@@ -12,18 +12,16 @@ module Ruy
         super
         @value = value
         @attr = attr
-        instance_exec(&block) if block_given?
       end
 
       def call(ctx)
-        @value <= ctx.resolve(@attr) && super
+        @value <= ctx.resolve(@attr)
       end
 
       def ==(o)
         o.kind_of?(GreaterThanOrEqual) &&
           attr == o.attr &&
-          value == o.value &&
-          self.conditions == o.conditions
+          value == o.value
       end
     end
   end

data/lib/ruy/conditions/in.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute is included in a set of values.
-    class In < Ruy::Rule
+    class In < Condition
       attr_reader :attr, :values
 
       # @param values Expected set of values
@@ -12,18 +12,16 @@ module Ruy
         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
+        self.values.include?(var_ctx.resolve(self.attr))
       end
 
       def ==(o)
         o.kind_of?(In) &&
           self.attr == o.attr &&
-          self.values == o.values &&
-          self.conditions == o.conditions
+          self.values == o.values
       end
     end
 

data/lib/ruy/conditions/in_cyclic_order.rb

@@ -1,6 +1,6 @@
 module Ruy
   module Conditions
-    class InCyclicOrder < Ruy::Rule
+    class InCyclicOrder < Condition
       attr_reader :from, :to, :attr
 
       def initialize(from, to, attr, &block)
@@ -8,16 +8,15 @@ module Ruy
         @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
+          (@from <= value || @to >= value)
         else
-          (@from <= value && @to >= value) && super
+          (@from <= value && @to >= value)
         end
       end
 
@@ -25,8 +24,7 @@ module Ruy
         o.kind_of?(self.class) &&
           @from == o.from &&
           @to   == o.to &&
-          @attr == o.attr &&
-          self.conditions == o.conditions
+          @attr == o.attr
       end
     end
   end

data/lib/ruy/conditions/include.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a value is included in a set of values from the context attribute.
-    class Include < Ruy::Rule
+    class Include < Condition
       attr_reader :attr, :value
 
       # @param value Expected set of values
@@ -12,18 +12,16 @@ module Ruy
         super
         @value = value
         @attr = attr
-        instance_exec(&block) if block_given?
       end
 
       def call(ctx)
-        ctx.resolve(self.attr).include?(self.value) && super
+        ctx.resolve(self.attr).include?(self.value)
       end
 
       def ==(o)
         o.kind_of?(Include) &&
           self.attr == o.attr &&
-          self.value == o.value &&
-          self.conditions == o.conditions
+          self.value == o.value
       end
     end
   end

data/lib/ruy/conditions/included.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a value is included in a set of values from the context attribute.
-    class Included < Ruy::Rule
+    class Included < Condition
       attr_reader :attr, :value
 
       # @param attr Context attribute's name
@@ -12,18 +12,16 @@ module Ruy
         super
         @attr = attr
         @value = value
-        instance_exec(&block) if block_given?
       end
 
       def call(ctx)
-        ctx.resolve(self.attr).include?(self.value) && super
+        ctx.resolve(self.attr).include?(self.value)
       end
 
       def ==(o)
         o.kind_of?(Included) &&
           self.attr == o.attr &&
-          self.value == o.value &&
-          self.conditions == o.conditions
+          self.value == o.value
       end
     end
   end

data/lib/ruy/conditions/less_than.rb

@@ -2,13 +2,12 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute will be less than given value.
-    class LessThan < Ruy::Rule
+    class LessThan < Condition
       attr_reader :attr, :value
 
       # @param value
       # @param attr Context attribute's name
       def initialize(value, attr)
-        super
         @value = value
         @attr = attr
       end

data/lib/ruy/conditions/less_than_or_equal.rb

@@ -2,7 +2,7 @@ module Ruy
   module Conditions
 
     # Expects that a context attribute will be less than or equal to the given value.
-    class LessThanOrEqual < Ruy::Rule
+    class LessThanOrEqual < Condition
       attr_reader :attr, :value
 
       # @param attr Context attribute's name

data/lib/ruy/conditions/tz.rb

@@ -6,7 +6,7 @@ module Ruy
     # @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
+    class TZ < CompoundCondition
       # @param [String] tz_identifier String representing IANA's time zone identifier.
       def initialize(tz_identifier)
         super
@@ -15,7 +15,7 @@ module Ruy
 
       # @param [Ruy::VariableContext] ctx
       def call(ctx)
-        @conditions.all? do |condition|
+        conditions.all? do |condition|
           condition.call(ctx)
         end
       end
@@ -24,7 +24,7 @@ module Ruy
       #
       # @param (see Ruy::Conditions::DayOfWeek#initialize)
       def day_of_week(dow, attr)
-        @conditions << DayOfWeek.new(dow, attr, @tz_identifier)
+        conditions << DayOfWeek.new(dow, attr, @tz_identifier)
       end
 
       # Intercepts an 'eq' call to the superclass and enhances its arguments

data/lib/ruy/dsl.rb

@@ -55,15 +55,15 @@ module Ruy
     # 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.
     #
     # @param (see Conditions::GreaterThanOrEqual#initialize)
     def greater_than(value, attr)
-      @conditions << Conditions::GreaterThan.new(value, attr)
+      self.conditions << Conditions::GreaterThan.new(value, attr)
     end
 
     # Adds a GreaterThanOrEqual condition.
@@ -84,7 +84,7 @@ module Ruy
     #
     # @param (see Conditions::InCyclicOrder#initialize)
     def in_cyclic_order(from, to, attr, &block)
-      @conditions << Conditions::InCyclicOrder.new(from, to, attr, &block)
+      self.conditions << Conditions::InCyclicOrder.new(from, to, attr, &block)
     end
 
     # Adds an Include condition.
@@ -107,7 +107,7 @@ module Ruy
     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
@@ -132,7 +132,7 @@ module Ruy
         s << ' ' << stringified_params.join(', ')
       end
 
-      if self.conditions.empty?
+      if !self.respond_to?(:conditions) || self.conditions.empty?
         s << "\n"
       else
         s << " do\n"

data/lib/ruy/outcome.rb

@@ -11,7 +11,7 @@ module Ruy
     # @param value The value of this outcome
     def initialize(value)
       @value = value
-      @rule = Ruy::Rule.new
+      @root_condition = Ruy::Conditions::All.new
     end
 
     # Returns the value of this outcome is all of the conditions succeed.
@@ -23,14 +23,14 @@ module Ruy
     # @return [Object]
     # @return [nil] If some of the conditions does not succeeds
     def call(ctx)
-      if @rule.call(ctx)
+      if @root_condition.call(ctx)
         @value
       end
     end
 
-    # @return [Array<Ruy::Rule>]
+    # @return [Array<Ruy::Condition>]
     def conditions
-      @rule.conditions
+      @root_condition.conditions
     end
 
     # @return [Array] An array containing the value of this outcome

data/lib/ruy/rule.rb

@@ -4,11 +4,14 @@ module Ruy
     include Utils::Printable
 
     attr_reader :conditions
+    attr_reader :outcomes
 
-    def initialize(*args)
+    def initialize
       @attrs = {}
       @conditions = []
-      @params = args
+      @fallback = nil
+      @lets = []
+      @outcomes = []
     end
 
     # Gets attribute's value from the given name.
@@ -28,28 +31,65 @@ module Ruy
       @attrs[name] = value
     end
 
-    # Evaluates all conditions.
+    # Evaluates rule conditions return the corresponding outcome or fallback depending on whether
+    # the conditions matched or not.
     #
-    # @return [true] When all conditions succeeds
-    # @return [false] Otherwise
-    def call(ctx)
-      success = @conditions.take_while do |condition|
-        condition.call(ctx)
-      end
+    # @param [Hash] context
+    #
+    # @return [Object] outcome or fallback
+    def call(context)
+      ctx = Context.new(context, @lets)
 
-      success.length == @conditions.length
+      if Ruy::Utils::Rules.evaluate_conditions(@conditions, ctx)
+        Ruy::Utils::Rules.compute_outcome(@outcomes, ctx)
+
+      else
+        @fallback
+      end
     end
 
-    def ==(o)
-      o.kind_of?(Rule) &&
-        conditions == o.conditions
+    # TODO document
+    def fallback(value)
+      @fallback = value
     end
 
-    # Getter method for rules params. It returns all the params without nil objects.
+    # Defines a memoized value.
     #
-    # @return [Array<Object>]
-    def params
-      @params.compact
+    # The value will be resolved upon the context during evaluation. Let is lazy evaluated, it is
+    # not evaluated until the first condition referencing it is invoked. Once evaluated, its value
+    # is stored, so subsequent invocations during the same evaluation will resolve again its value.
+    def let(name)
+      @lets << name
+    end
+
+    # TODO document
+    def outcome(value, &block)
+      outcome = Outcome.new(value)
+      outcome.instance_exec(&block) if block_given?
+      @outcomes << outcome
+    end
+
+    def to_s
+      s = @attrs.map { |name, value| "set #{name.inspect}, #{value.inspect}" }.join("\n")
+      s << "\n\n" if @attrs.any?
+
+      s << @lets.map { |name| "let #{name.inspect}" }.join("\n")
+      s << "\n\n" if @lets.any?
+
+      s << self.conditions.join("\n")
+
+      if @outcomes.any?
+        s << "\n" unless s == ''
+        s << @outcomes.join("\n")
+      end
+
+      if @fallback
+        s << "\n" unless s == ''
+        s << "fallback #{@fallback.inspect}\n"
+      end
+
+      s
     end
+
   end
 end

data/lib/ruy/utils.rb

@@ -1,2 +1,3 @@
 require_relative 'utils/naming'
 require_relative 'utils/printable'
+require_relative 'utils/rules'

data/lib/ruy/utils/rules.rb

@@ -0,0 +1,40 @@
+module Ruy
+  module Utils
+    module Rules
+
+      # Evaluates conditions against the given context
+      #
+      # Returns true when all the conditions match, false otherwise.
+      #
+      # @param [Array<Condition>] conditions
+      # @param [Hash] ctx
+      #
+      # @return [Boolean]
+      def self.evaluate_conditions(conditions, ctx)
+        succeed_conditions = conditions.take_while do |condition|
+          condition.call(ctx)
+        end
+
+        succeed_conditions.length == conditions.length
+      end
+
+      # Returns the value of the first outcome that matches
+      #
+      # @param [Ruy::Context] ctx
+      #
+      # @return [Object] The value of the first matching outcome
+      # @return [nil] when no outcome matches
+      def self.compute_outcome(outcomes, ctx)
+        outcomes.each do |outcome|
+          result = outcome.call(ctx)
+          unless result.nil?
+            return result
+          end
+        end
+
+        nil
+      end
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruy
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Moove-IT
@@ -67,7 +67,9 @@ files:
 - lib/ruy/conditions/any.rb
 - lib/ruy/conditions/assert.rb
 - lib/ruy/conditions/between.rb
+- lib/ruy/conditions/compound_condition.rb
 - lib/ruy/conditions/cond.rb
+- lib/ruy/conditions/condition.rb
 - lib/ruy/conditions/day_of_week.rb
 - lib/ruy/conditions/eq.rb
 - lib/ruy/conditions/except.rb
@@ -84,11 +86,11 @@ files:
 - lib/ruy/dsl.rb
 - lib/ruy/outcome.rb
 - lib/ruy/rule.rb
-- lib/ruy/rule_set.rb
 - lib/ruy/time_pattern.rb
 - lib/ruy/utils.rb
 - lib/ruy/utils/naming.rb
 - lib/ruy/utils/printable.rb
+- lib/ruy/utils/rules.rb
 homepage: http://moove-it.github.io/ruy/
 licenses:
 - MIT

data/lib/ruy/rule_set.rb

@@ -1,85 +0,0 @@
-module Ruy
-  class RuleSet
-    include DSL
-
-    attr_reader :lets
-    attr_reader :outcomes
-
-    def initialize
-      super
-
-      @lets = []
-      @outcomes = []
-
-      @fallback = nil
-
-      @rule = Ruy::Rule.new
-    end
-
-    def conditions
-      @rule.conditions
-    end
-
-    def outcome(value, &block)
-      outcome = Outcome.new(value)
-      outcome.instance_exec(&block) if block_given?
-      @outcomes << outcome
-    end
-
-    def fallback(value)
-      @fallback = value
-    end
-
-    # @param [Hash] context
-    def call(context)
-      ctx = Context.new(context, @lets)
-      if @rule.call(ctx)
-        compute_outcome(ctx)
-      else
-        @fallback
-      end
-    end
-
-    def compute_outcome(ctx)
-      @outcomes.each do |outcome|
-        result = outcome.call(ctx)
-        unless result.nil?
-          return result
-        end
-      end
-
-      nil
-    end
-
-    # Defines a memoized value.
-    #
-    # The value will be resolved upon the context during evaluation. Let is lazy evaluated, it is
-    # not evaluated until the first condition referencing it is invoked. Once evaluated, it's value
-    # is stored, so subsequent invocations during the same evaluation will resolve again its value.
-    def let(name)
-      @lets << name
-    end
-
-    def to_s
-      s = lets.map { |name| "let #{name.inspect}" }.join("\n")
-
-      s << "\n\n" unless s == ''
-
-      s << self.conditions.join("\n")
-
-      if @outcomes.any?
-        s << "\n" unless s == ''
-        s << @outcomes.join("\n")
-      end
-
-      if @fallback
-        s << "\n" unless s == ''
-        s << "fallback #{@fallback.inspect}\n"
-      end
-
-      s
-    end
-
-  end
-
-end