wrong 0.1.0 → 0.2.0

data/lib/predicated/test/constrain_test.rb

@@ -0,0 +1,86 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/predicate"
+require "predicated/constrain"
+include Predicated
+
+regarding %{constraints are rules about the content and structure of predicates.
+          a predicate might violate a constraint} do
+            
+  before do
+    @value_not_equal_to_two =
+      Constraint.new(:name => "Value can't be two",
+                     :selectors => [Operation],
+                     :check_that => proc{|predicate, ancestors| predicate.right!=2})
+                     
+    @not_more_than_two_levels_deep =
+      Constraint.new(:name => "Limited to two levels deep",
+                     :check_that => proc{|predicate, ancestors| ancestors.length<=2})
+                     
+    @one = Predicate{Eq(1,1)}
+    @two = Predicate{Eq(2,2)}
+    @three = Predicate{Eq(3,3)}
+    
+    @one_and_three = Predicate{And(Eq(1,1), Eq(3,3))}
+    @one_and_two = Predicate{And(Eq(1,1), Eq(2,2))}
+    
+    @deeply_nested = Predicate{Or(Or(And(Eq(1,1), Eq(3,3)), Eq(4,4)), Eq(5,5))}
+  end
+  
+  test "apply to each predicate - simple" do
+    constraints = Constraints.new.add(@value_not_equal_to_two)
+    
+    assert{ constraints.check(@one).pass? }
+    deny  { constraints.check(@two).pass? }
+    
+    assert{ constraints.check(@one_and_three).pass? }
+    deny  { constraints.check(@one_and_two).pass? }
+  end
+  
+  test "apply each to each predicate - many constraints" do
+    constraints = 
+      Constraints.new.
+        add(@value_not_equal_to_two).
+        add(@not_more_than_two_levels_deep)
+
+    assert{ constraints.check(@one_and_three).pass? }
+    deny  { constraints.check(@one_and_two).pass? }
+    
+    assert{ constraints.check(@one_and_three).pass? }
+    deny  { constraints.check(@deeply_nested).pass? }
+  end
+
+  test "equality" do
+    one = Constraint.new(:name => "Value can't be two",
+                         :selectors => [Operation],
+                         :check_that => proc{|predicate, ancestors| predicate.right!=2})
+    two = Constraint.new(:name => "Value can't be two",
+                         :selectors => [Operation],
+                         :check_that => proc{|predicate, ancestors| predicate.right!=2})
+    three = Constraint.new(:name => "Some other constraint",
+                           :check_that => proc{|predicate, ancestors| false})
+                           
+    assert{ one == two }
+    deny  { one == three }
+  end
+
+  test %{result contains information about whether the checks passed, 
+         which constraints were violated, 
+         along with the offending predicates} do
+    constraints = Constraints.new.add(@value_not_equal_to_two)
+    
+    result = constraints.check(@one)
+    assert{ result.pass? }
+    assert{ result.violations == {} }
+    
+    result = constraints.check(Predicate{And(Eq(1,1), And(Eq(2,2), Eq(3,2)))})
+    deny  { result.pass? }
+    assert{ 
+      result.violations == {
+        @value_not_equal_to_two => [Equal.new(2,2), Equal.new(3,2)]
+      } 
+    }
+  end
+
+  
+end

data/lib/predicated/test/enumerable_test.rb

@@ -0,0 +1,32 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+regarding "you can flip through the predicate tree, like any enumerable.  a list of ancestors of each node are provided" do
+  
+  test "simple" do
+    assert { Predicate { Eq(1, 2) }.to_a == [[Predicate { Eq(1, 2) }, []]] }
+  end
+    
+  test "complex" do
+    the_top = Predicate { And(Eq(1, 2), Or(Eq(3, 4), Eq(5, 6))) }
+    the_or = Predicate { Or(Eq(3, 4), Eq(5, 6)) }
+    assert { the_top.to_a == 
+       [
+        [the_top, []],
+        [Predicate { Eq(1, 2) }, [the_top]],
+        [Predicate { Or(Eq(3, 4), Eq(5, 6)) }, [the_top]],
+        [Predicate { Eq(3, 4) }, [the_top, the_or]],
+        [Predicate { Eq(5, 6) }, [the_top, the_or]]
+       ] 
+     }
+  end
+
+  test "not" do
+    the_top = Predicate { Not(Eq(1, 2)) }
+    assert {  the_top.to_a == [[the_top, []], [Predicate { Eq(1, 2) }, [the_top]]] }
+  end
+    
+end
+

data/lib/predicated/test/equality_test.rb

@@ -0,0 +1,32 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+regarding "prove value equality" do
+  
+  test "simple" do
+    assert { Predicate { Eq(1, 1) } == Predicate { Eq(1, 1) } }
+    deny   { Predicate { Eq(1, 1) } == Predicate { Eq(1, 99) } }
+  end
+  
+  test "unary" do
+    assert { Predicate { Not(Eq(1, 1)) } == Predicate { Not(Eq(1, 1)) } }
+    deny   { Predicate { Not(Eq(1, 1)) } == Predicate { Not(Eq(99, 99)) } }
+  end
+  
+  test "complex" do
+    assert { Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } ==
+             Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } }
+    
+    deny   { Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } ==
+             Predicate { And(Eq(1, 1), Or(Eq(2, 99), Eq(3, 3))) } }
+  end
+
+end
+
+regarding "predicate base class.  not sure I'm happy with the implementation...too tricky" do
+  test "all predicates descend from a predicate base class.  it's a marker class" do
+    assert{ And.new(Equal.new(1,1),Equal.new(2,2)).is_a?(Predicate) }
+  end
+end

data/lib/predicated/test/evaluate_test.rb

@@ -0,0 +1,149 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/evaluate"
+include Predicated
+
+regarding "evaluate a predicate as boolean logic in ruby.  change the context by providing and optional binding." do
+
+  regarding "proving out basic operations" do
+    test "equals" do
+      assert { Predicate { Eq(1, 1) }.evaluate }
+      deny   { Predicate { Eq(1, 2) }.evaluate }
+    end
+  
+    test "less than" do
+      assert { Predicate { Lt(1, 2) }.evaluate }
+      deny   { Predicate { Lt(2, 2) }.evaluate }
+      deny   { Predicate { Lt(3, 2) }.evaluate }
+    end
+
+    test "greater than" do
+      deny   { Predicate { Gt(1, 2) }.evaluate }
+      deny   { Predicate { Gt(2, 2) }.evaluate }
+      assert { Predicate { Gt(3, 2) }.evaluate }
+    end
+
+    test "less than or equal to" do
+      assert { Predicate { Lte(1, 2) }.evaluate }
+      assert { Predicate { Lte(2, 2) }.evaluate }
+      deny   { Predicate { Lte(3, 2) }.evaluate }
+    end
+  
+    test "greater than or equal to" do
+      deny   { Predicate { Gte(1, 2) }.evaluate }
+      assert { Predicate { Gte(2, 2) }.evaluate }
+      assert { Predicate { Gte(3, 2) }.evaluate }
+    end
+  end
+
+  regarding "comparing values of different data types" do
+    test "strings" do
+      assert { Predicate { Eq("1", "1") }.evaluate }
+      deny   { Predicate { Eq("1", 1) }.evaluate }
+      deny   { Predicate { Eq("1", nil) }.evaluate }
+    end
+  
+    test "booleans" do
+      assert { Predicate { Eq(true, true) }.evaluate }
+      deny   { Predicate { Eq(false, true) }.evaluate }
+      
+      deny   { Predicate { Eq(false, nil) }.evaluate }
+      deny   { Predicate { Eq(true, nil) }.evaluate }
+      
+      deny   { Predicate { Eq("false", false) }.evaluate }
+      deny   { Predicate { Eq("true", true) }.evaluate }
+    end
+  
+    test "numbers" do
+      assert { Predicate { Eq(1, 1) }.evaluate }
+      assert { Predicate { Eq(1, 1.0) }.evaluate }
+      assert { Predicate { Eq(1.0, 1.0) }.evaluate }
+      deny   { Predicate { Eq(1, 2) }.evaluate }
+      deny   { Predicate { Eq(1, nil) }.evaluate }
+    end
+
+    test "objects" do
+      assert { Predicate { Eq(Color.new("red"), Color.new("red")) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), Color.new("BLUE")) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), 2) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), "red") }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), nil) }.evaluate }
+    end
+  end
+  
+  
+  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 }
+      deny   { Predicate { And( Eq(1, 1), Eq(99, 2) ) }.evaluate }
+    end
+
+    test "simple true and false work too" do
+      assert { Predicate { And( true, true ) }.evaluate }
+      assert { Predicate { And( true, Eq(2, 2) ) }.evaluate }
+      deny   { Predicate { And( true, false ) }.evaluate }
+      deny   { Predicate { And( Eq(2, 2), false ) }.evaluate }
+    end
+    
+    test "nested" do
+      assert { Predicate { And( true, And(true, true) ) }.evaluate }
+      deny   { Predicate { And( false, And(true, true) ) }.evaluate }
+      deny   { Predicate { And( true, And(true, false) ) }.evaluate }
+    end
+  end
+  
+  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 }
+      assert { Predicate { Or(false, true) }.evaluate }
+      deny   { Predicate { Or(false, false) }.evaluate }
+    end
+  end  
+  
+  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 }
+    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 }
+
+      assert { Predicate { Call(nil, :nil?) }.evaluate }
+      deny   { Predicate { Call("abc", :nil?) }.evaluate }
+    end
+
+    test "inspect" do
+      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") }
+    end
+    
+
+  end  
+  
+end

data/lib/predicated/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/lib/predicated/test/from/callable_object_test.rb

@@ -0,0 +1,78 @@
+require "./test/test_helper"
+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 "convert a ruby callable object - a proc or lambda - into a predicate" do
+
+  regarding "basic operations" do
+                                             
+    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 "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 or 2==2}, Predicate{ Or(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_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 "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
+  
+  regarding "errors" do
+    test "predicates only" do
+      assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
+        Predicate.from_callable_object{a=1}
+      end
+    end
+  end
+end
+
+end

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