wrong 0.3.1 → 0.3.2

data/lib/predicated/test/constrain_test.rb

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

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

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

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

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

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

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