predicated 0.1.0

data/lib/predicated/print.rb

@@ -0,0 +1,50 @@
+module Predicated
+  class Binary
+    def inspect
+      "#{self.class.shorthand}(#{part_inspect(left)},#{part_inspect(right)})"
+    end
+    
+    def to_s(indent="")
+      indent + inspect
+    end
+    
+    private
+    def part_inspect(thing)
+      part_to_str(thing) {|thing| thing.inspect}
+    end
+    
+    def part_to_s(thing, indent="")
+      part_to_str(thing, indent) {|thing| thing.to_s(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)
+      else
+        "#{thing.class.name}{'#{thing.to_s}'}"
+      end
+    end
+  end
+  
+  module ContainerToString
+    def to_s(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 << "#{indent})"
+      str << "\n" if indent == ""
+      
+      str
+    end
+  end
+  
+  class And; include ContainerToString end
+  class Or; include ContainerToString end
+  
+end

data/lib/predicated/selector.rb

@@ -0,0 +1,55 @@
+module Predicated
+  module Selector  
+    #this is no doubt totally non-performant with all the extends, and 
+    #could probably be just done better / more elegantly
+    #seek help.
+    
+    def self.SelectorEnumerable(key_to_selecting_proc)
+      Module.new do
+        @key_to_selecting_proc = key_to_selecting_proc
+      
+        def self.extended(base)
+          sym = "@key_to_selecting_proc".to_sym
+          hash = base.instance_variable_get(sym) || {}
+          base.instance_variable_set(sym, hash.merge(@key_to_selecting_proc))
+        end
+      
+        def self.included(base)
+          extended(base)
+        end    
+        
+        #ugh ugh
+        def key_to_selecting_proc
+          @key_to_selecting_proc || self.class.instance_variable_get("@key_to_selecting_proc".to_sym)
+        end
+        
+        def select(*keys, &block)
+          key = keys.shift if keys.length>=1
+          result = 
+            if key
+              selecting_proc = key_to_selecting_proc[key]
+              raise "no selector found for '#{key}'.  current selectors: [#{key_to_selecting_proc.collect{|k,v|k.to_s}.join(",")}]" unless selecting_proc
+              memos_for(:select)[key] ||= super(&selecting_proc)
+            else
+              super(&block)
+            end
+          #ugh
+          result.extend(Predicated::Selector.SelectorEnumerable(key_to_selecting_proc))
+          keys.length>=1 ? result.select(*keys, &block) : result
+        end
+    
+        private
+        def memos_for(group)
+          @memos ||= {}
+          @memos[group] ||= {}
+        end
+      end
+    end
+    
+    #ugh
+    def SelectorEnumerable(key_to_selecting_proc)
+      Predicated::Selector.SelectorEnumerable(key_to_selecting_proc)
+    end
+
+  end  
+end

data/lib/predicated/to/arel.rb

@@ -0,0 +1,35 @@
+raise "this doesn't work in 1.8.6 because the arel gem is 1.8.7-only" if RUBY_VERSION=="1.8.6"
+
+require "predicated/predicate"
+
+module Predicated
+  
+  require_gem_version("arel", "0.4.0")
+  
+  {And => Arel::Predicates::And,
+   Or => Arel::Predicates::Or}.each do |predicated_class, arel_class|
+
+     predicated_class.class_eval %{
+      def to_arel
+        #{arel_class.name}.new(left.to_arel, right.to_arel)
+      end
+    }
+     
+
+  end
+  
+  {Equal => Arel::Predicates::Equality,
+   GreaterThan => Arel::Predicates::GreaterThan,
+   LessThan => Arel::Predicates::LessThan,
+   GreaterThanOrEqualTo => Arel::Predicates::GreaterThanOrEqualTo,
+   LessThanOrEqualTo => Arel::Predicates::LessThanOrEqualTo}.each do |predicated_class, arel_class|
+
+    predicated_class.class_eval %{
+      def to_arel
+        #{arel_class.name}.new(left, right)
+      end
+    }
+
+  end
+  
+end

data/lib/predicated/to/sentence.rb

@@ -0,0 +1,91 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+module Predicated
+  
+  module ContainerSentence
+    def to_sentence
+      left.to_sentence + "#{joining_str}" + right.to_sentence
+    end
+
+    def to_negative_sentence
+      "This is not true: " + to_sentence
+    end
+  end
+  
+  class And; include ContainerSentence; def joining_str; " and " end; end
+  class Or; include ContainerSentence; def joining_str; " or " end;end
+  
+  class Operation
+
+    def self.register_verb_phrase(method_sym, 
+                                  positive_verb_phrase, 
+                                  negative_verb_phrase, 
+                                  accepts_object=true)      
+      @@method_sym_to_phrase_info[method_sym] = {
+        :positive => positive_verb_phrase,
+        :negative => negative_verb_phrase,
+        :accepts_object => accepts_object
+      }
+    end
+    
+    def self.reset_verb_phrases
+      @@method_sym_to_phrase_info = {}
+      
+      register_verb_phrase(:==, "is equal to", "is not equal to")
+      register_verb_phrase(:>, "is greater than", "is not greater than")
+      register_verb_phrase(:<, "is less than", "is not less than")
+      register_verb_phrase(:>=, "is greater than or equal to", "is not greater than or equal to")
+      register_verb_phrase(:<=, "is less than or equal to", "is not less than or equal to")
+
+      register_verb_phrase(:include?, "includes", "does not include")
+      register_verb_phrase(:is_a?, "is a", "is not a")
+      register_verb_phrase(:nil?, "is nil", "is not nil", accepts_object=false)
+      
+      nil
+    end
+    
+    reset_verb_phrases
+    
+    
+    def to_sentence
+      sentence(verb_phrase[:positive])
+    end
+    
+    def to_negative_sentence
+      sentence(verb_phrase[:negative])
+    end
+    
+    private 
+    
+    def sentence(verb_phrase_str)
+      left_str = format_value(left)
+      right_str = format_value(right)
+      
+      str = left_str + " " + verb_phrase_str
+      str << " " + right_str if verb_phrase[:accepts_object]
+      str
+    end
+          
+    def verb_phrase
+      @@method_sym_to_phrase_info[method_sym] || {
+        :positive => "is " + rudimentary=method_sym.to_s.gsub("_", " ").gsub("?", ""),
+        :negative => "is not " + rudimentary,
+        :accepts_object => true
+      } 
+    end
+        
+    def format_value(value)
+      if value.is_a?(String)
+        "'" + value.to_s + "'"
+      elsif value.nil?
+        "nil"
+      elsif value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        value.to_s
+      else
+        "'" + value.inspect + "'"
+      end
+    end
+  end
+  
+end

data/lib/predicated/version.rb

@@ -0,0 +1,3 @@
+module Predicated
+  VERSION = "0.1.0" unless defined?(Predicated::VERSION)
+end

data/test/constrain_test.rb

@@ -0,0 +1,77 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/predicate"
+require "predicated/constrain"
+include Predicated
+
+apropos %{constraints are rules about the content and structure of predicates.
+          a predicate might violate a constraint} do
+            
+  before do
+    @value_not_equal_to_two =
+      Constraint.new(:name => "Value can't be two",
+                     :selectors => [Operation],
+                     :check_that => proc{|predicate, ancestors| predicate.right!=2})
+                     
+    @not_more_than_two_levels_deep =
+      Constraint.new(:name => "Limited to two levels deep",
+                     :check_that => proc{|predicate, ancestors| ancestors.length<=2})
+  end
+  
+  test "apply to each predicate - simple" do
+    constraints = Constraints.new.add(@value_not_equal_to_two)
+    
+    assert{ constraints.check(Predicate{Eq(1,1)}).pass? }
+    deny  { constraints.check(Predicate{Eq(1,2)}).pass? }
+    
+    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(1,3))}).pass? }
+    deny  { constraints.check(Predicate{And(Eq(1,1), Eq(1,2))}).pass? }
+  end
+  
+  test "apply each to each predicate - many constraints" do
+    constraints = 
+      Constraints.new.
+        add(@value_not_equal_to_two).
+        add(@not_more_than_two_levels_deep)
+
+    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(3,3))}).pass? }
+    deny  { constraints.check(Predicate{And(Eq(1,1), Eq(2,2))}).pass? }
+    
+    assert{ constraints.check(Predicate{And(Eq(1,1), Eq(3,3))}).pass? }
+    deny  { constraints.check(Predicate{Or(Or(And(Eq(1,1), Eq(3,3)), Eq(4,4)), Eq(5,5))}).pass? }
+  end
+
+  test "equality" do
+    one = Constraint.new(:name => "Value can't be two",
+                         :selectors => [Operation],
+                         :check_that => proc{|predicate, ancestors| predicate.right!=2})
+    two = Constraint.new(:name => "Value can't be two",
+                         :selectors => [Operation],
+                         :check_that => proc{|predicate, ancestors| predicate.right!=2})
+    three = Constraint.new(:name => "Some other constraint",
+                           :check_that => proc{|predicate, ancestors| false})
+                           
+    assert{ one == two }
+    deny  { one == three }
+  end
+
+  test %{result contains information about whether the checks passed, 
+         which constraints were violated, 
+         along with the offending predicates} do
+    constraints = Constraints.new.add(@value_not_equal_to_two)
+    
+    result = constraints.check(Predicate{Eq(1,1)})
+    assert{ result.pass? }
+    assert{ result.violations == {} }
+    
+    result = constraints.check(Predicate{And(Eq(1,1), And(Eq(2,2), Eq(3,2)))})
+    deny  { result.pass? }
+    assert{ 
+      result.violations == {
+        @value_not_equal_to_two => [Equal.new(2,2), Equal.new(3,2)]
+      } 
+    }
+  end
+
+  
+end

data/test/enumerable_test.rb

@@ -0,0 +1,60 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+apropos "you can flip through the predicate tree, like any enumerable.  a list of ancestors of each node are provided" do
+  
+  test "simple" do
+    assert { Predicate { Eq(1, 2) }.to_a == [[Predicate { Eq(1, 2) }, []]] }
+  end
+    
+  test "complex" do
+    the_top = Predicate { And(Eq(1, 2), Or(Eq(3, 4), Eq(5, 6))) }
+    the_or = Predicate { Or(Eq(3, 4), Eq(5, 6)) }
+    assert { the_top.to_a == 
+       [
+        [the_top, []],
+        [Predicate { Eq(1, 2) }, [the_top]],
+        [Predicate { Or(Eq(3, 4), Eq(5, 6)) }, [the_top]],
+        [Predicate { Eq(3, 4) }, [the_top, the_or]],
+        [Predicate { Eq(5, 6) }, [the_top, the_or]]
+       ] 
+     }
+  end
+
+end
+
+apropos "there are convenient selectors defined for getting things out of a predicate" do
+  class Array
+    def predicates
+      collect{|p, a|p}
+    end
+  end
+  
+  it "gets predicate parts by type" do
+    root = Predicate { And(Eq(1, 2), Or(Eq(3, 4), Eq(5, 6))) }
+    the_or = Predicate { Or(Eq(3, 4), Eq(5, 6)) }
+
+    assert{ root.select(:all).predicates == [root, Equal.new(1, 2), the_or, Equal.new(3, 4), Equal.new(5, 6)] }
+    
+    assert{ root.select(And).predicates == [root] }
+    assert{ root.select(Or).predicates == [the_or] }
+    assert{ root.select(Equal).predicates == [Equal.new(1, 2), Equal.new(3, 4), Equal.new(5, 6)] }
+    assert{ root.select(GreaterThan).predicates == [] }
+    
+    gt_lt = Predicate { And(Gt(1, 2), Lt(3, 4)) }
+    assert{ gt_lt.select(GreaterThan).predicates == [GreaterThan.new(1, 2)] }
+    assert{ gt_lt.select(LessThan).predicates == [LessThan.new(3, 4)] }
+
+    gte_lte = Predicate { And(Gte(1, 2), Lte(3, 4)) }
+    assert{ gte_lte.select(GreaterThanOrEqualTo).predicates == [GreaterThanOrEqualTo.new(1, 2)] }
+    assert{ gte_lte.select(LessThanOrEqualTo).predicates == [LessThanOrEqualTo.new(3, 4)] }
+    
+    mixed = Predicate { And(Eq(1, 2), Or(Gt(3, 4), Lt(5, 6))) }
+    mixed_or = Predicate { Or(Gt(3, 4), Lt(5, 6)) }
+    assert{ mixed.select(Operation).predicates == [Equal.new(1, 2), GreaterThan.new(3, 4), LessThan.new(5, 6)] }
+    assert{ mixed.select(Operation).select(Equal).predicates == [Equal.new(1, 2)] }
+    assert{ mixed.select(Binary).predicates == [mixed, Equal.new(1, 2), mixed_or, GreaterThan.new(3, 4), LessThan.new(5, 6)] }
+  end
+end

data/test/equality_test.rb

@@ -0,0 +1,21 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/predicate"
+include Predicated
+
+apropos "prove value equality" do
+  
+  test "simple" do
+    assert { Predicate { Eq(1, 1) } == Predicate { Eq(1, 1) } }
+    deny   { Predicate { Eq(1, 1) } == Predicate { Eq(1, 99) } }
+  end
+  
+  test "complex" do
+    assert { Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } ==
+             Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } }
+    
+    deny {   Predicate { And(Eq(1, 1), Or(Eq(2, 2), Eq(3, 3))) } ==
+             Predicate { And(Eq(1, 1), Or(Eq(2, 99), Eq(3, 3))) } }
+  end
+
+end

data/test/evaluate_test.rb

@@ -0,0 +1,144 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/evaluate"
+include Predicated
+
+apropos "evaluate a predicate as boolean logic in ruby.  change the context by providing and optional binding." do
+
+  apropos "proving out basic operations" do
+    test "equals" do
+      assert { Predicate { Eq(1, 1) }.evaluate }
+      deny   { Predicate { Eq(1, 2) }.evaluate }
+    end
+  
+    test "less than" do
+      assert { Predicate { Lt(1, 2) }.evaluate }
+      deny   { Predicate { Lt(2, 2) }.evaluate }
+      deny   { Predicate { Lt(3, 2) }.evaluate }
+    end
+
+    test "greater than" do
+      deny   { Predicate { Gt(1, 2) }.evaluate }
+      deny   { Predicate { Gt(2, 2) }.evaluate }
+      assert { Predicate { Gt(3, 2) }.evaluate }
+    end
+
+    test "less than or equal to" do
+      assert { Predicate { Lte(1, 2) }.evaluate }
+      assert { Predicate { Lte(2, 2) }.evaluate }
+      deny   { Predicate { Lte(3, 2) }.evaluate }
+    end
+  
+    test "greater than or equal to" do
+      deny   { Predicate { Gte(1, 2) }.evaluate }
+      assert { Predicate { Gte(2, 2) }.evaluate }
+      assert { Predicate { Gte(3, 2) }.evaluate }
+    end
+  end
+
+  apropos "comparing values of different data types" do
+    test "strings" do
+      assert { Predicate { Eq("1", "1") }.evaluate }
+      deny   { Predicate { Eq("1", 1) }.evaluate }
+      deny   { Predicate { Eq("1", nil) }.evaluate }
+    end
+  
+    test "booleans" do
+      assert { Predicate { Eq(true, true) }.evaluate }
+      deny   { Predicate { Eq(false, true) }.evaluate }
+      
+      deny   { Predicate { Eq(false, nil) }.evaluate }
+      deny   { Predicate { Eq(true, nil) }.evaluate }
+      
+      deny   { Predicate { Eq("false", false) }.evaluate }
+      deny   { Predicate { Eq("true", true) }.evaluate }
+    end
+  
+    test "numbers" do
+      assert { Predicate { Eq(1, 1) }.evaluate }
+      assert { Predicate { Eq(1, 1.0) }.evaluate }
+      assert { Predicate { Eq(1.0, 1.0) }.evaluate }
+      deny   { Predicate { Eq(1, 2) }.evaluate }
+      deny   { Predicate { Eq(1, nil) }.evaluate }
+    end
+
+    class Color
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    
+      def ==(other)
+        other.is_a?(Color) && @name == other.name
+      end
+    end
+
+    test "objects" do
+      assert { Predicate { Eq(Color.new("red"), Color.new("red")) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), Color.new("BLUE")) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), 2) }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), "red") }.evaluate }
+      deny   { Predicate { Eq(Color.new("red"), nil) }.evaluate }
+    end
+  end
+  
+  
+  apropos "and" do
+    test "left and right must be true" do
+      assert { Predicate { And( Eq(1, 1), Eq(2, 2) ) }.evaluate }
+      deny   { Predicate { And( Eq(99, 1), Eq(2, 2) ) }.evaluate }
+      deny   { Predicate { And( Eq(1, 1), Eq(99, 2) ) }.evaluate }
+    end
+
+    test "simple true and false work too" do
+      assert { Predicate { And( true, true ) }.evaluate }
+      assert { Predicate { And( true, Eq(2, 2) ) }.evaluate }
+      deny   { Predicate { And( true, false ) }.evaluate }
+      deny   { Predicate { And( Eq(2, 2), false ) }.evaluate }
+    end
+    
+    test "nested" do
+      assert { Predicate { And( true, And(true, true) ) }.evaluate }
+      deny   { Predicate { And( false, And(true, true) ) }.evaluate }
+      deny   { Predicate { And( true, And(true, false) ) }.evaluate }
+    end
+  end
+  
+  apropos "or" do
+    test "one of left or right must be true" do
+      assert { Predicate { Or(true, true) }.evaluate }
+      assert { Predicate { Or(true, false) }.evaluate }
+      assert { Predicate { Or(false, true) }.evaluate }
+      deny   { Predicate { Or(false, false) }.evaluate }
+    end
+  end  
+  
+  apropos "evaluate adds a generic 'call' class.  that is, object.message(args)" do
+    test "evaluate simple calls" do
+      assert { Predicate { Call("abc", :include?, "bc") }.evaluate }
+      deny { Predicate { Call("abc", :include?, "ZZ") }.evaluate }
+    end
+
+    test "nil call.  call defaults to no args if none are specified" do
+      assert { Predicate { Call(nil, :nil?, []) }.evaluate }
+      deny { Predicate { Call("abc", :nil?, []) }.evaluate }
+
+      assert { Predicate { Call(nil, :nil?) }.evaluate }
+      deny { Predicate { Call("abc", :nil?) }.evaluate }
+    end
+
+    test "inspect" do
+      assert{ Call.new("abc", :include?, "bc").inspect == "Call('abc'.include?('bc'))" }
+    end
+    
+    test "call equality" do
+      assert { Call.new("abc", :include?, "bc") == Call.new("abc", :include?, "bc") }
+      deny { Call.new("ZZZ", :include?, "bc") == Call.new("abc", :include?, "bc") }
+      deny { Call.new("abc", :zzz, "bc") == Call.new("abc", :include?, "bc") }
+      deny { Call.new("abc", :include?, "ZZZ") == Call.new("abc", :include?, "bc") }
+    end
+    
+
+  end  
+  
+end