activerecord-jdbc-alt-adapter 50.3.0-java

data/LICENSE.txt

@@ -0,0 +1,26 @@
+Copyright (c) 2017-2018 The JRuby Team
+Copyright (c) 2012-2016 Karol Bucek <self@kares.org>
+Copyright (c) 2006-2012 Nick Sieger <nick@nicksieger.com>
+Copyright (c) 2006-2008 Ola Bini <ola.bini@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,240 @@
+# ActiveRecord JDBC Alternative Adapter
+
+This adapter is a fork of the ActiveRecord JDBC Adapter with basic support for
+**SQL Server/Azure SQL** only, At this stage only works with JRuby on Rails 5.0
+and support for Rails 5.1 is planned in the near future. This adapter may work
+with other databases supported by the original adapter but it is advised to
+use the [original adapter](https://github.com/jruby/activerecord-jdbc-adapter)
+
+
+### How to use it:
+
+Add the following to your `Gemfile`:
+
+```
+gem 'activerecord-jdbc-alt-adapter', '~> 50.3.0'
+
+gem 'jdbc-mssql', '~> 0.6.0'
+```
+
+
+### Breaking changes
+
+- This adapter let SQL Server be SQL Server, it does not make SQL Server to be
+  more like MySQL or PostgreSQL, The query will just fails if SQL Server does not
+  support that SQL dialect.
+- This adapter uses the `datetime2` sql data type as the Rails logical `datetime` data type.
+- This adapter needs the mssql jdbc driver version 7.0.0  onwards to work properly,
+  therefore you can use the gem `jdbc-mssql` version `0.5.0` onwards or the actual
+  driver jar file  version `7.0.0`.
+
+
+### Recommendation
+
+In order to avoid deadlocks it is advised to use `SET READ_COMMITTED_SNAPSHOT ON`
+Make sure to run `ALTER DATABASE your_db SET READ_COMMITTED_SNAPSHOT ON` against
+your database.
+
+If you prefer to use the `READ_UNCOMMITED` transaction isolation level as your
+default isolation level, add the `transaction_isolation: 'read_uncommitted'` in
+your database config.
+
+If you have slow queries on your background jobs and locking queries you can change the default
+`lock_timeout` config, add the `lock_timeout: 10000` in your database config.
+
+database config example (`database.yml`):
+
+```yml
+# SQL Server (2012 or higher recommended)
+
+default: &default
+  adapter: sqlserver
+  encoding: utf8
+
+development:
+  <<: *default
+  host: localhost
+  database: jruby_development
+  username: dev
+  password: password
+  transaction_isolation: read_uncommitted
+  lock_timeout: 10000
+```
+
+### WARNING
+
+Keep one eye in the Rails connection pool, we have not thoroughly tested that
+part since we don't use the default Rails connection pool, other than that
+this adapter should just work.
+
+
+
+# ActiveRecord JDBC Adapter
+
+[![Gem Version](https://badge.fury.io/rb/activerecord-jdbc-adapter.svg)][7]
+
+ActiveRecord-JDBC-Adapter (AR-JDBC) is the main database adapter for Rails'
+*ActiveRecord* component that can be used with [JRuby][0].
+ActiveRecord-JDBC-Adapter provides full or nearly full support for:
+**MySQL**, **PostgreSQL**, **SQLite3**.  In the near future there are plans to
+add support **MSSQL**. Unless we get more contributions we will not be going
+beyond these four adapters.  Note that the amount of work needed to get
+another adapter is not huge but the amount of testing required to make sure
+that adapter continues to work is not something we can do with the resources
+we currently have.
+
+For Oracle database users you are encouraged to use
+https://github.com/rsim/oracle-enhanced.
+
+Version **50.x** supports Rails version 5.0.x and it lives on branch 50-stable.
+Version **51.x** supports Rails version 5.1.x and is currently on master until
+its first release. The minimum version of JRuby for 50+ is JRuby **9.1.x** and
+JRuby 9.1+ requires Java 7 or newer (we recommend Java 8 at minimum).
+
+## Using ActiveRecord JDBC
+
+### Inside Rails
+
+To use AR-JDBC with JRuby on Rails:
+
+1. Choose the adapter you wish to gem install. The following pre-packaged
+adapters are available:
+
+  - MySQL (`activerecord-jdbcmysql-adapter`)
+  - PostgreSQL (`activerecord-jdbcpostgresql-adapter`)
+  - SQLite3 (`activerecord-jdbcsqlite3-adapter`)
+
+2. If you're generating a new Rails application, use the following command:
+
+    jruby -S rails new sweetapp
+
+3. Configure your *database.yml* in the normal Rails style:
+
+```yml
+development:
+  adapter: mysql2 # or mysql
+  database: blog_development
+  username: blog
+  password: 1234
+```
+
+For JNDI data sources, you may simply specify the JNDI location as follows, it's
+recommended to use the same adapter: setting as one would configure when using
+"bare" (JDBC) connections e.g. :
+
+```yml
+production:
+  adapter: postgresql
+  jndi: jdbc/PostgreDS
+```
+
+**NOTE:** any other settings such as *database:*, *username:*, *properties:* make
+no difference since everything is already configured on the JNDI DataSource end.
+
+JDBC driver specific properties might be set if you use an URL to specify the DB
+or preferably using the *properties:* syntax:
+
+```yml
+production:
+  adapter: mysql
+  username: blog
+  password: blog
+  url: "jdbc:mysql://localhost:3306/blog?profileSQL=true"
+  properties: # specific to com.mysql.jdbc.Driver
+    socketTimeout:  60000
+    connectTimeout: 60000
+```
+
+### Standalone with ActiveRecord
+
+Once the setup is made (see below) you can establish a JDBC connection like this
+(e.g. for `activerecord-jdbcderby-adapter`):
+
+```ruby
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: 'db/my-database'
+)
+```
+
+#### Using Bundler
+
+Proceed as with Rails; specify `ActiveRecord` in your Bundle along with the
+chosen JDBC adapter(s), this time sample *Gemfile* for MySQL:
+
+```ruby
+gem 'activerecord', '~> 5.0.6'
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby
+```
+
+When you `require 'bundler/setup'` everything will be set up for you as expected.
+
+#### Without Bundler
+
+Install the needed gems with JRuby, for example:
+
+    gem install activerecord -v "~> 5.0.6"
+    gem install activerecord-jdbc-adapter --ignore-dependencies
+
+If you wish to use the adapter for a specific database, you can install it
+directly and the (jdbc-) driver gem (dependency) will be installed as well:
+
+    jruby -S gem install activerecord-jdbcmysql-adapter
+
+Your program should include:
+
+```ruby
+require 'active_record'
+require 'activerecord-jdbc-adapter' if defined? JRUBY_VERSION
+```
+
+## Source
+
+The source for activerecord-jdbc-adapter is available using git:
+
+    git clone git://github.com/jruby/activerecord-jdbc-adapter.git
+
+Please note that the project manages multiple gems from a single repository,
+if you're using *Bundler* >= 1.2 it should be able to locate all gemspecs from
+the git repository. Sample *Gemfile* for running with (MySQL) master:
+
+```ruby
+gem 'activerecord-jdbc-adapter', :github => 'jruby/activerecord-jdbc-adapter'
+gem 'activerecord-jdbcmysql-adapter', :github => 'jruby/activerecord-jdbc-adapter'
+```
+
+## Getting Involved
+
+Please read our [CONTRIBUTING](CONTRIBUTING.md) & [RUNNING_TESTS](RUNNING_TESTS.md)
+guides for starters. You can always help us by maintaining AR-JDBC's [wiki][5].
+
+## Feedback
+
+Please report bugs at our [issue tracker][3]. If you're not sure if
+something's a bug, feel free to pre-report it on the [mailing lists][1] or
+ask on the #JRuby IRC channel on http://freenode.net/ (try [web-chat][6]).
+
+## Authors
+
+This project was originally written by [Nick Sieger](http://github.com/nicksieger)
+and [Ola Bini](http://github.com/olabini) with lots of help from the JRuby community.
+Polished 3.x compatibility and 4.x support (for AR-JDBC >= 1.3.0) was managed by
+[Karol Bucek](http://github.com/kares) among others.
+
+## License
+
+ActiveRecord-JDBC-Adapter is open-source released under the BSD/MIT license.
+See [LICENSE.txt](LICENSE.txt) included with the distribution for details.
+
+Open-source driver gems within AR-JDBC's sources are licensed under the same
+license the database's drivers are licensed. See each driver gem's LICENSE.txt.
+
+[0]: http://www.jruby.org/
+[1]: http://jruby.org/community
+[2]: http://github.com/jruby/activerecord-jdbc-adapter/blob/master/activerecord-jdbcmssql-adapter
+[3]: https://github.com/jruby/activerecord-jdbc-adapter/issues
+[4]: http://github.com/nicksieger/activerecord-cachedb-adapter
+[5]: https://github.com/jruby/activerecord-jdbc-adapter/wiki
+[6]: https://webchat.freenode.net/?channels=#jruby
+[7]: http://badge.fury.io/rb/activerecord-jdbc-adapter
+[8]: https://github.com/jruby/activerecord-jdbc-adapter/wiki/Migrating-from-1.2.x-to-1.3.0

data/RUNNING_TESTS.md

@@ -0,0 +1,127 @@
+There are two sets of tests which we run in CI.  Local (AR-JDBC) test and
+Rails activerecord tests.  The next two sections details how to run each
+and customize behavior.
+
+
+## Running AR-JDBC's Tests
+
+After you have built arjdbc (run rake), then you can try testing it (if you
+do not build then adapter_java.jar is not put into the lib dir).  If you
+change any of the .java files you will need to rebuild.
+
+Most DB specific unit tests hide under the **test/db** directory, the files
+included in the *test* directory are mostly shared test modules and helpers.
+
+Rake tasks are loaded from **rakelib/02-test-rake**, most adapters have a
+corresponding test_[adapter] task e.g. `rake test_sqlite3` that run against DB.
+To check all available (test related) tasks simply `rake -T | grep test`.
+
+If the adapter supports creating a database it will try to do so automatically
+(most embed databases such as SQLite3) for some adapters (MySQL, PostgreSQL) we
+do this auto-magically (see the `rake db:create` tasks), but otherwise you'll
+need to setup a database dedicated for tests (using the standard tools that come
+with your DB installation).
+
+Connection parameters: database, host etc. can usually be changed from the shell
+`env` for adapters where there might be no direct control over the DB
+instance/configuration, e.g. for Oracle (by looking at **test/db/oracle.rb**)
+one might adapt the test database configuration using :
+```
+export ORACLE_HOST=192.168.1.2
+export ORACLE_USER=SAMPLE
+export ORACLE_PASS=sample
+export ORACLE_SID=MAIN
+```
+
+Tests are run by calling the rake task corresponding the database adapter being
+tested, e.g. for MySQL :
+
+    rake test_mysql TEST=test/db/mysql/rake_test.rb
+
+Observe the **TEST** variable used to specify a single file to be used to resolve
+test cases, you pick tests by matching their names as well using **TESTOPTS** :
+
+    rake test_postgres TESTOPTS="--name=/integer/"
+
+Since 1.3.0 we also support prepared statements, these are enabled by default (AR)
+but one can easily run tests with prepared statements disabled using env vars :
+
+    rake test_derby PREPARED_STATEMENTS=false
+
+
+### ActiveRecord (Rails) Tests
+
+We also can run our adapters against Rails ActiveRecord tests.  There are two
+ways you can do this:
+
+ - Run against local clone (by setting RAILS environment variable). This is helpful when you are adding puts or hacking on activerecord code directly.
+
+ - Run against bundler provided clone (by setting AR_VERSION environment variable). This is useful when you want to submit to travis and want all the adapters to run against your code.
+
+Note: RAILS will trump AR_VERSION and setting neither will assume version as
+set in the gemspec.
+
+### Run against local clone
+
+Make sure you have rails cloned somewhere:
+
+```text
+git clone git://github.com/rails/rails.git
+```
+
+Set up a fully qualified RAILS environment variable. For example, if you were
+in activerecord direction you can just do something like:
+
+```ext
+export RAILS=`pwd`/../rails
+```
+
+Now that is this set up we may have changed the gems we need so we have
+to run bundler:
+
+```text
+bundle install
+```
+
+Before you run tests you need to be aware that each support branch we have is
+written to run with a single significant release of rails (50-stable will only
+work well with rails 5.0.x).  So you need to make sure you local copy of rails
+is checked out to match whatever you are testing (e.g. git checkout v5.0.6).
+Now you can run rails tests:
+
+```text
+jruby -S rake rails:test_sqlite3
+jruby -S rake rails:test_postgres
+jruby -S rake rails:test_mysql
+```
+
+### Run against bundler provided clone
+
+AR_VERSION is a very flexible variable.  You can:
+
+ - specify tag (export AR_VERSION=v5.0.6)
+ - specify version (export AR_VERSION=5.0.6)
+ - specify SHA hash (export AR_VERSION=875bb788f56311ac4628402667187f755c1a331c)
+ - specify branch (export AR_VERSION=verify-release)
+ - specify nothing to assume LOADPATH has loaded it (export AR_VERSION=false)
+
+Now that is this set up we may have changed the gems we need so we have
+to run bundler:
+
+```text
+bundle install
+```
+
+Once you have picked what you want to test you can run:
+
+```text
+jruby -S rake rails:test_sqlite3
+jruby -S rake rails:test_postgres
+jruby -S rake rails:test_mysql
+```
+
+[![Build Status][0]](http://travis-ci.org/#!/jruby/activerecord-jdbc-adapter)
+
+Happy Testing!
+
+[0]: https://secure.travis-ci.org/jruby/activerecord-jdbc-adapter.png

data/Rakefile

@@ -0,0 +1,336 @@
+require 'rake/clean'
+
+CLEAN.include 'derby*', 'test.db.*', '*test.sqlite3', 'test/reports'
+CLEAN.include 'lib/**/*.jar', 'MANIFEST.MF', '*.log', 'target/*'
+
+task :default => :jar # RubyGems extention will do a bare `rake' e.g. :
+# jruby" -rubygems /opt/local/rvm/gems/jruby-1.7.16@jdbc/gems/rake-10.3.2/bin/rake
+#   RUBYARCHDIR=/opt/local/rvm/gems/jruby-1.7.16@jdbc/gems/activerecord-jdbc-adapter-1.4.0.dev/lib
+#   RUBYLIBDIR=/opt/local/rvm/gems/jruby-1.7.16@jdbc/gems/activerecord-jdbc-adapter-1.4.0.dev/lib
+#
+# under Bundler it points those DIRs to an empty one where only built extensions are stored :
+# jruby -rubygems /opt/local/rvm/gems/jruby-1.7.19@temp/gems/rake-10.4.2/bin/rake
+#   RUBYARCHDIR=/opt/local/rvm/gems/jruby-1.7.19@temp/bundler/gems/extensions/universal-java-1.7/1.9/activerecord-jdbc-adapter-472b5fddba43
+#   RUBYLIBDIR=/opt/local/rvm/gems/jruby-1.7.19@temp/bundler/gems/extensions/universal-java-1.7/1.9/activerecord-jdbc-adapter-472b5fddba43
+#
+# javac -target 1.6 -source 1.6 -Xlint:unchecked -g -cp
+#   "/opt/local/rvm/rubies/jruby-1.7.19/lib/jruby.jar:
+#    /opt/local/maven-repo/mysql/mysql-connector-java/5.1.33/mysql-connector-java-5.1.33.jar:
+#    /opt/local/maven-repo/org/postgresql/postgresql/9.4-1200-jdbc4/postgresql-9.4-1200-jdbc4.jar"
+#   -d /tmp/d20150417-32100-7mb1bk src/java/arjdbc/ArJdbcModule.java ...
+
+
+base_dir = Dir.pwd
+gem_name = 'activerecord-jdbc-alt-adapter'
+gemspec_path = File.expand_path('activerecord-jdbc-alt-adapter.gemspec', File.dirname(__FILE__))
+gemspec = lambda do
+  @_gemspec_ ||= Dir.chdir(File.dirname(__FILE__)) do
+    Gem::Specification.load(gemspec_path)
+  end
+end
+built_gem_path = lambda do
+  Dir[File.join(base_dir, "#{gem_name}-*.gem")].sort_by{ |f| File.mtime(f) }.last
+end
+current_version = lambda { gemspec.call.version }
+rake = lambda { |task| ruby "-S", "rake", task }
+
+# NOTE: avoid Bundler loading due native extension building!
+
+desc "Build #{gem_name} gem into the pkg directory."
+task :build => :jar do
+  sh("RELEASE=#{ENV['RELEASE']} gem build -V '#{gemspec_path}'") do
+    gem_path = built_gem_path.call
+    file_name = File.basename(gem_path)
+    FileUtils.mkdir_p(File.join(base_dir, 'pkg'))
+    FileUtils.mv(gem_path, 'pkg')
+    puts "\n#{gem_name} #{current_version.call} built to 'pkg/#{file_name}'"
+  end
+end
+
+desc "Build and install #{gem_name} gem into system gems."
+task :install => :build do
+  gem_path = built_gem_path.call
+  sh("gem install '#{gem_path}' --local") do |ok|
+    raise "Couldn't install gem, run `gem install #{gem_path}' for more detailed output" unless ok
+    puts "\n#{gem_name} (#{current_version.call}) installed"
+  end
+end
+
+desc "Releasing AR-JDBC gems (use NOOP=true to disable gem pushing)"
+task 'release:do' do
+  ENV['RELEASE'] = 'true' # so that .gemspec is built with adapter_java.jar
+  Rake::Task['build'].invoke
+  # Rake::Task['build:adapters'].invoke
+
+  noop = ENV.key?('NOOP') && (ENV['NOOP'] != 'false' && ENV['NOOP'] != '')
+
+  version = current_version.call; version_tag = "v#{version}"
+
+  sh("git diff --no-patch --exit-code", :noop => noop) { |ok| fail "git working dir is not clean" unless ok }
+  sh("git diff-index --quiet --cached HEAD", :noop => noop) { |ok| fail "git index is not clean" unless ok }
+
+  sh "git tag -a -m \"AR-JDBC #{version}\" #{version_tag}", :noop => noop
+  branch = `git rev-parse --abbrev-ref HEAD`.strip
+  puts "releasing from (current) branch #{branch.inspect}"
+  sh "for gem in `ls pkg/*-#{version}-java.gem`; do gem push $gem; done", :noop => noop do |ok|
+    sh "git push origin #{branch} --tags", :noop => noop if ok
+  end
+end
+
+task 'release:push' do
+  sh "for gem in `ls pkg/*-#{current_version.call}-java.gem`; do gem push $gem; done"
+end
+
+ADAPTERS = %w[mysql postgresql sqlite3].map { |a| "activerecord-jdbc#{a}-adapter" }
+DRIVERS  = %w[mysql postgres sqlite3].map { |a| "jdbc-#{a}" }
+TARGETS = ( ADAPTERS + DRIVERS )
+
+ADAPTERS.each do |target|
+  namespace target do
+    task :build do
+      version = current_version.call
+      Dir.chdir(target) { rake.call "build" }
+      cp FileList["#{target}/pkg/#{target}-#{version}-java.gem"], "pkg"
+    end
+  end
+end
+DRIVERS.each do |target|
+  namespace target do
+    task :build do
+      Dir.chdir(target) { rake.call "build" }
+      cp FileList["#{target}/pkg/#{target}-*.gem"], "pkg"
+    end
+  end
+end
+TARGETS.each do |target|
+  namespace target do
+    task :install do
+      Dir.chdir(target) { rake.call "install" }
+    end
+    #task :release do
+    #  Dir.chdir(target) { rake.call "release" }
+    #end
+  end
+end
+
+# DRIVERS
+
+desc "Build drivers"
+task "build:drivers" => DRIVERS.map { |name| "#{name}:build" }
+task "drivers:build" => 'build:drivers'
+
+desc "Install drivers"
+task "install:drivers" => DRIVERS.map { |name| "#{name}:install" }
+task "drivers:install" => 'install:drivers'
+
+# ADAPTERS
+
+desc "Build adapters"
+task "build:adapters" => [ 'build' ] + ADAPTERS.map { |name| "#{name}:build" }
+task "adapters:build" => 'build:adapters'
+
+desc "Install adapters"
+task "install:adapters" => [ 'install' ] + ADAPTERS.map { |name| "#{name}:install" }
+task "adapters:install" => 'install:adapters'
+
+# ALL
+
+task "build:all" => [ 'build' ] + TARGETS.map { |name| "#{name}:build" }
+task "all:build" => 'build:all'
+task "install:all" => [ 'install' ] + TARGETS.map { |name| "#{name}:install" }
+task "all:install" => 'install:all'
+
+require 'rake/testtask'
+
+# native JRuby extension (adapter_java.jar) compilation :
+
+if defined? JRUBY_VERSION
+  jar_file = 'lib/arjdbc/jdbc/adapter_java.jar'; CLEAN << jar_file
+  desc "Compile the native (Java) extension."
+  task :jar => jar_file
+
+  namespace :jar do
+    task :force do
+      rm jar_file if File.exist?(jar_file)
+      Rake::Task['jar'].invoke
+    end
+  end
+
+  #directory classes = 'pkg/classes'; CLEAN << classes
+
+  file jar_file => FileList[ 'src/java/**/*.java' ] do
+    source = target = '1.7'; debug = true
+
+    get_driver_jars_local = lambda do |*args|
+      driver_deps = args.empty? ? [ :Postgres, :MySQL ] : args
+      driver_jars = []
+      driver_deps.each do |name|
+        driver_jars << Dir.glob("jdbc-#{name.to_s.downcase}/lib/*.jar").sort.last
+      end
+      if driver_jars.empty? # likely on a `gem install ...'
+        # NOTE: we're currently assuming jdbc-xxx (compile) dependencies are
+        # installed, they are declared as gemspec.development_dependencies !
+        # ... the other option is to simply `mvn prepare-package'
+        driver_deps.each do |name|
+          #require "jdbc/#{name.to_s.downcase}"
+          #driver_jars << Jdbc.const_get(name).driver_jar
+          # thanks Bundler for mocking RubyGems completely :
+          #spec = Gem::Specification.find_by_name("jdbc-#{name.to_s.downcase}")
+          #driver_jars << Dir.glob(File.join(spec.gem_dir, 'lib/*.jar')).sort.last
+          gem_name = "jdbc-#{name.to_s.downcase}"; matched_gem_paths = []
+          Gem.paths.path.each do |path|
+            base_path = File.join(path, "gems/")
+            Dir.glob(File.join(base_path, "*")).each do |gem_path|
+              if gem_path.sub(base_path, '').start_with?(gem_name)
+                matched_gem_paths << gem_path
+              end
+            end
+          end
+          if gem_path = matched_gem_paths.sort.last
+            driver_jars << Dir.glob(File.join(gem_path, 'lib/*.jar')).sort.last
+          end
+        end
+      end
+      driver_jars
+    end
+
+    get_driver_jars_maven = lambda do
+      require 'jar_dependencies'
+
+      requirements = gemspec.call.requirements
+      match_driver_jars = lambda do
+        matched_jars = []
+        gemspec.call.requirements.each do |requirement|
+          if match = requirement.match(/^jar\s+([\w\-\.]+):([\w\-]+),\s+?([\w\.\-]+)?/)
+            matched_jar = Jars.send :to_jar, match[1], match[2], match[3], nil
+            matched_jar = File.join( Jars.home, matched_jar )
+            matched_jars << matched_jar if File.exists?( matched_jar )
+          end
+        end
+        matched_jars
+      end
+
+      driver_jars = match_driver_jars.call
+      if driver_jars.size < requirements.size
+        if (ENV['JARS_SKIP'] || ENV_JAVA['jars.skip']) == 'true'
+          warn "jar resolving skipped, extension might not compile"
+        else
+          require 'jars/installer'
+          ENV['JARS_QUIET'] = 'true'
+          puts "resolving jar dependencies to build extension (should only happen once) ..."
+          installer = Jars::Installer.new( gemspec_path )
+          installer.install_jars( false )
+
+          driver_jars = match_driver_jars.call
+        end
+      end
+
+      driver_jars
+    end
+
+    # TODO not good but since jar-dependencies doesn't do the job, let's default to local (for now)
+    if ENV['BUILD_EXT_MAVEN'] == 'true' # || ENV['RUBYARCHDIR']
+      driver_jars = get_driver_jars_maven.call
+    else
+      driver_jars = get_driver_jars_local.call
+    end
+
+    classpath = []
+    [ '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
+    # 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' ]
+
+    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
+
+      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|
+          exts.map { |ext| File.join(path, "#{cmd}#{ext}") }
+        end.flatten.select{|f| File.executable? f}.first
+      end
+
+      args = [ '-Xlint:unchecked' ]
+
+      unless javac = which.call('javac')
+        warn "could not find javac, please make sure it's on the PATH"
+      end
+      javac = "#{javac} -target #{target} -source #{source} #{args.join(' ')}"
+      javac << " #{debug ? '-g' : ''}"
+      javac << " -cp \"#{classpath}\" -d #{classes_dir} #{source_files.join(' ')}"
+      sh(javac) do |ok|
+        raise 'could not build .jar extension - compilation failure' unless ok
+      end
+
+      # class_files = FileList["#{classes_dir}/**/*.class"].gsub("#{classes_dir}/", '')
+      # avoid environment variable expansion using backslash
+      # class_files.gsub!('$', '\$') unless windows?
+      # args = class_files.map { |path| [ "-C #{classes_dir}", path ] }.flatten
+
+      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']
+        jar_path = File.join(ext_lib_dir, File.basename(jar_file))
+      end
+
+      unless jar = which.call('jar')
+        warn "could not find jar tool, please make sure it's on the PATH"
+      end
+      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?!
+    end
+  end
+else
+  task :jar do
+    warn "please run `rake jar' under JRuby to re-compile the native (Java) extension"
+  end
+end