wrong 0.1.0 → 0.2.0

data/lib/predicated/test/from/ruby_code_string_canonical_test.rb

@@ -0,0 +1,37 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/from/ruby_code_string"
+include Predicated
+
+regarding "ruby code string - canoical transform cases" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_ruby_code_string("'a'==3"),
+      "gt" => Predicate.from_ruby_code_string("'a'>3"),
+      "lt" => Predicate.from_ruby_code_string("'a'<3"),
+      "gte" => Predicate.from_ruby_code_string("'a'>=3"),
+      "lte" => Predicate.from_ruby_code_string("'a'<=3")
+    },
+    "primitive types" => {
+      "false" => Predicate.from_ruby_code_string("'a'==false"),
+      "true" => Predicate.from_ruby_code_string("'a'==true"),
+      "string" => Predicate.from_ruby_code_string("'a'=='yyy'"),
+    },
+    "not" => {
+      "simple" => Predicate.from_ruby_code_string("!('a'==true)")
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_ruby_code_string("'a'==1 && 'b'==2"),
+      "or" => Predicate.from_ruby_code_string("'a'==1 || 'b'==2")
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_ruby_code_string("'a'==1 && 'b'==2 || 'c'==3")
+    }
+  }
+
+  create_canonical_tests(@expectations)
+end

data/lib/predicated/test/from/ruby_code_string_test.rb

@@ -0,0 +1,103 @@
+require "./test/test_helper"
+
+require "predicated/from/ruby_code_string"
+include Predicated
+
+regarding "parse a ruby predicate string" do
+  
+  regarding "basic operations" do
+    
+    #'Wrong'-style asserts are specifically avoided here.
+    #the circularity between the two projects will make you crazy if you're not careful
+    
+    test "word and" do
+      assert_equal Predicate.from_ruby_code_string("1==1 and 2==2"), Predicate{ And(Eq(1,1),Eq(2,2)) }
+    end
+
+    test "substitute in from the binding" do
+      a = 1
+      b = "1"
+      c = "c"
+      d = Color.new("purple")
+      
+      assert_equal Predicate.from_ruby_code_string("a==1", binding()), Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_ruby_code_string("b==1", binding()), Predicate{ Eq("1",1) }
+      assert_equal Predicate.from_ruby_code_string("c==b", binding()), Predicate{ Eq("c","1") }
+      assert_equal Predicate.from_ruby_code_string("d==d", binding()), Predicate{ Eq(Color.new("purple"),
+                                                              Color.new("purple")) }
+      assert_equal Predicate.from_ruby_code_string("d==d", binding()).left, d
+
+      assert_equal Predicate.from_ruby_code_string("a==b && b==c", binding()), 
+                Predicate{ And(Eq(1,"1"),Eq("1","c")) }
+    end
+
+
+    test "parens change precedence" do
+      assert_equal Predicate.from_ruby_code_string("1==1 || 2==2 && 3==3"),
+                   Predicate{ Or( Eq(1,1), And(Eq(2,2),Eq(3,3)) ) }
+
+      assert_equal Predicate.from_ruby_code_string("(1==1 || 2==2) && 3==3"), 
+                   Predicate{ And( Or(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
+    end
+    
+    regarding "only pay attention to the final line" do
+      #might hate myself one day for this.  but what else does it make sense to do?
+      
+      test "simple" do
+        assert_equal Predicate.from_ruby_code_string("z=2\nb=5\n1==1"), Predicate{ Eq(1,1) }
+      end
+
+      test "can make use of variables defined earlier in the block" do
+        #might hate myself one day for this.  but what else does it make sense to do?
+        assert_equal Predicate.from_ruby_code_string("z=2\nb=5\nz==1"), Predicate{ Eq(2,1) }
+      end
+    end
+    
+    test "a call that returns a boolean result" do
+      assert_equal Predicate.from_ruby_code_string("'abc'.include?('bc')"), 
+                   Predicate{ Call("abc", :include?, "bc") }
+      
+      color = Color.new("purple")  
+      assert_equal Predicate.from_ruby_code_string("color.name.include?('rp')", binding()), 
+                   Predicate{ Call("purple", :include?, "rp") }
+                   
+      assert_equal Predicate.from_ruby_code_string("'abc'.nil?"), 
+                   Predicate{ Call("abc", :nil?, nil) }
+    end
+    
+    test "use of instance variables" do
+      @a = 1
+      
+      assert_equal Predicate.from_ruby_code_string("@a==1", binding()), Predicate{ Eq(1,1) }
+    end
+                            
+    test "use of inline assignments" do
+      assert_equal Predicate.from_ruby_code_string("(a=2)==1 && a==1"), 
+                   Predicate{ And(Eq(2,1), Eq(2,1)) }
+    end
+                            
+    test "use of inline expressions" do
+      assert_equal Predicate.from_ruby_code_string("(2*1)==1"), 
+                   Predicate{ Eq(2,1) }
+                   
+      assert_equal Predicate.from_ruby_code_string("[2,1].first==1"), 
+                   Predicate{ Eq(2,1) }
+    end
+
+
+  end
+  
+  regarding "errors" do
+    test "can't parse" do
+      assert_raises(Racc::ParseError) do 
+        Predicate.from_ruby_code_string("bad ruby @@@@@****()(((")
+      end
+    end  
+    
+    test "predicates only" do
+      assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
+        Predicate.from_ruby_code_string("a=1")
+      end
+    end
+  end
+end

data/lib/predicated/test/from/url_part_parser_test.rb

@@ -0,0 +1,123 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/predicate"
+require "predicated/from/url_part"
+include Predicated
+
+regarding "parse a url part, the result is a parse tree" do
+  
+  before do
+    @parser = TreetopUrlPartParser.new
+  end
+
+  regarding "simple operations" do
+    
+    test "parse" do
+      tree = @parser.parse("a=1")
+      
+      assert{ tree.is_a?(Predicated::TreetopUrlPart::OperationNode) }      
+      assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", "=", "1"] }
+      
+      tree = @parser.parse("a>1")
+      assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", ">", "1"] }
+      
+      tree = @parser.parse("a<1")
+      assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", "<", "1"] }
+
+      tree = @parser.parse("a>=1")
+      assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", ">=", "1"] }
+
+      tree = @parser.parse("a<=1")
+      assert{ [tree.left_text, tree.sign_text, tree.right_text] == ["a", "<=", "1"] }
+    end
+    
+    test "...to predicate" do
+      assert{ @parser.parse("a=1").to_predicate == Predicate{Eq("a", "1")} }
+      assert{ @parser.parse("a>1").to_predicate == Predicate{Gt("a", "1")} }
+      assert{ @parser.parse("a<1").to_predicate == Predicate{Lt("a", "1")} }
+      assert{ @parser.parse("a>=1").to_predicate == Predicate{Gte("a", "1")} }
+      assert{ @parser.parse("a<=1").to_predicate == Predicate{Lte("a", "1")} }
+    end
+
+  end
+
+  regarding "simple and" do
+    test "parse" do
+      tree = @parser.parse("a=1&b=2")
+      
+      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"]] }      
+    end
+    
+    test "...to predicate" do
+      assert{ @parser.parse("a=1&b=2").to_predicate == Predicate{ And( Eq("a", "1"),Eq("b", "2") ) } }
+    end
+  end
+
+  regarding "simple or" do
+    test "parse" do
+      tree = @parser.parse("a=1|b=2")
+
+      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"]] }      
+    end
+    
+    test "...to predicate" do
+      assert{ @parser.parse("a=1|b=2").to_predicate == Predicate{ Or( Eq("a", "1"),Eq("b", "2") ) } }
+    end
+  end
+  
+  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")) ) } }
+    end
+
+    test "many and's" do
+      assert{ @parser.parse("a=1&b=2&c=3").to_predicate == 
+        Predicate{ And( Eq("a", "1"), And(Eq("b", "2"),Eq("c", "3")) ) } }
+    end
+
+    test "mixed and/or" do
+      assert{ @parser.parse("a=1|b=2&c=3").to_predicate == 
+        Predicate{ Or( Eq("a", "1"), And(Eq("b", "2"),Eq("c", "3")) ) } }
+
+      assert{ @parser.parse("a=1&b=2|c=3").to_predicate == 
+        Predicate{ Or( And(Eq("a", "1"),Eq("b", "2")), Eq("c", "3") ) } }
+    end
+  end
+
+  regarding "parens (force higher precedence)" do
+    test "no effect" do
+      str = "(a=1|b=2)|c=3"
+      assert{ @parser.parse(str).to_predicate == 
+        Predicate{ Or( Or(Eq("a", "1"),Eq("b", "2")), Eq("c", "3") ) } }
+      
+      str = "((a=1|b=2))|c=3"
+      assert{ @parser.parse(str).to_predicate == 
+        Predicate{ Or( Or(Eq("a", "1"),Eq("b", "2")), Eq("c", "3") ) } }
+    end
+
+    test "force precedence" do
+      #before
+      assert{ @parser.parse("a=1|b=2&c=3").to_predicate == 
+        Predicate{ Or( Eq("a", "1"), And(Eq("b", "2"),Eq("c", "3")) ) } }
+      
+      #after
+      assert{ @parser.parse("(a=1|b=2)&c=3").to_predicate == 
+        Predicate{ And( Or(Eq("a", "1"),Eq("b", "2")), Eq("c", "3") ) } }
+    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/lib/predicated/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/lib/predicated/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/lib/predicated/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/lib/predicated/test/print_test.rb

@@ -0,0 +1,66 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+regarding "a predicate looks nice with you to_s it" do
+  test "numbers" do
+    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) }.to_s == "Eq(false,true)" }
+  end
+  
+  test "strings" do
+    assert { Predicate { Eq("foo", "bar") }.to_s == "Eq('foo','bar')" }
+  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"))
+      }.to_s == "Eq(Color{'name:red'},Color{'name:blue'})"
+    }
+  end
+  
+  test "and, or" do
+    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)) }.to_s == "And(Eq(1,1),Eq(2,2))" }
+    
+    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
+
+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) }.inspect == "Eq(1,1)" }
+  end
+  
+  test "complex" do
+    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)
+  )
+)
+}
+    }
+  end
+end