wrong 0.1.0 → 0.2.0

data/lib/predicated/lib/predicated.rb

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

data/lib/predicated/lib/predicated/autogen_call.rb

@@ -0,0 +1,37 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+require "predicated/string_utils"
+
+module Predicated
+  class AutogenCall < Call
+    def to_s
+      method_cameled = StringUtils.uppercamelize(method_sym.to_s)
+      
+      if Predicated.const_defined?(:SimpleTemplatedShorthand) && left == Placeholder
+        "#{method_cameled}#{right_to_s}"
+      else
+        left_str = left_to_s
+        right_str = right_to_s
+        right_str = "," + right_str unless right_str.empty?
+        "#{method_cameled}(#{left_str}#{right_str})"
+      end
+    end
+  end
+  
+  module Shorthand
+    def method_missing(uppercase_cameled_method_sym, *args)
+      subject = args.shift
+      method_sym = StringUtils.underscore(uppercase_cameled_method_sym.to_s).to_sym
+      object = args
+      AutogenCall.new(subject, method_sym, (object.empty? ? [] : object))
+    end
+  end
+
+  module SimpleTemplatedShorthand
+    def method_missing(uppercase_cameled_method_sym, *args)
+      method_sym = StringUtils.underscore(uppercase_cameled_method_sym.to_s).to_sym
+      object = args
+      AutogenCall.new(Placeholder, method_sym, (object.empty? ? [] : object))
+    end
+  end
+end

data/lib/predicated/lib/predicated/constrain.rb

@@ -0,0 +1,66 @@
+require "predicated/selectable"
+
+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/lib/predicated/evaluate.rb

@@ -0,0 +1,94 @@
+require "predicated/predicate"
+
+module Predicated
+  
+  
+  class Operation < Binary
+    attr_reader :method_sym
+    
+    def initialize(left, method_sym, right)
+      super(left, right)
+      @method_sym = method_sym
+    end    
+
+    def evaluate
+      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)
+      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 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
+  Shorthand.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
+
+  class Not
+    include Container
+    def evaluate
+      ! boolean_or_evaluate(inner)
+    end 
+  end
+end

data/lib/predicated/lib/predicated/from/callable_object.rb

@@ -0,0 +1,108 @@
+require "predicated/predicate"
+require "predicated/from/ruby_code_string"
+
+
+#raise %{
+#
+#This will never work in ruby 1.9.
+#
+#see http://blog.zenspider.com/2009/04/parsetree-eol.html
+#
+#} if RUBY_VERSION =~/^1.9/
+
+raise %{
+  
+You appear to be using ruby 1.8.7 and you don't have 
+an INLINEDIR environment variable set to a valid directory.
+
+ParseTree (used by "from_callable_object") uses RubyInline.
+RubyInline requires that the INLINEDIR environment variable point
+to a directory.  The easiest thing to do is to just go
+create a directory somewhere - let's say, ~/inlinedir,
+and point the INLINEDIR at it.  In bash this would be:
+
+mkdir ~/inlinedir
+export INLINEDIR=~/inlinedir
+
+You'll probably want to put this in .bash_profile too.
+
+Sorry for the inconvenience.  I hope the value you'll
+get out of "from_callable_object" makes it all worth it.
+
+} if RUBY_VERSION=="1.8.7" && !ENV["INLINEDIR"]
+#Procs and lambdas are "callable objects"
+
+module Predicated
+  
+  require_gem_version("ParseTree", "3.0.5", "parse_tree") if RUBY_VERSION < "1.9"
+  
+  class 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_code_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_code_string = Ruby2Ruby.translate(temp_class, :serializable)    
+        ruby_code_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/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/lib/predicated/from/ruby_code_string.rb

@@ -0,0 +1,73 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+module Predicated
+
+  require_gem_version("ruby_parser", "2.0.4")
+  require_gem_version("ruby2ruby", "1.2.4")
+
+  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
+    
+    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_sexp(upper_sexp)
+          end
+          convert(body_sexps.last)
+        elsif first_element == :call
+          sym, left_sexp, method_sym, right_sexp = sexp
+          left = eval_sexp(left_sexp)
+          right = eval_sexp(right_sexp)
+
+          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))
+        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}")
+      end
+    end
+  end
+end