predicated 0.1.0 → 0.2.0

data/test/from/{url_fragment_parser_test.rb → url_part_parser_test.rb}

@@ -1,21 +1,21 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/predicate"
-require "predicated/from/url_fragment"
+require "predicated/from/url_part"
 include Predicated
 
-apropos "parse a url fragment, the result is a parse tree" do
+regarding "parse a url part, the result is a parse tree" do
   
   before do
-    @parser = TreetopUrlFragmentParser.new
+    @parser = TreetopUrlPartParser.new
   end
 
-  apropos "simple operations" do
+  regarding "simple operations" do
     
     test "parse" do
       tree = @parser.parse("a=1")
       
-      assert{ tree.is_a?(Predicated::TreetopUrlFragment::OperationNode) }      
+      assert{ tree.is_a?(Predicated::TreetopUrlPart::OperationNode) }      
       assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", "=", "1"] }
       
       tree = @parser.parse("a>1")
@@ -41,11 +41,11 @@ apropos "parse a url fragment, the result is a parse tree" do
 
   end
 
-  apropos "simple and" do
+  regarding "simple and" do
     test "parse" do
       tree = @parser.parse("a=1&b=2")
-
-      assert{ tree.is_a?(Predicated::TreetopUrlFragment::AndNode) }      
+      
+      assert{ tree.is_a?(Predicated::TreetopUrlPart::AndNode) }      
       assert{ [[tree.left.left_text, tree.left.sign_text, tree.left.right_text],
                [tree.right.left_text, tree.right.sign_text, tree.right.right_text]] == 
                [["a", "=", "1"], ["b", "=", "2"]] }      
@@ -56,11 +56,11 @@ apropos "parse a url fragment, the result is a parse tree" do
     end
   end
 
-  apropos "simple or" do
+  regarding "simple or" do
     test "parse" do
       tree = @parser.parse("a=1|b=2")
 
-      assert{ tree.is_a?(Predicated::TreetopUrlFragment::OrNode) }      
+      assert{ tree.is_a?(Predicated::TreetopUrlPart::OrNode) }      
       assert{ [[tree.left.left_text, tree.left.sign_text, tree.left.right_text],
                [tree.right.left_text, tree.right.sign_text, tree.right.right_text]] == 
                [["a", "=", "1"], ["b", "=", "2"]] }      
@@ -71,7 +71,7 @@ apropos "parse a url fragment, the result is a parse tree" do
     end
   end
   
-  apropos "complex and/or" do
+  regarding "complex and/or" do
     test "many or's" do
       assert{ @parser.parse("a=1|b=2|c=3").to_predicate == 
         Predicate{ Or( Eq("a", "1"), Or(Eq("b", "2"),Eq("c", "3")) ) } }
@@ -91,7 +91,7 @@ apropos "parse a url fragment, the result is a parse tree" do
     end
   end
 
-  apropos "parens (force higher precedence)" do
+  regarding "parens (force higher precedence)" do
     test "no effect" do
       str = "(a=1|b=2)|c=3"
       assert{ @parser.parse(str).to_predicate == 
@@ -113,4 +113,11 @@ apropos "parse a url fragment, the result is a parse tree" do
     end
   end
 
+  regarding "not" do
+    test "force precedence" do
+      assert{ @parser.parse("!(a=1)").to_predicate == 
+        Predicate{ Not(Eq("a", "1")) } }
+    end
+  end
+
 end

data/test/from/url_part_test.rb

@@ -0,0 +1,48 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/from/url_part"
+require "./test/canonical_transform_cases"
+include Predicated
+
+regarding "parse url parts and convert them into predicates" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_url_part("a=3"),
+      "gt" => Predicate.from_url_part("a>3"),
+      "lt" => Predicate.from_url_part("a<3"),
+      "gte" => Predicate.from_url_part("a>=3"),
+      "lte" => Predicate.from_url_part("a<=3")
+    },
+    "primitive types" => {
+      "false" => Predicate.from_url_part("a=false"),
+      "true" => Predicate.from_url_part("a=true"),
+      "string" => Predicate.from_url_part("a=yyy"),
+    },
+    "not" => {
+      "simple" => Predicate.from_url_part("!(a=true)")
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_url_part("a=1&b=2"),
+      "or" => Predicate.from_url_part("a=1|b=2")
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_url_part("a=1&b=2|c=3")
+    }
+  }
+
+  create_canonical_tests(@expectations, proper_typing=false)
+
+
+  
+  test "parens change precedence" do
+    assert { Predicate.from_url_part("a=1|b=2&c=3") == 
+      Predicate{ Or( Eq("a","1"), And(Eq("b","2"),Eq("c","3")) ) } }
+
+    assert { Predicate.from_url_part("(a=1|b=2)&c=3") == 
+      Predicate{ And( Or(Eq("a","1"),Eq("b","2")), Eq("c","3") ) } }
+  end
+
+end

data/test/from/xml_test.rb

@@ -0,0 +1,57 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/from/xml"
+include Predicated
+
+regarding "convert an xml string to a predicate" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_xml("<equal><left>a</left><right>3</right></equal>"),
+      "gt" => Predicate.from_xml("<greaterThan><left>a</left><right>3</right></greaterThan>"),
+      "lt" => Predicate.from_xml("<lessThan><left>a</left><right>3</right></lessThan>"),
+      "gte" => 
+        Predicate.from_xml("<greaterThanOrEqualTo><left>a</left><right>3</right></greaterThanOrEqualTo>"),
+      "lte" => 
+        Predicate.from_xml("<lessThanOrEqualTo><left>a</left><right>3</right></lessThanOrEqualTo>")
+    },
+    "primitive types" => {
+      "false" => Predicate.from_xml("<equal><left>a</left><right>false</right></equal>"),
+      "true" => Predicate.from_xml("<equal><left>a</left><right>true</right></equal>"),
+      "string" => Predicate.from_xml("<equal><left>a</left><right>yyy</right></equal>"),
+    },
+    "not" => {
+      "simple" => Predicate.from_xml("<not><equal><left>a</left><right>true</right></equal></not>")
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_xml(%{
+        <and>
+          <equal><left>a</left><right>1</right></equal>
+          <equal><left>b</left><right>2</right></equal>
+        </and>
+      }),
+      "or" => Predicate.from_xml(%{
+        <or>
+          <equal><left>a</left><right>1</right></equal>
+          <equal><left>b</left><right>2</right></equal>
+        </or>
+      })
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_xml(%{
+        <or>
+          <and>
+            <equal><left>a</left><right>1</right></equal>
+            <equal><left>b</left><right>2</right></equal>
+          </and>
+          <equal><left>c</left><right>3</right></equal>
+        </or>
+      })
+    }
+  }
+
+  create_canonical_tests(@expectations, proper_typing=false)
+end

data/test/json_conversion_test.rb

@@ -0,0 +1,33 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/from/json"
+require "predicated/to/json"
+include Predicated
+
+regarding "convert json back and forth" do
+
+  test "string to predicate to string" do
+    assert{ Predicate.from_json_str(%{["a","==",3]}).to_json_str == 
+              JSON.pretty_generate(JSON.parse(%{["a","==",3]})) }
+    
+    complex_json_str = %{
+      {
+        "or":[
+          {"and":[["a","==",1],["b","==",2]]},
+          ["c","==",3]
+        ]
+      }
+    }
+              
+    assert{ Predicate.from_json_str(complex_json_str).to_json_str == 
+              JSON.pretty_generate(JSON.parse(complex_json_str)) }
+  end
+  
+  test "predicate to string to predicate" do
+    assert{ Predicate.from_json_str(Predicate{ Eq("a",3) }.to_json_str) == Predicate{ Eq("a",3) } }
+    
+    assert{ Predicate.from_json_str(Predicate{ Or(And(Eq("a",1),Eq("b",2)), Eq("c",3)) }.to_json_str) ==
+              Predicate{ Or(And(Eq("a",1),Eq("b",2)), Eq("c",3)) } }
+  end
+
+end

data/test/print_test.rb

@@ -1,57 +1,58 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/predicate"
 include Predicated
 
-apropos "a predicate looks nice with you inspect it" do
+regarding "a predicate looks nice with you to_s it" do
   test "numbers" do
-    assert { Predicate { Eq(1, 1) }.inspect == "Eq(1,1)" }
-    assert { Predicate { Lt(1, 2) }.inspect == "Lt(1,2)" }
+    assert { Predicate { Eq(1, 1) }.to_s == "Eq(1,1)" }
+    assert { Predicate { Lt(1, 2) }.to_s == "Lt(1,2)" }
   end
   
   test "booleans" do
-    assert { Predicate { Eq(false, true) }.inspect == "Eq(false,true)" }
+    assert { Predicate { Eq(false, true) }.to_s == "Eq(false,true)" }
   end
   
   test "strings" do
-    assert { Predicate { Eq("foo", "bar") }.inspect == "Eq('foo','bar')" }
+    assert { Predicate { Eq("foo", "bar") }.to_s == "Eq('foo','bar')" }
   end
 
-  class Color
-    attr_reader :name
-    def initialize(name)
-      @name = name
-    end
-  
-    def to_s
-      "name:#{@name}"
-    end
+  test "nil" do
+    assert { Predicate { Eq("foo", nil) }.to_s == "Eq('foo',nil)" }
   end
-    
+
   test "objects" do
-    assert { Predicate { Eq(Color.new("red"), Color.new("blue")) }.inspect == "Eq(Color{'name:red'},Color{'name:blue'})" }
+    assert {
+      Predicate {
+        Eq(Color.new("red"), Color.new("blue"))
+      }.to_s == "Eq(Color{'name:red'},Color{'name:blue'})"
+    }
   end
   
   test "and, or" do
-    assert { Predicate { And(true, false) }.inspect == "And(true,false)" }
-    assert { Predicate { Or(true, false) }.inspect == "Or(true,false)" }
+    assert { Predicate { And(true, false) }.to_s == "And(true,false)" }
+    assert { Predicate { Or(true, false) }.to_s == "Or(true,false)" }
     
-    assert { Predicate { And(Eq(1, 1) , Eq(2, 2)) }.inspect == "And(Eq(1,1),Eq(2,2))" }
+    assert { Predicate { And(Eq(1, 1) , Eq(2, 2)) }.to_s == "And(Eq(1,1),Eq(2,2))" }
     
-    assert { Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) }.inspect == "And(Eq(1,1),Or(Eq(2,2),Eq(3,3)))" }
+    assert { Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) }.to_s == "And(Eq(1,1),Or(Eq(2,2),Eq(3,3)))" }
+  end
+
+  test "not" do
+    assert { Predicate { Not(Eq(1, 1)) }.to_s == "Not(Eq(1,1))" }
   end
 
 end
 
-apropos "to_s is like inspect except it's multiline, so you see the tree structure" do
+regarding "inspect is like to_s except it's multiline, so you see the tree structure" do
   
   test "an uncomplicated predicate prints on one line" do
-    assert { Predicate { Eq(1, 1) }.to_s == "Eq(1,1)" }
+    assert { Predicate { Eq(1, 1) }.inspect == "Eq(1,1)" }
   end
   
   test "complex" do
     assert { 
-      Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) }.to_s == 
+      Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) }.inspect == 
 %{And(
   Eq(1,1),
   Or(
@@ -62,4 +63,4 @@ apropos "to_s is like inspect except it's multiline, so you see the tree structu
 }
     }
   end
-end
+end

data/test/selectable_test.rb

@@ -0,0 +1,123 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/selectable"
+
+regarding "part one: selectors on an array (simple enumerable).  proving them out more generally." do
+  before do
+    @arr = [1,2,"c",4,"e",6]
+    Predicated::Selectable.bless_enumerable(@arr,
+      :strings => proc{|item|item.is_a?(String)}, 
+      :numbers => proc{|item|item.is_a?(Numeric)}, 
+      :less_than_3 => proc{|item|item < 3} 
+    )
+  end
+  
+  test %{selection basics.  
+         People often remark that this kind of thing is jQuery-like.
+         I keep thinking I got it from Eric Evans.} do
+    assert{ @arr.select(:numbers) == [1,2,4,6] }
+    assert{ @arr.select(:strings) == ["c","e"] }
+    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
+    
+    assert do
+      rescuing{ @arr.select(:less_than_3) }.is_a?(ArgumentError)
+      #because strings don't respond to <
+      #...there's no substitute for knowing what you're doing.
+    end
+    
+    #normal select still works
+    assert{ @arr.select{|item|item.is_a?(String)} == ["c","e"] }
+  end
+
+  test "...selector name can be any object" do
+    arr = [1,2,"c",4,"e",6]
+
+    Predicated::Selectable.bless_enumerable(arr,
+      String => proc{|item|item.is_a?(String)},
+      Numeric => proc{|item|item.is_a?(Numeric)},
+      :less_than_3 => proc{|item|item < 3}
+    )
+
+    assert{ arr.select(String) == ["c","e"] }
+    assert{ arr.select(Numeric) == [1,2,4,6] }
+    assert{ arr.select(Numeric).select(:less_than_3) == [1,2] }
+  end
+    
+  test "chaining.  also works using varargs" do
+    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
+    assert{ @arr.select(:numbers, :less_than_3) == [1,2] }
+  end
+    
+  test "extending twice is additive (not destructive)" do
+    arr = [1,2,"c",4,"e",6]
+    Predicated::Selectable.bless_enumerable(arr, :strings => proc{|item|item.is_a?(String)})
+    Predicated::Selectable.bless_enumerable(arr, :numbers => proc{|item|item.is_a?(Numeric)})
+
+    assert{ arr.select(:strings) == ["c","e"] }
+    assert{ arr.select(:numbers) == [1,2,4,6] }
+  end
+    
+  test "works as a macro" do
+    class MyArray < Array
+      include Predicated::Selectable
+      selector :strings => proc{|item|item.is_a?(String)}
+      selector :numbers => proc{|item|item.is_a?(Numeric)}
+      selector :small => proc{|item|item.is_a?(Numeric) && item < 3},
+        :big => proc{|item|item.is_a?(Numeric) && item >= 3}
+    end
+    
+    arr = MyArray.new
+    arr.replace([1,2,"c",4,"e",6])
+
+    assert{ arr.select(:strings) == ["c","e"] }
+    assert{ arr.select(:numbers) == [1,2,4,6] }
+    assert{ arr.select(:small) == [1,2] }
+    assert{ arr.select(:big) == [4,6] }
+  end
+    
+  test %{memoizes.
+         Selector enumerable assumes an immutable collection.
+         I'm going to use that assumption against it, and cleverly prove that memoization works.
+         (Others might choose to mock in similar circumstances.)} do
+    assert{ @arr.select(:strings) == ["c","e"] }
+
+    @arr << "zzz"
+
+    assert{ @arr.select(:strings) == ["c","e"] }
+  end
+end
+
+include Predicated
+regarding "there are convenient selectors defined for getting things out of a predicate" do
+  class ::Array
+    def predicates
+      collect{|p, a|p}
+    end
+  end
+  
+  it "gets predicate parts by type" do
+    root = Predicate { And(Eq(1, 2), Or(Eq(3, 4), Eq(5, 6))) }
+    the_or = Predicate { Or(Eq(3, 4), Eq(5, 6)) }
+
+    assert{ root.select(:all).predicates == [root, Equal.new(1, 2), the_or, Equal.new(3, 4), Equal.new(5, 6)] }
+    
+    assert{ root.select(And).predicates == [root] }
+    assert{ root.select(Or).predicates == [the_or] }
+    assert{ root.select(Equal).predicates == [Equal.new(1, 2), Equal.new(3, 4), Equal.new(5, 6)] }
+    assert{ root.select(GreaterThan).predicates == [] }
+    
+    gt_lt = Predicate { And(Gt(1, 2), Lt(3, 4)) }
+    assert{ gt_lt.select(GreaterThan).predicates == [GreaterThan.new(1, 2)] }
+    assert{ gt_lt.select(LessThan).predicates == [LessThan.new(3, 4)] }
+
+    gte_lte = Predicate { And(Gte(1, 2), Lte(3, 4)) }
+    assert{ gte_lte.select(GreaterThanOrEqualTo).predicates == [GreaterThanOrEqualTo.new(1, 2)] }
+    assert{ gte_lte.select(LessThanOrEqualTo).predicates == [LessThanOrEqualTo.new(3, 4)] }
+    
+    mixed = Predicate { And(Eq(1, 2), Or(Gt(3, 4), Lt(5, 6))) }
+    mixed_or = Predicate { Or(Gt(3, 4), Lt(5, 6)) }
+    assert{ mixed.select(Operation).predicates == [Equal.new(1, 2), GreaterThan.new(3, 4), LessThan.new(5, 6)] }
+    assert{ mixed.select(Operation).select(Equal).predicates == [Equal.new(1, 2)] }
+    assert{ mixed.select(Binary).predicates == [mixed, Equal.new(1, 2), mixed_or, GreaterThan.new(3, 4), LessThan.new(5, 6)] }
+  end
+end

data/test/simple_templated_predicate_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/simple_templated_predicate"
+include Predicated
+
+regarding "simple templated predicates.  the left sides of operations and calls is a common unbound variable" do
+
+  test "operations.  the left side is a placeholder" do
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.fill_in(1) == Predicate { Eq(1, 1) } }
+    assert{ SimpleTemplatedPredicate{ Lt(2) }.fill_in(1) == Predicate { Lt(1, 2) } }
+    assert{ SimpleTemplatedPredicate{ Gt(1) }.fill_in(2) == Predicate { Gt(2, 1) } }
+    assert{ SimpleTemplatedPredicate{ Gte(1) }.fill_in(2) == Predicate { Gte(2, 1) } }
+    assert{ SimpleTemplatedPredicate{ Lte(2) }.fill_in(1) == Predicate { Lte(1, 2) } }
+
+    assert{ SimpleTemplatedPredicate{ Eq(true) }.fill_in(true) == Predicate { Eq(true, true) } }
+  end
+  
+  test "and, or, not.  just pass on the fill_in" do
+    assert{ SimpleTemplatedPredicate{ And(Gt(3),Lt(5)) }.fill_in(4) == Predicate { And(Gt(4,3),Lt(4,5)) } }
+    assert{ SimpleTemplatedPredicate{ Or(Gt(3),Lt(5)) }.fill_in(4) == Predicate { Or(Gt(4,3),Lt(4,5)) } }
+    assert{ SimpleTemplatedPredicate{ Not(Gt(5)) }.fill_in(4) == Predicate { Not(Gt(4,5)) } }
+  end
+  
+  test "call.  left side is a placeholder" do
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.fill_in("abc") == 
+              Predicate { Call("abc", :include?, "bc") } }
+
+    assert{ SimpleTemplatedPredicate{ Call(:nil?) }.fill_in("abc") == 
+              Predicate { Call("abc", :nil?) } }
+  end
+  
+  test "to_s and inspect" do
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.inspect == "Eq(1)" }
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.to_s == "Eq(1)" }
+    
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.inspect == "Call(include?('bc'))" }
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.to_s == "Call(include?('bc'))" }
+  end
+end