sequel_core 1.0.1 → 1.0.2

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 1.0.2 (2008-01-14)
+
+* Removed ConnectionPool, NumericExtensions. Added dependency on assistance.
+
 === 1.0.1 (2008-01-12)
 
 * Changed postgres adapter to quote column references using double quotes.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.0.1"
+VERS = "1.0.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -58,6 +58,7 @@ spec = Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.8.4"
 
   s.add_dependency("metaid")
+  s.add_dependency("assistance", ">= 0.1")
 
   case RUBY_PLATFORM
   when /mswin/

data/lib/sequel_core/core_ext.rb

@@ -22,38 +22,3 @@ class Object
     nil
   end
 end
-
-module Sequel
-  # Facilitates time calculations by providing methods to convert from larger
-  # time units to seconds, and to convert relative time intervals to absolute
-  # ones. This module duplicates some of the functionality provided by Rails'
-  # ActiveSupport::CoreExtensions::Numeric::Time module.
-  module NumericExtensions
-    MINUTE = 60
-    HOUR = 3600
-    DAY = 86400
-    WEEK = DAY * 7
-  
-    # Converts self from minutes to seconds
-    def minutes;  self * MINUTE;  end; alias_method :minute, :minutes
-    # Converts self from hours to seconds
-    def hours;    self * HOUR;    end; alias_method :hour, :hours
-    # Converts self from days to seconds
-    def days;     self * DAY;     end; alias_method :day, :days
-    # Converts self from weeks to seconds
-    def weeks;    self * WEEK;    end; alias_method :week, :weeks
-  
-    # Returns the time at now - self.
-    def ago(t = Time.now); t - self; end
-    alias_method :before, :ago
-
-    # Returns the time at now + self.
-    def from_now(t = Time.now); t + self; end
-    alias_method :since, :from_now
-    
-    # Extends the Numeric class with numeric extensions.
-    def self.enable
-      Numeric.send(:include, self)
-    end
-  end
-end

data/lib/sequel_core.rb

@@ -1,9 +1,12 @@
+gem "assistance", ">= 0.1"
+
 require "metaid"
+require "assistance"
 require "bigdecimal"
 require "bigdecimal/util"
 
 files = %w[
-  core_ext core_sql array_keys exceptions connection_pool pretty_table
+  core_ext core_sql array_keys exceptions pretty_table
   dataset migration model schema database worker
 ]
 dir = File.join(File.dirname(__FILE__), "sequel_core")

data/spec/core_ext_spec.rb

@@ -17,51 +17,3 @@ context "Range#interval" do
     (t1..t2).interval.should == r
   end
 end
-
-context "Numeric extensions" do
-  setup do
-    Sequel::NumericExtensions.enable
-  end
-  
-  specify "should support conversion of minutes to seconds" do
-    1.minute.should == 60
-    3.minutes.should == 180
-  end
-  
-  specify "should support conversion of hours to seconds" do
-    1.hour.should == 3600
-    3.hours.should == 3600 * 3
-  end
-
-  specify "should support conversion of days to seconds" do
-    1.day.should == 86400
-    3.days.should == 86400 * 3
-  end
-
-  specify "should support conversion of weeks to seconds" do
-    1.week.should == 86400 * 7
-    3.weeks.should == 86400 * 7 * 3
-  end
-  
-  specify "should provide #ago functionality" do
-    t1 = Time.now
-    t2 = 1.day.ago
-    t1.should > t2
-    ((t1 - t2).to_i - 86400).abs.should < 2
-    
-    t1 = Time.now
-    t2 = 1.day.before(t1)
-    t2.should == t1 - 1.day
-  end
-
-  specify "should provide #from_now functionality" do
-    t1 = Time.now
-    t2 = 1.day.from_now
-    t1.should < t2
-    ((t2 - t1).to_i - 86400).abs.should < 2
-    
-    t1 = Time.now
-    t2 = 1.day.since(t1)
-    t2.should == t1 + 1.day
-  end
-end

data/spec/database_spec.rb

@@ -14,7 +14,7 @@ context "A new Database" do
   end
   
   specify "should create a connection pool" do
-    @db.pool.should be_a_kind_of(Sequel::ConnectionPool)
+    @db.pool.should be_a_kind_of(ConnectionPool)
     @db.pool.max_size.should == 4
     
     Sequel::Database.new(:max_connections => 10).pool.max_size.should == 10
@@ -590,24 +590,24 @@ context "A single threaded database" do
   
   specify "should use a SingleThreadedPool instead of a ConnectionPool" do
     db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db.pool.should be_a_kind_of(SingleThreadedPool)
   end
   
   specify "should be constructable using :single_threaded => true option" do
     db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db.pool.should be_a_kind_of(SingleThreadedPool)
   end
   
   specify "should be constructable using Database.single_threaded = true" do
     Sequel::Database.single_threaded = true
     db = Sequel::Database.new
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db.pool.should be_a_kind_of(SingleThreadedPool)
   end
 
   specify "should be constructable using Sequel.single_threaded = true" do
     Sequel.single_threaded = true
     db = Sequel::Database.new
-    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+    db.pool.should be_a_kind_of(SingleThreadedPool)
   end
 end
 

data/spec/rcov.opts

@@ -1,4 +1,6 @@
 --exclude
 gems
 --exclude
-spec
+spec
+--exclude
+00*

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-12 00:00:00 +02:00
+date: 2008-01-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +21,15 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: assistance
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: RubyInline
   version_requirement: 
@@ -63,7 +72,6 @@ files:
 - README
 - Rakefile
 - bin/sequel
-- doc/rdoc
 - spec/adapters
 - spec/adapters/informix_spec.rb
 - spec/adapters/mysql_spec.rb
@@ -71,7 +79,6 @@ files:
 - spec/adapters/postgres_spec.rb
 - spec/adapters/sqlite_spec.rb
 - spec/array_keys_spec.rb
-- spec/connection_pool_spec.rb
 - spec/core_ext_spec.rb
 - spec/core_sql_spec.rb
 - spec/database_spec.rb
@@ -101,7 +108,6 @@ files:
 - lib/sequel_core/adapters/postgres.rb
 - lib/sequel_core/adapters/sqlite.rb
 - lib/sequel_core/array_keys.rb
-- lib/sequel_core/connection_pool.rb
 - lib/sequel_core/core_ext.rb
 - lib/sequel_core/core_sql.rb
 - lib/sequel_core/database.rb

data/lib/sequel_core/connection_pool.rb

@@ -1,152 +0,0 @@
-require 'thread'
-
-module Sequel
-  # A ConnectionPool manages access to database connections by keeping
-  # multiple connections and giving threads exclusive access to each
-  # connection.
-  class ConnectionPool
-    attr_reader :mutex
-    
-    # The maximum number of connections.
-    attr_reader :max_size
-    
-    # The proc used to create a new connection.
-    attr_accessor :connection_proc
-    
-    attr_reader :available_connections, :allocated, :created_count
-  
-    # Constructs a new pool with a maximum size. If a block is supplied, it
-    # is used to create new connections as they are needed.
-    #
-    #   pool = ConnectionPool.new(10) {MyConnection.new(opts)}
-    #
-    # The connection creation proc can be changed at any time by assigning a 
-    # Proc to pool#connection_proc.
-    #
-    #   pool = ConnectionPool.new(10)
-    #   pool.connection_proc = proc {MyConnection.new(opts)}
-    def initialize(max_size = 4, &block)
-      @max_size = max_size
-      @mutex = Mutex.new
-      @connection_proc = block
-
-      @available_connections = []
-      @allocated = {}
-      @created_count = 0
-    end
-    
-    # Returns the number of created connections.
-    def size
-      @created_count
-    end
-    
-    # Assigns a connection to the current thread, yielding the connection
-    # to the supplied block.
-    # 
-    #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
-    # 
-    # Pool#hold is re-entrant, meaning it can be called recursively in
-    # the same thread without blocking.
-    #
-    # If no connection is available, Pool#hold will block until a connection
-    # is available.
-    def hold
-      t = Thread.current
-      if (conn = owned_connection(t))
-        return yield(conn)
-      end
-      while !(conn = acquire(t))
-        sleep 0.001
-      end
-      begin
-        yield conn
-      ensure
-        release(t)
-      end
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise e.is_a?(StandardError) ? e : e.message
-    end
-    
-    # Removes all connection currently available, optionally yielding each 
-    # connection to the given block. This method has the effect of 
-    # disconnecting from the database. Once a connection is requested using
-    # #hold, the connection pool creates new connections to the database.
-    def disconnect(&block)
-      @mutex.synchronize do
-        @available_connections.each {|c| block[c]} if block
-        @available_connections = []
-        @created_count = @allocated.size
-      end
-    end
-    
-    private
-      # Returns the connection owned by the supplied thread, if any.
-      def owned_connection(thread)
-        @mutex.synchronize {@allocated[thread]}
-      end
-      
-      # Assigns a connection to the supplied thread, if one is available.
-      def acquire(thread)
-        @mutex.synchronize do
-          if conn = available
-            @allocated[thread] = conn
-          end
-        end
-      end
-      
-      # Returns an available connection. If no connection is available,
-      # tries to create a new connection.
-      def available
-        @available_connections.pop || make_new
-      end
-      
-      # Creates a new connection if the size of the pool is less than the
-      # maximum size.
-      def make_new
-        if @created_count < @max_size
-          @created_count += 1
-          @connection_proc ? @connection_proc.call : \
-            (raise Error, "No connection proc specified")
-        end
-      end
-      
-      # Releases the connection assigned to the supplied thread.
-      def release(thread)
-        @mutex.synchronize do
-          @available_connections << @allocated[thread]
-          @allocated.delete(thread)
-        end
-      end
-  end
-
-  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
-  # in single-threaded applications. ConnectionPool imposes a substantial
-  # performance penalty, so SingleThreadedPool is used to gain some speed.
-  class SingleThreadedPool
-    attr_reader :conn
-    attr_writer :connection_proc
-    
-    # Initializes the instance with the supplied block as the connection_proc.
-    def initialize(&block)
-      @connection_proc = block
-    end
-    
-    # Yields the connection to the supplied block. This method simulates the
-    # ConnectionPool#hold API.
-    def hold
-      @conn ||= @connection_proc.call
-      yield @conn
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise e.is_a?(StandardError) ? e : e.message
-    end
-    
-    # Disconnects from the database. Once a connection is requested using
-    # #hold, the connection is reestablished.
-    def disconnect(&block)
-      block[@conn] if block && @conn
-      @conn = nil
-    end
-  end
-end

data/spec/connection_pool_spec.rb

@@ -1,356 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "An empty ConnectionPool" do
-  setup do
-    @cpool = Sequel::ConnectionPool.new
-  end
-
-  specify "should have no available connections" do
-    @cpool.available_connections.should == []
-  end
-
-  specify "should have no allocated connections" do
-    @cpool.allocated.should == {}
-  end
-
-  specify "should have a created_count of zero" do
-    @cpool.created_count.should == 0
-  end
-end
-
-context "A connection pool handling connections" do
-  setup do
-    @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(@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}
-    end
-  end
-
-  specify "#hold should add the connection to the #allocated hash" do
-    @cpool.hold do
-      @cpool.allocated.size.should == 1
-  
-      @cpool.allocated.values.should == [:got_connection]
-    end
-  end
-
-  specify "#hold should yield a new connection" do
-    @cpool.hold {|conn| conn.should == :got_connection}
-  end
-
-  specify "a connection should be de-allocated after it has been used in #hold" do
-    @cpool.hold {}
-    @cpool.allocated.size.should == 0
-  end
-
-  specify "#hold should return the value of its block" do
-    @cpool.hold {:block_return}.should == :block_return
-  end
-
-  specify "#make_new should not make more than max_size connections" do
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == nil
-    @cpool.created_count.should == 2
-  end
-end
-
-class DummyConnection
-  @@value = 0
-  def initialize
-    @@value += 1
-  end
-  
-  def value
-    @@value
-  end
-end
-
-context "ConnectionPool#hold" do
-  setup do
-    @pool = Sequel::ConnectionPool.new {DummyConnection.new}
-  end
-  
-  specify "should pass the result of the connection maker proc to the supplied block" do
-    res = nil
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1
-    @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
-    res.value.should == 1 # the connection maker is invoked only once
-  end
-  
-  specify "should be re-entrant by the same thread" do
-    cc = nil
-    @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
-    cc.should be_a_kind_of(DummyConnection)
-  end
-  
-  specify "should catch exceptions and reraise them" do
-    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
-  end
-  
-  specify "should handle Exception errors (normally not caught be rescue)" do
-    begin
-      @pool.hold {raise Exception}
-    rescue => e
-      e.should be_a_kind_of(RuntimeError)
-    end
-  end
-end
-
-context "ConnectionPool#connection_proc" do
-  setup do
-    @pool = Sequel::ConnectionPool.new
-  end
-  
-  specify "should be nil if no block is supplied to the pool" do
-    @pool.connection_proc.should be_nil
-    proc {@pool.hold {}}.should raise_error
-  end
-  
-  specify "should be mutable" do
-    @pool.connection_proc = proc {'herro'}
-    res = nil
-    proc {@pool.hold {|c| res = c}}.should_not raise_error
-    res.should == 'herro'
-  end
-end
-
-context "A connection pool with a max size of 1" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
-  end
-  
-  specify "should let only one thread access the connection at any time" do
-    cc,c1, c2 = nil
-    
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
-    sleep 0.2
-    cc.should == 'herro'
-    c1.should == 'herro'
-    
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
-    sleep 0.2
-    
-    # connection held by t1
-    t1.should be_alive
-    t2.should be_alive
-    
-    cc.should == 'herro'
-    c1.should == 'herro'
-    c2.should be_nil
-    
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t1 => cc}
-    
-    cc.gsub!('rr', 'll')
-    sleep 0.5
-    
-    # connection held by t2
-    t1.should_not be_alive
-    t2.should be_alive
-
-    c2.should == 'hello'
-
-    @pool.available_connections.should be_empty
-    @pool.allocated.should == {t2 => cc}
-    
-    cc.gsub!('ll', 'rr')
-    sleep 0.5
-    
-    #connection released
-    t2.should_not be_alive
-    
-    cc.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.should == [cc]
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should let the same thread reenter #hold" do
-    c1, c2, c3 = nil
-    @pool.hold do |c|
-      c1 = c
-      @pool.hold do |c|
-        c2 = c
-        @pool.hold do |c|
-          c3 = c
-        end
-      end
-    end
-    c1.should == 'herro'
-    c2.should == 'herro'
-    c3.should == 'herro'
-    
-    @invoked_count.should == 1
-    @pool.size.should == 1
-    @pool.available_connections.size.should == 1
-    @pool.allocated.should be_empty
-  end
-end
-
-context "A connection pool with a max size of 5" do
-  setup do
-    @invoked_count = 0
-    @pool = Sequel::ConnectionPool.new(5) {@invoked_count += 1}
-  end
-  
-  specify "should let five threads simultaneously access separate connections" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    cc.size.should == 5
-    @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}
-    
-    threads[0].raise "your'e dead"
-    sleep 0.1
-    threads[3].raise "your'e dead too"
-    
-    sleep 0.1
-    
-    @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1] => 2, threads[2] => 3, threads[4] => 5}
-    
-    stop = true
-    sleep 0.2
-    
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-  
-  specify "should block threads until a connection becomes available" do
-    cc = {}
-    threads = []
-    stop = nil
-    
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
-    threads.each {|t| t.should be_alive}
-    @pool.available_connections.should be_empty
-
-    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
-    
-    sleep 0.2
-    threads[5].should be_alive
-    threads[6].should be_alive
-    threads[7].should be_alive
-    cc.size.should == 5
-    cc[5].should be_nil
-    cc[6].should be_nil
-    cc[7].should be_nil
-    
-    stop = true
-    sleep 0.3
-    
-    threads.each {|t| t.should_not be_alive}
-    
-    @pool.size.should == 5
-    @invoked_count.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.allocated.should be_empty
-  end
-end
-
-context "ConnectionPool#disconnect" do
-  setup do
-    @count = 0
-    @pool = Sequel::ConnectionPool.new(5) {{:id => @count += 1}}
-  end
-  
-  specify "should invoke the given block for each available connection" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.available_connections.size.should == 5
-    @pool.available_connections.each {|c| c[:id].should_not be_nil}
-    conns = []
-    @pool.disconnect {|c| conns << c}
-    conns.size.should == 5
-  end
-  
-  specify "should remove all available connections" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    @pool.disconnect
-    @pool.size.should == 0
-  end
-
-  specify "should not touch connections in use" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
-    while @pool.size < 5
-      sleep 0.2
-    end
-    stop = true
-    sleep 1
-    threads.each {|t| t.join}
-    
-    @pool.size.should == 5
-    
-    @pool.hold do |conn|
-      @pool.available_connections.size.should == 4
-      @pool.available_connections.each {|c| c.should_not be(conn)}
-      conns = []
-      @pool.disconnect {|c| conns << c}
-      conns.size.should == 4
-    end
-    @pool.size.should == 1
-  end
-end
-
-context "SingleThreadedPool" do
-  setup do
-    @pool = Sequel::SingleThreadedPool.new {1234}
-  end
-  
-  specify "should provide a #hold method" do
-    conn = nil
-    @pool.hold {|c| conn = c}
-    conn.should == 1234
-  end
-  
-  specify "should provide a #disconnect method" do
-    @pool.hold {|c|}
-    @pool.conn.should == 1234
-    conn = nil
-    @pool.disconnect {|c| conn = c}
-    conn.should == 1234
-    @pool.conn.should be_nil
-  end
-end