predicated 0.1.0

data/test/from/callable_object_test.rb

@@ -0,0 +1,102 @@
+require "test/test_helper"
+
+require "predicated/from/callable_object"
+include Predicated
+
+apropos "convert a ruby callable object - a proc or lambda - into a predicate" do
+
+  apropos "basic operations" do
+
+    test "simple signs" do
+      assert_equal Predicate.from_callable_object{1==1}, Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_callable_object{1 == 1}, Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_callable_object{0<1}, Predicate{ Lt(0,1) }
+      assert_equal Predicate.from_callable_object{2>1}, Predicate{ Gt(2,1) }
+      assert_equal Predicate.from_callable_object{1<=1}, Predicate{ Lte(1,1) }
+      assert_equal Predicate.from_callable_object{1>=1}, Predicate{ Gte(1,1) }
+    end
+    
+    test "primitive types" do
+      assert_equal Predicate.from_callable_object{false==true}, Predicate{ Eq(false,true) }
+      assert_equal Predicate.from_callable_object{"yyy"=="zzz"}, Predicate{ Eq("yyy","zzz") }
+    end                                      
+                                             
+    test "complex types" do
+      assert_equal Predicate.from_callable_object{Color.new("red")==Color.new("blue")}, 
+        Predicate{ Eq(Color.new("red"),Color.new("blue")) }
+    
+      assert_equal Predicate.from_callable_object{ {1=>2}=={"a"=>"b"} }, 
+        Predicate{ Eq({1=>2},{"a"=>"b"}) }
+    end                                      
+                                             
+    test "simple and + or" do                
+      assert_equal Predicate.from_callable_object{1==1 && 2==2}, Predicate{ And(Eq(1,1),Eq(2,2)) }
+      assert_equal Predicate.from_callable_object{1==1 and 2==2}, Predicate{ And(Eq(1,1),Eq(2,2)) }
+      assert_equal Predicate.from_callable_object{1==1 || 2==2}, Predicate{ Or(Eq(1,1),Eq(2,2)) }
+      assert_equal Predicate.from_callable_object{1==1 or 2==2}, Predicate{ Or(Eq(1,1),Eq(2,2)) }
+    end
+    
+    class Color
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    
+      def ==(other)
+        other.is_a?(Color) && @name == other.name
+      end
+    end
+    
+    test "substitute in from the binding" do
+      a = 1
+      b = "1"
+      c = "c"
+      d = Color.new("purple")
+      
+      assert_equal Predicate.from_callable_object(binding()){a==1}, Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_callable_object(binding()){b==1}, Predicate{ Eq("1",1) }
+      assert_equal Predicate.from_callable_object(binding()){c==b}, Predicate{ Eq("c","1") }
+      assert_equal Predicate.from_callable_object(binding()){d==d}, Predicate{ Eq(Color.new("purple"),
+                                                                                Color.new("purple")) }
+      assert Predicate.from_callable_object(binding()){d==d}.left === d
+                                             
+      assert_equal Predicate.from_callable_object(binding()){a==b && b==c}, 
+                Predicate{ And(Eq(1,"1"),Eq("1","c")) }
+    end
+    
+    
+    test "complex and + or" do
+      assert_equal Predicate.from_callable_object{1==1 && 2==2 || 3==3}, 
+        Predicate{ Or( And(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
+    end
+    
+    test "parens change precedence" do
+      assert_equal Predicate.from_callable_object{1==1 || 2==2 && 3==3}, 
+        Predicate{ Or( Eq(1,1), And(Eq(2,2),Eq(3,3)) ) }
+    
+      assert_equal Predicate.from_callable_object{(1==1 || 2==2) && 3==3}, 
+        Predicate{ And( Or(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
+    end
+    
+    test "works with procs and lambdas" do
+      
+      assert_equal Predicate.from_callable_object(proc{1<2}), Predicate{ Lt(1,2) }
+      assert_equal Predicate.from_callable_object(lambda{1<2}), Predicate{ Lt(1,2) }
+      
+      a = "aaa"
+      assert_equal Predicate.from_callable_object(proc{a=="bbb"}, binding()), 
+        Predicate{ Eq("aaa","bbb") }
+      assert_equal Predicate.from_callable_object(lambda{a=="bbb"}, binding()), 
+        Predicate{ Eq("aaa","bbb") }
+    end          
+
+  end
+  
+  apropos "errors" do
+    test "predicates only" do
+      assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
+        Predicate.from_callable_object{a=1}
+      end
+    end
+  end
+end

data/test/from/ruby_string_test.rb

@@ -0,0 +1,135 @@
+require "test/test_helper"
+
+require "predicated/from/ruby_string"
+include Predicated
+
+apropos "parse a ruby predicate string" do
+  
+  apropos "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 "simple signs" do
+      assert_equal Predicate.from_ruby_string("1==1"), Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_ruby_string(" 1 == 1 "), Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_ruby_string("0<1"), Predicate{ Lt(0,1) }
+      assert_equal Predicate.from_ruby_string("2>1"), Predicate{ Gt(2,1) }
+      assert_equal Predicate.from_ruby_string("1<=1"), Predicate{ Lte(1,1) }
+      assert_equal Predicate.from_ruby_string("1>=1"), Predicate{ Gte(1,1) }
+    end
+    
+    test "primitive types" do
+      assert_equal Predicate.from_ruby_string("false==true"), Predicate{ Eq(false,true) }
+      assert_equal Predicate.from_ruby_string("'yyy'=='zzz'"), Predicate{ Eq("yyy","zzz") }
+    end
+
+    test "simple and + or" do
+      assert_equal Predicate.from_ruby_string("1==1 && 2==2"), Predicate{ And(Eq(1,1),Eq(2,2)) }
+      assert_equal Predicate.from_ruby_string("1==1 and 2==2"), Predicate{ And(Eq(1,1),Eq(2,2)) }
+      assert_equal Predicate.from_ruby_string("1==1 || 2==2"), Predicate{ Or(Eq(1,1),Eq(2,2)) }
+    end
+
+    class Color
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    
+      def ==(other)
+        other.is_a?(Color) && @name == other.name
+      end
+    end
+
+    test "substitute in from the binding" do
+      a = 1
+      b = "1"
+      c = "c"
+      d = Color.new("purple")
+      
+      assert_equal Predicate.from_ruby_string("a==1", binding()), Predicate{ Eq(1,1) }
+      assert_equal Predicate.from_ruby_string("b==1", binding()), Predicate{ Eq("1",1) }
+      assert_equal Predicate.from_ruby_string("c==b", binding()), Predicate{ Eq("c","1") }
+      assert_equal Predicate.from_ruby_string("d==d", binding()), Predicate{ Eq(Color.new("purple"),
+                                                              Color.new("purple")) }
+      assert_equal Predicate.from_ruby_string("d==d", binding()).left, d
+
+      assert_equal Predicate.from_ruby_string("a==b && b==c", binding()), 
+                Predicate{ And(Eq(1,"1"),Eq("1","c")) }
+    end
+
+
+    test "complex and + or" do
+      assert_equal Predicate.from_ruby_string("1==1 && 2==2 || 3==3"), 
+                   Predicate{ Or( And(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
+    end
+    
+    test "parens change precedence" do
+      assert_equal Predicate.from_ruby_string("1==1 || 2==2 && 3==3"),
+                   Predicate{ Or( Eq(1,1), And(Eq(2,2),Eq(3,3)) ) }
+
+      assert_equal Predicate.from_ruby_string("(1==1 || 2==2) && 3==3"), 
+                   Predicate{ And( Or(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
+    end
+    
+    apropos "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_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_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_string("'abc'.include?('bc')"), 
+                   Predicate{ Call("abc", :include?, "bc") }
+      
+      color = Color.new("purple")  
+      assert_equal Predicate.from_ruby_string("color.name.include?('rp')", binding()), 
+                   Predicate{ Call("purple", :include?, "rp") }
+                   
+      assert_equal Predicate.from_ruby_string("'abc'.nil?"), 
+                   Predicate{ Call("abc", :nil?, nil) }
+    end
+    
+    test "use of instance variables" do
+      @a = 1
+      
+      assert_equal Predicate.from_ruby_string("@a==1", binding()), Predicate{ Eq(1,1) }
+    end
+                            
+    test "use of inline assignments" do
+      assert_equal Predicate.from_ruby_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_string("(2*1)==1"), 
+                   Predicate{ Eq(2,1) }
+                   
+      assert_equal Predicate.from_ruby_string("[2,1].first==1"), 
+                   Predicate{ Eq(2,1) }
+    end
+
+
+  end
+  
+  apropos "errors" do
+    test "can't parse" do
+      assert_raises(Racc::ParseError) do 
+        Predicate.from_ruby_string("bad ruby @@@@@****()(((")
+      end
+    end  
+    
+    test "predicates only" do
+      assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
+        Predicate.from_ruby_string("a=1")
+      end
+    end
+  end
+end

data/test/from/url_fragment_parser_test.rb

@@ -0,0 +1,116 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/predicate"
+require "predicated/from/url_fragment"
+include Predicated
+
+apropos "parse a url fragment, the result is a parse tree" do
+  
+  before do
+    @parser = TreetopUrlFragmentParser.new
+  end
+
+  apropos "simple operations" do
+    
+    test "parse" do
+      tree = @parser.parse("a=1")
+      
+      assert{ tree.is_a?(Predicated::TreetopUrlFragment::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
+
+  apropos "simple and" do
+    test "parse" do
+      tree = @parser.parse("a=1&b=2")
+
+      assert{ tree.is_a?(Predicated::TreetopUrlFragment::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
+
+  apropos "simple or" do
+    test "parse" do
+      tree = @parser.parse("a=1|b=2")
+
+      assert{ tree.is_a?(Predicated::TreetopUrlFragment::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
+  
+  apropos "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
+
+  apropos "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
+
+end

data/test/from/url_fragment_test.rb

@@ -0,0 +1,37 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/from/url_fragment"
+include Predicated
+
+apropos "parse url fragments and convert them into predicates" do
+
+  apropos "basic operations" do
+
+    test "simple signs" do
+      assert { Predicate.from_url_fragment("a=1") == Predicate{ Eq("a","1") } }
+      assert { Predicate.from_url_fragment("a<1") == Predicate{ Lt("a","1") } }
+      assert { Predicate.from_url_fragment("a>1") == Predicate{ Gt("a","1") } }
+      assert { Predicate.from_url_fragment("a<=1") == Predicate{ Lte("a","1") } }
+      assert { Predicate.from_url_fragment("a>=1") == Predicate{ Gte("a","1") } }
+    end
+
+    test "simple and + or" do
+      assert { Predicate.from_url_fragment("a=1&b=2") == Predicate{ And(Eq("a","1"),Eq("b","2")) } }
+      assert { Predicate.from_url_fragment("a=1|b=2") == Predicate{ Or(Eq("a","1"),Eq("b","2")) } }
+    end
+
+    test "complex and + or" do
+      assert { Predicate.from_url_fragment("a=1&b=2|c=3") == 
+        Predicate{ Or( And(Eq("a","1"),Eq("b","2")), Eq("c","3") ) } }
+    end
+    
+    test "parens change precedence" do
+      assert { Predicate.from_url_fragment("a=1|b=2&c=3") == 
+        Predicate{ Or( Eq("a","1"), And(Eq("b","2"),Eq("c","3")) ) } }
+
+      assert { Predicate.from_url_fragment("(a=1|b=2)&c=3") == 
+        Predicate{ And( Or(Eq("a","1"),Eq("b","2")), Eq("c","3") ) } }
+    end
+
+  end
+end

data/test/print_test.rb

@@ -0,0 +1,65 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+apropos "a predicate looks nice with you inspect it" do
+  test "numbers" do
+    assert { Predicate { Eq(1, 1) }.inspect == "Eq(1,1)" }
+    assert { Predicate { Lt(1, 2) }.inspect == "Lt(1,2)" }
+  end
+  
+  test "booleans" do
+    assert { Predicate { Eq(false, true) }.inspect == "Eq(false,true)" }
+  end
+  
+  test "strings" do
+    assert { Predicate { Eq("foo", "bar") }.inspect == "Eq('foo','bar')" }
+  end
+
+  class Color
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  
+    def to_s
+      "name:#{@name}"
+    end
+  end
+    
+  test "objects" do
+    assert { Predicate { Eq(Color.new("red"), Color.new("blue")) }.inspect == "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(Eq(1, 1) , Eq(2, 2)) }.inspect == "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)))" }
+  end
+
+end
+
+apropos "to_s is like inspect 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)" }
+  end
+  
+  test "complex" do
+    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
+end