predicated 0.1.0 → 0.2.0

data/README.markdown

@@ -1,8 +1,190 @@
-Predicated is a simple predicate model for Ruby.
+## Abstract ##
+
+Predicated is a simple predicate model for Ruby.  It provides useful predicate transformations and operations.
 
 Tracker project:
 [http://www.pivotaltracker.com/projects/95014](http://www.pivotaltracker.com/projects/95014)
 
+## Transformations ##
+
+- From:
+  - json
+  - xml
+  - url part, ex: "!(a=1&b=2|c=3)"
+  - callable objects (lambdas/procs, and therefore blocks) - ruby 1.8.x only
+  - ruby code - ruby 1.8.x only
+- To:
+  - json
+  - xml
+  - sql where clause via [arel](http://github.com/rails/arel)
+  - [solr](http://lucene.apache.org/solr/) query string
+  - english sentence, ex: "'a' is not equal to 'b'"
+
+## Usage ##
+
+Note: The test suite acts as a comprehensive usage guide.
+
+
+Evaluate a predicate:
+    
+    require "predicated/evaluate"
+    include Predicated
+            
+    Predicate { Eq(1, 2) }.evaluate == false
+    Predicate { Lt(1, 2) }.evaluate == true
+    Predicate { Or(Lt(1, 2),Eq(1, 2)) }.evaluate == true
+    
+    x = 1
+    Predicate { Lt(x, 2) }.evaluate == true
+
+
+Parse a predicate from part of a url and then turn it into a sql where clause:
+    
+    require "predicated/from/url_part"
+    require "predicated/to/arel"
+        
+    predicate = Predicated::Predicate.from_url_part("(color=red|color=green)&size=large")
+    
+    predicate.inspect == 
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+    
+    predicate.to_arel(Table(:shirt)).to_sql == 
+      %{(("shirt"."color" = 'red' OR "shirt"."color" = 'green') AND "shirt"."size" = 'large')} 
+  
+
+Parse a predicate from json and then turn it into a solr query string:
+    
+    require "predicated/from/json"
+    require "predicated/to/solr"
+        
+    predicate = Predicated::Predicate.from_json_str(%{
+      {"and":[{"or":[["color","==","red"],["color","==","green"]]},["size","==","large"]]}
+    })
+        
+    predicate.inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+        
+    predicate.to_solr == "((color:red OR color:green) AND size:large)" 
+
+  
+From json:
+    
+    require "predicated/from/json"
+        
+    Predicated::Predicate.from_json_str(%{
+      {"and":[
+        {"or":[
+          ["color","==","red"],
+          ["color","==","green"]
+        ]},
+        ["size","==","large"]
+      ]}
+    }).inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+
+
+From xml:
+    
+    require "predicated/from/xml"
+        
+    Predicated::Predicate.from_xml(%{
+      <and>
+        <or>
+          <equal><left>color</left><right>red</right></equal>
+          <equal><left>color</left><right>green</right></equal>
+        </or>
+        <equal><left>size</left><right>large</right></equal>
+      </and>
+    }).inspect == "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+
+
+From url part:
+    
+    require "predicated/from/url_part"
+        
+    Predicated::Predicate.from_url_part("(color=red|color=green)&size=large").inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+
+
+From callable object:
+    
+    require "predicated/from/callable_object"
+        
+    Predicated::Predicate.from_callable_object{('color'=='red' || 'color'=='green') && 'size'=='large'}.inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+
+
+From ruby code string:
+      
+    require "predicated/from/ruby_code_string"
+            
+    Predicated::Predicate.from_ruby_code_string("('color'=='red' || 'color'=='green') && 'size'=='large'").inspect ==
+      "And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))" 
+  
+  
+To json:
+      
+    require "predicated/to/json"
+    include Predicated
+            
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_json_str ==
+    %{
+      {"and":[
+        {"or":[
+          ["color","==","red"],
+          ["color","==","green"]
+        ]},
+        ["size","==","large"]
+      ]}
+    }
+  
+  
+To xml:
+      
+    require "predicated/to/xml"
+    include Predicated
+            
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_xml ==
+    %{
+      <and>
+        <or>
+          <equal><left>color</left><right>red</right></equal>
+          <equal><left>color</left><right>green</right></equal>
+        </or>
+        <equal><left>size</left><right>large</right></equal>
+      </and>      
+    }
+  
+  
+To arel (sql where clause):
+      
+    require "predicated/to/arel"
+    include Predicated
+            
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_arel(Table(:shirt)).to_sql ==
+      %{(("shirt"."color" = 'red' OR "shirt"."color" = 'green') AND "shirt"."size" = 'large')}
+  
+  
+To solr query string:
+      
+    require "predicated/to/solr"
+    include Predicated
+            
+    Predicate{And(Or(Eq('color','red'),Eq('color','green')),Eq('size','large'))}.to_solr ==
+      "((color:red OR color:green) AND size:large)"
+  
+  
+To sentence:
+      
+    require "predicated/to/sentence"
+    include Predicated
+        
+    Predicate{ And(Eq("a",1),Eq("b",2)) }.to_sentence == 
+      "'a' is equal to 1 and 'b' is equal to 2"
+    
+    Predicate{ Gt("a",1) }.to_negative_sentence == 
+      "'a' is not greater than 1" 
+
+
+## Testing Notes ##
 
 Right now this project makes use of Wrong for assertions.  Wrong uses this project.  It's kind of neat in an eat-your-own-dogfood sense, but it's possible that this will be problematic over time (particularly when changes in this project cause assertions to behave differently - if even temporarily).
 

data/lib/predicated.rb

@@ -1,6 +1,4 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require "predicated/gem_check"
-require "predicated/predicate"
-require "predicated/evaluate"
-require "predicated/constrain"
+require "predicated/predicate"

data/lib/predicated/constrain.rb

@@ -1,3 +1,5 @@
+require "predicated/selectable"
+
 module Predicated
   class Constraints
     def initialize

data/lib/predicated/evaluate.rb

@@ -3,7 +3,7 @@ require "predicated/predicate"
 module Predicated
   
   
-  class Operation
+  class Operation < Binary
     attr_reader :method_sym
     
     def initialize(left, method_sym, right)
@@ -12,7 +12,8 @@ module Predicated
     end    
 
     def evaluate
-      left.send(@method_sym, *right)
+      right_values = right.nil? ? [nil] : right #1.9 problem where nils and varargs don't play nicely
+      left.send(@method_sym, *right_values)
     end
     
     def ==(other)
@@ -36,11 +37,22 @@ module Predicated
       super
     end    
     
-    def inspect
-      "Call(#{self.send(:part_inspect,left)}.#{method_sym.to_s}(#{self.send(:part_inspect, right)}))"
+    def to_s
+      "Call(#{left_to_s}.#{method_sym.to_s}#{right_to_s})"
+    end
+    
+    private 
+    def left_to_s
+      part_to_s(left)
+    end
+
+    def right_to_s
+      values = right.is_a?(::Enumerable) ? right : [right]
+      values.empty? ? "" :
+        "(" + values.collect{|arg|part_to_s(arg)}.join(",") + ")"
     end
   end
-  Predicate.module_eval(%{
+  Shorthand.module_eval(%{
     def Call(left_object, method_sym, right_args=[])
       ::Predicated::Call.new(left_object, method_sym, right_args)
     end
@@ -72,4 +84,11 @@ module Predicated
       boolean_or_evaluate(left) || boolean_or_evaluate(right)
     end 
   end
-end
+
+  class Not
+    include Container
+    def evaluate
+      ! boolean_or_evaluate(inner)
+    end 
+  end
+end

data/lib/predicated/from/callable_object.rb

@@ -1,13 +1,12 @@
 require "predicated/predicate"
-require "predicated/from/ruby_string"
+require "predicated/from/ruby_code_string"
 
 #Procs and lambdas are "callable objects"
-
 module Predicated
   
-  require_gem_version("ParseTree", "3.0.5", "parse_tree")
+  require_gem_version("ParseTree", "3.0.5", "parse_tree") if RUBY_VERSION < "1.9"
   
-  module Predicate
+  class Predicate
 
                                   #hrm
     def self.from_callable_object(context_or_callable_object=nil, context=nil, &block)
@@ -22,7 +21,7 @@ module Predicated
       
       context ||= callable_object.binding
       
-      from_ruby_string(TranslateToRubyString.convert(callable_object), context)
+      from_ruby_code_string(TranslateToRubyString.convert(callable_object), context)
     end
 
     module TranslateToRubyString
@@ -32,8 +31,8 @@ module Predicated
         temp_class.class_eval do
           define_method :serializable, &callable_object
         end
-        ruby_string = Ruby2Ruby.translate(temp_class, :serializable)    
-        ruby_string.sub(/^def serializable\n  /, "").sub(/\nend$/, "")
+        ruby_code_string = Ruby2Ruby.translate(temp_class, :serializable)    
+        ruby_code_string.sub(/^def serializable\n  /, "").sub(/\nend$/, "")
       end
     end
     
@@ -76,4 +75,4 @@ module Predicated
     end
     
   end
-end
+end

data/lib/predicated/from/json.rb

@@ -0,0 +1,59 @@
+require "predicated/predicate"
+
+module Predicated
+
+  require_gem_version("json", "1.1.9")
+
+  class Predicate
+    def self.from_json_str(json_str)
+      from_json_struct(JSON.parse(json_str))
+    end
+    
+    def self.from_json_struct(json_struct)
+      JsonStructToPredicate.convert(json_struct)
+    end
+    
+    module JsonStructToPredicate
+      SIGN_TO_CLASS = {
+        "==" => Equal, 
+        ">" => GreaterThan, 
+        "<" => LessThan, 
+        ">=" => GreaterThanOrEqualTo, 
+        "<=" => LessThanOrEqualTo
+      }
+      
+      def self.convert(json_struct)        
+        if json_struct.is_a?(Array)
+          left, sign, right = json_struct
+          if operation_class=SIGN_TO_CLASS[sign]
+            operation_class.new(left, right)
+          else
+            raise DontKnowWhatToDoWithThisJson.new(json_struct)
+          end
+        elsif json_struct.is_a?(Hash)
+          if left_and_right=json_struct["and"]
+            left, right = left_and_right
+            And.new(convert(left), convert(right))
+          elsif left_and_right=json_struct["or"]
+            left, right = left_and_right
+            Or.new(convert(left), convert(right))
+          elsif inner=json_struct["not"]
+            Not.new(convert(inner))
+          else
+            raise DontKnowWhatToDoWithThisJson.new(json_struct)
+          end
+        else
+          raise DontKnowWhatToDoWithThisJson.new(json_struct)
+        end
+      end
+      
+    end
+    
+    class DontKnowWhatToDoWithThisJson < StandardError
+      def initialize(json_struct)
+        super("don't know what to do with #{JSON.generate(json_struct)}")
+      end
+    end
+
+  end
+end

data/lib/predicated/from/{ruby_string.rb → ruby_code_string.rb}

@@ -6,8 +6,8 @@ module Predicated
   require_gem_version("ruby_parser", "2.0.4")
   require_gem_version("ruby2ruby", "1.2.4")
 
-  module Predicate
-    def self.from_ruby_string(ruby_predicate_string, context=binding())
+  class Predicate
+    def self.from_ruby_code_string(ruby_predicate_string, context=binding())
       sexp = RubyParser.new.process(ruby_predicate_string.strip)
       SexpToPredicate.new(context).convert(sexp)
     end
@@ -31,13 +31,13 @@ module Predicated
           #eval all the top lines and then treat the last one as a predicate
           body_sexps = sexp.sexp_body.to_a
           body_sexps.slice(0..-2).each do |upper_sexp|
-            eval(Ruby2Ruby.new.process(upper_sexp), @context)
+            eval_sexp(upper_sexp)
           end
           convert(body_sexps.last)
         elsif first_element == :call
           sym, left_sexp, method_sym, right_sexp = sexp
-          left = eval(Ruby2Ruby.new.process(left_sexp), @context)
-          right = eval(Ruby2Ruby.new.process(right_sexp), @context)
+          left = eval_sexp(left_sexp)
+          right = eval_sexp(right_sexp)
 
           if operation_class=SIGN_TO_PREDICATE_CLASS[method_sym]
             operation_class.new(left, right)
@@ -50,12 +50,20 @@ module Predicated
         elsif first_element == :or
           sym, left, right = sexp
           Or.new(convert(left), convert(right))
+        elsif first_element == :not
+          sym, inner = sexp
+          Not.new(convert(inner))
         else
           raise DontKnowWhatToDoWithThisSexpError.new(sexp)
         end
       end
+    
+      def eval_sexp(sexp)
+        eval(Ruby2Ruby.new.process(sexp), @context)
+      end
     end
     
+    
     class DontKnowWhatToDoWithThisSexpError < StandardError
       def initialize(sexp)
         super("don't know what to do with #{sexp.inspect}")

data/lib/predicated/from/{url_fragment.rb → url_part.rb}

@@ -4,21 +4,21 @@ module Predicated
   
   require_gem_version("treetop", "1.4.8")
   
-  module Predicate
-    def self.from_url_fragment(url_fragment_string)
-      TreetopUrlFragmentParser.new.parse(url_fragment_string).to_predicate
+  class Predicate
+    def self.from_url_part(url_part)
+      TreetopUrlPartParser.new.parse(url_part).to_predicate
     end
   end
 
-  module TreetopUrlFragment
+  module TreetopUrlPart
     Treetop.load_from_string(%{
 
-grammar TreetopUrlFragment
+grammar TreetopUrlPart
 
-include Predicated::TreetopUrlFragment
+include Predicated::TreetopUrlPart
 
 rule or
- 	( and "|" or <OrNode>)  / and
+  ( and "|" or <OrNode>)  / and
 end 
 
 rule and
@@ -30,9 +30,14 @@ rule operation
 end
 
 rule parens
-  "(" or ")" <ParensNode>
+  not? "(" or ")" <ParensNode>
 end
 
+rule not
+  '!'
+end
+
+
 
 rule leaf
   operation / parens
@@ -86,10 +91,12 @@ end
     end
     
     class ParensNode < Treetop::Runtime::SyntaxNode
-      def inner; elements[1] end
+      def inner; elements[2] end
+      def not?; elements[0].text_value=="!" end
       
       def to_predicate
-        inner.to_predicate
+        inner_predicate = inner.to_predicate
+        not? ? Not.new(inner_predicate) : inner_predicate
       end
     end