sequel_core 1.5.1 → 2.0.0

data/spec/blockless_filters_spec.rb

@@ -0,0 +1,269 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Blockless Ruby Filters" do
+  before do
+    db = Sequel::Database.new
+    db.quote_identifiers = false
+    @d = db[:items]
+    def @d.l(*args)
+      literal(filter_expr(*args))
+    end
+  end
+  
+  it "should support boolean columns directly" do
+    @d.l(:x).should == 'x'
+  end
+  
+  it "should support NOT via Symbol#~" do
+    @d.l(~:x).should == 'NOT x'
+  end
+  
+  it "should support qualified columns" do
+    @d.l(:x__y).should == 'x.y'
+    @d.l(~:x__y).should == 'NOT x.y'
+  end
+
+  it "should support NOT with SQL functions" do
+    @d.l(~:is_blah[]).should == 'NOT is_blah()'
+    @d.l(~:is_blah[:x]).should == 'NOT is_blah(x)'
+    @d.l(~:is_blah[:x__y]).should == 'NOT is_blah(x.y)'
+    @d.l(~:is_blah[:x, :x__y]).should == 'NOT is_blah(x, x.y)'
+  end
+
+  it "should handle multiple ~" do
+    @d.l(~~:x).should == 'x'
+    @d.l(~~~:x).should == 'NOT x'
+    @d.l(~~(:x > 100)).should == '(x > 100)'
+    @d.l(~~(:x & :y)).should == '(x AND y)'
+    @d.l(~~(:x | :y)).should == '(x OR y)'
+  end
+
+  it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
+    @d.l(:x > 100).should == '(x > 100)'
+    @d.l(:x < 100.01).should == '(x < 100.01)'
+    @d.l(:x >= 100000000000000000000000000000000000).should == '(x >= 100000000000000000000000000000000000)'
+    @d.l(:x <= 100).should == '(x <= 100)'
+  end
+  
+  it "should support negation of >, <, >=, and <= via Symbol#~" do
+    @d.l(~(:x > 100)).should == '(x <= 100)'
+    @d.l(~(:x < 100.01)).should == '(x >= 100.01)'
+    @d.l(~(:x >= 100000000000000000000000000000000000)).should == '(x < 100000000000000000000000000000000000)'
+    @d.l(~(:x <= 100)).should == '(x > 100)'
+  end
+
+  it "should support = via Hash" do
+    @d.l(:x => 100).should == '(x = 100)'
+    @d.l(:x => 'a').should == '(x = \'a\')'
+    @d.l(:x => true).should == '(x = \'t\')'
+    @d.l(:x => false).should == '(x = \'f\')'
+    @d.l(:x => nil).should == '(x IS NULL)'
+    @d.l(:x => [1,2,3]).should == '(x IN (1, 2, 3))'
+  end
+  
+  it "should support != via Hash#~" do
+    @d.l(~{:x => 100}).should == '(x != 100)'
+    @d.l(~{:x => 'a'}).should == '(x != \'a\')'
+    @d.l(~{:x => true}).should == '(x != \'t\')'
+    @d.l(~{:x => false}).should == '(x != \'f\')'
+    @d.l(~{:x => nil}).should == '(x IS NOT NULL)'
+  end
+  
+  it "should support ~ via Hash and Regexp (if supported by database)" do
+    @d.l(:x => /blah/).should == '(x ~ \'blah\')'
+  end
+  
+  it "should support !~ via Hash#~ and Regexp" do
+    @d.l(~{:x => /blah/}).should == '(x !~ \'blah\')'
+  end
+  
+  it "should support LIKE via Symbol#like" do
+    @d.l(:x.like('a')).should == '(x LIKE \'a\')'
+    @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
+    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
+    @d.l(:x.like(/a/, /b/)).should == '((x ~ \'a\') OR (x ~ \'b\'))'
+    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
+  end
+
+  it "should support NOT LIKE via Symbol#like and Symbol#~" do
+    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\')'
+    @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
+    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
+    @d.l(~:x.like(/a/, /b/)).should == '((x !~ \'a\') AND (x !~ \'b\'))'
+    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
+  end
+
+  it "should support negating ranges via Hash#~ and Range" do
+    @d.l(~{:x => 1..5}).should == '((x < 1) OR (x > 5))'
+    @d.l(~{:x => 1...5}).should == '((x < 1) OR (x >= 5))'
+  end
+  
+  it "should support negating NOT IN via Hash#~ and Dataset or Array" do
+    @d.l(~{:x => @d.select(:i)}).should == '(x NOT IN (SELECT i FROM items))'
+    @d.l(~{:x => [1,2,3]}).should == '(x NOT IN (1, 2, 3))'
+  end
+
+  it "should support + - * / via Symbol#+,-,*,/" do
+    @d.l(:x + 1 > 100).should == '((x + 1) > 100)'
+    @d.l((:x * :y) < 100.01).should == '((x * y) < 100.01)'
+    @d.l((:x - :y/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
+    @d.l((((:x - :y)/(:x + :y))*:z) <= 100).should == '((((x - y) / (x + y)) * z) <= 100)'
+    @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
+  end
+  
+  it "should not allow negation of non-boolean expressions" do
+    proc{~(:x + 1 > 100)}.should_not raise_error 
+    proc{~(:x + 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should not allow mathematical, inequality, or string operations on true, false, or nil" do
+    proc{:x + 1}.should_not raise_error
+    proc{:x - true}.should raise_error(Sequel::Error)
+    proc{:x / false}.should raise_error(Sequel::Error)
+    proc{:x * nil}.should raise_error(Sequel::Error)
+    proc{:x > 1}.should_not raise_error
+    proc{:x < true}.should raise_error(Sequel::Error)
+    proc{:x >= false}.should raise_error(Sequel::Error)
+    proc{:x <= nil}.should raise_error(Sequel::Error)
+    proc{[:x, nil].sql_string_join}.should raise_error(Sequel::Error)
+  end
+
+  it "should not allow mathematical, inequality, or string operations on boolean complex expressions" do
+    proc{:x + (:y + 1)}.should_not raise_error
+    proc{:x - (~:y)}.should raise_error(Sequel::Error)
+    proc{:x / (:y & :z)}.should raise_error(Sequel::Error)
+    proc{:x * (:y | :z)}.should raise_error(Sequel::Error)
+    proc{:x > (:y > 5)}.should raise_error(Sequel::Error)
+    proc{:x < (:y < 5)}.should raise_error(Sequel::Error)
+    proc{:x >= (:y >= 5)}.should raise_error(Sequel::Error)
+    proc{:x <= (:y <= 5)}.should raise_error(Sequel::Error)
+    proc{:x > {:y => nil}}.should raise_error(Sequel::Error)
+    proc{:x < ~{:y => nil}}.should raise_error(Sequel::Error)
+    proc{:x >= {:y => 5}}.should raise_error(Sequel::Error)
+    proc{:x <= ~{:y => 5}}.should raise_error(Sequel::Error)
+    proc{:x >= {:y => [1,2,3]}}.should raise_error(Sequel::Error)
+    proc{:x <= ~{:y => [1,2,3]}}.should raise_error(Sequel::Error)
+    proc{:x + :y.like('a')}.should raise_error(Sequel::Error)
+    proc{:x - :y.like(/a/)}.should raise_error(Sequel::Error)
+    proc{:x * :y.like(/a/i)}.should raise_error(Sequel::Error)
+    proc{:x + ~:y.like('a')}.should raise_error(Sequel::Error)
+    proc{:x - ~:y.like(/a/)}.should raise_error(Sequel::Error)
+    proc{:x * ~:y.like(/a/i)}.should raise_error(Sequel::Error)
+    proc{[:x, ~:y.like(/a/i)].sql_string_join}.should raise_error(Sequel::Error)
+  end
+
+  it "should support AND conditions via &" do
+    @d.l(:x & :y).should == '(x AND y)'
+    @d.l(:x & :y & :z).should == '((x AND y) AND z)'
+    @d.l(:x & {:y => :z}).should == '(x AND (y = z))'
+    @d.l({:y => :z} & :x).should == '((y = z) AND x)'
+    @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
+    @d.l((:x > 200) & (:y < 200)).should == '((x > 200) AND (y < 200))'
+    @d.l(:x & ~:y).should == '(x AND NOT y)'
+    @d.l(~:x & :y).should == '(NOT x AND y)'
+    @d.l(~:x & ~:y).should == '(NOT x AND NOT y)'
+  end
+  
+  it "should support OR conditions via |" do
+    @d.l(:x | :y).should == '(x OR y)'
+    @d.l(:x | :y | :z).should == '((x OR y) OR z)'
+    @d.l(:x | {:y => :z}).should == '(x OR (y = z))'
+    @d.l({:y => :z} | :x).should == '((y = z) OR x)'
+    @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
+    @d.l((:x > 200) | (:y < 200)).should == '((x > 200) OR (y < 200))'
+  end
+  
+  it "should support & | combinations" do
+    @d.l((:x | :y) & :z).should == '((x OR y) AND z)'
+    @d.l(:x | (:y & :z)).should == '(x OR (y AND z))'
+    @d.l((:x & :w) | (:y & :z)).should == '((x AND w) OR (y AND z))'
+  end
+  
+  it "should support & | with ~" do
+    @d.l(~((:x | :y) & :z)).should == '((NOT x AND NOT y) OR NOT z)'
+    @d.l(~(:x | (:y & :z))).should == '(NOT x AND (NOT y OR NOT z))'
+    @d.l(~((:x & :w) | (:y & :z))).should == '((NOT x OR NOT w) AND (NOT y OR NOT z))'
+    @d.l(~((:x > 200) | (:y & :z))).should == '((x <= 200) AND (NOT y OR NOT z))'
+  end
+  
+  it "should support LiteralString" do
+    @d.l('x'.lit).should == '(x)'
+    @d.l(~'x'.lit).should == 'NOT x'
+    @d.l(~~'x'.lit).should == '(x)'
+    @d.l(~(('x'.lit | :y) & :z)).should == '((NOT x AND NOT y) OR NOT z)'
+    @d.l(~(:x | 'y'.lit)).should == '(NOT x AND NOT y)'
+    @d.l(~('x'.lit & 'y'.lit)).should == '(NOT x OR NOT y)'
+    @d.l({'y'.lit => 'z'.lit} & 'x'.lit).should == '((y = z) AND x)'
+    @d.l(('x'.lit > 200) & ('y'.lit < 200)).should == '((x > 200) AND (y < 200))'
+    @d.l(~('x'.lit + 1 > 100)).should == '((x + 1) <= 100)'
+    @d.l('x'.lit.like(/a/)).should == '(x ~ \'a\')'
+    @d.l('x'.lit + 1 > 100).should == '((x + 1) > 100)'
+    @d.l(('x'.lit * :y) < 100.01).should == '((x * y) < 100.01)'
+    @d.l(('x'.lit - :y/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
+    @d.l(('z'.lit * (('x'.lit / :y)/(:x + :y))) <= 100).should == '((z * ((x / y) / (x + y))) <= 100)'
+    @d.l(~(((('x'.lit - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
+  end
+
+  it "should support hashes by ANDing the conditions" do
+    @d.l(:x => 100, :y => 'a')[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l(:x => true, :y => false)[1...-1].split(' AND ').sort.should == ['(x = \'t\')', '(y = \'f\')']
+    @d.l(:x => nil, :y => [1,2,3])[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
+  it "should support sql_negate on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != \'t\')', '(y != \'f\')']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support ~ on hashes" do
+    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x != \'t\')', '(y != \'f\')']
+    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support sql_or on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = \'t\')', '(y = \'f\')']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
+  it "should support arrays with all two pairs the same as hashes" do
+    @d.l([[:x, 100],[:y, 'a']]).should == '((x = 100) AND (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]]).should == '((x = \'t\') AND (y = \'f\'))'
+    @d.l([[:x, nil], [:y, [1,2,3]]]).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_negate on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x != \'t\') AND (y != \'f\'))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support ~ on arrays with all two pairs" do
+    @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
+    @d.l(~[[:x, true], [:y, false]]).should == '((x != \'t\') OR (y != \'f\'))'
+    @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_or on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_or).should == '((x = \'t\') OR (y = \'f\'))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
+  end
+  
+  it "should support Array#sql_string_join for concatenation of SQL strings" do
+    @d.l([:x].sql_string_join).should == '(x)'
+    @d.l([:x].sql_string_join(', ')).should == '(x)'
+    @d.l([:x, :y].sql_string_join).should == '(x || y)'
+    @d.l([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
+    @d.l([:x[1], :y|1].sql_string_join).should == '(x(1) || y[1])'
+    @d.l([:x[1], 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
+    @d.l([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
+    @d.l([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
+    @d.l([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
+    @d.l([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
+    @d.l([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
+    @d.l([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "((x || y) || (a || b))"
+  end
+end

data/spec/connection_pool_spec.rb

@@ -1,8 +1,10 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
+CONNECTION_POOL_DEFAULTS = {:pool_timeout=>5, :pool_sleep_time=>0.001,
+  :pool_reuse_connections=>:allow, :pool_convert_exceptions=>true, :max_connections=>4}
 
 context "An empty ConnectionPool" do
   setup do
-    @cpool = ConnectionPool.new
+    @cpool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
   end
 
   specify "should have no available connections" do
@@ -10,7 +12,7 @@ context "An empty ConnectionPool" do
   end
 
   specify "should have no allocated connections" do
-    @cpool.allocated.should == {}
+    @cpool.allocated.should == []
   end
 
   specify "should have a created_count of zero" do
@@ -21,21 +23,22 @@ end
 context "A connection pool handling connections" do
   setup do
     @max_size = 2
-    @cpool = ConnectionPool.new(@max_size) {:got_connection}
+    @cpool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>@max_size)) {:got_connection}
   end
 
   specify "#hold should increment #created_count" do
     @cpool.hold do
       @cpool.created_count.should == 1
-      @cpool.hold {@cpool.created_count.should == 1}
+      @cpool.hold {@cpool.created_count.should == 2}
+      @cpool.hold {@cpool.hold {@cpool.created_count.should == 2}}
     end
   end
 
-  specify "#hold should add the connection to the #allocated hash" do
+  specify "#hold should add the connection to the #allocated array" do
     @cpool.hold do
       @cpool.allocated.size.should == 1
   
-      @cpool.allocated.values.should == [:got_connection]
+      @cpool.allocated.should == [[Thread.current, :got_connection]]
     end
   end
 
@@ -73,7 +76,7 @@ end
 
 context "ConnectionPool#hold" do
   setup do
-    @pool = ConnectionPool.new {DummyConnection.new}
+    @pool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
   end
   
   specify "should pass the result of the connection maker proc to the supplied block" do
@@ -109,7 +112,7 @@ end
 
 context "ConnectionPool#connection_proc" do
   setup do
-    @pool = ConnectionPool.new
+    @pool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS)
   end
   
   specify "should be nil if no block is supplied to the pool" do
@@ -128,7 +131,7 @@ end
 context "A connection pool with a max size of 1" do
   setup do
     @invoked_count = 0
-    @pool = ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
+    @pool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>1)) {@invoked_count += 1; 'herro'}
   end
   
   specify "should let only one thread access the connection at any time" do
@@ -151,7 +154,7 @@ context "A connection pool with a max size of 1" do
     c2.should be_nil
     
     @pool.available_connections.should be_empty
-    @pool.allocated.should == {t1 => cc}
+    @pool.allocated.should == [[t1, cc]]
     
     cc.gsub!('rr', 'll')
     sleep 0.5
@@ -163,7 +166,7 @@ context "A connection pool with a max size of 1" do
     c2.should == 'hello'
 
     @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2 => cc}
+    @pool.allocated.should == [[t2, cc]]
     
     cc.gsub!('ll', 'rr')
     sleep 0.5
@@ -204,7 +207,7 @@ end
 context "A connection pool with a max size of 5" do
   setup do
     @invoked_count = 0
-    @pool = ConnectionPool.new(5) {@invoked_count += 1}
+    @pool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
   end
   
   specify "should let five threads simultaneously access separate connections" do
@@ -219,8 +222,8 @@ context "A connection pool with a max size of 5" do
     @invoked_count.should == 5
     @pool.size.should == 5
     @pool.available_connections.should be_empty
-    @pool.allocated.should == {threads[0] => 1, threads[1] => 2, threads[2] => 3,
-      threads[3] => 4, threads[4] => 5}
+    i = 0
+    @pool.allocated.should == threads.collect{|t| [t,i+=1]}
     
     threads[0].raise "your'e dead"
     sleep 0.1
@@ -229,7 +232,7 @@ context "A connection pool with a max size of 5" do
     sleep 0.1
     
     @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1] => 2, threads[2] => 3, threads[4] => 5}
+    @pool.allocated.should == [[threads[1], 2], [threads[2], 3], [threads[4], 5]]
     
     stop = true
     sleep 0.2
@@ -274,7 +277,7 @@ end
 context "ConnectionPool#disconnect" do
   setup do
     @count = 0
-    @pool = ConnectionPool.new(5) {{:id => @count += 1}}
+    @pool = ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {{:id => @count += 1}}
   end
   
   specify "should invoke the given block for each available connection" do
@@ -338,7 +341,7 @@ end
 
 context "SingleThreadedPool" do
   setup do
-    @pool = SingleThreadedPool.new {1234}
+    @pool = SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS){1234}
   end
   
   specify "should provide a #hold method" do
@@ -355,4 +358,4 @@ context "SingleThreadedPool" do
     conn.should == 1234
     @pool.conn.should be_nil
   end
-end
+end

data/spec/core_ext_spec.rb

@@ -1,19 +1,169 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "Enumerable#send_each" do
-  specify "should send the supplied method to each item" do
-    a = ['abbc', 'bbccdd', 'hebtre']
-    a.send_each(:gsub!, 'b', '_')
-    a.should == ['a__c', '__ccdd', 'he_tre']
-  end
-end
-
-context "Range#interval" do
-  specify "should return the interval between the beginning and end of the range" do
-    (1..10).interval.should == 9
-    
-    r = rand(100000) + 10
-    t1 = Time.now; t2 = t1 + r
-    (t1..t2).interval.should == r
-  end
-end
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Array#extract_options!" do
+  specify "should pop the last item if it is a hash" do
+    a = [1,2,{1=>2}]
+    a.extract_options!.should == {1=>2}
+    a.should == [1,2]
+  end
+
+  specify "should return an empty hash if the last item is not a hash" do
+    a = [1,2]
+    a.extract_options!.should == {}
+    a.should == [1,2]
+  end
+end
+
+context "Enumerable#send_each" do
+  specify "should send the supplied method to each item" do
+    a = ['abbc', 'bbccdd', 'hebtre']
+    a.send_each(:gsub!, 'b', '_')
+    a.should == ['a__c', '__ccdd', 'he_tre']
+  end
+end
+
+context "Range#interval" do
+  specify "should return the interval between the beginning and end for an inclusive range" do
+    (1..10).interval.should == 9
+    
+    r = rand(100000) + 10
+    t1 = Time.now; t2 = t1 + r
+    (t1..t2).interval.should == r
+  end
+
+  specify "should return the interval between the beginning and end for an exclusive range" do
+    (1...10).interval.should == 8
+    
+    r = rand(100000) + 10
+    t1 = Time.now; t2 = t1 + r
+    (t1...t2).interval.should == r - 1
+  end
+end
+
+context "Module#class_attr_reader" do
+  specify "it should create instance methods that call class methods of the same name" do
+    @c = Class.new do
+      def self.x; 1; end
+      class_attr_reader :x
+    end
+    @c.new.x.should == 1
+    def @c.x; 2; end
+    @c.new.x.should == 2
+  end
+end
+
+context "Module#metaalias" do
+  specify "it should create aliases of singleton/class methods" do
+    @c = Class.new do
+      def self.x; 1; end
+      metaalias :y, :x
+    end
+    @c.y.should == 1
+    def @c.x; 2; end
+    @c.y.should == 1
+  end
+end
+
+context "Module#metaattr_reader" do
+  specify "it should create attr_readers of singleton/class methods" do
+    @c = Class.new do
+      @y = 1
+      @x = 2
+      metaattr_reader :y, :x
+    end
+    @c.y.should == 1
+    @c.x.should == 2
+  end
+end
+
+context "Module#metaprivate" do
+  specify "it should create aliases of singleton/class methods" do
+    @c = Class.new do
+      def self.x; 1; end
+    end
+    @c.x.should == 1
+    @c.class_eval do
+      metaprivate :x
+    end
+    proc{@c.x}.should raise_error(NoMethodError)
+  end
+end
+
+context "Object#is_one_of?" do
+  specify "it should be true if the object is one of the classes" do
+    1.is_one_of?(Numeric, Array).should == true
+    [].is_one_of?(Numeric, Array).should == true
+    {}.is_one_of?(Numeric, Enumerable).should == true
+  end
+
+  specify "it should be false if the object is not one of the classes" do
+    'a'.is_one_of?(Numeric, Array).should == false
+    Object.new.is_one_of?(Numeric, Array).should == false
+  end
+end
+
+context "Object#blank?" do
+  specify "it should be true if the object responds true to empty?" do
+    [].blank?.should == true
+    {}.blank?.should == true
+    o = Object.new
+    def o.empty?; true; end
+    o.blank?.should == true
+  end
+
+  specify "it should be false if the object doesn't respond true to empty?" do
+    [2].blank?.should == false
+    {1=>2}.blank?.should == false
+    Object.new.blank?.should == false
+  end
+end
+
+context "Numeric#blank?" do
+  specify "it should always be false" do
+    1.blank?.should == false
+    0.blank?.should == false
+    -1.blank?.should == false
+    1.0.blank?.should == false
+    0.0.blank?.should == false
+    -1.0.blank?.should == false
+    10000000000000000.blank?.should == false
+    -10000000000000000.blank?.should == false
+    10000000000000000.0.blank?.should == false
+    -10000000000000000.0.blank?.should == false
+  end
+end
+
+context "NilClass#blank?" do
+  specify "it should always be true" do
+    nil.blank?.should == true
+  end
+end
+
+context "TrueClass#blank?" do
+  specify "it should always be false" do
+    true.blank?.should == false
+  end
+end
+
+context "FalseClass#blank?" do
+  specify "it should always be true" do
+    false.blank?.should == true
+  end
+end
+
+context "FalseClass#blank?" do
+  specify "it should be true if the string is empty" do
+    ''.blank?.should == true
+  end
+  specify "it should be true if the string is composed of just whitespace" do
+    ' '.blank?.should == true
+    "\r\n\t".blank?.should == true
+    (' '*4000).blank?.should == true
+    ("\r\n\t"*4000).blank?.should == true
+  end
+  specify "it should be false if the string has any non whitespace characters" do
+    '1'.blank?.should == false
+    ("\r\n\t"*4000 + 'a').blank?.should == false
+    ("\r\na\t"*4000).blank?.should == false
+  end
+end