wrong 0.1.0 → 0.2.0

data/lib/predicated/lib/predicated/from/url_part.rb

@@ -0,0 +1,104 @@
+require "predicated/predicate"
+
+module Predicated
+  
+  require_gem_version("treetop", "1.4.8")
+  
+  class Predicate
+    def self.from_url_part(url_part)
+      TreetopUrlPartParser.new.parse(url_part).to_predicate
+    end
+  end
+
+  module TreetopUrlPart
+    Treetop.load_from_string(%{
+
+grammar TreetopUrlPart
+
+include Predicated::TreetopUrlPart
+
+rule or
+  ( and "|" or <OrNode>)  / and
+end 
+
+rule and
+  ( leaf "&" and <AndNode> ) / leaf
+end
+
+rule operation
+  unquoted_string sign unquoted_string <OperationNode>
+end
+
+rule parens
+  not? "(" or ")" <ParensNode>
+end
+
+rule not
+  '!'
+end
+
+
+
+rule leaf
+  operation / parens
+end
+
+rule unquoted_string
+  [0-9a-zA-Z]*
+end
+
+rule sign
+  ('>=' / '<=' / '<' / '>' / '=' )
+end
+end
+
+})
+  
+    class OperationNode < Treetop::Runtime::SyntaxNode
+      def left_text; elements[0].text_value end
+      def sign_text; elements[1].text_value end
+      def right_text; elements[2].text_value end      
+      
+      SIGN_TO_PREDICATE_CLASS = {
+        "=" => Equal, 
+        ">" => GreaterThan,
+        "<" => LessThan,
+        ">=" => GreaterThanOrEqualTo,
+        "<=" => LessThanOrEqualTo
+      }
+      
+      def to_predicate
+        SIGN_TO_PREDICATE_CLASS[sign_text].new(left_text, right_text)
+      end
+    end      
+    
+    class AndNode < Treetop::Runtime::SyntaxNode
+      def left; elements[0] end
+      def right; elements[2] end      
+      
+      def to_predicate
+        And.new(left.to_predicate, right.to_predicate)
+      end
+    end
+          
+    class OrNode < Treetop::Runtime::SyntaxNode
+      def left; elements[0] end
+      def right; elements[2] end      
+      
+      def to_predicate
+        Or.new(left.to_predicate, right.to_predicate)
+      end
+    end
+    
+    class ParensNode < Treetop::Runtime::SyntaxNode
+      def inner; elements[2] end
+      def not?; elements[0].text_value=="!" end
+      
+      def to_predicate
+        inner_predicate = inner.to_predicate
+        not? ? Not.new(inner_predicate) : inner_predicate
+      end
+    end
+    
+  end
+end

data/lib/predicated/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/lib/predicated/gem_check.rb

@@ -0,0 +1,34 @@
+module Predicated
+  def self.require_gem_version(gem_name, minimum_version, require_name=gem_name)
+    unless Gem.available?(gem_name, Gem::Requirement.create(">= #{minimum_version}"))
+      raise %{
+Gem: #{gem_name} >=#{minimum_version}
+Does not appear to be installed.  Please install it.
+
+Predicated is built in a way that allows you to pick and 
+choose which features to use.
+
+RubyGems has no way to specify optional dependencies,
+therefore I've made the decision not to have Predicated
+automatically depend into the various gems referenced
+in from/to "extensions".
+
+The cost here is that the gem install doesn't necessarily 
+"just work" for you out of the box.  But in return you get 
+greater flexibility.  
+
+Notably, rails/arel unfortunately has a hard dependency 
+on Rails 3 activesupport, which requires ruby 1.8.7.  
+By making from/to dependencies optional, those with 
+no interest in arel can use Predicated in a wider 
+variety of environments.
+
+For more discussion see:
+http://stackoverflow.com/questions/2993335/rubygems-optional-dependencies
+}
+    end
+    
+    require require_name
+  end
+  
+end

data/lib/predicated/lib/predicated/predicate.rb

@@ -0,0 +1,111 @@
+require "predicated/gem_check"
+
+module Predicated
+
+  def Predicate(&block)
+    result = nil
+    Module.new do
+      extend Shorthand
+      result = instance_eval(&block)
+    end
+    result
+  end
+  
+  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)
+      @left = left
+      @right = right
+    end    
+    
+    module FlipThroughMe
+      def each(ancestors=[], &block)
+        yield([self, ancestors])
+        ancestors_including_me = ancestors.dup + [self]
+        enumerate_side(@left, ancestors_including_me, &block)
+        enumerate_side(@right, ancestors_including_me, &block)
+      end
+      
+      private 
+      def enumerate_side(thing, ancestors)
+        thing.each(ancestors) { |item| yield(item) } if thing.is_a?(Enumerable)
+      end
+    end
+    include FlipThroughMe
+    include Enumerable
+    
+    module ValueEquality
+      def ==(other)
+        self.class == other.class && 
+        self.left == other.left && 
+        self.right == other.right
+      end
+    end
+    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
+  
+  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"

data/lib/predicated/lib/predicated/print.rb

@@ -0,0 +1,62 @@
+module Predicated
+  module PrintSupport
+    def inspect(indent="")
+      indent + to_s
+    end
+
+    private
+    def part_to_s(thing)
+      part_to_str(thing) {|thing| thing.to_s}
+    end
+    
+    def part_inspect(thing, indent="")
+      part_to_str(thing, indent) {|thing| thing.inspect(indent)}
+    end
+    
+    def part_to_str(thing, indent="")
+      if thing.is_a?(String)
+        "'#{thing}'"
+      elsif thing.is_a?(Numeric) || thing.is_a?(TrueClass) || thing.is_a?(FalseClass)
+        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 inspect(indent="")
+      next_indent = indent + " " + " "
+      
+      str = "#{indent}#{self.class.shorthand}(\n"
+      str << "#{part_inspect(left, next_indent)},\n"
+      str << "#{part_inspect(right, next_indent)}\n"
+      str << "#{indent})"
+      str << "\n" if indent == ""
+      
+      str
+    end
+  end
+  
+  class And; include ContainerToString end
+  class Or; include ContainerToString end
+  
+end

data/lib/predicated/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
+
+