predicated 0.1.0 → 0.2.0

data/lib/predicated/to/arel.rb

@@ -6,30 +6,36 @@ module Predicated
   
   require_gem_version("arel", "0.4.0")
   
-  {And => Arel::Predicates::And,
-   Or => Arel::Predicates::Or}.each do |predicated_class, arel_class|
-
-     predicated_class.class_eval %{
-      def to_arel
-        #{arel_class.name}.new(left.to_arel, right.to_arel)
-      end
-    }
-     
-
+  class And
+    def to_arel(arel_table)
+      Arel::Predicates::And.new(left.to_arel(arel_table), right.to_arel(arel_table))
+    end
   end
   
-  {Equal => Arel::Predicates::Equality,
-   GreaterThan => Arel::Predicates::GreaterThan,
-   LessThan => Arel::Predicates::LessThan,
-   GreaterThanOrEqualTo => Arel::Predicates::GreaterThanOrEqualTo,
-   LessThanOrEqualTo => Arel::Predicates::LessThanOrEqualTo}.each do |predicated_class, arel_class|
-
-    predicated_class.class_eval %{
-      def to_arel
-        #{arel_class.name}.new(left, right)
-      end
-    }
-
+  class Or
+    def to_arel(arel_table)
+      Arel::Predicates::Or.new(left.to_arel(arel_table), right.to_arel(arel_table))
+    end
+  end
+  
+  class Not
+    def to_arel(arel_table)
+      Arel::Predicates::Not.new(inner.to_arel(arel_table))
+    end
   end
   
+  
+  class Operation
+    def to_arel(arel_table)
+      arel_class.new(arel_table.attributes[left], right)
+    end
+  end
+  
+  class Equal; def arel_class; Arel::Predicates::Equality end end
+  class LessThan; def arel_class; Arel::Predicates::LessThan end end
+  class GreaterThan; def arel_class; Arel::Predicates::GreaterThan end end
+  class LessThanOrEqualTo; def arel_class; Arel::Predicates::LessThanOrEqualTo end end
+  class GreaterThanOrEqualTo; def arel_class; Arel::Predicates::GreaterThanOrEqualTo end end
+  
+  
 end

data/lib/predicated/to/json.rb

@@ -0,0 +1,48 @@
+require "predicated/predicate"
+
+module Predicated
+
+  require_gem_version("json", "1.1.9")
+
+  module JsonStructToJsonStr
+    def to_json_str
+      JSON.pretty_generate(to_json_struct)
+    end
+  end
+  
+  class And
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"and" => [left.to_json_struct, right.to_json_struct]}
+    end
+  end
+
+  class Or
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"or" => [left.to_json_struct, right.to_json_struct]}
+    end
+  end
+
+  class Not
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"not" => inner.to_json_struct}
+    end
+  end
+  
+  class Operation
+    include JsonStructToJsonStr
+    def to_json_struct
+      [left, json_sign, right]
+    end
+  end
+
+  class Equal; private; def json_sign; "==" end end
+  class LessThan; private; def json_sign; "<" end end
+  class GreaterThan; private; def json_sign; ">" end end
+  class LessThanOrEqualTo; private; def json_sign; "<=" end end
+  class GreaterThanOrEqualTo; private; def json_sign; ">=" end end
+  
+
+end

data/lib/predicated/to/sentence.rb

@@ -3,18 +3,28 @@ require "predicated/evaluate"
 
 module Predicated
   
-  module ContainerSentence
+  module Conjunction
     def to_sentence
-      left.to_sentence + "#{joining_str}" + right.to_sentence
+      left.to_sentence + joining_str + right.to_sentence
     end
 
     def to_negative_sentence
       "This is not true: " + to_sentence
     end
   end
+
+  class And; include Conjunction; def joining_str; " and " end; end
+  class Or; include Conjunction; def joining_str; " or " end;end
   
-  class And; include ContainerSentence; def joining_str; " and " end; end
-  class Or; include ContainerSentence; def joining_str; " or " end;end
+  class Not
+    def to_sentence
+      inner.to_negative_sentence
+    end
+
+    def to_negative_sentence
+      inner.to_sentence
+    end
+  end
   
   class Operation
 
@@ -76,16 +86,9 @@ module Predicated
     end
         
     def format_value(value)
-      if value.is_a?(String)
-        "'" + value.to_s + "'"
-      elsif value.nil?
-        "nil"
-      elsif value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
-        value.to_s
-      else
-        "'" + value.inspect + "'"
-      end
+      value.inspect
     end
+
   end
   
-end
+end

data/lib/predicated/to/solr.rb

@@ -0,0 +1,15 @@
+require "predicated/predicate"
+
+module Predicated
+  
+  class And; def to_solr; "(#{left.to_solr} AND #{right.to_solr})" end end
+  class Or;  def to_solr; "(#{left.to_solr} OR #{right.to_solr})" end end
+  class Not; def to_solr; "NOT(#{inner.to_solr})" end end
+  
+  class Equal;                def to_solr; "#{left}:#{right}" end end
+  class GreaterThan;          def to_solr; "#{left}:[#{(right+1)} TO *]" end end
+  class LessThan;             def to_solr; "#{left}:[* TO #{(right-1)}]" end end  
+  class GreaterThanOrEqualTo; def to_solr; "#{left}:[#{right} TO *]" end end
+  class LessThanOrEqualTo;    def to_solr; "#{left}:[* TO #{right}]" end end
+  
+end

data/lib/predicated/to/xml.rb

@@ -0,0 +1,67 @@
+require "predicated/predicate"
+
+module Predicated
+
+  module ContainerToXml
+    private
+    def to_xml_with_tag_name(indent, tag_name)
+      inner = %{\n#{left.to_xml(indent + "  ")}\n#{right.to_xml(indent + "  ")}}
+      "#{indent}<#{tag_name}>#{inner}\n#{indent}</#{tag_name}>"
+    end
+  end
+  
+  class And
+    include ContainerToXml
+    def to_xml(indent="")
+      to_xml_with_tag_name(indent, "and")
+    end
+  end
+
+  class Or
+    include ContainerToXml
+    def to_xml(indent="")
+      to_xml_with_tag_name(indent, "or")
+    end
+  end
+
+  class Not
+    def to_xml(indent="")
+      "#{indent}<not>\n#{inner.to_xml(indent + "  ")}\n#{indent}</not>"
+    end
+  end
+  
+  class Operation
+    def to_xml(indent="")
+      "#{indent}<#{tag_name}><left>#{escape(left)}</left><right>#{escape(right)}</right></#{tag_name}>"
+    end
+    
+    private 
+    
+    CONVERSION_TABLE = [
+       ['&', '&amp;'],
+       ['<', '&lt;'],
+       ['>', '&gt;'],
+       ["'", '&apos;'],
+       ['"', '&quot;']
+    ]
+    
+    #it's fast.  see http://groups.google.com/group/ruby-talk-google/browse_thread/thread/c0280bab8a037184/9b8ca81c2607189d?hl=en&ie=UTF-8
+    def escape(value)
+      if value.class == String
+        value.gsub(/['"&<>]/) do |match|
+          CONVERSION_TABLE.assoc(match).last
+        end
+      else
+        value
+      end
+    end
+  end
+
+  class Equal; private; def tag_name; "equal" end end
+  class LessThan; private; def tag_name; "lessThan" end end
+  class GreaterThan; private; def tag_name; "greaterThan" end end
+  class LessThanOrEqualTo; private; def tag_name; "lessThanOrEqualTo" end end
+  class GreaterThanOrEqualTo; private; def tag_name; "greaterThanOrEqualTo" end end
+  
+
+end

data/lib/predicated/version.rb

@@ -1,3 +1,3 @@
 module Predicated
-  VERSION = "0.1.0" unless defined?(Predicated::VERSION)
-end
+  VERSION = "0.2.0" unless defined?(Predicated::VERSION)
+end

data/test/canonical_transform_cases.rb

@@ -0,0 +1,67 @@
+module CanonicalTransformCases
+
+  module ClassMethods
+    def create_canonical_tests(expectations, proper_typing=true)
+      val = {
+        :one => 1,
+        :two => 2,
+        :three => 3,
+        :true_value => true,
+        :false_value => false
+      }
+
+      val.each{|k,v|val[k]=v.to_s} unless proper_typing
+
+      tests = {
+        "simple operations" => {
+          "eq" => Predicate{ Eq("a",val[:three]) },
+          "gt" => Predicate{ Gt("a",val[:three]) },
+          "lt" => Predicate{ Lt("a",val[:three]) },
+          "gte" => Predicate{ Gte("a",val[:three]) },
+          "lte" => Predicate{ Lte("a",val[:three]) }
+        },
+        "primitive types" => {
+          "true" => Predicate{ Eq("a",val[:true_value]) },
+          "false" => Predicate{ Eq("a",val[:false_value]) },
+          "string" => Predicate{ Eq("a","yyy") },
+        },
+        "not" => {
+          "simple" => Predicate{ Not(Eq("a",val[:true_value])) }
+        },
+        "simple and / or" => {
+          "and" => Predicate{ And(Eq("a", val[:one]),Eq("b", val[:two])) },
+          "or" => Predicate{ Or(Eq("a", val[:one]),Eq("b", val[:two])) }
+        },
+        "complex and / or" => {
+          "or and" => Predicate{ Or(And(Eq("a", val[:one]),Eq("b", val[:two])), Eq("c",val[:three])) }
+        }
+      }
+
+      tests.each do |test_name, cases|
+        test test_name do
+
+          not_found =
+            cases.keys.sort.select do |case_name|
+              expectations[test_name].nil? ||
+              expectations[test_name][case_name].nil?
+            end
+
+          raise "no expectation defined for test: '#{test_name}'  cases: [#{not_found.join(", ")}]" unless not_found.empty?
+
+          cases.each do |case_name, predicate|
+            actual = if block_given?
+                       yield(predicate)
+                     else
+                       predicate
+                     end
+            assert { actual == expectations[test_name][case_name] }
+          end
+        end
+      end
+    end
+  end
+
+  def self.included(other)
+    other.extend(ClassMethods)
+  end
+end

data/test/constrain_test.rb

@@ -1,10 +1,10 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/predicate"
 require "predicated/constrain"
 include Predicated
 
-apropos %{constraints are rules about the content and structure of predicates.
+regarding %{constraints are rules about the content and structure of predicates.
           a predicate might violate a constraint} do
             
   before do
@@ -16,16 +16,25 @@ apropos %{constraints are rules about the content and structure of predicates.
     @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(Predicate{Eq(1,1)}).pass? }
-    deny  { constraints.check(Predicate{Eq(1,2)}).pass? }
+    assert{ constraints.check(@one).pass? }
+    deny  { constraints.check(@two).pass? }
     
-    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(1,3))}).pass? }
-    deny  { constraints.check(Predicate{And(Eq(1,1), Eq(1,2))}).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
@@ -34,11 +43,11 @@ apropos %{constraints are rules about the content and structure of predicates.
         add(@value_not_equal_to_two).
         add(@not_more_than_two_levels_deep)
 
-    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(3,3))}).pass? }
-    deny  { constraints.check(Predicate{And(Eq(1,1), Eq(2,2))}).pass? }
+    assert{ constraints.check(@one_and_three).pass? }
+    deny  { constraints.check(@one_and_two).pass? }
     
-    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(3,3))}).pass? }
-    deny  { constraints.check(Predicate{Or(Or(And(Eq(1,1), Eq(3,3)), Eq(4,4)), Eq(5,5))}).pass? }
+    assert{ constraints.check(@one_and_three).pass? }
+    deny  { constraints.check(@deeply_nested).pass? }
   end
 
   test "equality" do
@@ -60,7 +69,7 @@ apropos %{constraints are rules about the content and structure of predicates.
          along with the offending predicates} do
     constraints = Constraints.new.add(@value_not_equal_to_two)
     
-    result = constraints.check(Predicate{Eq(1,1)})
+    result = constraints.check(@one)
     assert{ result.pass? }
     assert{ result.violations == {} }
     

data/test/enumerable_test.rb

@@ -1,9 +1,9 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/predicate"
 include Predicated
 
-apropos "you can flip through the predicate tree, like any enumerable.  a list of ancestors of each node are provided" do
+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) }, []]] }
@@ -23,38 +23,10 @@ apropos "you can flip through the predicate tree, like any enumerable.  a list o
      }
   end
 
-end
-
-apropos "there are convenient selectors defined for getting things out of a predicate" do
-  class Array
-    def predicates
-      collect{|p, a|p}
-    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
-  
-  it "gets predicate parts by type" do
-    root = Predicate { And(Eq(1, 2), Or(Eq(3, 4), Eq(5, 6))) }
-    the_or = Predicate { Or(Eq(3, 4), Eq(5, 6)) }
-
-    assert{ root.select(:all).predicates == [root, Equal.new(1, 2), the_or, Equal.new(3, 4), Equal.new(5, 6)] }
     
-    assert{ root.select(And).predicates == [root] }
-    assert{ root.select(Or).predicates == [the_or] }
-    assert{ root.select(Equal).predicates == [Equal.new(1, 2), Equal.new(3, 4), Equal.new(5, 6)] }
-    assert{ root.select(GreaterThan).predicates == [] }
-    
-    gt_lt = Predicate { And(Gt(1, 2), Lt(3, 4)) }
-    assert{ gt_lt.select(GreaterThan).predicates == [GreaterThan.new(1, 2)] }
-    assert{ gt_lt.select(LessThan).predicates == [LessThan.new(3, 4)] }
+end
 
-    gte_lte = Predicate { And(Gte(1, 2), Lte(3, 4)) }
-    assert{ gte_lte.select(GreaterThanOrEqualTo).predicates == [GreaterThanOrEqualTo.new(1, 2)] }
-    assert{ gte_lte.select(LessThanOrEqualTo).predicates == [LessThanOrEqualTo.new(3, 4)] }
-    
-    mixed = Predicate { And(Eq(1, 2), Or(Gt(3, 4), Lt(5, 6))) }
-    mixed_or = Predicate { Or(Gt(3, 4), Lt(5, 6)) }
-    assert{ mixed.select(Operation).predicates == [Equal.new(1, 2), GreaterThan.new(3, 4), LessThan.new(5, 6)] }
-    assert{ mixed.select(Operation).select(Equal).predicates == [Equal.new(1, 2)] }
-    assert{ mixed.select(Binary).predicates == [mixed, Equal.new(1, 2), mixed_or, GreaterThan.new(3, 4), LessThan.new(5, 6)] }
-  end
-end

data/test/equality_test.rb

@@ -1,21 +1,32 @@
-require "test/test_helper_with_wrong"
+require "./test/test_helper_with_wrong"
 
 require "predicated/predicate"
 include Predicated
 
-apropos "prove value equality" do
+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))) } ==
+    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
+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