predicated 0.1.0 → 0.2.0

data/test/evaluate_test.rb

@@ -1,11 +1,11 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/evaluate"
 include Predicated
 
-apropos "evaluate a predicate as boolean logic in ruby.  change the context by providing and optional binding." do
+regarding "evaluate a predicate as boolean logic in ruby.  change the context by providing and optional binding." do
 
-  apropos "proving out basic operations" do
+  regarding "proving out basic operations" do
     test "equals" do
       assert { Predicate { Eq(1, 1) }.evaluate }
       deny   { Predicate { Eq(1, 2) }.evaluate }
@@ -36,7 +36,7 @@ apropos "evaluate a predicate as boolean logic in ruby.  change the context by p
     end
   end
 
-  apropos "comparing values of different data types" do
+  regarding "comparing values of different data types" do
     test "strings" do
       assert { Predicate { Eq("1", "1") }.evaluate }
       deny   { Predicate { Eq("1", 1) }.evaluate }
@@ -62,17 +62,6 @@ apropos "evaluate a predicate as boolean logic in ruby.  change the context by p
       deny   { Predicate { Eq(1, nil) }.evaluate }
     end
 
-    class Color
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    
-      def ==(other)
-        other.is_a?(Color) && @name == other.name
-      end
-    end
-
     test "objects" do
       assert { Predicate { Eq(Color.new("red"), Color.new("red")) }.evaluate }
       deny   { Predicate { Eq(Color.new("red"), Color.new("BLUE")) }.evaluate }
@@ -83,7 +72,7 @@ apropos "evaluate a predicate as boolean logic in ruby.  change the context by p
   end
   
   
-  apropos "and" do
+  regarding "and" do
     test "left and right must be true" do
       assert { Predicate { And( Eq(1, 1), Eq(2, 2) ) }.evaluate }
       deny   { Predicate { And( Eq(99, 1), Eq(2, 2) ) }.evaluate }
@@ -104,7 +93,7 @@ apropos "evaluate a predicate as boolean logic in ruby.  change the context by p
     end
   end
   
-  apropos "or" do
+  regarding "or" do
     test "one of left or right must be true" do
       assert { Predicate { Or(true, true) }.evaluate }
       assert { Predicate { Or(true, false) }.evaluate }
@@ -113,32 +102,48 @@ apropos "evaluate a predicate as boolean logic in ruby.  change the context by p
     end
   end  
   
-  apropos "evaluate adds a generic 'call' class.  that is, object.message(args)" do
+  regarding "not" do
+    test "simple negation" do
+      assert { Predicate { Not(Eq(3, 2)) }.evaluate }
+      deny   { Predicate { Not(Eq(2, 2)) }.evaluate }
+    end
+
+    test "complex" do
+      assert { Predicate { Not( And(Eq(2, 2),false) ) }.evaluate }
+      deny   { Predicate { Not( And(Eq(2, 2),true) ) }.evaluate }
+    end
+  end  
+  
+  regarding "evaluate adds a generic 'call' class.  that is, object.message(args)" do
     test "evaluate simple calls" do
       assert { Predicate { Call("abc", :include?, "bc") }.evaluate }
-      deny { Predicate { Call("abc", :include?, "ZZ") }.evaluate }
+      deny   { Predicate { Call("abc", :include?, "ZZ") }.evaluate }
     end
 
     test "nil call.  call defaults to no args if none are specified" do
       assert { Predicate { Call(nil, :nil?, []) }.evaluate }
-      deny { Predicate { Call("abc", :nil?, []) }.evaluate }
+      deny   { Predicate { Call("abc", :nil?, []) }.evaluate }
 
       assert { Predicate { Call(nil, :nil?) }.evaluate }
-      deny { Predicate { Call("abc", :nil?) }.evaluate }
+      deny   { Predicate { Call("abc", :nil?) }.evaluate }
     end
 
     test "inspect" do
-      assert{ Call.new("abc", :include?, "bc").inspect == "Call('abc'.include?('bc'))" }
+      assert { Call.new("abc", :include?, "bc").inspect == "Call('abc'.include?('bc'))" }
+    end
+    
+    test "inspect, empty right hand side" do
+      assert { Call.new("abc", :nil?).inspect == "Call('abc'.nil?)" }
     end
     
     test "call equality" do
       assert { Call.new("abc", :include?, "bc") == Call.new("abc", :include?, "bc") }
-      deny { Call.new("ZZZ", :include?, "bc") == Call.new("abc", :include?, "bc") }
-      deny { Call.new("abc", :zzz, "bc") == Call.new("abc", :include?, "bc") }
-      deny { Call.new("abc", :include?, "ZZZ") == Call.new("abc", :include?, "bc") }
+      deny   { Call.new("ZZZ", :include?, "bc") == Call.new("abc", :include?, "bc") }
+      deny   { Call.new("abc", :zzz, "bc") == Call.new("abc", :include?, "bc") }
+      deny   { Call.new("abc", :include?, "ZZZ") == Call.new("abc", :include?, "bc") }
     end
     
 
   end  
   
-end
+end

data/test/from/callable_object_canonical_test.rb

@@ -0,0 +1,43 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+if RUBY_VERSION =~/^1.9/
+  puts "skipping callable object-related tests in 1.9"
+else
+  
+require "predicated/from/callable_object"
+include Predicated
+
+regarding "callable object - canoical transform cases" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_callable_object{"a"==3},
+      "gt" => Predicate.from_callable_object{"a">3},
+      "lt" => Predicate.from_callable_object{"a"<3},
+      "gte" => Predicate.from_callable_object{"a">=3},
+      "lte" => Predicate.from_callable_object{"a"<=3}
+    },
+    "primitive types" => {
+      "false" => Predicate.from_callable_object{"a"==false},
+      "true" => Predicate.from_callable_object{"a"==true},
+      "string" => Predicate.from_callable_object{"a"=="yyy"}
+    },
+    "not" => {
+      "simple" => Predicate.from_callable_object{!("a"==true)}
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_callable_object{"a"==1 && "b"==2},
+      "or" => Predicate.from_callable_object{"a"==1 || "b"==2}
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_callable_object{"a"==1 && "b"==2 || "c"==3}
+    }
+  }
+
+  create_canonical_tests(@expectations)
+end
+
+end

data/test/from/callable_object_test.rb

@@ -1,25 +1,17 @@
-require "test/test_helper"
+require "./test/test_helper"
+require "./test/canonical_transform_cases"
 
-require "predicated/from/callable_object"
-include Predicated
 
-apropos "convert a ruby callable object - a proc or lambda - into a predicate" do
+if RUBY_VERSION =~/^1.9/
+  puts "skipping callable object-related tests in 1.9"
+else
 
-  apropos "basic operations" do
+require "predicated/from/callable_object"
+include Predicated
+  
+regarding "convert a ruby callable object - a proc or lambda - into a predicate" 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                                      
+  regarding "basic operations" do
                                              
     test "complex types" do
       assert_equal Predicate.from_callable_object{Color.new("red")==Color.new("blue")}, 
@@ -29,24 +21,11 @@ apropos "convert a ruby callable object - a proc or lambda - into a predicate" d
         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)) }
+    test "word and / or" do
       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"
@@ -65,11 +44,6 @@ apropos "convert a ruby callable object - a proc or lambda - into a predicate" d
     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)) ) }
@@ -92,11 +66,13 @@ apropos "convert a ruby callable object - a proc or lambda - into a predicate" d
 
   end
   
-  apropos "errors" do
+  regarding "errors" do
     test "predicates only" do
       assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
         Predicate.from_callable_object{a=1}
       end
     end
   end
-end
+end
+
+end

data/test/from/json_test.rb

@@ -0,0 +1,83 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/from/json"
+require "./test/canonical_transform_cases"
+include Predicated
+
+regarding "convert a json string to a predicate" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_json_str(%{["a","==",3]}),
+      "gt" => Predicate.from_json_str(%{["a",">",3]}),
+      "lt" => Predicate.from_json_str(%{["a","<",3]}),
+      "gte" => Predicate.from_json_str(%{["a",">=",3]}),
+      "lte" => Predicate.from_json_str(%{["a","<=",3]})
+    },
+    "primitive types" => {
+      "false" => Predicate.from_json_str(%{["a","==",false]}),
+      "true" => Predicate.from_json_str(%{["a","==",true]}),
+      "string" => Predicate.from_json_str(%{["a","==","yyy"]})
+    },
+    "not" => {
+      "simple" => Predicate.from_json_str(%{{"not":["a","==",true]}})
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_json_str(%{{"and":[["a","==",1],["b","==",2]]}}),
+      "or" => Predicate.from_json_str(%{{"or":[["a","==",1],["b","==",2]]}})
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_json_str(%{
+        {
+          "or":[
+            {"and":[["a","==",1],["b","==",2]]},
+            ["c","==",3]
+          ]
+        }
+      })
+    }
+  }
+
+  create_canonical_tests(@expectations)
+
+end
+
+regarding "convert a json structure to a predicate" do
+  include CanonicalTransformCases
+
+  @expectations = {
+    "simple operations" => {
+      "eq" => Predicate.from_json_struct(["a", "==", 3]),
+      "gt" => Predicate.from_json_struct(["a", ">", 3]),
+      "lt" => Predicate.from_json_struct(["a", "<", 3]),
+      "gte" => Predicate.from_json_struct(["a", ">=", 3]),
+      "lte" => Predicate.from_json_struct(["a", "<=", 3])
+    },
+    "primitive types" => {
+      "false" => Predicate.from_json_struct(["a", "==", false]),
+      "true" => Predicate.from_json_struct(["a", "==", true]),
+      "string" => Predicate.from_json_struct(["a", "==", "yyy"])
+    },
+    "not" => {
+      "simple" => Predicate.from_json_struct("not" => ["a", "==", true])
+    },
+    "simple and / or" => {
+      #parens are necessary around AND's in solr in order to force precedence
+      "and" => Predicate.from_json_struct("and" => [["a", "==", 1],["b", "==", 2]]),
+      "or" => Predicate.from_json_struct("or" => [["a", "==", 1],["b", "==", 2]])
+    },
+    "complex and / or" => {
+      "or and" => Predicate.from_json_struct(
+        "or" => [
+          {"and" => [["a", "==", 1],["b", "==", 2]]}, 
+          ["c", "==", 3]
+        ]
+      )
+    }
+  }
+
+  create_canonical_tests(@expectations)
+
+end

data/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/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