predicated 0.1.0

data/test/selector_test.rb

@@ -0,0 +1,82 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/selector"
+include Predicated::Selector
+
+apropos "part one: selectors on an array (simple enumerable).  proving them out more generally." do
+  before do
+    @arr = [1,2,"c",4,"e",6]
+    @arr.extend SelectorEnumerable(
+      :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(:strings) == ["c","e"] }
+    assert{ @arr.select(:numbers) == [1,2,4,6] }
+    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]
+    arr.extend SelectorEnumerable(
+      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]
+    arr.extend SelectorEnumerable(:strings => proc{|item|item.is_a?(String)}) 
+    arr.extend SelectorEnumerable(: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 an include" do    
+    class MyArray < Array
+      include SelectorEnumerable(:strings => proc{|item|item.is_a?(String)}) 
+      include SelectorEnumerable(:numbers => proc{|item|item.is_a?(Numeric)}) 
+    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] }
+  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

data/test/suite.rb

@@ -0,0 +1,4 @@
+#simple way to make sure requires are isolated
+result = Dir["test/**/*_test.rb"].collect{|test_file| system("ruby #{test_file}") }.uniq == [true]
+puts "suite " + (result ? "passed" : "FAILED")
+exit(result ? 0 : 1)

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+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 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 :apropos, :describe
+  
+  def xapropos(str)
+    puts "x'd out 'apropos \"#{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/test/test_helper_with_wrong.rb

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

data/test/to/arel_test.rb

@@ -0,0 +1,45 @@
+require "test/test_helper_with_wrong"
+
+unless RUBY_VERSION=="1.8.6"
+  
+require "predicated/to/arel"
+include Predicated
+
+apropos "convert a predicate to an arel where clause" do
+
+  test "operations" do
+    assert { Predicate{ Eq("a",1) }.to_arel == Arel::Predicates::Equality.new("a", 1) }
+    assert { Predicate{ Gt("a",1) }.to_arel == Arel::Predicates::GreaterThan.new("a", 1) }
+    assert { Predicate{ Lt("a",1) }.to_arel == Arel::Predicates::LessThan.new("a", 1) }
+    assert { Predicate{ Gte("a",1) }.to_arel == Arel::Predicates::GreaterThanOrEqualTo.new("a", 1) }
+    assert { Predicate{ Lte("a",1) }.to_arel == Arel::Predicates::LessThanOrEqualTo.new("a", 1) }
+  end
+
+  test "simple and + or" do
+    assert { Predicate{ And(Eq("a", 1),Eq("b", 2)) }.to_arel == 
+              Arel::Predicates::And.new(
+                Arel::Predicates::Equality.new("a", 1), 
+                Arel::Predicates::Equality.new("b", 2)
+              ) }
+
+    assert { Predicate{ Or(Eq("a", 1),Eq("b", 2)) }.to_arel == 
+              Arel::Predicates::Or.new(
+                Arel::Predicates::Equality.new("a", 1), 
+                Arel::Predicates::Equality.new("b", 2)
+              ) }
+  end
+  
+  test "complex and + or" do
+    assert { Predicate{ Or( And(Eq("a", 1),Eq("b", 2)), Eq("c", 3) ) }.to_arel ==
+              Arel::Predicates::Or.new(
+                Arel::Predicates::And.new(
+                  Arel::Predicates::Equality.new("a", 1), 
+                  Arel::Predicates::Equality.new("b", 2)
+                ), 
+                Arel::Predicates::Equality.new("c", 3)
+              ) }
+  end
+
+end
+
+end

data/test/to/sentence_test.rb

@@ -0,0 +1,83 @@
+require "test/test_helper_with_wrong"
+
+require "predicated/to/sentence"
+include Predicated
+
+apropos "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" }
+  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?, "does exclude", "does not exclude")
+    assert { Predicate{ Call("abc", :exclude?, "bc") }.to_sentence == 
+      "'abc' does exclude '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'" }
+    
+    assert { Predicate{ Call("abc", :is_a?, String) }.to_sentence == "'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

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: predicated
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Steve Conover
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Predicated is a simple predicate model for Ruby.
+email: sconover@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- lib/predicated/constrain.rb
+- lib/predicated/evaluate.rb
+- lib/predicated/from/callable_object.rb
+- lib/predicated/from/ruby_string.rb
+- lib/predicated/from/url_fragment.rb
+- lib/predicated/gem_check.rb
+- lib/predicated/predicate.rb
+- lib/predicated/print.rb
+- lib/predicated/selector.rb
+- lib/predicated/to/arel.rb
+- lib/predicated/to/sentence.rb
+- lib/predicated/version.rb
+- lib/predicated.rb
+- README.markdown
+- test/constrain_test.rb
+- test/enumerable_test.rb
+- test/equality_test.rb
+- test/evaluate_test.rb
+- test/from/callable_object_test.rb
+- test/from/ruby_string_test.rb
+- test/from/url_fragment_parser_test.rb
+- test/from/url_fragment_test.rb
+- test/print_test.rb
+- test/selector_test.rb
+- test/suite.rb
+- test/test_helper.rb
+- test/test_helper_with_wrong.rb
+- test/to/arel_test.rb
+- test/to/sentence_test.rb
+has_rdoc: true
+homepage: http://github.com/sconover/predicated
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: predicated
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Predicated is a simple predicate model for Ruby
+test_files: 
+- test/constrain_test.rb
+- test/enumerable_test.rb
+- test/equality_test.rb
+- test/evaluate_test.rb
+- test/from/callable_object_test.rb
+- test/from/ruby_string_test.rb
+- test/from/url_fragment_parser_test.rb
+- test/from/url_fragment_test.rb
+- test/print_test.rb
+- test/selector_test.rb
+- test/suite.rb
+- test/test_helper.rb
+- test/test_helper_with_wrong.rb
+- test/to/arel_test.rb
+- test/to/sentence_test.rb