predicated 0.1.0 → 0.2.0

data/test/suite.rb

@@ -1,4 +1,2 @@
-#simple way to make sure requires are isolated
-result = Dir["test/**/*_test.rb"].collect{|test_file| system("ruby #{test_file}") }.uniq == [true]
-puts "suite " + (result ? "passed" : "FAILED")
-exit(result ? 0 : 1)
+require "./test/test_helper"
+run_suite("test/**/*_test.rb")

data/test/test_helper.rb

@@ -8,6 +8,28 @@ require "pp"
 #DO NOT REQUIRE WRONG IN HERE
 #The circularity between projects will cause certain tests to not work.
 
+class Color
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    other.is_a?(Color) && @name == other.name
+  end
+
+  def to_s
+    "name:#{@name}"
+  end
+end
+
+def run_suite(wildcard)
+  #simple way to make sure requires are isolated
+  result = Dir[wildcard].collect{|test_file| system("ruby #{test_file}") }.uniq == [true]
+  puts "suite " + (result ? "passed" : "FAILED")
+  exit(result ? 0 : 1)
+end
+
 class MiniTest::Unit::TestCase
   
   def assert_raise(exception_info_regex)
@@ -21,10 +43,10 @@ class MiniTest::Unit::TestCase
 end
 
 module Kernel
-  alias_method :apropos, :describe
+  alias_method :regarding, :describe
   
-  def xapropos(str)
-    puts "x'd out 'apropos \"#{str}\"'"
+  def xregarding(str)
+    puts "x'd out 'regarding \"#{str}\"'"
   end
 end
 
@@ -39,4 +61,4 @@ class MiniTest::Spec
   end
 end
 
-MiniTest::Unit.autorun
+MiniTest::Unit.autorun

data/test/test_helper_with_wrong.rb

@@ -1,5 +1,6 @@
-require "test/test_helper"
+require "./test/test_helper"
+
 require "wrong"
 require "wrong/adapters/minitest"
 require "wrong/message/test_context"
-require "wrong/message/string_diff"
+require "wrong/message/string_diff"

data/test/to/arel_test.rb

@@ -1,43 +1,83 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
 
 unless RUBY_VERSION=="1.8.6"
   
 require "predicated/to/arel"
 include Predicated
 
-apropos "convert a predicate to an arel where clause" do
-
-  test "operations" do
-    assert { Predicate{ Eq("a",1) }.to_arel == Arel::Predicates::Equality.new("a", 1) }
-    assert { Predicate{ Gt("a",1) }.to_arel == Arel::Predicates::GreaterThan.new("a", 1) }
-    assert { Predicate{ Lt("a",1) }.to_arel == Arel::Predicates::LessThan.new("a", 1) }
-    assert { Predicate{ Gte("a",1) }.to_arel == Arel::Predicates::GreaterThanOrEqualTo.new("a", 1) }
-    assert { Predicate{ Lte("a",1) }.to_arel == Arel::Predicates::LessThanOrEqualTo.new("a", 1) }
+regarding "convert a predicate to an arel where clause" do
+  include CanonicalTransformCases
+  
+  class FakeEngine
+    def connection
+    end
+    
+    def table_exists?(name)
+      true
+    end
   end
-
-  test "simple and + or" do
-    assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_arel == 
-              Arel::Predicates::And.new(
-                Arel::Predicates::Equality.new("a", 1), 
-                Arel::Predicates::Equality.new("b", 2)
-              ) }
-
-    assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_arel == 
-              Arel::Predicates::Or.new(
-                Arel::Predicates::Equality.new("a", 1), 
-                Arel::Predicates::Equality.new("b", 2)
-              ) }
+  
+  class FakeColumn
+    attr_reader :name, :type
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+    
+    def type_cast(value)
+      value
+    end
   end
   
-  test "complex and + or" do
-    assert { Predicate{ Or( And(Eq("a", 1),Eq("b", 2)), Eq("c", 3) ) }.to_arel ==
-              Arel::Predicates::Or.new(
-                Arel::Predicates::And.new(
-                  Arel::Predicates::Equality.new("a", 1), 
-                  Arel::Predicates::Equality.new("b", 2)
-                ), 
-                Arel::Predicates::Equality.new("c", 3)
-              ) }
+  @table = Arel::Table.new(:widget, :engine => FakeEngine.new)
+  Arel::Table.tables = [@table]
+  @table.instance_variable_set("@columns".to_sym, [
+    FakeColumn.new("a", :integer), 
+    FakeColumn.new("b", :integer),
+    FakeColumn.new("c", :integer)
+  ])
+
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => Arel::Predicates::Equality.new(@table.attributes["a"], 3),
+      "gt" => Arel::Predicates::GreaterThan.new(@table.attributes["a"], 3),
+      "lt" => Arel::Predicates::LessThan.new(@table.attributes["a"], 3),
+      "gte" => Arel::Predicates::GreaterThanOrEqualTo.new(@table.attributes["a"], 3),
+      "lte" => Arel::Predicates::LessThanOrEqualTo.new(@table.attributes["a"], 3)
+    },
+    "primitive types" => {
+      "false" => Arel::Predicates::Equality.new(@table.attributes["a"], false),
+      "true" => Arel::Predicates::Equality.new(@table.attributes["a"], true),
+      "string" => Arel::Predicates::Equality.new(@table.attributes["a"], "yyy")
+    },
+    "not" => {
+      "simple" => Arel::Predicates::Not.new(Arel::Predicates::Equality.new(@table.attributes["a"], true))
+    },
+    "simple and / or" => {
+      "and" => Arel::Predicates::And.new(
+                 Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                 Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+               ),
+      "or" => Arel::Predicates::Or.new(
+                Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+              )
+    },
+    "complex and / or" => {
+      "or and" => Arel::Predicates::Or.new(
+                    Arel::Predicates::And.new(
+                      Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                      Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+                    ), 
+                    Arel::Predicates::Equality.new(@table.attributes["c"], 3)
+                  )
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_arel(@table)
   end
 
 end

data/test/to/json_test.rb

@@ -0,0 +1,74 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/json"
+include Predicated
+
+regarding "convert a predicate to a json structure" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => ["a", "==", 3],
+      "gt" => ["a", ">", 3],
+      "lt" => ["a", "<", 3],
+      "gte" => ["a", ">=", 3],
+      "lte" => ["a", "<=", 3]
+    },
+    "primitive types" => {
+      "false" => ["a", "==", false],
+      "true" => ["a", "==", true],
+      "string" => ["a", "==", "yyy"]
+    },
+    "not" => {
+      "simple" => {"not" => ["a", "==", true]}
+    },
+    "simple and / or" => {
+      "and" => {"and" => [["a", "==", 1], ["b", "==", 2]] },
+      "or" =>  {"or" =>  [["a", "==", 1], ["b", "==", 2]] }
+    },
+    "complex and / or" => {
+      "or and" => {"or" =>  [
+                    {"and" => [["a", "==", 1], ["b", "==", 2]]},
+                    ["c", "==", 3]
+                   ]}
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_json_struct
+  end
+end
+
+regarding "convert a predicate to a json string" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => %{["a","==",3]},
+      "gt" => %{["a",">",3]},
+      "lt" => %{["a","<",3]},
+      "gte" => %{["a",">=",3]},
+      "lte" => %{["a","<=",3]}
+    },
+    "primitive types" => {
+      "false" => %{["a","==",false]},
+      "true" =>  %{["a","==",true]},
+      "string" => %{["a","==","yyy"]}
+    },
+    "not" => {
+      "simple" => %{{"not":["a","==",true]}}
+    },
+    "simple and / or" => {
+      "and" => %{{"and":[["a","==",1],["b","==",2]]}},
+      "or" =>  %{{"or":[["a","==",1],["b","==",2]]}}
+    },
+    "complex and / or" => {
+      "or and" => %{{"or":[{"and":[["a","==",1],["b","==",2]]},["c","==",3]]}}
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_json_str.gsub("\n", "").gsub(" ", "")
+  end
+end

data/test/to/sentence_test.rb

@@ -1,83 +1,90 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/to/sentence"
 include Predicated
 
-apropos "convert a predicate to an english sentence" do
+regarding "convert a predicate to an english sentence" do
   
   after do
     Operation.reset_verb_phrases
   end
   
   test "operations" do
-    assert { Predicate{ Eq("a",1) }.to_sentence == "'a' is equal to 1" }
-    assert { Predicate{ Gt("a",1) }.to_sentence == "'a' is greater than 1" }
-    assert { Predicate{ Lt("a",1) }.to_sentence == "'a' is less than 1" }
-    assert { Predicate{ Gte("a",1) }.to_sentence == "'a' is greater than or equal to 1" }
-    assert { Predicate{ Lte("a",1) }.to_sentence == "'a' is less than or equal to 1" }
+    assert { Predicate{ Eq("a",1) }.to_sentence == '"a" is equal to 1' }
+    assert { Predicate{ Gt("a",1) }.to_sentence == '"a" is greater than 1' }
+    assert { Predicate{ Lt("a",1) }.to_sentence == '"a" is less than 1' }
+    assert { Predicate{ Gte("a",1) }.to_sentence == '"a" is greater than or equal to 1' }
+    assert { Predicate{ Lte("a",1) }.to_sentence == '"a" is less than or equal to 1' }
 
-    assert { Predicate{ Eq("a",1) }.to_negative_sentence == "'a' is not equal to 1" }
-    assert { Predicate{ Gt("a",1) }.to_negative_sentence == "'a' is not greater than 1" }
-    assert { Predicate{ Lt("a",1) }.to_negative_sentence == "'a' is not less than 1" }
-    assert { Predicate{ Gte("a",1) }.to_negative_sentence == "'a' is not greater than or equal to 1" }
-    assert { Predicate{ Lte("a",1) } .to_negative_sentence == "'a' is not less than or equal to 1" }
+    assert { Predicate{ Eq("a",1) }.to_negative_sentence == '"a" is not equal to 1' }
+    assert { Predicate{ Gt("a",1) }.to_negative_sentence == '"a" is not greater than 1' }
+    assert { Predicate{ Lt("a",1) }.to_negative_sentence == '"a" is not less than 1' }
+    assert { Predicate{ Gte("a",1) }.to_negative_sentence == '"a" is not greater than or equal to 1' }
+    assert { Predicate{ Lte("a",1) } .to_negative_sentence == '"a" is not less than or equal to 1' }
   end
   
   test "primitive types" do
-    assert { Predicate{ Eq("a",1) }.to_sentence == "'a' is equal to 1" }
-    assert { Predicate{ Eq("a",nil) }.to_sentence == "'a' is equal to nil" }
-    assert { Predicate{ Eq("a",true) }.to_sentence == "'a' is equal to true" }
+    assert { Predicate{ Eq("a",1) }.to_sentence == '"a" is equal to 1' }
+    assert { Predicate{ Eq("a",nil) }.to_sentence == '"a" is equal to nil' }
+    assert { Predicate{ Eq("a",true) }.to_sentence == '"a" is equal to true' }
+    assert { Predicate{ Eq("a",3.14) }.to_sentence == '"a" is equal to 3.14' }
+  end
+
+  test "not" do
+    assert { Predicate{ Not(Eq("a",1)) }.to_sentence == '"a" is not equal to 1' }
+    assert { Predicate{ Not(Eq("a",1)) }.to_negative_sentence == '"a" is equal to 1' }
   end
   
   test "complex types" do
-    assert { Predicate{ Eq([1,2],{3=>4}) }.to_sentence == "'[1, 2]' is equal to '{3=>4}'" }
+    assert { Predicate{ Eq([1,2],{3=>4}) }.to_sentence == "[1, 2] is equal to {3=>4}" }
   end
   
   test "default verb phrases for unknown methods (which are awkward/ESL-ish)" do
     assert { Predicate{ Call("abc", :exclude?, "bc") }.to_sentence == 
-      "'abc' is exclude 'bc'" }
+      '"abc" is exclude "bc"' }
 
     assert { Predicate{ Call("abc", :exclude?, "bc") }.to_negative_sentence == 
-      "'abc' is not exclude 'bc'" }
+      '"abc" is not exclude "bc"' }
       
     assert { Predicate{ Call("abc", :friends_with?, "bc") }.to_sentence == 
-      "'abc' is friends with 'bc'" }
+      '"abc" is friends with "bc"' }
   end
   
   test "register methods and their verb phrases" do
-    Operation.register_verb_phrase(:exclude?, "does exclude", "does not exclude")
+    Operation.register_verb_phrase(:exclude?, "excludes", "does not exclude")
     assert { Predicate{ Call("abc", :exclude?, "bc") }.to_sentence == 
-      "'abc' does exclude 'bc'" }
+      '"abc" excludes "bc"' }
 
     assert { Predicate{ Call("abc", :exclude?, "bc") }.to_negative_sentence == 
-      "'abc' does not exclude 'bc'" }
+      '"abc" does not exclude "bc"' }
   end
   
   test "some other common methods have sensible verb phrases by default" do
-    assert { Predicate{ Call("abc", :include?, 'bc') }.to_sentence == "'abc' includes 'bc'" }
-    assert { Predicate{ Call("abc", :include?, 'bc') }.to_negative_sentence == "'abc' does not include 'bc'" }
-    
-    assert { Predicate{ Call("abc", :is_a?, String) }.to_sentence == "'abc' is a 'String'" }
-    assert { Predicate{ Call("abc", :is_a?, String) }.to_negative_sentence == "'abc' is not a 'String'" }
+    assert { Predicate{ Call("abc", :include?, 'bc') }.to_sentence == '"abc" includes "bc"' }
+    assert { Predicate{ Call("abc", :include?, 'bc') }.to_negative_sentence == '"abc" does not include "bc"' }
+
+    s = Predicate{ Call("abc", :is_a?, String) }.to_sentence
+    assert { s == '"abc" is a String' }
+    assert { Predicate{ Call("abc", :is_a?, String) }.to_negative_sentence == '"abc" is not a String' }
   end
   
   test "nothing on the far side" do
-    assert { Predicate{ Call("abc", :nil?) }.to_sentence == "'abc' is nil" }
-    assert { Predicate{ Call("abc", :nil?) }.to_negative_sentence == "'abc' is not nil" }
+    assert { Predicate{ Call("abc", :nil?) }.to_sentence == '"abc" is nil' }
+    assert { Predicate{ Call("abc", :nil?) }.to_negative_sentence == '"abc" is not nil' }
   end
   
   test "simple and + or" do
     assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_sentence == 
-              "'a' is equal to 1 and 'b' is equal to 2" }
+              '"a" is equal to 1 and "b" is equal to 2' }
 
     assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_sentence == 
-              "'a' is equal to 1 or 'b' is equal to 2" }
+              '"a" is equal to 1 or "b" is equal to 2' }
 
     assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_negative_sentence == 
-              "This is not true: 'a' is equal to 1 and 'b' is equal to 2" }
+              'This is not true: "a" is equal to 1 and "b" is equal to 2' }
 
     assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_negative_sentence == 
-              "This is not true: 'a' is equal to 1 or 'b' is equal to 2" }
+              'This is not true: "a" is equal to 1 or "b" is equal to 2' }
   end
 
-end
+end

data/test/to/solr_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/solr"
+include Predicated
+
+regarding "convert a predicate to a solr query" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => "a:3",
+      "gt" => "a:[4 TO *]",
+      "lt" => "a:[* TO 2]",
+      "gte" => "a:[3 TO *]",
+      "lte" => "a:[* TO 3]"
+    },
+    "primitive types" => {
+      "false" => "a:false",
+      "true" => "a:true",
+      "string" => "a:yyy"
+    },
+    "not" => {
+      "simple" => "NOT(a:true)"
+    },
+    "simple and / or" => {
+      "and" => "(a:1 AND b:2)", #parens are necessary around AND's in solr in order to force precedence
+      "or" => "(a:1 OR b:2)",
+    },
+    "complex and / or" => {
+      "or and" => "((a:1 AND b:2) OR c:3)"
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_solr
+  end
+
+end

data/test/to/xml_test.rb

@@ -0,0 +1,72 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/xml"
+include Predicated
+
+regarding "convert a predicate to an xml string" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => "<equal><left>a</left><right>3</right></equal>",
+      "gt" => "<greaterThan><left>a</left><right>3</right></greaterThan>",
+      "lt" => "<lessThan><left>a</left><right>3</right></lessThan>",
+      "gte" => "<greaterThanOrEqualTo><left>a</left><right>3</right></greaterThanOrEqualTo>",
+      "lte" => "<lessThanOrEqualTo><left>a</left><right>3</right></lessThanOrEqualTo>"
+    },
+    "primitive types" => {
+      "false" => "<equal><left>a</left><right>false</right></equal>",
+      "true" => "<equal><left>a</left><right>true</right></equal>",
+      "string" => "<equal><left>a</left><right>yyy</right></equal>"
+    },
+    "not" => {
+      "simple" => "<not><equal><left>a</left><right>true</right></equal></not>"
+    },
+    "simple and / or" => {
+      "and" => %{<and>
+                  <equal><left>a</left><right>1</right></equal>
+                  <equal><left>b</left><right>2</right></equal>
+                </and>}.gsub("\n", "").gsub(" ", ""),
+      "or" => %{<or>
+                  <equal><left>a</left><right>1</right></equal>
+                  <equal><left>b</left><right>2</right></equal>
+                </or>}.gsub("\n", "").gsub(" ", "")
+    },
+    "complex and / or" => {
+      "or and" =>  %{<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>}.gsub("\n", "").gsub(" ", "")
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_xml.gsub("\n", "").gsub(" ", "")
+  end
+  
+  test "pretty printing" do
+    assert{ 
+      Predicate{ Or(And(Eq("a", 1),Eq("b", 2)), Not(Eq("c",3))) }.to_xml ==
+%{<or>
+  <and>
+    <equal><left>a</left><right>1</right></equal>
+    <equal><left>b</left><right>2</right></equal>
+  </and>
+  <not>
+    <equal><left>c</left><right>3</right></equal>
+  </not>
+</or>}
+    }
+  end
+
+  test "characters that need to be encoded" do
+    assert{ 
+      Predicate{ Eq(%{'"&<>}, %{'"&<>}) }.to_xml ==
+        %{<equal><left>&apos;&quot;&amp;&lt;&gt;</left><right>&apos;&quot;&amp;&lt;&gt;</right></equal>}
+    }
+  end
+end