wrong 0.3.1 → 0.3.2

data/lib/predicated/test/selectable_test.rb

@@ -1,123 +0,0 @@
-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
-      rescuing{ @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

@@ -1,39 +0,0 @@
-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

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

data/lib/predicated/test/test_helper.rb

@@ -1,64 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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