wrong 0.3.1 → 0.3.2

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

@@ -1,37 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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