activerecord-jdbc-adapter 50.1-java → 50.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b084099c62150191b20ce945af56f678dbea01a
-  data.tar.gz: 503f2431a2d3d8a2a9f8aed698dea351cead1e91
+  metadata.gz: 0222c94a160b13665c886d04020a3e549a1cd040
+  data.tar.gz: ef8cf19be8e3e6febef802e235a940069b445168
 SHA512:
-  metadata.gz: ccda53ecea8b3f8d2107ceba72c66a927168d4a9ea3fbb2e06c548276401e69a9b6ffbfaa737a92a2617b8ac2a7295555d09b73dc98c431fbf0f5e19456aa6e2
-  data.tar.gz: 9b8efb23326005581ec55a168175e366af08b3025f4ca025a7cc6f391a3b6484889257b9b61fce0baa9746a8339598edbd298e6939b82e90e8c1cf71185d4dd4
+  metadata.gz: d105602d32ac438487c69d77120006847ac2f995e3434820a594db4d4a04a40a2880d8a8c4101ff3581ce7391aff085864df9f6b9ae195858a41159172138cb8
+  data.tar.gz: 639a1928003e48251aa9c143298643bb282f93086df821c1bf31dac8f5c425c5b55b4654f7bdbf472e78af653dd0481ad3764576ed71211b3747b675371d9e32

data/.travis.yml

@@ -21,8 +21,8 @@ before_script:
     mysql -e "grant all privileges on activerecord_unittest.* to rails@localhost;" && \
     mysql -e "grant all privileges on activerecord_unittest2.* to rails@localhost;" && \
     mysql -e "grant all privileges on inexistent_activerecord_unittest.* to rails@localhost;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest2;" \
+    mysql -e "CREATE DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" && \
+    mysql -e "CREATE DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" \
     || true
   - |
     [ "$DB" == "postgresql" ] && [ "$TEST_PREFIX" == "rails:" ] && \

data/Rakefile

@@ -236,23 +236,43 @@ if defined? JRUBY_VERSION
     end
 
     classpath = []
-    [ 'java.class.path', 'sun.boot.class.path' ].each do |key|
-      classpath += ENV_JAVA[key].split(File::PATH_SEPARATOR).find_all { |jar| jar =~ /jruby/i }
+    [ 'java.class.path', 'sun.boot.class.path' ].map { |key| ENV_JAVA[key] }.each do |v|
+      classpath += v.split(File::PATH_SEPARATOR).find_all { |jar| jar =~ /jruby/i } if v
     end
-
-    #classpath += ENV_JAVA['java.class.path'].split(File::PATH_SEPARATOR)
-    #classpath += ENV_JAVA['sun.boot.class.path'].split(File::PATH_SEPARATOR)
-
+    # Using Java 9+.  Let's try and infer jruby.jar location from rbconfig
+    if classpath.empty?; require 'rbconfig'
+      libdir = RbConfig::CONFIG['libdir']
+      if libdir.start_with? 'classpath:'
+        error "Cannot build activerecord-jdbc with jruby-complete"
+      end
+      classpath << File.join(libdir, 'jruby.jar')
+    end
+    
     classpath += driver_jars
     classpath = classpath.compact.join(File::PATH_SEPARATOR)
 
     source_files = FileList[ 'src/java/**/*.java' ]
 
-    require 'tmpdir'
+    version = lambda do
+      begin
+        require 'arjdbc/version'
+      rescue LoadError
+        path = File.expand_path('../lib', File.dirname(__FILE__))
+        unless $LOAD_PATH.include?(path)
+          $LOAD_PATH << path; retry
+        end
+      end
 
-    Dir.mktmpdir do |classes_dir|
-      # Cross-platform way of finding an executable in the $PATH.
-      # Thanks to @mislav
+      gem_version = Gem::Version.create(ArJdbc::VERSION)
+      if gem_version.segments.last == 'DEV'
+        gem_version.segments[0...-1] # 50.0.DEV -> 50.0
+      else
+        gem_version.segments.dup
+      end
+    end
+
+    require 'tmpdir'; Dir.mktmpdir do |classes_dir|
+      # Cross-platform way of finding an executable in the $PATH. Thanks to @mislav
       which = lambda do |cmd|
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
         ENV['PATH'].split(File::PATH_SEPARATOR).map do |path|
@@ -276,7 +296,24 @@ if defined? JRUBY_VERSION
       # avoid environment variable expansion using backslash
       # class_files.gsub!('$', '\$') unless windows?
       # args = class_files.map { |path| [ "-C #{classes_dir}", path ] }.flatten
-      args = [ '-C', "#{classes_dir}/ ." ] # args = class_files
+
+      if ENV['RELEASE'] == 'true'; require 'tempfile'
+        manifest  = "Built-Time: #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')}\n"
+        manifest += "Built-JRuby: #{JRUBY_VERSION}\n"
+        manifest += "Specification-Title: ActiveRecord-JDBC\n"
+        manifest += "Specification-Vendor: JRuby\n"
+        manifest += "Specification-Version: #{version.call[0].to_s.split('').join('.')}\n" # AR VERSION (52 -> 5.2)
+        manifest += "Implementation-Vendor: The JRuby Team\n"
+        manifest += "Implementation-Version: #{version.call.join('.')}\n"
+        manifest  = Tempfile.new('MANIFEST').tap { |f| f << manifest; f.close }.path
+      end
+
+      args = []; opts = '-cf'
+      if manifest
+        opts = "#{opts}m"
+        args = [ "#{manifest}" ]
+      end
+      args += [ '-C', "#{classes_dir}/ ." ]
 
       jar_path = jar_file
       if ext_lib_dir = ENV['RUBYLIBDIR']
@@ -286,7 +323,7 @@ if defined? JRUBY_VERSION
       unless jar = which.call('jar')
         warn "could not find jar tool, please make sure it's on the PATH"
       end
-      sh("#{jar} cf #{jar_path} #{args.join(' ')}") do |ok|
+      sh("#{jar} #{opts} #{jar_path} #{args.join(' ')}") do |ok|
         raise 'could not build .jar extension - packaging failure' unless ok
       end
       cp jar_path, jar_file if ext_lib_dir # NOTE: hopefully RG won't mind?!
@@ -294,6 +331,6 @@ if defined? JRUBY_VERSION
   end
 else
   task :jar do
-    puts "please run `rake jar' under JRuby to re-compile the native (Java) extension"
+    warn "please run `rake jar' under JRuby to re-compile the native (Java) extension"
   end
 end

data/activerecord-jdbc-adapter.gemspec

@@ -44,7 +44,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency 'activerecord', '~> 5.0.0'
+  gem.add_dependency 'activerecord', '~> 5.0.0', '>= 5.0.3'
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arjdbc/abstract/core.rb

@@ -58,7 +58,17 @@ module ArJdbc
         end
       end
 
+      def extract_raw_bind_values(binds)
+        binds.map(&:value_for_database)
+      end
 
+      # this version of log() automatically fills type_casted_binds from binds if necessary
+      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+        if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
+          type_casted_binds = ->{ extract_raw_bind_values(binds) }
+        end
+        super
+      end
     end
   end
 end

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -4,15 +4,8 @@ module ArJdbc
   ConnectionMethods.module_eval do
 
     def jdbc_connection(config)
-      adapter_class = config[:adapter_class]
-      adapter_class ||= ::ActiveRecord::ConnectionAdapters::JdbcAdapter
-
-      # Once all adapters converted to AR5 then this rescue can be removed
-      begin
-        adapter_class.new(nil, logger, nil, config)
-      rescue ArgumentError
-        adapter_class.new(nil, logger, config)
-      end
+      adapter_class = config[:adapter_class] || ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+      adapter_class.new(nil, logger, nil, config)
     end
 
     def jndi_connection(config); jdbc_connection(config) end

data/lib/arjdbc/mysql/adapter.rb

@@ -31,8 +31,8 @@ module ActiveRecord
 
       include ArJdbc::MySQL
 
-      def initialize(connection, logger, config)
-        super(connection, logger, nil, config)
+      def initialize(connection, logger, connection_parameters, config)
+        super
         @prepared_statements = false unless config.key?(:prepared_statements)
         # configure_connection taken care of at ArJdbc::Abstract::Core
       end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -13,11 +13,14 @@ ArJdbc::ConnectionMethods.module_eval do
     driver = config[:driver] ||=
       defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
 
+    mysql_driver = driver.start_with?('com.mysql.')
+    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
+
     begin
       require 'jdbc/mysql'
       ::Jdbc::MySQL.load_driver(:require) if defined?(::Jdbc::MySQL.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
-    end if mysql_driver = driver[0, 10] == 'com.mysql.'
+    end if mysql_driver
 
     config[:username] = 'root' unless config.key?(:username)
     # jdbc:mysql://[host][,failoverhost...][:port]/[database]
@@ -25,12 +28,12 @@ ArJdbc::ConnectionMethods.module_eval do
     # - if the port is not specified, it defaults to 3306
     # - alternate fail-over syntax: [host:port],[host:port]/[database]
     unless config[:url]
-      host = config[:host]; host = host.join(',') if host.respond_to?(:join)
+      host = config[:host]
+      host ||= 'localhost' if mariadb_driver
+      host = host.join(',') if host.respond_to?(:join)
       config[:url] = "jdbc:mysql://#{host}#{ config[:port] ? ":#{config[:port]}" : nil }/#{config[:database]}"
     end
 
-    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
-
     properties = ( config[:properties] ||= {} )
     if mysql_driver
       properties['zeroDateTimeBehavior'] ||= 'convertToNull'
@@ -63,8 +66,8 @@ ArJdbc::ConnectionMethods.module_eval do
     end
     if config[:sslkey] || sslcert = config[:sslcert] # || config[:use_ssl]
       properties['useSSL'] ||= true # supported by MariaDB as well
-      properties['requireSSL'] ||= true if mysql_driver
       if mysql_driver
+        properties['requireSSL'] ||= true
         properties['clientCertificateKeyStoreUrl'] ||= java.io.File.new(sslcert).to_url.to_s if sslcert
         if sslca = config[:sslca]
           properties['trustCertificateKeyStoreUrl'] ||= java.io.File.new(sslca).to_url.to_s

data/lib/arjdbc/postgresql/adapter.rb

@@ -54,8 +54,30 @@ module ArJdbc
       @postgresql_version ||=
         begin
           version = @connection.database_product
-          if version =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
-            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+          if match = version.match(/([\d\.]*\d).*?/)
+            version = match[1].split('.').map(&:to_i)
+            # PostgreSQL version representation does not have more than 4 digits
+            # From version 10 onwards, PG has changed its versioning policy to
+            # limit it to only 2 digits. i.e. in 10.x, 10 being the major
+            # version and x representing the patch release
+            # Refer to:
+            #   https://www.postgresql.org/support/versioning/
+            #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
+            # for more info
+
+            if version.size >= 3
+              (version[0] * 100 + version[1]) * 100 + version[2]
+            elsif version.size == 2
+              if version[0] >= 10
+                version[0] * 100 * 100 + version[1]
+              else
+                (version[0] * 100 + version[1]) * 100
+              end
+            elsif version.size == 1
+              version[0] * 100 * 100
+            else
+              0
+            end
           else
             0
           end
@@ -217,6 +239,8 @@ module ArJdbc
 
     def supports_ddl_transactions?; true end
 
+    def supports_advisory_locks?; true end
+
     def supports_explain?; true end
 
     def supports_expression_index?; true end
@@ -237,6 +261,10 @@ module ArJdbc
 
     def supports_views?; true end
 
+    def supports_datetime_with_precision?; true end
+
+    def supports_comments?; true end
+
     # Does PostgreSQL support standard conforming strings?
     def supports_standard_conforming_strings?
       standard_conforming_strings?
@@ -247,6 +275,14 @@ module ArJdbc
       postgresql_version >= 90000
     end
 
+    def supports_materialized_views?
+      postgresql_version >= 90300
+    end
+
+    def supports_json?
+      postgresql_version >= 90200
+    end
+
     def supports_insert_with_returning?
       postgresql_version >= 80200
     end
@@ -370,6 +406,12 @@ module ArJdbc
       @connection.configure_connection
     end
 
+    def default_sequence_name(table_name, pk = "id") #:nodoc:
+      serial_sequence(table_name, pk)
+    rescue ActiveRecord::StatementInvalid
+      %Q("#{table_name}_#{pk}_seq")
+    end
+
     def last_insert_id_result(sequence_name)
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
@@ -649,11 +691,11 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, config = {})
+    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
 
-      super # configure_connection happens in super
+      super(connection, logger, config) # configure_connection happens in super
 
       initialize_type_map(@type_map = Type::HashLookupTypeMap.new)
 
@@ -676,21 +718,6 @@ module ActiveRecord::ConnectionAdapters
       TableDefinition.new(*args)
     end
 
-    def exec_query(sql, name = nil, binds = [], prepare: false)
-      super
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless e.cause.message.include?('cached plan must not change result type'.freeze)
-
-      if open_transactions > 0
-        # In a transaction, have to fail it - See AR code for details
-        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
-      else
-        # Not in a transaction, clear the prepared statement and try again
-        delete_cached_statement(sql)
-        retry
-      end
-    end
-
     public :sql_for_insert
 
     def schema_creation # :nodoc:

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -51,8 +51,15 @@ ArJdbc::ConnectionMethods.module_eval do
     properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
     properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
 
-    # If prepared statements are off, lets make sure they are really *off*
-    properties['prepareThreshold'] ||= 0 unless config[:prepared_statements]
+    prepared_statements = config.fetch(:prepared_statements) { true }
+    prepared_statements = false if prepared_statements == 'false'
+    if prepared_statements
+      # this makes the pgjdbc driver handle hot compatibility internally
+      properties['autosave'] ||= 'conservative'
+    else
+      # If prepared statements are off, lets make sure they are really *off*
+      properties['prepareThreshold'] = 0
+    end
 
     jdbc_connection(config)
   end

data/lib/arjdbc/sqlite3/adapter.rb

@@ -60,8 +60,7 @@ module ArJdbc
       Arel::Visitors::SQLite.new(self)
     end
 
-    # Difference we remove connection_options because we are not using it.
-    def initialize(connection, logger, config)
+    def initialize(connection, logger, connection_options, config)
       super(connection, logger, config)
 
       @active     = nil

data/lib/arjdbc/tasks/database_tasks.rb

@@ -1,52 +1,32 @@
 module ArJdbc
   module Tasks
 
-    if defined? ActiveRecord::Tasks::DatabaseTasks # AR-4.x
-
-      def self.register_tasks(pattern, task)
-        ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
-      end
-
-      # support adapter: mariadb (as if it were mysql)
-      register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
-
-    else
-
-      @@tasks = {}
-
-      def self.register_tasks(pattern, task)
-        @@tasks[pattern] = task
-      end
-
-      def self.tasks_instance(config)
-        adapter = config['adapter']
-        key = @@tasks.keys.detect { |pattern| adapter[pattern] }
-        ( @@tasks[key] || JdbcDatabaseTasks ).new(config)
-      end
-
+    def self.register_tasks(pattern, task)
+      ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
     end
 
+    # support adapter: mariadb (as if it were mysql)
+    register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+
     require 'arjdbc/tasks/jdbc_database_tasks'
-    require 'arjdbc/tasks/db2_database_tasks'
-    require 'arjdbc/tasks/derby_database_tasks'
-    require 'arjdbc/tasks/h2_database_tasks'
-    require 'arjdbc/tasks/hsqldb_database_tasks'
-    require 'arjdbc/tasks/mssql_database_tasks'
+    #require 'arjdbc/tasks/db2_database_tasks'
+    #require 'arjdbc/tasks/derby_database_tasks'
+    #require 'arjdbc/tasks/h2_database_tasks'
+    #require 'arjdbc/tasks/hsqldb_database_tasks'
+    #require 'arjdbc/tasks/mssql_database_tasks'
 
     # re-invent built-in (but deprecated on 4.0) tasks :
-    register_tasks(/sqlserver/, MSSQLDatabaseTasks)
-    register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
+    #register_tasks(/sqlserver/, MSSQLDatabaseTasks)
+    #register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
     # tasks for custom (JDBC) adapters :
-    register_tasks(/db2/, DB2DatabaseTasks)
-    register_tasks(/derby/, DerbyDatabaseTasks)
-    register_tasks(/h2/, H2DatabaseTasks)
-    register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
+    #register_tasks(/db2/, DB2DatabaseTasks)
+    #register_tasks(/derby/, DerbyDatabaseTasks)
+    #register_tasks(/h2/, H2DatabaseTasks)
+    #register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
     # (default) generic JDBC task :
     register_tasks(/^jdbc$/, JdbcDatabaseTasks)
 
     # NOTE: no need to register "built-in" adapters such as MySQL
-    # - on 4.0 these are registered and will be instantiated
-    # - while on 2.3/3.x we keep the AR built-in task behavior
 
   end
 end

data/lib/arjdbc/tasks/databases.rake

@@ -1,91 +1,48 @@
-raise "ArJdbc needs rake 0.9.x or newer" unless Rake.const_defined?(:VERSION)
-
-Rake::DSL.module_eval do
-
-  def redefine_task(*args, &block)
-    if Hash === args.first
-      task_name = args.first.keys[0]
-      old_prereqs = false # leave as specified
-    else
-      task_name = args.first; old_prereqs = []
-      # args[0] = { task_name => old_prereqs }
-    end
-
-    full_name = Rake::Task.scope_name(Rake.application.current_scope, task_name)
-
-    if old_task = Rake.application.lookup(task_name)
-      old_comment = old_task.full_comment
-      old_prereqs = old_task.prerequisites.dup if old_prereqs
-      old_actions = old_task.actions.dup
-      old_actions.shift # remove the main 'action' block - we're redefining it
-      # old_task.clear_prerequisites if old_prereqs
-      # old_task.clear_actions
-      # remove the (old) task instance from the application :
-      Rake.application.send(:instance_variable_get, :@tasks)[full_name.to_s] = nil
-    else
-      # raise "could not find rake task with (full) name '#{full_name}'"
-    end
-
-    new_task = task(*args, &block)
-    new_task.comment = old_comment if old_comment
-    new_task.actions.concat(old_actions) if old_actions
-    new_task.prerequisites.concat(old_prereqs) if old_prereqs
-    new_task
-  end
-
-end
-
-namespace :db do
-
-  def rails_env
-    defined?(Rails.env) ? Rails.env : ( RAILS_ENV || 'development' )
-  end
+require 'arjdbc/tasks/database_tasks'
 
-  if defined? adapt_jdbc_config
-    ArJdbc.warn "double loading #{__FILE__} please delete lib/tasks/jdbc.rake if present!"
-  end
+module ActiveRecord::Tasks
 
-  def adapt_jdbc_config(config)
-    return config unless config['adapter']
-    config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
-  end
+  DatabaseTasks.module_eval do
 
-  if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
+    # @override patched to adapt jdbc configuration
+    def each_current_configuration(environment)
+      environments = [environment]
+      environments << 'test' if environment == 'development'
 
-    def current_config(options = {})
-      ActiveRecord::Tasks::DatabaseTasks.current_config(options)
+      configurations = ActiveRecord::Base.configurations.values_at(*environments)
+      configurations.compact.each do |config|
+        yield adapt_jdbc_config(config) unless config['database'].blank?
+      end
     end
 
-  else # 3.x / 2.3
+    # @override patched to adapt jdbc configuration
+    def each_local_configuration
+      ActiveRecord::Base.configurations.each_value do |config|
+        next unless config['database']
 
-    def current_config(options = {}) # not on 2.3
-      options = { :env => rails_env }.merge! options
-      if options[:config]
-        @current_config = options[:config]
-      else
-        @current_config ||= ENV['DATABASE_URL'] ?
-          database_url_config : ActiveRecord::Base.configurations[options[:env]]
+        if local_database?(config)
+          yield adapt_jdbc_config(config)
+        else
+          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
+        end
       end
     end
 
-    def database_url_config(url = ENV['DATABASE_URL'])
-      # NOTE: ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
-      # since AR 4.0 that is handled by DatabaseTasks - only care about 2.3/3.x :
-      unless defined? ActiveRecord::Base::ConnectionSpecification::Resolver
-        raise "DATABASE_URL not supported on ActiveRecord #{ActiveRecord::VERSION::STRING}"
-      end
-      resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url, {})
-      resolver.spec.config.stringify_keys
+    private
+
+    def adapt_jdbc_config(config)
+      return config unless config['adapter']
+      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
     end
 
   end
 
-end
+  MySQLDatabaseTasks.class_eval do
 
-require 'arjdbc/tasks/database_tasks'
+    def error_class
+      ActiveRecord::JDBCError
+    end
+
+  end if const_defined?(:MySQLDatabaseTasks)
 
-if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
-  load File.expand_path('databases4.rake', File.dirname(__FILE__))
-else # 3.x / 2.3
-  load File.expand_path('databases3.rake', File.dirname(__FILE__))
-end
+end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '50.1'
+  VERSION = '50.2'
 end

data/rakelib/db.rake

@@ -4,25 +4,35 @@ namespace :db do
   task :mysql do
     require File.expand_path('../../test/shared_helper', __FILE__)
     fail "could not create test database: mysql executable not found" unless mysql = which('mysql')
+
     load 'test/db/mysql_config.rb' # rescue nil
     enc = MYSQL_CONFIG[:encoding] || 'utf8' # 'utf8mb4'
     puts MYSQL_CONFIG.inspect if $VERBOSE
-    # DROP USER arjdbc@localhost; __ERROR 1396 (HY000): Operation CREATE USER failed__
+
+    clean_script = sql_script <<-SQL, 'mysqlclean'
+DROP USER #{MYSQL_CONFIG[:username]}@localhost;
+    SQL
+
     script = sql_script <<-SQL, 'mysql'
 DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
 CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `#{enc}` COLLATE `#{enc}_general_ci`;
+CREATE USER #{MYSQL_CONFIG[:username]}@localhost IDENTIFIED BY '#{MYSQL_CONFIG[:password]}';
 GRANT ALL PRIVILEGES ON `#{MYSQL_CONFIG[:database]}`.* TO #{MYSQL_CONFIG[:username]}@localhost;
 GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
-SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
     SQL
+
     params = { '-u' => 'root' }
-    if ENV['DATABASE_YML']; require 'yaml'
-    params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+    if ENV['DATABASE_YML']
+      require 'yaml'
+      params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
     end
     params['-u'] = ENV['MY_USER'] if ENV['MY_USER']
     params['-p'] = ENV['MY_PASSWORD'] if ENV['MY_PASSWORD']
+
     puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
-    sh "cat #{script.path} | #{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}", :verbose => $VERBOSE # so password is not echoed
+    mysql_cmd = "#{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}"
+    sh "cat #{clean_script.path} | #{mysql_cmd}", verbose: false
+    sh "cat #{script.path} | #{mysql_cmd}", verbose: $VERBOSE # so password is not echoed
   end
 
   desc "Creates the test database for PostgreSQL"
@@ -30,8 +40,10 @@ SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG
     require File.expand_path('../../test/shared_helper', __FILE__)
     fail 'could not create test database: psql executable not found' unless psql = which('psql')
     fail 'could not create test database: missing "postgres" role' unless PostgresHelper.postgres_role?
+
     load 'test/db/postgres_config.rb' # rescue nil
     puts POSTGRES_CONFIG.inspect if $VERBOSE
+
     script = sql_script <<-SQL, 'psql'
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
 DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
@@ -40,12 +52,14 @@ CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]
        TEMPLATE template0
        ENCODING '#{POSTGRES_CONFIG[:encoding]}' LC_COLLATE '#{POSTGRES_CONFIG[:collate]}' LC_CTYPE '#{POSTGRES_CONFIG[:collate]}';
     SQL
+
     params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
     params['-q'] = nil unless $VERBOSE
+
     puts "Creating PostgreSQL (test) database: #{POSTGRES_CONFIG[:database]}"
-    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
+    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", verbose: $VERBOSE
   end
-  task :postgres => :postgresql
+  task postgres: :postgresql
 
   private
 

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -284,7 +284,7 @@ public class RubyJdbcConnection extends RubyObject {
     public static int mapTransactionIsolationLevel(final IRubyObject isolation) {
         final Object isolationString;
         if ( isolation instanceof RubySymbol ) {
-            isolationString = isolation.toString(); // RubySymbol.toString (interned)
+            isolationString = ((RubySymbol) isolation).asJavaString(); // RubySymbol (interned)
         }
         else {
             isolationString = isolation.asString().toString().toLowerCase(Locale.ENGLISH).intern();
@@ -2712,7 +2712,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     private String default_timezone(final ThreadContext context) {
         final RubyClass base = getBase(context.runtime);
-        return default_timezone.call(context, base, base).toString(); // :utc (or :local)
+        return default_timezone.call(context, base, base).asJavaString(); // :utc (or :local)
     }
 
     // ActiveRecord::Base.default_timezone
@@ -2894,14 +2894,13 @@ public class RubyJdbcConnection extends RubyObject {
         final RubySymbol type = (RubySymbol) attributeSQLType(context, attribute);
 
         // For some reason the driver doesn't like "character varying" as a type
-        if ( type.eql(context.runtime.newSymbol("string")) ){
-            return "text";
-        }
+        if ( type.eql(context.runtime.newSymbol("string")) ) return "text";
 
         final RubyHash nativeTypes = (RubyHash) getAdapter().callMethod(context, "native_database_types");
+        // e.g. `integer: { name: 'integer' }`
         final RubyHash typeInfo = (RubyHash) nativeTypes.op_aref(context, type);
 
-        return typeInfo.op_aref(context, context.runtime.newSymbol("name")).asString().toString();
+        return typeInfo.op_aref(context, context.runtime.newSymbol("name")).toString();
     }
 
     protected void setXmlParameter(final ThreadContext context,
@@ -3442,12 +3441,14 @@ public class RubyJdbcConnection extends RubyObject {
                 if ( ! gotConnection ) { // SQLException from driver/data-source
                     reconnectOnRetry = connected;
                 }
+                else if (!autoCommit) {
+                    // never retry inside a transaction
+                    break;
+                }
                 else if ( isTransient(exception) ) {
                     reconnectOnRetry = false; // continue;
                 }
                 else {
-                    if ( ! autoCommit ) break; // do not retry if (inside) transactions
-
                     if ( isConnectionValid(context, getConnectionImpl()) ) {
                         break; // connection not broken yet failed (do not retry)
                     }

data/src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -54,6 +54,7 @@ import org.joda.time.DateTimeZone;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -99,6 +100,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         POSTGRES_JDBC_TYPE_FOR.put("line", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("lseg", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("ltree", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("money", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("numrange", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("path", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("point", Types.OTHER);
@@ -440,6 +442,14 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
                 }
                 break;
 
+            case "money":
+                if (value instanceof RubyBigDecimal) {
+                    statement.setBigDecimal(index, ((RubyBigDecimal) value).getValue());
+                } else {
+                    setPGobjectParameter(statement, index, value, columnType);
+                }
+                break;
+
             case "lseg":
                 pointValues = parseDoubles(value);
                 statement.setObject(index, new PGlseg(pointValues[0], pointValues[1], pointValues[2], pointValues[3]));
@@ -484,7 +494,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         return points;
     }
 
-    private Double[] parseDoubles(IRubyObject value) {
+    private static Double[] parseDoubles(IRubyObject value) {
         Matcher matches = doubleValuePattern.matcher(value.toString());
         ArrayList<Double> doubles = new ArrayList<Double>(4); // Paths and polygons may be larger but this covers points/circles/boxes/line segments
 

data/src/java/arjdbc/util/StringHelper.java

@@ -25,12 +25,9 @@ package arjdbc.util;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.charset.Charset;
 
 import org.jcodings.Encoding;
-import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
-import org.jruby.RubyEncoding;
 import org.jruby.RubyString;
 import org.jruby.util.ByteList;
 
@@ -61,18 +58,6 @@ public abstract class StringHelper {
         return RubyString.newString(runtime, new ByteList(bytes, false));
     }
 
-    private static final Charset ASCII_CHARSET = Charset.forName("ISO-8859-1");
-
-    public static RubyString newASCIIString(final Ruby runtime, final String str) {
-        final ByteList byteList = new ByteList(str.getBytes(ASCII_CHARSET), false);
-        return RubyString.newString(runtime, byteList);
-    }
-
-    public static RubyString newUTF8String(final Ruby runtime, final byte[] bytes) {
-        final ByteList byteList = new ByteList(bytes, false);
-        return RubyString.newString(runtime, byteList, UTF8Encoding.INSTANCE);
-    }
-
     public static RubyString newDefaultInternalString(final Ruby runtime, final byte[] bytes) {
         final ByteList byteList = new ByteList(bytes, false);
         Encoding enc = runtime.getDefaultInternalEncoding();
@@ -83,18 +68,19 @@ public abstract class StringHelper {
     public static RubyString newDefaultInternalString(final Ruby runtime, final CharSequence str) {
         Encoding enc = runtime.getDefaultInternalEncoding();
         if (enc == null) enc = runtime.getEncodingService().getJavaDefault();
-        return RubyString.newString(runtime, new ByteList(RubyEncoding.encode(str, enc.getCharset()), enc));
+        return new RubyString(runtime, runtime.getString(), str, enc);
     }
 
+    // NOTE: a 'better' RubyString.newInternalFromJavaExternal - to be back-ported in JRuby 9.2
     public static RubyString newDefaultInternalString(final Ruby runtime, final String str) {
-        return RubyString.newInternalFromJavaExternal(runtime, str);
+        Encoding enc = runtime.getDefaultInternalEncoding();
+        if (enc == null) enc = runtime.getEncodingService().getJavaDefault();
+        return RubyString.newString(runtime, str, enc);
     }
 
     public static int readBytes(final ByteList output, final InputStream input)
         throws IOException {
-        @SuppressWarnings("deprecation") // capacity :
-        final int buffSize = output.bytes.length - output.begin;
-        return readBytes(output, input, buffSize);
+        return readBytes(output, input, output.unsafeBytes().length - output.getBegin());
     }
 
     public static int readBytes(final ByteList output, final InputStream input, int buffSize)

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '50.1'
+  version: '50.2'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-05-16 00:00:00.000000000 Z
+date: 2018-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.3
+  name: activerecord
+  prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.0.0
-  prerelease: false
-  type: :runtime
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.3
 description: 'AR-JDBC is a database adapter for Rails'' ActiveRecord component designed
   to be used with JRuby built upon Java''s JDBC API for database access. Provides
   (ActiveRecord) built-in adapters: MySQL, PostgreSQL and SQLite3 as well as adapters
@@ -119,7 +125,6 @@ files:
 - lib/arjdbc/jdbc/error.rb
 - lib/arjdbc/jdbc/extension.rb
 - lib/arjdbc/jdbc/java.rb
-- lib/arjdbc/jdbc/jdbc.rake
 - lib/arjdbc/jdbc/railtie.rb
 - lib/arjdbc/jdbc/rake_tasks.rb
 - lib/arjdbc/jdbc/serialized_attributes_helper.rb
@@ -158,8 +163,6 @@ files:
 - lib/arjdbc/tasks.rb
 - lib/arjdbc/tasks/database_tasks.rb
 - lib/arjdbc/tasks/databases.rake
-- lib/arjdbc/tasks/databases3.rake
-- lib/arjdbc/tasks/databases4.rake
 - lib/arjdbc/tasks/db2_database_tasks.rb
 - lib/arjdbc/tasks/derby_database_tasks.rb
 - lib/arjdbc/tasks/h2_database_tasks.rb
@@ -182,7 +185,6 @@ files:
 - rakelib/01-tomcat.rake
 - rakelib/02-test.rake
 - rakelib/bundler_ext.rb
-- rakelib/compile.rake
 - rakelib/db.rake
 - rakelib/rails.rake
 - src/java/arjdbc/ArJdbcModule.java

data/lib/arjdbc/jdbc/jdbc.rake

@@ -1,4 +0,0 @@
-load 'arjdbc/tasks.rb'
-
-require 'arjdbc'
-ArJdbc.deprecate "load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"

data/lib/arjdbc/tasks/databases3.rake

@@ -1,215 +0,0 @@
-module ArJdbc
-  module Tasks
-    class << self
-
-      # API similar to ActiveRecord::Tasks::DatabaseTasks on AR 4.0
-
-      def create(config)
-        tasks_instance(config).create
-      end
-
-      def drop(config)
-        tasks_instance(config).drop
-      end
-
-      def purge(config)
-        tasks_instance(config).purge
-      end
-
-      def charset(config)
-        tasks_instance(config).charset
-      end
-
-      def collation(config)
-        tasks_instance(config).collation
-      end
-
-      def structure_dump(config, filename)
-        tasks_instance(config).structure_dump(filename)
-      end
-
-      def structure_load(config, filename)
-        tasks_instance(config).structure_load(filename)
-      end
-
-    end
-  end
-end
-
-namespace :db do
-
-  class << self
-    alias_method :_rails_create_database, :create_database
-    alias_method :_rails_drop_database,   :drop_database
-  end
-
-  def create_database(config)
-    case config['adapter']
-    when /mysql2/
-      unless defined? Mysql2::Error
-        # NOTE: fake it for create_database(config)
-        Object.const_set :Mysql2, Module.new
-        Mysql2.const_set :Error, ActiveRecord::JDBCError
-        ActiveRecord::JDBCError.class_eval do
-          def error; self end # Mysql2::Error#error
-        end
-      end
-      _rails_create_database adapt_jdbc_config(config)
-    when /mysql/
-      unless defined? Mysql::Error
-        # NOTE: fake it for create_database(config)
-        Object.const_set :Mysql, Module.new
-        Mysql.const_set :Error, ActiveRecord::JDBCError
-        ActiveRecord::JDBCError.class_eval do
-          def error; self end # Mysql::Error#error
-        end
-      end
-      _rails_create_database adapt_jdbc_config(config)
-    when /postgresql|sqlite/
-      _rails_create_database adapt_jdbc_config(config)
-    else
-      ArJdbc::Tasks.create(config)
-    end
-  end
-
-  def drop_database(config)
-    case config['adapter']
-    when /mysql|postgresql|sqlite/
-      _rails_drop_database adapt_jdbc_config(config)
-    else
-      ArJdbc::Tasks.drop(config)
-    end
-  end
-
-  redefine_task :charset do # available on 2.3
-    ArJdbc::Tasks.charset ActiveRecord::Base.configurations[rails_env]
-  end
-
-  redefine_task :collation do # available on 2.3
-    ArJdbc::Tasks.collation ActiveRecord::Base.configurations[rails_env]
-  end
-
-  namespace :structure do
-
-    redefine_task :dump do
-      config = ActiveRecord::Base.configurations[rails_env] # current_config
-      filename = structure_sql
-
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config)
-        File.open(filename, 'w:utf-8') { |f| f << ActiveRecord::Base.connection.structure_dump }
-      when /postgresql/
-        ActiveRecord::Base.establish_connection(config)
-
-        ENV['PGHOST'] = config['host'] if config['host']
-        ENV['PGPORT'] = config['port'].to_s if config['port']
-        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-        ENV['PGUSER'] = config['username'].to_s if config['username']
-
-        require 'shellwords'
-        search_path = config['schema_search_path']
-        unless search_path.blank?
-          search_path = search_path.split(",").map{ |part| "--schema=#{Shellwords.escape(part.strip)}" }.join(" ")
-        end
-        sh "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}"
-
-        File.open(filename, 'a') { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
-      when /sqlite/
-        dbfile = config['database']
-        sh "sqlite3 #{dbfile} .schema > #{filename}"
-      else
-        ActiveRecord::Base.establish_connection(config)
-        ArJdbc::Tasks.structure_dump(config, filename)
-      end
-
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open(filename, 'a') { |f| f << ActiveRecord::Base.connection.dump_schema_information }
-      end
-
-    end
-
-    redefine_task :load do
-      config = current_config
-      filename = structure_sql
-
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config)
-        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-        IO.read(filename).split("\n\n").each do |table|
-          ActiveRecord::Base.connection.execute(table)
-        end
-      when /postgresql/
-        ENV['PGHOST'] = config['host'] if config['host']
-        ENV['PGPORT'] = config['port'].to_s if config['port']
-        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-        ENV['PGUSER'] = config['username'].to_s if config['username']
-
-        `psql -f "#{filename}" #{config['database']}`
-      when /sqlite/
-        dbfile = config['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
-      else
-        ArJdbc::Tasks.structure_load(config, filename)
-      end
-    end
-
-    def structure_sql
-      ENV['DB_STRUCTURE'] ||= begin
-        root = defined?(Rails.root) ? Rails.root : ( RAILS_ROOT rescue nil )
-        if ActiveRecord::VERSION::STRING > '3.2'
-          root ? File.join(root, "db", "structure.sql") : File.join("db", "structure.sql")
-        else
-          root ? File.join(root, "db/#{rails_env}_structure.sql") : "db/#{rails_env}_structure.sql"
-        end
-      end
-    end
-
-  end
-
-  namespace :test do
-
-    # desc "Recreate the test database from an existent structure.sql file"
-    redefine_task :load_structure => 'db:test:purge' do # not on 2.3
-      begin
-        current_config(:config => ActiveRecord::Base.configurations['test'])
-        Rake::Task["db:structure:load"].invoke
-      ensure
-        current_config(:config => nil)
-      end
-    end
-
-    # desc "Recreate the test database from a fresh structure.sql file"
-    redefine_task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
-    # same as on 3.2 - but this task gets changed on 2.3 by depending on :load_structure
-
-    # desc "Empty the test database"
-    redefine_task :purge do
-      config = ActiveRecord::Base.configurations['test']
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(:test)
-        options = mysql_creation_options(config) rescue config
-        ActiveRecord::Base.connection.recreate_database(config['database'], options)
-      when /postgresql/
-        ActiveRecord::Base.clear_active_connections!
-        # drop_database(config) :
-        ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-        ActiveRecord::Base.connection.drop_database config['database']
-        # create_database(config) :
-        encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
-        ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => encoding))
-      when /sqlite/
-        dbfile = config['database']
-        File.delete(dbfile) if File.exist?(dbfile)
-      else
-        ArJdbc::Tasks.purge(config)
-      end
-    end
-    # only does (:purge => :environment) on AR < 3.2
-    task :purge => :load_config if Rake::Task.task_defined?(:load_config)
-
-  end
-
-end

data/lib/arjdbc/tasks/databases4.rake

@@ -1,39 +0,0 @@
-module ActiveRecord::Tasks
-
-  DatabaseTasks.module_eval do
-    
-    # patched to adapt jdbc configuration
-    def each_current_configuration(environment)
-      environments = [environment]
-      environments << 'test' if environment == 'development'
-
-      configurations = ActiveRecord::Base.configurations.values_at(*environments)
-      configurations.compact.each do |config|
-        yield adapt_jdbc_config(config) unless config['database'].blank?
-      end
-    end
-
-    # patched to adapt jdbc configuration
-    def each_local_configuration
-      ActiveRecord::Base.configurations.each_value do |config|
-        next unless config['database']
-
-        if local_database?(config)
-          yield adapt_jdbc_config(config)
-        else
-          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
-        end
-      end
-    end
-
-  end
-
-  MySQLDatabaseTasks.class_eval do
-
-    def error_class
-      ActiveRecord::JDBCError
-    end
-
-  end
-  
-end

data/rakelib/compile.rake

@@ -1,70 +0,0 @@
-jar_file = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
-begin
-  require 'ant'
-  directory classes = "pkg/classes"
-  CLEAN << classes
-
-  driver_jars = []
-  # PostgreSQL driver :
-  driver_jars << Dir.glob("jdbc-postgres/lib/*.jar").sort.last
-  
-  file jar_file => FileList['src/java/**/*.java', 'pkg/classes'] do
-    rm_rf FileList["#{classes}/**/*"]
-    ant.javac :srcdir => "src/java", :destdir => "pkg/classes",
-      :source => "7", :target => "7", :debug => true, :deprecation => true,
-      :classpath => "${java.class.path}:${sun.boot.class.path}:#{driver_jars.join(':')}",
-      :includeantRuntime => false
-
-    ant.tstamp do |ts|
-      ts.format(:property => 'TODAY', :pattern => 'yyyy-MM-dd HH:mm:ss')
-    end
-
-    begin
-      require 'arjdbc/version'
-    rescue LoadError
-      path = File.expand_path('../lib', File.dirname(__FILE__))
-      unless $LOAD_PATH.include?(path)
-        $LOAD_PATH << path; retry
-      end
-    end
-
-    gem_version = Gem::Version.create(ArJdbc::VERSION)
-    if gem_version.segments.last == 'DEV'
-      version = gem_version.segments[0...-1] # 1.3.0.DEV -> 1.3.0
-    else
-      version = gem_version.segments.dup
-    end
-    version = version.join('.')
-    
-    ant.manifest :file => 'MANIFEST.MF' do |mf|
-      mf.attribute :name => 'Built-By', :value => '${user.name}'
-      mf.attribute :name => 'Built-Time', :value => '${TODAY}'
-      mf.attribute :name => 'Built-Jdk', :value => '${java.version}'
-      mf.attribute :name => 'Built-JRuby', :value => JRUBY_VERSION
-      
-      mf.attribute :name => 'Specification-Title', :value => 'ActiveRecord-JDBC'
-      mf.attribute :name => 'Specification-Version', :value => '1.3'
-      mf.attribute :name => 'Specification-Vendor', :value => 'JRuby'
-      mf.attribute :name => 'Implementation-Version', :value => version
-      mf.attribute :name => 'Implementation-Vendor', :value => 'The JRuby Team'
-    end
-    
-    ant.jar :basedir => "pkg/classes", :includes => "**/*.class", 
-            :destfile => jar_file, :manifest => 'MANIFEST.MF'
-  end
-
-  desc "Compile the native Java code."
-  task :jar => jar_file
-  
-  namespace :jar do
-    task :force do
-      rm jar_file if File.exist?(jar_file)
-      Rake::Task['jar'].invoke
-    end
-  end
-  
-rescue LoadError
-  task :jar do
-    puts "Run 'jar' with JRuby to re-compile the agent extension class"
-  end
-end