assistance 0.0.1 → 0.0.2

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 0.0.2 (2008-01-10)
+
+* Removed Sequel namespace for ConnectionPool.
+
 === 0.0.1 (2008-01-10)
 
 * Imported #blank? from DataMapper.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "assistance"
-VERS = "0.0.1"
+VERS = "0.0.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -33,6 +33,13 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.add ["README", "COPYING", "lib/assistance.rb", "lib/**/*.rb"]
 end
 
+task :doc_rforge => [:doc]
+
+desc "Update docs and upload to rubyforge.org"
+task :doc_rforge do
+  sh %{scp -r doc/rdoc/* ciconia@rubyforge.org:/var/www/gforge-projects/assistance}
+end
+
 ##############################################################################
 # Gem packaging
 ##############################################################################
@@ -85,7 +92,7 @@ end
 
 task :tag do
   cwd = FileUtils.pwd
-  sh %{cd ../.. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
+  sh %{cd .. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
 end
 
 ##############################################################################

data/lib/assistance/connection_pool.rb

@@ -1,152 +1,150 @@
 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
+# A ConnectionPool manages access to database connections by keeping
+# multiple connections and giving threads exclusive access to each
+# connection.
+class ConnectionPool
+  attr_reader :mutex
   
-    # 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
+  # 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
 
-      @available_connections = []
-      @allocated = {}
-      @created_count = 0
+  # 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
-    
-    # Returns the number of created connections.
-    def size
-      @created_count
+    while !(conn = acquire(t))
+      sleep 0.001
     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
+    begin
+      yield conn
+    ensure
+      release(t)
     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
+  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
     
-    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)
+    # 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
-
-  # 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
+    end
     
-    # Initializes the instance with the supplied block as the connection_proc.
-    def initialize(&block)
-      @connection_proc = block
+    # Returns an available connection. If no connection is available,
+    # tries to create a new connection.
+    def available
+      @available_connections.pop || make_new
     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
+    # 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
     
-    # 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
+    # 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

data/spec/connection_pool_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 context "An empty ConnectionPool" do
   setup do
-    @cpool = Sequel::ConnectionPool.new
+    @cpool = ConnectionPool.new
   end
 
   specify "should have no available connections" do
@@ -21,7 +21,7 @@ end
 context "A connection pool handling connections" do
   setup do
     @max_size = 2
-    @cpool = Sequel::ConnectionPool.new(@max_size) {:got_connection}
+    @cpool = ConnectionPool.new(@max_size) {:got_connection}
   end
 
   specify "#hold should increment #created_count" do
@@ -73,7 +73,7 @@ end
 
 context "ConnectionPool#hold" do
   setup do
-    @pool = Sequel::ConnectionPool.new {DummyConnection.new}
+    @pool = ConnectionPool.new {DummyConnection.new}
   end
   
   specify "should pass the result of the connection maker proc to the supplied block" do
@@ -109,7 +109,7 @@ end
 
 context "ConnectionPool#connection_proc" do
   setup do
-    @pool = Sequel::ConnectionPool.new
+    @pool = ConnectionPool.new
   end
   
   specify "should be nil if no block is supplied to the pool" do
@@ -128,7 +128,7 @@ 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'}
+    @pool = ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
   end
   
   specify "should let only one thread access the connection at any time" do
@@ -204,7 +204,7 @@ 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}
+    @pool = ConnectionPool.new(5) {@invoked_count += 1}
   end
   
   specify "should let five threads simultaneously access separate connections" do
@@ -274,7 +274,7 @@ end
 context "ConnectionPool#disconnect" do
   setup do
     @count = 0
-    @pool = Sequel::ConnectionPool.new(5) {{:id => @count += 1}}
+    @pool = ConnectionPool.new(5) {{:id => @count += 1}}
   end
   
   specify "should invoke the given block for each available connection" do
@@ -338,7 +338,7 @@ end
 
 context "SingleThreadedPool" do
   setup do
-    @pool = Sequel::SingleThreadedPool.new {1234}
+    @pool = SingleThreadedPool.new {1234}
   end
   
   specify "should provide a #hold method" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assistance
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz, Sam Smoot, Sharon Rosner