predicated 0.1.0

data/README.markdown

@@ -0,0 +1,9 @@
+Predicated is a simple predicate model for Ruby.
+
+Tracker project:
+[http://www.pivotaltracker.com/projects/95014](http://www.pivotaltracker.com/projects/95014)
+
+
+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).
+
+A middle ground is to make "from ruby string" and "from callable object" use minitest asserts, since these are the "interesting" parts of Predicated relied on by Wrong.

data/lib/predicated.rb

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

data/lib/predicated/constrain.rb

@@ -0,0 +1,64 @@
+module Predicated
+  class Constraints
+    def initialize
+      @constraints = []
+    end
+    
+    def add(constraint)
+      @constraints << constraint
+      self
+    end
+    
+    def check(whole_predicate)
+      result = ConstraintCheckResult.new
+      
+      @constraints.collect do |constraint|
+        whole_predicate.select(*constraint.selectors).collect do |predicate, ancestors|
+          if ! constraint.check(predicate, ancestors)
+            result.violation(constraint, predicate)
+          end
+        end
+      end
+      
+      result
+    end
+    
+    def ==(other)
+      @constraints == other.instance_variable_get("@constraints".to_sym)
+    end
+  end
+  
+  class Constraint
+    attr_reader :name, :selectors
+    def initialize(args)
+      @name = args[:name]
+      @selectors = args[:selectors] || [:all]
+      @check_that = args[:check_that]
+    end
+    
+    def check(predicate, ancestors)
+      @check_that.call(predicate, ancestors)
+    end
+    
+    def ==(other)
+      @name == other.name && @selectors == other.selectors
+    end
+  end
+  
+  class ConstraintCheckResult
+    attr_reader :violations
+    def initialize
+      @violations = {}
+    end
+    
+    def pass?
+      @violations.empty?
+    end
+    
+    def violation(constraint, predicate)
+      @violations[constraint] ||= []
+      @violations[constraint] << predicate
+      self
+    end
+  end
+end

data/lib/predicated/evaluate.rb

@@ -0,0 +1,75 @@
+require "predicated/predicate"
+
+module Predicated
+  
+  
+  class Operation
+    attr_reader :method_sym
+    
+    def initialize(left, method_sym, right)
+      super(left, right)
+      @method_sym = method_sym
+    end    
+
+    def evaluate
+      left.send(@method_sym, *right)
+    end
+    
+    def ==(other)
+      super && method_sym==other.method_sym
+    end
+  end
+  
+
+  class Equal < Operation; def initialize(left, right); super(left, :==, right); end end
+  class LessThan < Operation; def initialize(left, right); super(left, :<, right); end end
+  class GreaterThan < Operation; def initialize(left, right); super(left, :>, right); end end
+  class LessThanOrEqualTo < Operation; def initialize(left, right); super(left, :<=, right); end end
+  class GreaterThanOrEqualTo < Operation; def initialize(left, right); super(left, :>=, right); end end
+
+  class Call < Operation
+    def self.shorthand
+      :Call
+    end
+
+    def initialize(left, method_sym, right=[])
+      super
+    end    
+    
+    def inspect
+      "Call(#{self.send(:part_inspect,left)}.#{method_sym.to_s}(#{self.send(:part_inspect, right)}))"
+    end
+  end
+  Predicate.module_eval(%{
+    def Call(left_object, method_sym, right_args=[])
+      ::Predicated::Call.new(left_object, method_sym, right_args)
+    end
+  })
+  
+  module Container
+    private 
+    def boolean_or_evaluate(thing)
+      if thing.is_a?(FalseClass)
+        false
+      elsif thing.is_a?(TrueClass)
+        true
+      else
+        thing.evaluate
+      end
+    end
+  end
+
+  class And
+    include Container
+    def evaluate
+      boolean_or_evaluate(left) && boolean_or_evaluate(right)
+    end 
+  end
+
+  class Or
+    include Container
+    def evaluate
+      boolean_or_evaluate(left) || boolean_or_evaluate(right)
+    end 
+  end
+end

data/lib/predicated/from/callable_object.rb

@@ -0,0 +1,79 @@
+require "predicated/predicate"
+require "predicated/from/ruby_string"
+
+#Procs and lambdas are "callable objects"
+
+module Predicated
+  
+  require_gem_version("ParseTree", "3.0.5", "parse_tree")
+  
+  module Predicate
+
+                                  #hrm
+    def self.from_callable_object(context_or_callable_object=nil, context=nil, &block)
+      callable_object = nil
+      
+      if context_or_callable_object.is_a?(Binding) || context_or_callable_object.nil?
+        context = context_or_callable_object
+        callable_object = block
+      else
+        callable_object = context_or_callable_object
+      end
+      
+      context ||= callable_object.binding
+      
+      from_ruby_string(TranslateToRubyString.convert(callable_object), context)
+    end
+
+    module TranslateToRubyString
+      #see http://stackoverflow.com/questions/199603/how-do-you-stringize-serialize-ruby-code
+      def self.convert(callable_object)
+        temp_class = Class.new
+        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$/, "")
+      end
+    end
+    
+    #see http://gist.github.com/321038
+    # # Monkey-patch to have Ruby2Ruby#translate with r2r >= 1.2.3, from
+    # # http://seattlerb.rubyforge.org/svn/ruby2ruby/1.2.2/lib/ruby2ruby.rb
+    class ::Ruby2Ruby < ::SexpProcessor
+      def self.translate(klass_or_str, method = nil)
+        sexp = ParseTree.translate(klass_or_str, method)
+        unifier = Unifier.new
+        unifier.processors.each do |p|
+          p.unsupported.delete :cfunc # HACK
+        end
+        sexp = unifier.process(sexp)
+        self.new.process(sexp)
+      end
+      
+      #sconover - 7/2010 - monkey-patch
+      #{1=>2}=={1=>2}
+      #The right side was having its braces cut off because of 
+      #special handling of hashes within arglists within the seattlerb code.
+      #I tried to fork r2r and add a test, but a lot of other tests
+      #broke, and I just dont understand the test in ruby2ruby.
+      #So I'm emailing the author...
+      def process_hash(exp)
+        result = []
+        until exp.empty?
+          lhs = process(exp.shift)
+          rhs = exp.shift
+          t = rhs.first
+          rhs = process rhs
+          rhs = "(#{rhs})" unless [:lit, :str].include? t # TODO: verify better!
+
+          result << "#{lhs} => #{rhs}"
+        end
+
+        return "{ #{result.join(', ')} }"
+      end
+
+    end
+    
+  end
+end

data/lib/predicated/from/ruby_string.rb

@@ -0,0 +1,65 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+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())
+      sexp = RubyParser.new.process(ruby_predicate_string.strip)
+      SexpToPredicate.new(context).convert(sexp)
+    end
+    
+    class SexpToPredicate
+      SIGN_TO_PREDICATE_CLASS = {
+        :== => Equal,
+        :> => GreaterThan,
+        :< => LessThan,
+        :>= => GreaterThanOrEqualTo,
+        :<= => LessThanOrEqualTo,
+      }
+      
+      def initialize(context)
+        @context = context
+      end
+      
+      def convert(sexp)
+        first_element = sexp.first
+        if first_element == :block
+          #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)
+          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)
+
+          if operation_class=SIGN_TO_PREDICATE_CLASS[method_sym]
+            operation_class.new(left, right)
+          else
+            Call.new(left, method_sym, right)
+          end
+        elsif first_element == :and
+          sym, left, right = sexp
+          And.new(convert(left), convert(right))
+        elsif first_element == :or
+          sym, left, right = sexp
+          Or.new(convert(left), convert(right))
+        else
+          raise DontKnowWhatToDoWithThisSexpError.new(sexp)
+        end
+      end
+    end
+    
+    class DontKnowWhatToDoWithThisSexpError < StandardError
+      def initialize(sexp)
+        super("don't know what to do with #{sexp.inspect}")
+      end
+    end
+  end
+end

data/lib/predicated/from/url_fragment.rb

@@ -0,0 +1,97 @@
+require "predicated/predicate"
+
+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
+    end
+  end
+
+  module TreetopUrlFragment
+    Treetop.load_from_string(%{
+
+grammar TreetopUrlFragment
+
+include Predicated::TreetopUrlFragment
+
+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
+  "(" or ")" <ParensNode>
+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[1] end
+      
+      def to_predicate
+        inner.to_predicate
+      end
+    end
+    
+  end
+end

data/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/predicate.rb

@@ -0,0 +1,92 @@
+require "predicated/gem_check"
+require "predicated/selector"
+
+module Predicated
+  def Predicate(&block)
+    result = nil
+    Module.new do
+      extend Predicate      
+      result = instance_eval(&block)
+    end
+    result
+  end
+  
+  class Binary
+    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 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
+  end
+end
+
+require "predicated/print"