wrong 0.1.0 → 0.2.0

data/lib/predicated/test/selectable_test.rb

@@ -0,0 +1,123 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/selectable"
+
+regarding "part one: selectors on an array (simple enumerable).  proving them out more generally." do
+  before do
+    @arr = [1,2,"c",4,"e",6]
+    Predicated::Selectable.bless_enumerable(@arr,
+      :strings => proc{|item|item.is_a?(String)}, 
+      :numbers => proc{|item|item.is_a?(Numeric)}, 
+      :less_than_3 => proc{|item|item < 3} 
+    )
+  end
+  
+  test %{selection basics.  
+         People often remark that this kind of thing is jQuery-like.
+         I keep thinking I got it from Eric Evans.} do
+    assert{ @arr.select(:numbers) == [1,2,4,6] }
+    assert{ @arr.select(:strings) == ["c","e"] }
+    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
+    
+    assert do
+      catch_raise{ @arr.select(:less_than_3) }.is_a?(ArgumentError)
+      #because strings don't respond to <
+      #...there's no substitute for knowing what you're doing.
+    end
+    
+    #normal select still works
+    assert{ @arr.select{|item|item.is_a?(String)} == ["c","e"] }
+  end
+
+  test "...selector name can be any object" do
+    arr = [1,2,"c",4,"e",6]
+
+    Predicated::Selectable.bless_enumerable(arr,
+      String => proc{|item|item.is_a?(String)},
+      Numeric => proc{|item|item.is_a?(Numeric)},
+      :less_than_3 => proc{|item|item < 3}
+    )
+
+    assert{ arr.select(String) == ["c","e"] }
+    assert{ arr.select(Numeric) == [1,2,4,6] }
+    assert{ arr.select(Numeric).select(:less_than_3) == [1,2] }
+  end
+    
+  test "chaining.  also works using varargs" do
+    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
+    assert{ @arr.select(:numbers, :less_than_3) == [1,2] }
+  end
+    
+  test "extending twice is additive (not destructive)" do
+    arr = [1,2,"c",4,"e",6]
+    Predicated::Selectable.bless_enumerable(arr, :strings => proc{|item|item.is_a?(String)})
+    Predicated::Selectable.bless_enumerable(arr, :numbers => proc{|item|item.is_a?(Numeric)})
+
+    assert{ arr.select(:strings) == ["c","e"] }
+    assert{ arr.select(:numbers) == [1,2,4,6] }
+  end
+    
+  test "works as a macro" do
+    class MyArray < Array
+      include Predicated::Selectable
+      selector :strings => proc{|item|item.is_a?(String)}
+      selector :numbers => proc{|item|item.is_a?(Numeric)}
+      selector :small => proc{|item|item.is_a?(Numeric) && item < 3},
+        :big => proc{|item|item.is_a?(Numeric) && item >= 3}
+    end
+    
+    arr = MyArray.new
+    arr.replace([1,2,"c",4,"e",6])
+
+    assert{ arr.select(:strings) == ["c","e"] }
+    assert{ arr.select(:numbers) == [1,2,4,6] }
+    assert{ arr.select(:small) == [1,2] }
+    assert{ arr.select(:big) == [4,6] }
+  end
+    
+  test %{memoizes.
+         Selector enumerable assumes an immutable collection.
+         I'm going to use that assumption against it, and cleverly prove that memoization works.
+         (Others might choose to mock in similar circumstances.)} do
+    assert{ @arr.select(:strings) == ["c","e"] }
+
+    @arr << "zzz"
+
+    assert{ @arr.select(:strings) == ["c","e"] }
+  end
+end
+
+include Predicated
+regarding "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/lib/predicated/test/simple_templated_predicate_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/simple_templated_predicate"
+include Predicated
+
+regarding "simple templated predicates.  the left sides of operations and calls is a common unbound variable" do
+
+  test "operations.  the left side is a placeholder" do
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.fill_in(1) == Predicate { Eq(1, 1) } }
+    assert{ SimpleTemplatedPredicate{ Lt(2) }.fill_in(1) == Predicate { Lt(1, 2) } }
+    assert{ SimpleTemplatedPredicate{ Gt(1) }.fill_in(2) == Predicate { Gt(2, 1) } }
+    assert{ SimpleTemplatedPredicate{ Gte(1) }.fill_in(2) == Predicate { Gte(2, 1) } }
+    assert{ SimpleTemplatedPredicate{ Lte(2) }.fill_in(1) == Predicate { Lte(1, 2) } }
+
+    assert{ SimpleTemplatedPredicate{ Eq(true) }.fill_in(true) == Predicate { Eq(true, true) } }
+  end
+  
+  test "and, or, not.  just pass on the fill_in" do
+    assert{ SimpleTemplatedPredicate{ And(Gt(3),Lt(5)) }.fill_in(4) == Predicate { And(Gt(4,3),Lt(4,5)) } }
+    assert{ SimpleTemplatedPredicate{ Or(Gt(3),Lt(5)) }.fill_in(4) == Predicate { Or(Gt(4,3),Lt(4,5)) } }
+    assert{ SimpleTemplatedPredicate{ Not(Gt(5)) }.fill_in(4) == Predicate { Not(Gt(4,5)) } }
+  end
+  
+  test "call.  left side is a placeholder" do
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.fill_in("abc") == 
+              Predicate { Call("abc", :include?, "bc") } }
+
+    assert{ SimpleTemplatedPredicate{ Call(:nil?) }.fill_in("abc") == 
+              Predicate { Call("abc", :nil?) } }
+  end
+  
+  test "to_s and inspect" do
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.inspect == "Eq(1)" }
+    assert{ SimpleTemplatedPredicate{ Eq(1) }.to_s == "Eq(1)" }
+    
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.inspect == "Call(include?('bc'))" }
+    assert{ SimpleTemplatedPredicate{ Call(:include?, "bc") }.to_s == "Call(include?('bc'))" }
+  end
+end

data/lib/predicated/test/suite.rb

@@ -0,0 +1,2 @@
+require "./test/test_helper"
+run_suite("test/**/*_test.rb")

data/lib/predicated/test/test_helper.rb

@@ -0,0 +1,64 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+$LOAD_PATH.unshift "../wrong/lib"
+require "rubygems"
+require "minitest/spec"
+require "pp"
+
+#DO NOT REQUIRE WRONG IN HERE
+#The circularity between projects will cause certain tests to not work.
+
+class Color
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    other.is_a?(Color) && @name == other.name
+  end
+
+  def to_s
+    "name:#{@name}"
+  end
+end
+
+def run_suite(wildcard)
+  #simple way to make sure requires are isolated
+  result = Dir[wildcard].collect{|test_file| system("ruby #{test_file}") }.uniq == [true]
+  puts "suite " + (result ? "passed" : "FAILED")
+  exit(result ? 0 : 1)
+end
+
+class MiniTest::Unit::TestCase
+  
+  def assert_raise(exception_info_regex)
+    begin
+      yield
+    rescue Exception => e
+      assert{ exception_info_regex =~ "#{e.class.name} #{e.message}" }
+    end
+  end
+  
+end
+
+module Kernel
+  alias_method :regarding, :describe
+  
+  def xregarding(str)
+    puts "x'd out 'regarding \"#{str}\"'"
+  end
+end
+
+class MiniTest::Spec
+  class << self
+    alias_method :test, :it
+    
+    def xtest(str)
+      puts "x'd out 'test \"#{str}\"'"
+    end
+
+  end
+end
+
+MiniTest::Unit.autorun

data/lib/predicated/test/test_helper_with_wrong.rb

@@ -0,0 +1,6 @@
+require "./test/test_helper"
+
+require "wrong"
+require "wrong/adapters/minitest"
+require "wrong/message/test_context"
+require "wrong/message/string_diff"

data/lib/predicated/test/to/arel_test.rb

@@ -0,0 +1,85 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+unless RUBY_VERSION=="1.8.6"
+  
+require "predicated/to/arel"
+include Predicated
+
+regarding "convert a predicate to an arel where clause" do
+  include CanonicalTransformCases
+  
+  class FakeEngine
+    def connection
+    end
+    
+    def table_exists?(name)
+      true
+    end
+  end
+  
+  class FakeColumn
+    attr_reader :name, :type
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+    
+    def type_cast(value)
+      value
+    end
+  end
+  
+  @table = Arel::Table.new(:widget, :engine => FakeEngine.new)
+  Arel::Table.tables = [@table]
+  @table.instance_variable_set("@columns".to_sym, [
+    FakeColumn.new("a", :integer), 
+    FakeColumn.new("b", :integer),
+    FakeColumn.new("c", :integer)
+  ])
+
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => Arel::Predicates::Equality.new(@table.attributes["a"], 3),
+      "gt" => Arel::Predicates::GreaterThan.new(@table.attributes["a"], 3),
+      "lt" => Arel::Predicates::LessThan.new(@table.attributes["a"], 3),
+      "gte" => Arel::Predicates::GreaterThanOrEqualTo.new(@table.attributes["a"], 3),
+      "lte" => Arel::Predicates::LessThanOrEqualTo.new(@table.attributes["a"], 3)
+    },
+    "primitive types" => {
+      "false" => Arel::Predicates::Equality.new(@table.attributes["a"], false),
+      "true" => Arel::Predicates::Equality.new(@table.attributes["a"], true),
+      "string" => Arel::Predicates::Equality.new(@table.attributes["a"], "yyy")
+    },
+    "not" => {
+      "simple" => Arel::Predicates::Not.new(Arel::Predicates::Equality.new(@table.attributes["a"], true))
+    },
+    "simple and / or" => {
+      "and" => Arel::Predicates::And.new(
+                 Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                 Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+               ),
+      "or" => Arel::Predicates::Or.new(
+                Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+              )
+    },
+    "complex and / or" => {
+      "or and" => Arel::Predicates::Or.new(
+                    Arel::Predicates::And.new(
+                      Arel::Predicates::Equality.new(@table.attributes["a"], 1), 
+                      Arel::Predicates::Equality.new(@table.attributes["b"], 2)
+                    ), 
+                    Arel::Predicates::Equality.new(@table.attributes["c"], 3)
+                  )
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_arel(@table)
+  end
+
+end
+
+end

data/lib/predicated/test/to/json_test.rb

@@ -0,0 +1,74 @@
+require "./test/test_helper_with_wrong"
+require "./test/canonical_transform_cases"
+
+require "predicated/to/json"
+include Predicated
+
+regarding "convert a predicate to a json structure" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => ["a", "==", 3],
+      "gt" => ["a", ">", 3],
+      "lt" => ["a", "<", 3],
+      "gte" => ["a", ">=", 3],
+      "lte" => ["a", "<=", 3]
+    },
+    "primitive types" => {
+      "false" => ["a", "==", false],
+      "true" => ["a", "==", true],
+      "string" => ["a", "==", "yyy"]
+    },
+    "not" => {
+      "simple" => {"not" => ["a", "==", true]}
+    },
+    "simple and / or" => {
+      "and" => {"and" => [["a", "==", 1], ["b", "==", 2]] },
+      "or" =>  {"or" =>  [["a", "==", 1], ["b", "==", 2]] }
+    },
+    "complex and / or" => {
+      "or and" => {"or" =>  [
+                    {"and" => [["a", "==", 1], ["b", "==", 2]]},
+                    ["c", "==", 3]
+                   ]}
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_json_struct
+  end
+end
+
+regarding "convert a predicate to a json string" do
+  include CanonicalTransformCases
+  
+  @to_expectations = {
+    "simple operations" => {
+      "eq" => %{["a","==",3]},
+      "gt" => %{["a",">",3]},
+      "lt" => %{["a","<",3]},
+      "gte" => %{["a",">=",3]},
+      "lte" => %{["a","<=",3]}
+    },
+    "primitive types" => {
+      "false" => %{["a","==",false]},
+      "true" =>  %{["a","==",true]},
+      "string" => %{["a","==","yyy"]}
+    },
+    "not" => {
+      "simple" => %{{"not":["a","==",true]}}
+    },
+    "simple and / or" => {
+      "and" => %{{"and":[["a","==",1],["b","==",2]]}},
+      "or" =>  %{{"or":[["a","==",1],["b","==",2]]}}
+    },
+    "complex and / or" => {
+      "or and" => %{{"or":[{"and":[["a","==",1],["b","==",2]]},["c","==",3]]}}
+    }
+  }
+  
+  create_canonical_tests(@to_expectations) do |predicate|
+    predicate.to_json_str.gsub("\n", "").gsub(" ", "")
+  end
+end

data/lib/predicated/test/to/sentence_test.rb

@@ -0,0 +1,90 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/to/sentence"
+include Predicated
+
+regarding "convert a predicate to an english sentence" do
+  
+  after do
+    Operation.reset_verb_phrases
+  end
+  
+  test "operations" do
+    assert { Predicate{ Eq("a",1) }.to_sentence == '"a" is equal to 1' }
+    assert { Predicate{ Gt("a",1) }.to_sentence == '"a" is greater than 1' }
+    assert { Predicate{ Lt("a",1) }.to_sentence == '"a" is less than 1' }
+    assert { Predicate{ Gte("a",1) }.to_sentence == '"a" is greater than or equal to 1' }
+    assert { Predicate{ Lte("a",1) }.to_sentence == '"a" is less than or equal to 1' }
+
+    assert { Predicate{ Eq("a",1) }.to_negative_sentence == '"a" is not equal to 1' }
+    assert { Predicate{ Gt("a",1) }.to_negative_sentence == '"a" is not greater than 1' }
+    assert { Predicate{ Lt("a",1) }.to_negative_sentence == '"a" is not less than 1' }
+    assert { Predicate{ Gte("a",1) }.to_negative_sentence == '"a" is not greater than or equal to 1' }
+    assert { Predicate{ Lte("a",1) } .to_negative_sentence == '"a" is not less than or equal to 1' }
+  end
+  
+  test "primitive types" do
+    assert { Predicate{ Eq("a",1) }.to_sentence == '"a" is equal to 1' }
+    assert { Predicate{ Eq("a",nil) }.to_sentence == '"a" is equal to nil' }
+    assert { Predicate{ Eq("a",true) }.to_sentence == '"a" is equal to true' }
+    assert { Predicate{ Eq("a",3.14) }.to_sentence == '"a" is equal to 3.14' }
+  end
+
+  test "not" do
+    assert { Predicate{ Not(Eq("a",1)) }.to_sentence == '"a" is not equal to 1' }
+    assert { Predicate{ Not(Eq("a",1)) }.to_negative_sentence == '"a" is equal to 1' }
+  end
+  
+  test "complex types" do
+    assert { Predicate{ Eq([1,2],{3=>4}) }.to_sentence == "[1, 2] is equal to {3=>4}" }
+  end
+  
+  test "default verb phrases for unknown methods (which are awkward/ESL-ish)" do
+    assert { Predicate{ Call("abc", :exclude?, "bc") }.to_sentence == 
+      '"abc" is exclude "bc"' }
+
+    assert { Predicate{ Call("abc", :exclude?, "bc") }.to_negative_sentence == 
+      '"abc" is not exclude "bc"' }
+      
+    assert { Predicate{ Call("abc", :friends_with?, "bc") }.to_sentence == 
+      '"abc" is friends with "bc"' }
+  end
+  
+  test "register methods and their verb phrases" do
+    Operation.register_verb_phrase(:exclude?, "excludes", "does not exclude")
+    assert { Predicate{ Call("abc", :exclude?, "bc") }.to_sentence == 
+      '"abc" excludes "bc"' }
+
+    assert { Predicate{ Call("abc", :exclude?, "bc") }.to_negative_sentence == 
+      '"abc" does not exclude "bc"' }
+  end
+  
+  test "some other common methods have sensible verb phrases by default" do
+    assert { Predicate{ Call("abc", :include?, 'bc') }.to_sentence == '"abc" includes "bc"' }
+    assert { Predicate{ Call("abc", :include?, 'bc') }.to_negative_sentence == '"abc" does not include "bc"' }
+
+    s = Predicate{ Call("abc", :is_a?, String) }.to_sentence
+    assert { s == '"abc" is a String' }
+    assert { Predicate{ Call("abc", :is_a?, String) }.to_negative_sentence == '"abc" is not a String' }
+  end
+  
+  test "nothing on the far side" do
+    assert { Predicate{ Call("abc", :nil?) }.to_sentence == '"abc" is nil' }
+    assert { Predicate{ Call("abc", :nil?) }.to_negative_sentence == '"abc" is not nil' }
+  end
+  
+  test "simple and + or" do
+    assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_sentence == 
+              '"a" is equal to 1 and "b" is equal to 2' }
+
+    assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_sentence == 
+              '"a" is equal to 1 or "b" is equal to 2' }
+
+    assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_negative_sentence == 
+              'This is not true: "a" is equal to 1 and "b" is equal to 2' }
+
+    assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_negative_sentence == 
+              'This is not true: "a" is equal to 1 or "b" is equal to 2' }
+  end
+
+end