rudelo 0.2.3 → 0.2.4

data/Gemfile

@@ -7,5 +7,6 @@ gem 'rufus-decision', git: 'https://github.com/jmettraux/rufus-decision.git'
 # gem 'rufus-decision', git: 'https://github.com/lastobelus/rufus-decision.git', branch: 'short_circuit_matchers'
 
 group :development do
+  gem 'listen'
   gem "guard-rspec"
 end

data/README.md

@@ -57,10 +57,11 @@ For a detailed description of the mini-language the set logic matcher uses, see
 
 ## Short-Circuiting
 
-The current released version of rufus-decision does not provide for matchers to shortcircuit. This can cause errors if you have a SetLogic matcher followed by a String matcher. I have a branch of rufus-decision that does short-circuiting that is pending review, if you need to use it add this to your Gemfile:
+By default, Set Logic matchers short-circuit. That is to-say, if a cell does not match, the set logic matcher tells rufus-decision not to try any more matchers if the cell was valid set logic syntax. You can change this behaviour by setting ```matcher.short_circuit = false```
 
-```gem 'rufus-decision', git: 'https://github.com/lastobelus/rufus-decision.git', branch: 'short_circuit_matchers'
-```
+## Force Parsing
+
+By default Set Logic matchers return false for ```matches?``` if they cannot parse a cell. Set ```matcher.force = true``` to force parsing and raise errors if a cell cannot be parsed.
 
 ## Contributing
 

data/SET_LOGIC_MATCHER.md

@@ -1,3 +1,5 @@
+* NOTE: optional space delimiter was removed *
+
 # Set Logic Matcher
 
 The SetLogic matcher allows a decision table cell to match based on set logic between the decision table and the corresponding entry in the hash being transformed.
@@ -9,13 +11,13 @@ When a decision table cell contains a set expression, the corresponding value in
 
         $(bob, mary)       => Set["bob", "mary"]
         $(bob mary, jeff)  => Set["bob mary", "jeff"]
-        $('bob rob', jeff) => Set["bob rob", "jeff"]
+        $(bob rob, jeff) => Set["bob rob", "jeff"]
         ${r: ruby_code}    => eval ruby code, ignoring unless it returns a set
         ${other_column}    => apply set conversion to other_column
         $(${c1}, ${c2})    => Set["c1 contents", "c2 contents"]
         bob, mary          => Set["bob", "mary"]
         bob mary           => Set["bob mary"]
-        'bob, mary', jeff  => Set["bob, mary", "jeff"]
+        "bob, mary", jeff  => Set["bob, mary", "jeff"]
 
 ## Decision Table Cell Syntax
 
@@ -87,7 +89,7 @@ Set expressions can use the following operators:
 
 ## Examples
 
-        $(bob jeff mary) & $in #= 2
+        $(bob, jeff, mary) & $in #= 2
         => does not match (bob, jeff, mary)
         => matches (bob, mary) or (jeff, mary) etc.
         => does not match (bob) or (jeff) or (mary)

data/lib/rudelo/matchers/set_logic.rb

@@ -29,17 +29,31 @@ module Rudelo
   module Matchers
     class SetLogic < Rufus::Decision::Matcher
       SYNTAX_EXPR = %r{\$\([^)]*\)|\$in}
+
+      # if true, will raise if a cell is not valid set logic syntax
       attr_accessor :force
+      attr_writer :short_circuit
+
+      def short_circuit
+        defined?(@short_circuit) ? @short_circuit : true
+      end
+
+      def return_on_cant_match
+        short_circuit ? :break : false
+      end
 
-      def should_match?(cell, value)
+      def can_match?(cell)
         ! (cell =~ SYNTAX_EXPR).nil?
       end
 
       def matches?(cell, value)
+        puts "\n matches? `#{cell}` => `#{value}`"
+        return false unless force || can_match?(cell)
         evaluator = ast(cell)
-        return false if evaluator.nil?
+        return return_on_cant_match if evaluator.nil?
         in_set = value_transform.apply(value_parser.parse(value)) unless in_set.is_a?(Set)
-        ast(cell).eval(in_set)
+        result = evaluator.eval(in_set)
+        return result ? true : return_on_cant_match
       end
 
       def cell_substitution?

data/lib/rudelo/parsers/set_value_parser.rb

@@ -32,7 +32,7 @@ module Rudelo
       rule(:close_set)         { str(')') }
 
       rule(:unquoted_element)      { 
-         (close_set.absent? >> space.absent? >> comma.absent? >> any).
+         (close_set.absent? >> comma.absent? >> any).
         repeat(1).as(:element) }
       rule(:quoted_element)    { 
         (quote >> 
@@ -40,7 +40,7 @@ module Rudelo
         as(:element) >> 
         quote)}
       rule(:element)           { quoted_element | unquoted_element }
-      rule(:element_delimiter)    { (comma | space) >> space? }
+      rule(:element_delimiter)    { (comma) >> space? }
 
 
       rule(:bare_element_list) { 

data/lib/rudelo/version.rb

@@ -1,3 +1,3 @@
 module Rudelo
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/spec/matchers/set_logic_spec.rb

@@ -13,53 +13,53 @@ describe "Rudelo::Matchers::SetLogic" do
   end
 
   it "matches multiple values against multiple cells correctly" do
-    cell1 = "$in same-as $(a b c)"
-    cell2 = "$in same-as $(k f r)"
-    expect(subject.matches?(cell1, 'a b c')).to be_true
-    expect(subject.matches?(cell2, 'a b c')).to be_false
-    expect(subject.matches?(cell1, 'k f r')).to be_false
-    expect(subject.matches?(cell2, 'k f r')).to be_true
-    expect(subject.matches?(cell1, 'a b c')).to be_true
-    expect(subject.matches?(cell2, 'a b c')).to be_false
+    cell1 = "$in same-as $(a, b, c)"
+    cell2 = "$in same-as $(k, f, r)"
+    expect(subject.matches?(cell1, 'a,b,c')).to be_true
+    expect(subject.matches?(cell2, 'a,b,c')).to eq(:break)
+    expect(subject.matches?(cell1, 'k,f,r')).to eq(:break)
+    expect(subject.matches?(cell2, 'k,f,r')).to be_true
+    expect(subject.matches?(cell1, 'a,b,c')).to be_true
+    expect(subject.matches?(cell2, 'a,b,c')).to eq(:break)
   end
 
   context "rufus-decision" do
     let(:table){
       table = Rufus::Decision::Table.new(%{
-        in:group, out:situation
-        $(bob jeff mary alice ralph) & $in #= 2, company
-        $(bob jeff mary alice ralph) & $in same-as $in #= 3, crowd
-        $(bob jeff mary alice ralph) >= $in #> 3, exclusive-party
-        $(bob jeff mary alice ralph) & $in < $in #> 5, PARTY!
-        $(bob jeff mary alice ralph) & $in < $in #> 3, party
+in:group, out:situation
+"$(bob, jeff, mary, alice, ralph) & $in #= 2", company
+"$(bob, jeff, mary, alice, ralph) & $in same-as $in #= 3", crowd
+"$(bob, jeff, mary, alice, ralph) >= $in #> 3", exclusive-party
+"$(bob, jeff, mary, alice, ralph) & $in < $in #> 5", PARTY!
+"$(bob, jeff, mary, alice, ralph) & $in < $in #> 3", party
       })
       table.matchers.unshift Rudelo::Matchers::SetLogic.new
       table
     }
     it "transforms values" do
       expect(
-        table.transform({'group' =>  "bob alice"})
-      ).to eq({'group' => "bob alice", 'situation' => "company"})
+        table.transform({'group' =>  "bob, alice"})
+      ).to eq({'group' => "bob, alice", 'situation' => "company"})
 
       expect(
-        table.transform({'group' => "bob alice jeff"})
-      ).to eq({'group' => "bob alice jeff", 'situation' => "crowd"})
+        table.transform({'group' => "bob, alice, jeff"})
+      ).to eq({'group' => "bob, alice, jeff", 'situation' => "crowd"})
 
       expect(
-        table.transform({'group' => "bob alice jeff ralph"})
-      ).to eq({'group' => "bob alice jeff ralph", 'situation' => "exclusive-party"})
+        table.transform({'group' => "bob, alice, jeff, ralph"})
+      ).to eq({'group' => "bob, alice, jeff, ralph", 'situation' => "exclusive-party"})
 
       expect(
-        table.transform({'group' => "bob alice jeff don"})
-      ).to eq({'group' => "bob alice jeff don", 'situation' => "party"})
+        table.transform({'group' => "bob, alice, jeff, don"})
+      ).to eq({'group' => "bob, alice, jeff, don", 'situation' => "party"})
 
       expect(
-        table.transform({'group' => "bob alice jeff mary ralph don"})
-      ).to eq({'group' => "bob alice jeff mary ralph don", 'situation' => "PARTY!"})
+        table.transform({'group' => "bob, alice, jeff, mary, ralph, don"})
+      ).to eq({'group' => "bob, alice, jeff, mary, ralph, don", 'situation' => "PARTY!"})
 
       expect(
-        table.transform({'group' => "bob alice jeff mary don bev"})
-      ).to eq({'group' => "bob alice jeff mary don bev", 'situation' => "PARTY!"})
+        table.transform({'group' => "bob, alice, jeff, mary, don, bev"})
+      ).to eq({'group' => "bob, alice, jeff, mary, don, bev", 'situation' => "PARTY!"})
     end
   end
 

data/spec/parsers/set_logic_parser_spec.rb

@@ -31,7 +31,7 @@ describe "Rudelo::Parsers::SetLogicParser" do
 
     it "parses set construction to an iterative operation list" do
 
-      expect(expr_parser).to    parse('$(bob mary) union $(ralph jeff) & $in', trace: true).as({
+      expect(expr_parser).to    parse('$(bob, mary) union $(ralph, jeff) & $in', trace: true).as({
         :set_construction_expression=>{
           :left=>{:element_list=>[{:element=>"bob"}, {:element=>"mary"}] },
           :right=>[
@@ -68,7 +68,7 @@ describe "Rudelo::Parsers::SetLogicParser" do
     let(:expr_parser){ parser.set_logic_expression }
 
     it "parses set logic to a left-right tree" do
-      expect(expr_parser).to    parse('$(bob mary) < $(ralph jeff bob mary)', trace: true).as({
+      expect(expr_parser).to    parse('$(bob, mary) < $(ralph, jeff, bob, mary)', trace: true).as({
         :set_logic_expression=>{
           :left=>{:element_list=>[
             {:element=>"bob"}, {:element=>"mary"}] },
@@ -80,7 +80,7 @@ describe "Rudelo::Parsers::SetLogicParser" do
     end
 
     it "parses the left hand side as a set construction expression" do
-      expect(expr_parser).to    parse('$(bob mary) union $in < $(ralph jeff bob mary)', trace: true).as({
+      expect(expr_parser).to    parse('$(bob, mary) union $in < $(ralph, jeff, bob, mary)', trace: true).as({
         :set_logic_expression=>{
           :left=> {
             :set_construction_expression=>{
@@ -98,17 +98,17 @@ describe "Rudelo::Parsers::SetLogicParser" do
     end
 
     it "parses set logic ops in symbol form" do
-      expect(expr_parser).to    parse('$(bob mary) < $in', trace: true)
-      expect(expr_parser).to    parse('$(bob mary) <= $in', trace: true)
-      expect(expr_parser).to    parse('$(bob mary)>$in', trace: true)
-      expect(expr_parser).to    parse('$(bob mary) >= $in', trace: true)
+      expect(expr_parser).to    parse('$(bob, mary) < $in', trace: true)
+      expect(expr_parser).to    parse('$(bob, mary) <= $in', trace: true)
+      expect(expr_parser).to    parse('$(bob, mary)>$in', trace: true)
+      expect(expr_parser).to    parse('$(bob, mary) >= $in', trace: true)
     end
 
     it "parses set logic ops in word form" do
-      expect(expr_parser).to    parse('$in superset $(bob mary)', trace: true)
-      expect(expr_parser).to    parse('$in subset $(bob mary)', trace: true)
-      expect(expr_parser).to    parse('$in proper-superset $(bob mary)', trace: true)
-      expect(expr_parser).to    parse('$in proper-subset $(bob mary)', trace: true)
+      expect(expr_parser).to    parse('$in superset $(bob, mary)', trace: true)
+      expect(expr_parser).to    parse('$in subset $(bob, mary)', trace: true)
+      expect(expr_parser).to    parse('$in proper-superset $(bob, mary)', trace: true)
+      expect(expr_parser).to    parse('$in proper-subset $(bob, mary)', trace: true)
     end
 
   end

data/spec/parsers/set_logic_transform_spec.rb

@@ -152,7 +152,7 @@ describe "Rudelo::Parsers::SetLogicTransform" do
 
       end
       context "with cardinality" do
-        let(:expr){ "$(k z v) > $in #= 2" }
+        let(:expr){ "$(k, z, v) > $in #= 2" }
         it "transforms logic expression as match_expression.left" do
           expect(subject.left).to be_a_kind_of(
           Rudelo::Parsers::SetLogicTransform::SetLogicExpr)
@@ -166,7 +166,7 @@ describe "Rudelo::Parsers::SetLogicTransform" do
 
     context "construction expression" do
       context "alone" do
-        let(:expr){ "$(k z v) + $in" }
+        let(:expr){ "$(k, z, v) + $in" }
         it "transforms construction expression as match_expression.left" do
           expect(subject.left).to be_a_kind_of(
           Rudelo::Parsers::SetLogicTransform::SetConstructionExpr)
@@ -178,7 +178,7 @@ describe "Rudelo::Parsers::SetLogicTransform" do
 
       end
       context "with cardinality" do
-        let(:expr){ "$(k z v) + $in #= 2" }
+        let(:expr){ "$(k, z, v) + $in #= 2" }
         it "transforms construction expression as match_expression.left" do
           expect(subject.left).to be_a_kind_of(
           Rudelo::Parsers::SetLogicTransform::SetConstructionExpr)
@@ -201,11 +201,11 @@ describe "Rudelo::Parsers::SetLogicTransform" do
 
   context "cardinality examples" do
     specify{ expect(matching(
-     '#= 2', in_set: %w{a b})).to be_true }
+     '#= 2', in_set: %w{a, b})).to be_true }
     specify{ expect(matching(
-     '#< 3', in_set: %w{a b})).to be_true }
+     '#< 3', in_set: %w{a, b})).to be_true }
     specify{ expect(matching(
-     '#> 1', in_set: %w{a b})).to be_true }
+     '#> 1', in_set: %w{a, b})).to be_true }
     specify{ expect(matching(
      '#= 3', in_set: %w{a b})).to be_false }
     specify{ expect(matching(
@@ -216,42 +216,42 @@ describe "Rudelo::Parsers::SetLogicTransform" do
 
   context "construction examples" do
     specify{ expect(matching(
-     '$(a b c) & $in #= 2', in_set: %w{a b d})).to be_true }
+     '$(a, b, c) & $in #= 2', in_set: %w{a b d})).to be_true }
     specify{ expect(matching(
-     '$(a b c) & $in', in_set: %w{a b d})).to be_true }
+     '$(a, b, c) & $in', in_set: %w{a b d})).to be_true }
     specify{ expect(matching(
-     '$(a b c) & $in', in_set: %w{d e f})).to be_false }
+     '$(a, b, c) & $in', in_set: %w{d e f})).to be_false }
     specify{ expect(matching(
-     '$(a b c) & $in #= 2', in_set: %w{a k d})).to be_false }
+     '$(a, b, c) & $in #= 2', in_set: %w{a k d})).to be_false }
     specify{ expect(matching(
-     '$(a b c) + $in + $(e) #= 5', in_set: %w{b c d})).to be_true }
+     '$(a, b, c) + $in + $(e) #= 5', in_set: %w{b c d})).to be_true }
   end
 
   context "explicit set examples" do
     specify{ expect(matching(
-     '$(a b c)', in_set: %w{a b})).to be_true }
+     '$(a, b, c)', in_set: %w{a b})).to be_true }
     specify{ expect(matching(
-     '$(a b c)', in_set: %w{a k d})).to be_false }
+     '$(a, b, c)', in_set: %w{a k d})).to be_false }
   end
 
   context "logic examples" do
     specify{ expect(matching(
-     '$(a b c) > $in', in_set: %w{a b})).to be_true }
+     '$(a, b, c) > $in', in_set: %w{a b})).to be_true }
     specify{ expect(matching(
-     '$(a b c) > $in #=2', in_set: %w{a b})).to be_true }
+     '$(a, b, c) > $in #=2', in_set: %w{a b})).to be_true }
     specify{ expect(matching(
-     '$(a b c) > $in #=1', in_set: %w{a})).to be_true }
+     '$(a, b, c) > $in #=1', in_set: %w{a})).to be_true }
     specify{ expect(matching(
-     '$(a b c) ^ $in < $(a d k f)', in_set: %w{b c d})).to be_true }
+     '$(a, b, c) ^ $in < $(a, d, k, f)', in_set: %w{b c d})).to be_true }
     specify{ expect(matching(
-     '$(a b c) ^ $in < $(a e k f)', in_set: %w{b c d})).to be_false }
+     '$(a, b, c) ^ $in < $(a, e, k, f)', in_set: %w{b c d})).to be_false }
   end
 
   context "using transform with multiple in-set values" do
     it "allows re-using a transform" do
       abc = Set.new(%w{a b c})
       efg = Set.new(%w{e f g})
-      expr = '$in same-as $(a b c)'
+      expr = '$in same-as $(a, b, c)'
 
       transform = Rudelo::Parsers::SetLogicTransform.new(abc)
       ast = transform.apply(parser.parse(expr))

data/spec/parsers/set_value_parser_spec.rb

@@ -27,16 +27,13 @@ describe "Rudelo::Parsers::SetValueParser" do
       })
 
       expect(parser).to  parse(%Q{bob mary}, trace: true).as({
-        element_list: [
-          {element: "bob"},
-          {element: "mary"}
-        ]
+        element_list: 
+          {element: "bob mary"}
       })
 
       expect(parser).to  parse(%Q{bob    mary, ralph}, trace: true).as({
         element_list: [
-          {element: "bob"},
-          {element: "mary"},
+          {element: "bob    mary"},
           {element: "ralph"}
         ]
       })
@@ -78,8 +75,7 @@ describe "Rudelo::Parsers::SetValueParser" do
       expect(parser).to  parse(%Q{$("bob", mary jeff)}, trace: true).as({
         element_list: [
           {element: "bob"},
-          {element: "mary"},
-          {element: "jeff"},          
+          {element: "mary jeff"},          
         ]
       })
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rudelo
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-22 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rufus-decision
@@ -136,7 +136,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3209606744768379856
+      hash: -283585303558073235
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3209606744768379856
+      hash: -283585303558073235
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25