rudelo 0.1.0

data/spec/matchers/set_logic_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../spec_helper'
+
+require 'rudelo'
+require 'rufus-decision'
+describe "Rudelo::Matchers::SetLogic" do
+  subject{Rudelo::Matchers::SetLogic.new}
+
+  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
+  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
+      })
+      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"})
+
+      expect(
+        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"})
+
+      expect(
+        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!"})
+
+      expect(
+        table.transform({'group' => "bob alice jeff mary don bev"})
+      ).to eq({'group' => "bob alice jeff mary don bev", 'situation' => "PARTY!"})
+    end
+  end
+
+end

data/spec/parsers/set_logic_parser_spec.rb

@@ -0,0 +1,147 @@
+require_relative '../spec_helper'
+require 'pp'
+
+require 'rudelo/parsers/set_logic_parser'
+
+describe "Rudelo::Parsers::SetLogicParser" do
+  let(:parser) { Rudelo::Parsers::SetLogicParser.new }
+
+  context "cardinality_expression" do
+    let(:expr_parser){ parser.cardinality_expression }
+
+    it "parses cardinality (symbols)" do
+      expect(expr_parser).to    parse('#= 5', trace: true).as({
+        :cardinality_expression=>{ :op=>'#=', :qty=>"5"}
+      })
+      expect(expr_parser).to    parse('#> 5', trace: true)
+      expect(expr_parser).to    parse('#< 4', trace: true)
+    end
+
+    it "parses cardinality (words)" do
+      expect(expr_parser).to    parse('cardinality-equals 5', trace: true).as({
+        :cardinality_expression=>{ :op=>'cardinality-equals', :qty=>"5"}
+      })
+      expect(expr_parser).to    parse('cardinality-greater-than 5', trace: true)
+      expect(expr_parser).to    parse('cardinality-less-than 4', trace: true)
+    end
+  end
+
+  context "set construction expression" do
+    let(:expr_parser){ parser.set_construction_expression }
+
+    it "parses set construction to an iterative operation list" do
+
+      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=>[
+            { set_op: {
+              left: {op: "union"},
+              right: {element_list:[
+                {:element=>"ralph"}, {:element=>"jeff"}
+                ]}
+              }},
+            { set_op: {
+            left: {op: "&"},
+            right: {:in_set=>"$in"}}}
+          ]
+        }
+      })
+    end
+    it "parses set construction 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)
+    end
+
+    it "parses set construction ops in word form" do
+      expect(expr_parser).to    parse('$in intersection $(bob mary)', trace: true)
+      expect(expr_parser).to    parse('$in union $(bob mary)', trace: true)
+      expect(expr_parser).to    parse('$in difference $(bob mary)', trace: true)
+      expect(expr_parser).to    parse('$in exclusive $(bob mary)', trace: true)
+    end
+
+  end
+
+  context "set logic expression" 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({
+        :set_logic_expression=>{
+          :left=>{:element_list=>[
+            {:element=>"bob"}, {:element=>"mary"}] },
+          :op => "<",
+          :right=>{:element_list=>[
+            {:element=>"ralph"}, {:element=>"jeff"}, {:element=>"bob"}, {:element=>"mary"}]}
+        }
+      })
+    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({
+        :set_logic_expression=>{
+          :left=> {
+            :set_construction_expression=>{
+              :left=>{
+                :element_list=>[{:element=>"bob"}, {:element=>"mary"}]
+              },
+              :right=>[{set_op: { left: {:op=>"union"}, right: {:in_set=>"$in"}}}]
+            }
+          },
+          :op => "<",
+          :right=>{:element_list=>[
+            {:element=>"ralph"}, {:element=>"jeff"}, {:element=>"bob"}, {:element=>"mary"}]}
+        }
+      })
+    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)
+    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)
+    end
+
+  end
+
+  context "set logic expression" do
+    let(:expr_parser){ parser.match_expression }
+    it "parses a bare cardinality expression" do
+      expect(expr_parser).to    parse('#= 5', trace: true).as({
+        match_expression: {
+          right: {
+            cardinality_expression: {op: "#=", qty: "5"}
+          }
+        }
+      })
+    end
+
+    it "parses an explicit set expression" do
+      expect(expr_parser).to    parse('$(bob, jeff)', trace: true).as({
+        superset_match_expression: {
+          element_list: [{element: "bob"}, {element: "jeff"}]
+        }
+      })
+    end
+
+    it "parses a set construction expression with optional cardinality" do
+      expect(expr_parser).to    parse('$(bob, jeff) + $in', trace: true)
+      expect(expr_parser).to    parse('$(bob, jeff) + $in #> 3', trace: true)
+    end
+
+    it "parses a set logic expression with optional cardinality" do
+      expect(expr_parser).to    parse('$(bob, jeff) <= $in', trace: true)
+      expect(expr_parser).to    parse('$(bob, jeff) <= $in #> 3', trace: true)
+    end
+
+  end
+end

data/spec/parsers/set_logic_transform_spec.rb

@@ -0,0 +1,269 @@
+require_relative '../spec_helper'
+
+require 'rudelo/parsers/set_logic_parser'
+require 'rudelo/parsers/set_logic_transform'
+
+describe "Rudelo::Parsers::SetLogicTransform" do
+  let(:parser) { Rudelo::Parsers::SetLogicParser.new }
+  let(:in_set){ Set.new(%w{a b c}) }
+  let(:xform) { Rudelo::Parsers::SetLogicTransform.new(in_set) }
+  let(:empty_set) { Set.new }
+
+  context "ops" do
+    specify{expect(xform.apply(:op => "+")).to eq(:"+")}
+    specify{expect(xform.apply(:op => "#=")).to eq(:"==")}
+    specify{expect(xform.apply(:op => "cardinality-equals")).to eq(:"==")}
+    specify{expect(xform.apply(:op => "#>")).to eq(:>)}
+    specify{expect(xform.apply(:op => "cardinality-greater-than")).to eq(:>)}
+    specify{expect(xform.apply(:op => "proper-superset")).to eq(:proper_superset?)}
+
+  end
+
+  context "CardinalityExpr" do
+    subject{ Rudelo::Parsers::SetLogicTransform::CardinalityExpr }
+    let(:set){ Set.new(%w{a b c}) }
+    specify{ expect(subject.new(:>, 2).eval(set)).to be_true }
+    specify{ expect(subject.new(:<, 2).eval(set)).to be_false }
+    specify{ expect(subject.new(:==, 2).eval(set)).to be_false }
+    specify{ expect(subject.new(:==, 3).eval(set)).to be_true }
+  end
+
+  context "SetLogicExpr" do
+    subject{ Rudelo::Parsers::SetLogicTransform::SetLogicExpr }
+    let(:set1){ Set.new(%w{a b c}) }
+    let(:set2){ Set.new(%w{b c}) }
+    let(:set3){ Set.new(%w{b c d}) }
+    specify{ expect(
+      subject.new(set1, :proper_superset?, set2).eval
+    ).to be_true }
+    specify{ expect(subject.new(set1, :proper_subset?, set2).eval).to be_false }
+    specify{ expect(subject.new(set3, :proper_subset?, set1).eval).to be_false }
+    specify{ expect(subject.new(set1, :==, set1).eval).to be_true }
+  end
+
+  context "SetOp" do
+    subject{ Rudelo::Parsers::SetLogicTransform::SetOp }
+    let(:set1){ Set.new(%w{a b c}) }
+    let(:set2){ Set.new(%w{b c}) }
+    let(:set3){ Set.new(%w{b c d}) }
+    let(:set4){ Set.new(%w{a b c d}) }
+    let(:set5){ Set.new(%w{a}) }
+    specify{ expect(
+      subject.new(:+, set1).eval(set3)
+    ).to eq(set4) }
+    specify{ expect(
+      subject.new(:-, set3).eval(set4)
+    ).to eq(set5) }
+    specify{ expect(
+      subject.new(:-, set4).eval(set3)
+    ).to eq(empty_set) }
+  end
+
+  context "SetOp" do
+    subject{ Rudelo::Parsers::SetLogicTransform::EmptyExpr.new }
+    specify{ expect(subject.eval).to be_true }
+    specify{ expect(subject.eval(false)).to be_true }
+  end
+
+  context "Set#eval" do
+    let(:set1){ Set.new(%w{a b c}) }
+    specify{ expect(empty_set.eval).to eq(empty_set) }
+    specify{ expect(set1.eval).to eq(set1) }
+  end
+
+  context "MatchExpr" do
+    subject{ Rudelo::Parsers::SetLogicTransform::MatchExpr }
+    before do
+      @scon_full = mock('SetConstructionExpr')
+      @scon_full.stub(:eval).and_return(Set.new['a'])
+      @scon_empty = mock('SetConstructionExpr')
+      @scon_empty.stub(:eval).and_return(Set.new)
+
+      @slog_true = mock('SetLogicExpr')
+      @slog_true.stub(:eval).and_return(true)
+      @slog_true.stub(:set).and_return(Set.new['a'])
+
+      @slog_false = mock('SetLogicExpr')
+      @slog_false.stub(:eval).and_return(false)
+      @slog_false.stub(:set).and_return(Set.new)
+
+      @scar_one = CardinalityExpr.new(:==, 1)
+      @scar_two = CardinalityExpr.new(:==, 2)
+    end
+
+    context "when right is empty" do
+      context "when left is SetConstructionExpr" do
+        it "returns true if the result size is > 0"
+        it "returns false if the result size is < 1"
+      end
+      context "when left is SetLogicExpr" do
+        it "returns true if the result is true"
+        it "returns true if the result is false"
+      end
+    end
+    context "when right is CardinalityExpr" do
+      context "when left is SetConstructionExpr" do
+        it "runs cardinality expression on left result"
+      end
+      context "when left is SetLogicExpr" do
+        it "runs cardinality expression on left set"
+      end
+    end
+
+  end
+
+  context "match expressions" do
+    subject{ xform.apply(parser.parse(expr)) }
+    context "cardinality expressions alone" do
+      let(:set){ Set.new(%w{a b c}) }
+      let(:expr){ "#> 2" }
+      it "should transform cardinality_expressions as match_expression.right" do
+        expect(subject.right).to be_a_kind_of(
+        Rudelo::Parsers::SetLogicTransform::CardinalityExpr)
+      end
+      it "should set match_expression.left to in_set" do
+        expect(subject.left).to eq(in_set)
+      end
+
+      it "should eval correctly" do
+        expect(subject.right.eval(set)
+        ).to be_true
+        expect(subject.eval).to be_true
+
+        expect(
+          xform.apply(
+            parser.parse("#< 2")
+          ).right.eval(set)
+        ).to be_false
+      end
+    end
+
+    context "logic expression" do
+      context "alone" do
+        let(:expr){ "$(k z v) > $in" }
+        it "transforms logic expression as match_expression.left" do
+          expect(subject.left).to be_a_kind_of(
+          Rudelo::Parsers::SetLogicTransform::SetLogicExpr)
+        end
+        it "should set match_expression.right to nil" do
+          expect(subject.right).to be_a_kind_of(
+            Rudelo::Parsers::SetLogicTransform::EmptyExpr)
+        end
+
+      end
+      context "with cardinality" do
+        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)
+        end
+        it "should set match_expression.right to nil" do
+          expect(subject.right).to be_a_kind_of(
+          Rudelo::Parsers::SetLogicTransform::CardinalityExpr)
+        end
+      end
+    end
+
+    context "construction expression" do
+      context "alone" do
+        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)
+        end
+        it "should set match_expression.right to nil expr" do
+          expect(subject.right).to be_a_kind_of(
+          Rudelo::Parsers::SetLogicTransform::EmptyExpr)
+        end
+
+      end
+      context "with cardinality" do
+        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)
+        end
+        it "should set match_expression.right to nil" do
+          expect(subject.right).to be_a_kind_of(
+          Rudelo::Parsers::SetLogicTransform::CardinalityExpr)
+        end
+
+      end
+    end
+  end
+
+  def matching(expr, opts)
+    in_set = Set.new(opts[:in_set])
+    Rudelo::Parsers::SetLogicTransform.new(in_set).apply(
+      Rudelo::Parsers::SetLogicParser.new.parse(expr)
+    ).eval
+  end
+
+  context "cardinality examples" do
+    specify{ expect(matching(
+     '#= 2', in_set: %w{a b})).to be_true }
+    specify{ expect(matching(
+     '#< 3', in_set: %w{a b})).to be_true }
+    specify{ expect(matching(
+     '#> 1', in_set: %w{a b})).to be_true }
+    specify{ expect(matching(
+     '#= 3', in_set: %w{a b})).to be_false }
+    specify{ expect(matching(
+     '#> 3', in_set: %w{a b})).to be_false }
+    specify{ expect(matching(
+     '#< 1', in_set: %w{a b})).to be_false }
+  end
+
+  context "construction examples" do
+    specify{ expect(matching(
+     '$(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 }
+    specify{ expect(matching(
+     '$(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 }
+    specify{ expect(matching(
+     '$(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 }
+    specify{ expect(matching(
+     '$(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 }
+    specify{ expect(matching(
+     '$(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 }
+    specify{ expect(matching(
+     '$(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 }
+  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)'
+
+      transform = Rudelo::Parsers::SetLogicTransform.new(abc)
+      ast = transform.apply(parser.parse(expr))
+
+      expect(ast.eval).to be_true
+
+      expect(ast.eval(efg)).to be_false
+
+      expect(ast.eval(abc)).to be_true
+    end
+
+  end
+
+end
+

data/spec/parsers/set_value_parser_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../spec_helper'
+
+require 'rudelo/parsers/set_value_parser'
+
+describe "Rudelo::Parsers::SetValueParser" do
+  let(:parser) { Rudelo::Parsers::SetValueParser.new }
+  context "set parsing" do
+    it "parses bare sets" do
+      expect(parser).to  parse(%Q{bob, mary}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"}
+        ]
+      })
+      expect(parser).to  parse(%Q{bob}, trace: true).as({
+        element_list: 
+          {element: "bob"}
+        
+      })
+
+      expect(parser).to  parse(%Q{bob, mary, jeff}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"},
+          {element: "jeff"}
+        ]
+      })
+
+      expect(parser).to  parse(%Q{bob mary}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"}
+        ]
+      })
+
+      expect(parser).to  parse(%Q{bob    mary, ralph}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"},
+          {element: "ralph"}
+        ]
+      })
+
+      expect(parser).to  parse(%Q{"bob    mary", ralph}, trace: true).as({
+        element_list: [
+          {element: "bob    mary"},
+          {element: "ralph"}
+        ]
+      })
+
+      expect(parser).to  parse(%Q{"bob, mary", ralph}, trace: true).as({
+        element_list: [
+          {element: "bob, mary"},
+          {element: "ralph"}
+        ]
+      })
+    end
+
+    it "parses explicit sets" do
+      expect(parser).to  parse(%Q{$(bob, mary)}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"}
+        ]
+      })
+      expect(parser).to  parse(%Q{$("bob", mary)}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"}
+        ]
+      })
+      expect(parser).to  parse(%Q{$("bob)dad", mary)}, trace: true).as({
+        element_list: [
+          {element: "bob)dad"},
+          {element: "mary"}
+        ]
+      })
+      expect(parser).to  parse(%Q{$("bob", mary jeff)}, trace: true).as({
+        element_list: [
+          {element: "bob"},
+          {element: "mary"},
+          {element: "jeff"},          
+        ]
+      })
+
+    end
+
+  end
+end

data/spec/parsers/set_value_transform_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+require 'rudelo/parsers/set_value_parser'
+require 'rudelo/parsers/set_value_transform'
+
+describe "Rudelo::Parsers::SetValueTransform" do
+  let(:parser) { Rudelo::Parsers::SetValueParser.new }
+  let(:xform) { Rudelo::Parsers::SetValueTransform.new }
+
+  it "transforms an element to a string" do
+    expect(xform.apply(:element => "bob")).to eq("bob")
+  end
+
+  it "transforms a set to a Set" do
+    expect(xform.apply({:element_list=>[{:element=>"bob"}, {:element=>"mary"}]})).to eq(Set['mary', 'bob'])
+  end
+
+  it "works on a single element" do
+    expect(xform.apply(parser.parse('bob'))).to eq(Set['bob'])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rudelo'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.order = 'random'
+
+end
+
+require "parslet"
+require "parslet/rig/rspec"