predicated 0.1.0 → 0.2.0

data/lib/predicated/from/xml.rb

@@ -0,0 +1,61 @@
+require "predicated/predicate"
+
+module Predicated
+
+  require_gem_version("nokogiri", "1.4.3")
+
+  class Predicate
+    def self.from_xml(xml_str)
+      NodeToPredicate.convert(Nokogiri::XML(xml_str).root)
+    end
+    
+    module NodeToPredicate
+      OPERATION_TAG_TO_CLASS = {
+        "equal" => Equal, 
+        "greaterThan" => GreaterThan, 
+        "lessThan" => LessThan, 
+        "greaterThanOrEqualTo" => GreaterThanOrEqualTo, 
+        "lessThanOrEqualTo" => LessThanOrEqualTo
+      }
+      
+      def self.convert(node)
+        
+        node = next_non_text_node(node)
+        
+        if node.name == "and"
+          left = next_non_text_node(node.children[0])
+          right = next_non_text_node(left.next)
+          And.new(convert(left), convert(right))
+        elsif node.name == "or"
+          left = next_non_text_node(node.children[0])
+          right = next_non_text_node(left.next)
+          Or.new(convert(left), convert(right))
+        elsif node.name == "not"
+          inner = next_non_text_node(node.children[0])
+          Not.new(convert(inner))
+        elsif operation_class=OPERATION_TAG_TO_CLASS[node.name]
+          left = next_non_text_node(node.children[0])
+          right = next_non_text_node(left.next)
+          operation_class.new(left.text, right.text)
+        else
+          raise DontKnowWhatToDoWithThisXmlTag.new(node.name)
+        end
+      end
+      
+      def self.next_non_text_node(node)
+        while node.text?
+          node = node.next
+        end
+        node
+      end
+
+    end
+    
+    class DontKnowWhatToDoWithThisXmlTag < StandardError
+      def initialize(xml_tag)
+        super("don't know what to do with #{xml_tag}")
+      end
+    end
+
+  end
+end

data/lib/predicated/predicate.rb

@@ -1,17 +1,45 @@
 require "predicated/gem_check"
-require "predicated/selector"
 
 module Predicated
+
   def Predicate(&block)
     result = nil
     Module.new do
-      extend Predicate      
+      extend Shorthand
       result = instance_eval(&block)
     end
     result
   end
   
-  class Binary
+  class Predicate; end #marker class
+  
+  class Unary < Predicate
+    attr_accessor :inner
+    
+    def initialize(inner)
+      @inner = inner
+    end    
+    
+    module FlipThroughMe
+      def each(ancestors=[], &block)
+        yield([self, ancestors])
+        ancestors_including_me = ancestors.dup + [self]
+        inner.each(ancestors_including_me) { |item| block.call(item) } if inner.is_a?(Enumerable)
+      end
+    end
+    include FlipThroughMe
+    include Enumerable
+    
+    module ValueEquality
+      def ==(other)
+        self.class == other.class && 
+        self.inner == other.inner
+      end
+    end
+    include ValueEquality
+  end
+  
+  class Binary < Predicate
     attr_accessor :left, :right
     
     def initialize(left, right)
@@ -45,48 +73,39 @@ module Predicated
     include ValueEquality
   end
   
+  
+  
+  
+  class And < Binary; def self.shorthand; :And end end
+  class Or < Binary; def self.shorthand; :Or end end
+  class Not < Unary; def self.shorthand; :Not end end
+
+  
   class Operation < Binary; end
   
-  module Predicate
-    extend Predicated::Selector
-    
-    CLASS_INFO = [
-      [:And, :And, Class.new(Binary)],
-      [:Or, :Or, Class.new(Binary)],
-      [:Equal, :Eq, Class.new(Operation)],
-      [:LessThan, :Lt, Class.new(Operation)],
-      [:GreaterThan, :Gt, Class.new(Operation)],
-      [:LessThanOrEqualTo, :Lte, Class.new(Operation)],
-      [:GreaterThanOrEqualTo, :Gte, Class.new(Operation)]
-    ]
-    
-    #not great
-    base_selector_enumerable = SelectorEnumerable( 
-      (CLASS_INFO.collect{|class_sym, sh, class_obj|class_obj} + [Binary, Operation]).
-        inject({:all => proc{|predicate, enumerable|true}}) do |h, class_obj|
-          h[class_obj] = proc{|predicate, enumerable|predicate.is_a?(class_obj)}
-          h
-        end 
-    )
-    
-    CLASS_INFO.each do |operation_class_name, shorthand, class_object|
-      Predicated.const_set(operation_class_name, class_object)
-      class_object.instance_variable_set("@shorthand".to_sym, shorthand)
-      class_object.class_eval do
-        
-        def self.shorthand
-          @shorthand
-        end
-        
-        include base_selector_enumerable
-      end
-      module_eval(%{
-        def #{shorthand}(left, right)
-          ::Predicated::#{operation_class_name}.new(left, right)
-        end
-      })
-    end
+  class Equal < Operation; def self.shorthand; :Eq end end
+  class LessThan < Operation; def self.shorthand; :Lt end end
+  class GreaterThan < Operation; def self.shorthand; :Gt end end
+  class GreaterThanOrEqualTo < Operation; def self.shorthand; :Gte end end
+  class LessThanOrEqualTo < Operation; def self.shorthand; :Lte end end
+  
+  
+  module Shorthand
+    def And(left, right) ::Predicated::And.new(left, right) end
+    def Or(left, right) ::Predicated::Or.new(left, right) end
+    def Not(inner) ::Predicated::Not.new(inner) end
+
+    def Eq(left, right) ::Predicated::Equal.new(left, right) end
+    def Lt(left, right) ::Predicated::LessThan.new(left, right) end
+    def Gt(left, right) ::Predicated::GreaterThan.new(left, right) end
+    def Lte(left, right) ::Predicated::LessThanOrEqualTo.new(left, right) end
+    def Gte(left, right) ::Predicated::GreaterThanOrEqualTo.new(left, right) end    
   end
+  
+  ALL_PREDICATE_CLASSES = [
+    And, Or, Not, 
+    Equal, LessThan, GreaterThan, LessThanOrEqualTo, GreaterThanOrEqualTo
+  ]
 end
 
-require "predicated/print"
+require "predicated/print"

data/lib/predicated/print.rb

@@ -1,20 +1,16 @@
 module Predicated
-  class Binary
-    def inspect
-      "#{self.class.shorthand}(#{part_inspect(left)},#{part_inspect(right)})"
+  module PrintSupport
+    def inspect(indent="")
+      indent + to_s
     end
-    
-    def to_s(indent="")
-      indent + inspect
-    end
-    
+
     private
-    def part_inspect(thing)
-      part_to_str(thing) {|thing| thing.inspect}
+    def part_to_s(thing)
+      part_to_str(thing) {|thing| thing.to_s}
     end
     
-    def part_to_s(thing, indent="")
-      part_to_str(thing, indent) {|thing| thing.to_s(indent)}
+    def part_inspect(thing, indent="")
+      part_to_str(thing, indent) {|thing| thing.inspect(indent)}
     end
     
     def part_to_str(thing, indent="")
@@ -24,19 +20,35 @@ module Predicated
         thing.to_s
       elsif thing.is_a?(Binary)
         yield(thing)
+      elsif thing.nil?
+        "nil"
       else
         "#{thing.class.name}{'#{thing.to_s}'}"
       end
     end
   end
+
+  class Unary < Predicate
+    include PrintSupport
+    def to_s
+      "#{self.class.shorthand}(#{part_to_s(inner)})"
+    end    
+  end
+  
+  class Binary < Predicate
+    include PrintSupport
+    def to_s
+      "#{self.class.shorthand}(#{part_to_s(left)},#{part_to_s(right)})"
+    end
+  end
   
   module ContainerToString
-    def to_s(indent="")
+    def inspect(indent="")
       next_indent = indent + " " + " "
       
       str = "#{indent}#{self.class.shorthand}(\n"
-      str << "#{part_to_s(left, next_indent)},\n"
-      str << "#{part_to_s(right, next_indent)}\n"
+      str << "#{part_inspect(left, next_indent)},\n"
+      str << "#{part_inspect(right, next_indent)}\n"
       str << "#{indent})"
       str << "\n" if indent == ""
       
@@ -47,4 +59,4 @@ module Predicated
   class And; include ContainerToString end
   class Or; include ContainerToString end
   
-end
+end

data/lib/predicated/selectable.rb

@@ -0,0 +1,102 @@
+
+class Object
+  # todo: make this definition conditional
+  # todo: move this to a monkey patch file
+  def singleton_class
+     class << self
+       self
+     end
+  end
+end
+
+module Predicated
+  module Selectable
+    # Make an Enumerable instance into a Selectable. 
+    # This does for instances what "include Selectable" does for classes.
+    # todo: rename?
+    def self.bless_enumerable(enumerable, selectors)
+      enumerable.singleton_class.instance_eval do
+        include Selectable
+        selector selectors
+      end
+    end
+
+    # merge several hashes into one, skipping nils
+    # todo: unit test
+    # todo: move onto Hash?
+    def self.merge_many(*hashes)
+      result = {}
+      hashes.compact.each do |hash|
+        result.merge! hash
+      end
+      result
+    end
+
+    SELECTORS = :@_predicated_selectors
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def selector(hash)
+        instance_variable_set(SELECTORS, Selectable.merge_many(instance_variable_get(SELECTORS), hash))
+      end
+    end
+
+    def selectors
+      class_selectors = self.class.instance_variable_get(SELECTORS)
+      singleton_selectors = self.singleton_class.instance_variable_get(SELECTORS)
+      instance_selectors = self.instance_variable_get(SELECTORS)
+      Selectable.merge_many(class_selectors, singleton_selectors, instance_selectors)
+    end
+
+    def select(*keys, &block)
+      if block_given?
+        super
+      else
+        key = keys.shift
+        result =
+          if key
+            selecting_proc = selectors[key]
+            raise "no selector found for '#{key}'.  current selectors: [#{selectors.collect { |k, v| k.to_s }.join(",")}]" unless selecting_proc
+            memos_for(:select)[key] ||= begin
+              super(&selecting_proc)
+            end
+          else
+            raise "select must be called with either a key or a block"
+          end
+
+        Selectable.bless_enumerable(result, selectors)
+
+        if keys.length >= 1
+          result.select(*keys, &block)
+        else
+          result
+        end
+      end
+    end
+
+    private
+    def memos_for(group)
+      @_predicated_memos ||= {}
+      @_predicated_memos[group] ||= {}
+    end
+  end
+
+  all_basic_selectors = {:all => proc{|predicate, enumerable|true}}.merge(
+    ([Unary, Binary, Operation] + ALL_PREDICATE_CLASSES).inject({}) do |h, klass|
+      h[klass] = proc{|predicate, enumerable|predicate.is_a?(klass)}
+      h
+    end
+  )
+  
+  ALL_PREDICATE_CLASSES.each do |klass|
+    klass.class_eval do 
+      klass.send(:include, Selectable)
+      klass.selector all_basic_selectors
+    end
+  end
+end
+
+

data/lib/predicated/simple_templated_predicate.rb

@@ -0,0 +1,79 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+module Predicated
+  def SimpleTemplatedPredicate(&block)
+    result = nil
+    Module.new do
+      extend SimpleTemplatedShorthand
+      result = instance_eval(&block)
+    end
+    result
+  end
+  
+  class And
+    def fill_in(placeholder_replacement)
+      And.new(left.fill_in(placeholder_replacement), right.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Or
+    def fill_in(placeholder_replacement)
+      Or.new(left.fill_in(placeholder_replacement), right.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Not
+    def fill_in(placeholder_replacement)
+      Not.new(inner.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Operation
+    def fill_in(placeholder_replacement)
+      self.class.new(placeholder_replacement, right)
+    end
+  end
+  
+  class Call
+    def fill_in(placeholder_replacement)
+      self.class.new(placeholder_replacement, method_sym, right)
+    end
+  end
+  
+  class Placeholder; end
+  
+  module SimpleTemplatedShorthand
+    include Shorthand
+    
+    def Eq(right) ::Predicated::Equal.new(Placeholder, right) end
+    def Lt(right) ::Predicated::LessThan.new(Placeholder, right) end
+    def Gt(right) ::Predicated::GreaterThan.new(Placeholder, right) end
+    def Lte(right) ::Predicated::LessThanOrEqualTo.new(Placeholder, right) end
+    def Gte(right) ::Predicated::GreaterThanOrEqualTo.new(Placeholder, right) end    
+
+    def Call(method_sym, right=[]) ::Predicated::Call.new(Placeholder, method_sym, right) end    
+  end
+  
+  class Operation < Binary
+    def to_s
+      if left == Placeholder
+        "#{self.class.shorthand}(#{part_to_s(right)})"
+      else
+        super
+      end
+    end
+  end
+
+  class Call < Operation
+    def to_s
+      if left == Placeholder
+        "Call(#{method_sym.to_s}(#{part_to_s(right)}))"
+      else
+        super
+      end
+    end
+  end
+  
+  
+end

data/lib/predicated/string_utils.rb

@@ -0,0 +1,20 @@
+module Predicated
+  module StringUtils
+    
+    #Ripped from activesupport.  
+    #If I start using a bunch of code from that project I'll create a dependency.
+    #I hope this is not bad form.
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+     
+    def self.uppercamelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    
+  end
+end