data_objects 0.10.0 → 0.10.1

data/ChangeLog.markdown

@@ -0,0 +1,20 @@
+## 0.10.1 (unreleased, in git)
+
+* Removal of Extlib dependency: Pooling and Utilities code moved to DataObjects.
+* Switch to Jeweler for Gem building tasks (this change may be temporary).
+* Switch to using Bacon for running specs: This should make specs friendlier to
+  new Ruby implementations that are not yet 100% MRI-compatible, and in turn,
+  prepared the road for our own IronRuby and MacRuby support.
+* Make DataObjects::Reader Enumerable.
+
+## 0.10.0 2009-09-15
+
+* No Changes since 0.9.11
+
+## 0.9.11 2009-01-19
+* Fixes
+  * Use Extlib `Object.full_const_get` instead of custom code
+  * Remove Field as it was unused
+
+## 0.9.9 2008-11-27
+* No Changes since 0.9.8

data/LICENSE

@@ -1,32 +1,4 @@
-Copyright (c) 2007, 2008, 2009 Yehuda Katz, Dirkjan Bussink
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
----
----
-
-Some portions of tasks/ext_helper_java.rb are verbatim copies of software
-licensed under the MIT license. That license is included below:
-
-Copyright (c) 2006-2008 Nick Sieger <nick@nicksieger.com>
-Copyright (c) 2006-2008 Ola Bini <ola.bini@gmail.com>
+Copyright (c) 2007 - 2010 Yehuda Katz, Dirkjan Bussink
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,4 +1,18 @@
-data_objects
-============
+# do_derby
+
+* <http://dataobjects.info>
+
+## Description
 
 A unified Ruby API for popular databases.
+
+## License
+
+Licensed under the MIT license. Please see the {file:LICENSE} for more information.
+
+## Contact
+
+**IRC**:       **Join us on IRC in #datamapper on irc.freenode.net!**<br/>
+**Git**:       <http://github.com/datamapper/do><br/>
+**Author**:    Dirkjan Bussink<br/>
+**License**:   MIT License

data/Rakefile

@@ -1,15 +1,49 @@
+require 'pathname'
 require 'rubygems'
 require 'rake'
 require 'rake/clean'
 
-require 'pathname'
-require 'lib/data_objects/version'
+ROOT = Pathname(__FILE__).dirname.expand_path
 
-ROOT    = Pathname(__FILE__).dirname.expand_path
-JRUBY   = RUBY_PLATFORM =~ /java/
-WINDOWS = Gem.win_platform?
-SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+require ROOT + 'lib/data_objects/version'
 
-Dir['tasks/*.rake'].sort.each { |f| import f }
+JRUBY    = RUBY_PLATFORM =~ /java/
+IRONRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
+WINDOWS  = Gem.win_platform? || (JRUBY && ENV_JAVA['os.name'] =~ /windows/i)
+SUDO     = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
 
 CLEAN.include(%w[ pkg/ **/*.rbc ])
+
+begin
+  gem 'jeweler', '~> 1.4'
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'data_objects'
+    gem.version     = DataObjects::VERSION
+    gem.summary     = 'DataObjects basic API and shared driver specifications'
+    gem.description = 'Provide a standard and simplified API for communicating with RDBMS from Ruby'
+    gem.platform    = Gem::Platform::RUBY
+    gem.files       = FileList["lib/**/*.rb", "spec/**/*.rb", "tasks/**/*.rake",
+                        "LICENSE", "Rakefile", "*.{markdown,rdoc,txt,yml}"]
+    gem.test_files  = FileList['spec/**/*.rb']
+
+    gem.add_dependency 'addressable', '~>2.1'
+
+    gem.add_development_dependency 'bacon', '~>1.1'
+    gem.add_development_dependency 'mocha', '~>0.9'
+    gem.add_development_dependency 'yard',  '~>0.5'
+
+    gem.rubyforge_project = 'dorb'
+
+    gem.authors     = ['Dirkjan Bussink']
+    gem.email       = 'd.bussink@gmail.com'
+    gem.homepage    = 'http://github.com/datamapper/do'
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  FileList['tasks/**/*.rake'].each { |task| import task }
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end

data/lib/data_objects.rb

@@ -1,7 +1,8 @@
-require 'extlib'
-
 require 'data_objects/version'
+require 'data_objects/utilities'
 require 'data_objects/logger'
+require 'data_objects/byte_array'
+require 'data_objects/pooling'
 require 'data_objects/connection'
 require 'data_objects/uri'
 require 'data_objects/transaction'

data/lib/data_objects/byte_array.rb

@@ -0,0 +1,6 @@
+# This class has exists to represent binary data. This is mainly
+# used by DataObjects. Binary data sometimes needs to be quoted differently
+# than regular string data (even if the string is just plain ASCII).
+module Extlib
+  class ByteArray < ::String; end
+end

data/lib/data_objects/connection.rb

@@ -15,16 +15,18 @@ module DataObjects
       case uri.scheme.to_sym
       when :java
         warn 'JNDI URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
-        # TODO: handle jndi connection strings
+        driver_name = uri.query.delete("scheme")
+        conn_uri = uri.to_s.gsub(/\?$/, '')
       when :jdbc
         warn 'JDBC URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
 
-        driver_name = if uri.path.split(':').first == 'sqlite'
+        path = uri.path.sub(/jdbc:/, '')
+        driver_name = if path.split(':').first == 'sqlite'
           'sqlite3'
-        elsif uri.path.split(':').first == 'postgresql'
+        elsif path.split(':').first == 'postgresql'
           'postgres'
         else
-          uri.path.split(':').first
+          path.split(':').first
         end
 
         conn_uri = uri_s # NOTE: for now, do not reformat this JDBC connection
@@ -45,11 +47,24 @@ module DataObjects
         driver_name.capitalize
       end
 
-      DataObjects.const_get(driver_class)::Connection.new(conn_uri)
+      clazz = DataObjects.const_get(driver_class)::Connection
+      unless clazz.method_defined? :close
+        if (uri.scheme.to_sym == :java)
+          clazz.class_eval do
+            alias close dispose
+          end
+        else
+          clazz.class_eval do
+            include Pooling
+            alias close release
+          end
+        end
+      end
+      clazz.new(conn_uri)
     end
 
     # Ensure that all Connection subclasses handle pooling and logging uniformly.
-    # See also Extlib::Pooling and DataObjects::Logger
+    # See also DataObjects::Pooling and DataObjects::Logger
     def self.inherited(target)
       target.class_eval do
 
@@ -60,10 +75,7 @@ module DataObjects
           instance
         end
 
-        include Extlib::Pooling
         include Quoting
-
-        alias close release
       end
 
       if driver_module_name = target.name.split('::')[-2]

data/lib/data_objects/logger.rb

@@ -51,16 +51,16 @@ module DataObjects
     # The name of the log file
     attr_reader   :log
 
-    # @note
-    #   Ruby (standard) logger levels:
-    #     off:   absolutely nothing
-    #     fatal: an unhandleable error that results in a program crash
-    #     error: a handleable error condition
-    #     warn:  a warning
-    #     info:  generic (useful) information about system operation
-    #     debug: low-level information for developers
     #
-    #   DataObjects::Logger::LEVELS[:off, :fatal, :error, :warn, :info, :debug]
+    # Ruby (standard) logger levels:
+    #   off:   absolutely nothing
+    #   fatal: an unhandleable error that results in a program crash
+    #   error: a handleable error condition
+    #   warn:  a warning
+    #   info:  generic (useful) information about system operation
+    #   debug: low-level information for developers
+    #
+    # DataObjects::Logger::LEVELS[:off, :fatal, :error, :warn, :info, :debug]
     LEVELS =
     {
       :off   => 99999,
@@ -201,12 +201,12 @@ module DataObjects
 
     # Appends a string and log level to logger's buffer.
 
-    # @note
-    #   Note that the string is discarded if the string's log level less than the
-    #   logger's log level.
-    # @note
-    #   Note that if the logger is aio capable then the logger will use
-    #   non-blocking asynchronous writes.
+    #
+    # Note that the string is discarded if the string's log level less than the
+    # logger's log level.
+    #
+    # Note that if the logger is aio capable then the logger will use
+    # non-blocking asynchronous writes.
     #
     # @param level<Fixnum>  the logging level as an integer
     # @param string<String> the message string to be logged

data/lib/data_objects/pooling.rb

@@ -0,0 +1,250 @@
+require 'set'
+require 'thread'
+
+module DataObjects
+
+  def self.exiting= bool
+    if bool && DataObjects.const_defined?('Pooling')
+      if DataObjects::Pooling.scavenger?
+        DataObjects::Pooling.scavenger.wakeup
+      end
+    end
+    @exiting = true
+  end
+
+  def self.exiting
+    return @exiting if defined?(@exiting)
+    @exiting = false
+  end
+
+  # ==== Notes
+  # Provides pooling support to class it got included in.
+  #
+  # Pooling of objects is a faster way of aquiring instances
+  # of objects compared to regular allocation and initialization
+  # because instances are keeped in memory reused.
+  #
+  # Classes that include Pooling module have re-defined new
+  # method that returns instances acquired from pool.
+  #
+  # Term resource is used for any type of poolable objects
+  # and should NOT be thought as DataMapper Resource or
+  # ActiveResource resource and such.
+  #
+  # In Data Objects connections are pooled so that it is
+  # unnecessary to allocate and initialize connection object
+  # each time connection is needed, like per request in a
+  # web application.
+  #
+  # Pool obviously has to be thread safe because state of
+  # object is reset when it is released.
+  module Pooling
+
+    def self.scavenger?
+      defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
+    end
+
+    def self.scavenger
+      unless scavenger?
+        @scavenger = Thread.new do
+          running = true
+          while running do
+            # Sleep before we actually start doing anything.
+            # Otherwise we might clean up something we just made
+            sleep(scavenger_interval)
+
+            lock.synchronize do
+              pools.each do |pool|
+                # This is a useful check, but non-essential, and right now it breaks lots of stuff.
+                # if pool.expired?
+                pool.lock.synchronize do
+                  if pool.expired?
+                    pool.dispose
+                  end
+                end
+                # end
+              end
+
+              # The pool is empty, we stop the scavenger
+              # It wil be restarted if new resources are added again
+              if pools.empty?
+                running = false
+              end
+            end
+          end # loop
+        end
+      end
+
+      @scavenger.priority = -10
+      @scavenger
+    end
+
+    def self.pools
+      @pools ||= Set.new
+    end
+
+    def self.append_pool(pool)
+      lock.synchronize do
+        pools << pool
+      end
+      DataObjects::Pooling.scavenger
+    end
+
+    def self.lock
+      @lock ||= Mutex.new
+    end
+
+    class InvalidResourceError < StandardError
+    end
+
+    def self.included(target)
+      target.class_eval do
+        class << self
+          alias __new new
+        end
+
+        @__pools     = {}
+        @__pool_lock = Mutex.new
+        @__pool_wait = ConditionVariable.new
+
+        def self.__pool_lock
+          @__pool_lock
+        end
+
+        def self.__pool_wait
+          @__pool_wait
+        end
+
+        def self.new(*args)
+          (@__pools[args] ||= __pool_lock.synchronize { Pool.new(self.pool_size, self, args) }).new
+        end
+
+        def self.__pools
+          @__pools
+        end
+
+        def self.pool_size
+          8
+        end
+      end
+    end
+
+    def release
+      @__pool.release(self) unless @__pool.nil?
+    end
+
+    def detach
+      @__pool.delete(self) unless @__pool.nil?
+    end
+
+    class Pool
+      attr_reader :available
+      attr_reader :used
+
+      def initialize(max_size, resource, args)
+        raise ArgumentError.new("+max_size+ should be a Fixnum but was #{max_size.inspect}") unless Fixnum === max_size
+        raise ArgumentError.new("+resource+ should be a Class but was #{resource.inspect}") unless Class === resource
+
+        @max_size = max_size
+        @resource = resource
+        @args = args
+
+        @available = []
+        @used      = {}
+        DataObjects::Pooling.append_pool(self)
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def wait
+        @resource.__pool_wait
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+        begin
+          lock.synchronize do
+            if @available.size > 0
+              instance = @available.pop
+              @used[instance.object_id] = instance
+            elsif @used.size < @max_size
+              instance = @resource.__new(*@args)
+              raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
+              raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
+              instance.instance_variable_set(:@__pool, self)
+              instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+              @used[instance.object_id] = instance
+            else
+              # Wait for another thread to release an instance.
+              # If we exhaust the pool and don't release the active instance,
+              # we'll wait here forever, so it's *very* important to always
+              # release your services and *never* exhaust the pool within
+              # a single thread.
+              wait.wait(lock)
+            end
+          end
+        end until instance
+        instance
+      end
+
+      def release(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          @used.delete(instance.object_id)
+          @available.push(instance)
+          wait.signal
+        end
+        nil
+      end
+
+      def delete(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @used.delete(instance.object_id)
+          wait.signal
+        end
+        nil
+      end
+
+      def size
+        @used.size + @available.size
+      end
+      alias length size
+
+      def inspect
+        "#<DataObjects::Pooling::Pool<#{@resource.name}> available=#{@available.size} used=#{@used.size} size=#{@max_size}>"
+      end
+
+      def flush!
+        @available.pop.dispose until @available.empty?
+      end
+
+      def dispose
+        flush!
+        @resource.__pools.delete(@args)
+        !DataObjects::Pooling.pools.delete?(self).nil?
+      end
+
+      def expired?
+        @available.each do |instance|
+          if DataObjects.exiting || instance.instance_variable_get(:@__allocated_in_pool) + DataObjects::Pooling.scavenger_interval <= (Time.now + 0.02)
+            instance.dispose
+            @available.delete(instance)
+          end
+        end
+        size == 0
+      end
+
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module DataObjects