neo-activerecord-jdbc-adapter 5.0.pre2

data/rakelib/02-test.rake

@@ -0,0 +1,121 @@
+require File.expand_path('../../test/shared_helper', __FILE__)
+
+test_tasks = [ 'test_mysql', 'test_sqlite3', 'test_postgresql_with_hint' ]
+if defined?(JRUBY_VERSION)
+  test_tasks.push :test_derby, :test_hsqldb, :test_h2
+  test_tasks.push :test_jndi, :test_jdbc
+end
+
+desc "Run \"most\" available test_xxx tasks"
+task :test => test_tasks
+
+task 'test_postgresql_with_hint' do
+  if PostgresHelper.have_postgres?(false)
+    Rake::Task['test_postgresql'].invoke
+  else
+    puts "NOTE: won't run test_postgresql"
+  end
+end
+
+task 'test_appraisal_hint' do
+  next if File.exists?('.disable-appraisal-hint')
+  unless (ENV['BUNDLE_GEMFILE'] || '') =~ /gemfiles\/.*?\.gemfile/
+    appraisals = []; Appraisal::File.each { |file| appraisals << file.name }
+    puts "HINT: specify AR version with `rake appraisal:{version} test_{adapter}'" +
+         " where version=(#{appraisals.join('|')}) (`touch .disable-appraisal-hint' to disable)"
+  end
+end
+
+Rake::TestTask.class_eval { attr_reader :test_files }
+
+def test_task_for(adapter, options = {})
+  desc = options[:desc] || options[:comment] ||
+    "Run tests against #{options[:database_name] || adapter}"
+  adapter = adapter.to_s.downcase
+  driver = adapter if ( driver = options[:driver] ).nil?
+  prereqs = options[:prereqs] || []
+  unless prereqs.frozen?
+    prereqs = [ prereqs ].flatten; prereqs << 'test_appraisal_hint'
+  end
+  name = options[:name] || "test_#{adapter}"
+  test_task = Rake::TestTask.new(name => prereqs) do |test_task|
+    files = options[:files] || begin
+      FileList["test/#{adapter}*_test.rb"] +
+        FileList["test/db/#{adapter}/**/*_test.rb"]
+    end
+    test_task.test_files = files
+    test_task.libs = []
+    if defined?(JRUBY_VERSION)
+      test_task.libs << 'lib'
+      test_task.libs << "jdbc-#{driver}/lib" if driver && File.exists?("jdbc-#{driver}/lib")
+      test_task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
+    end
+    test_task.libs << 'test'
+    test_task.ruby_opts << '-v' if RUBY_VERSION.index('1.8') == 0
+    # set current Ruby compatibility version on JRuby <= 1.7 :
+    if defined?(JRUBY_VERSION) && JRUBY_VERSION.index('1.7') == 0
+      test_task.ruby_opts << "--#{RUBY_VERSION[/^(\d+\.\d+)/, 1]}"
+    end
+    test_task.options = '--use-color=t'
+    test_task.verbose = true if $VERBOSE
+    yield(test_task) if block_given?
+  end
+  task = Rake::Task[name]
+  # reset the description set-up by Rake::TestTask :
+  if task.instance_variable_defined? :@full_comment
+    task.instance_variable_set(:@full_comment, nil)
+  else
+    task.instance_variable_get(:@comments).clear
+  end
+  task.add_description(desc)
+  test_task
+end
+
+test_task_for :Derby, :desc => 'Run tests against (embedded) DerbyDB'
+test_task_for :H2, :desc => 'Run tests against H2 database engine'
+test_task_for :HSQLDB, :desc => 'Run tests against HyperSQL (Java) database'
+test_task_for :MSSQL, :driver => :jtds, :database_name => 'MS-SQL (SQLServer)'
+test_task_for :MySQL, :prereqs => 'db:mysql'
+test_task_for :PostgreSQL, :driver => 'postgres', :prereqs => 'db:postgresql'
+task :test_postgres => :test_postgresql # alias
+test_task_for :SQLite3, :driver => ENV['JDBC_SQLITE_VERSION']
+task :test_sqlite => :test_sqlite3 # alias
+test_task_for :Firebird
+
+test_task_for :MariaDB, :prereqs => 'db:mysql', :files => FileList["test/db/mysql/*_test.rb"]
+
+# ensure driver for these DBs is on your class-path
+[ :Oracle, :DB2, :Informix, :CacheDB ].each do |adapter|
+  test_task_for adapter, :desc => "Run tests against #{adapter} (ensure driver is on class-path)"
+end
+
+#test_task_for :MSSQL, :name => 'test_sqlserver', :driver => nil, :database_name => 'MS-SQL using SQLJDBC'
+
+test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is on class-path)",
+  :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
+
+test_task_for 'JDBC', :desc => 'Run tests against plain JDBC adapter (uses MySQL and Derby)',
+  :prereqs => 'db:mysql', :files => FileList['test/*jdbc_*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-mysql/lib' << 'jdbc-derby/lib'
+end
+
+test_task_for 'JNDI', :desc => 'Run tests against a JNDI connection (uses Derby)',
+  :prereqs => 'tomcat-jndi:check',
+  :files => FileList['test/*jndi_*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-derby/lib'
+end
+
+test_task_for :MySQL, :name => 'test_jdbc_mysql',
+  :prereqs => 'db:mysql', :database_name => 'MySQL (using adapter: jdbc)' do |test_task|
+  test_task.ruby_opts << '-rdb/jdbc_mysql' # replaces require 'db/mysql'
+end
+test_task_for :PostgreSQL, :name => 'test_jdbc_postgresql', :driver => 'postgres',
+  :prereqs => 'db:postgresql', :database_name => 'PostgreSQL (using adapter: jdbc)' do |test_task|
+  test_task.ruby_opts << '-rdb/jdbc_postgres' # replaces require 'db/postgres'
+end
+
+# TODO Sybase testing is currently broken, please fix it if you're on Sybase :
+#test_task_for :Sybase, :desc => "Run tests against Sybase (using jTDS driver)"
+#task :test_sybase_jtds => :test_sybase # alias
+#test_task_for :Sybase, :name => 'sybase_jconnect',
+#  :desc => "Run tests against Sybase (ensure jConnect driver is on class-path)"

data/rakelib/bundler_ext.rb

@@ -0,0 +1,11 @@
+module Bundler
+  class GemHelper
+    def guard_already_tagged
+      # parent project performs the tag
+    end
+    def tag_version
+      Bundler.ui.confirm "Parent project tagged #{version_tag}"
+      yield if block_given?
+    end
+  end
+end

data/rakelib/compile.rake

@@ -0,0 +1,62 @@
+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 => "1.6", :target => "1.6", :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
+    
+    require 'arjdbc/version'
+    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

data/rakelib/db.rake

@@ -0,0 +1,58 @@
+require File.expand_path('../../test/shared_helper', __FILE__)
+
+namespace :db do
+
+  desc "Creates the test database for MySQL"
+  task :mysql do
+    fail "could not create test database: mysql executable not found" unless mysql = which('mysql')
+    load 'test/db/mysql_config.rb' # rescue nil
+    script = sql_script <<-SQL, 'mysql'
+DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
+CREATE USER #{MYSQL_CONFIG[:username]}@localhost;
+CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_general_ci`;
+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'
+      password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+      params['--password'] = password
+    end
+    puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
+    sh "cat #{script.path} | #{mysql} -f #{params.to_a.join(' ')}", :verbose => $VERBOSE # so password is not echoed
+  end
+
+  desc "Creates the test database for PostgreSQL"
+  task :postgresql do
+    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
+    script = sql_script <<-SQL, 'psql'
+DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
+DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
+CREATE USER #{POSTGRES_CONFIG[:username]} CREATEDB SUPERUSER LOGIN PASSWORD '#{POSTGRES_CONFIG[:password]}';
+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
+  end
+  task :postgres => :postgresql
+
+  private
+
+  def sql_script(sql_content, name = 'sql_script')
+    require 'tempfile'; script = Tempfile.new(name)
+    script.puts sql_content
+    yield(script) if block_given?
+    script.close
+    at_exit { script.unlink }
+    script
+  end
+
+end

data/rakelib/rails.rake

@@ -0,0 +1,75 @@
+DEFAULT_RAILS_DIR = File.join('..', 'rails')
+DEFAULT_ADAPTERS = %w(MySQL SQLite3 Postgres)
+
+namespace :rails do
+  namespace :test do
+    task :all do
+      driver = ENV['DRIVER'] || ENV['ADAPTER']
+      raise "need a DRIVER (DRIVER=mysql)" unless driver
+      rails_dir = _rails_dir
+
+      Dir.chdir(File.join(rails_dir, 'activerecord')) do
+        sh FileUtils::RUBY, '-S', 'rake',
+           "RUBYLIB=#{_ruby_lib(rails_dir, driver)}",
+           _target(driver)
+      end
+    end
+  
+    DEFAULT_ADAPTERS.each do |adapter|
+      desc "Run Rails ActiveRecord tests with #{adapter} (JDBC)"
+      task adapter.downcase do
+        ENV['ADAPTER'] = adapter
+        Rake::Task['rails:test:all'].invoke
+      end
+
+      namespace adapter.downcase do 
+        desc "Runs Rails ActiveRecord base_test.rb with #{adapter}"
+        task "base_test" do
+          ENV['TEST'] = "test/cases/base_test.rb"
+          ENV['ADAPTER'] = adapter
+          Rake::Task['rails:test:all'].invoke
+        end
+      end
+    end
+  
+    private
+
+    def _rails_dir
+      rails_dir = ENV['RAILS'] || DEFAULT_RAILS_DIR
+      unless File.directory? rails_dir
+        raise "can't find RAILS source '#{rails_dir}' (maybe set ENV['RAILS'])"
+      end
+      rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
+      rails_dir
+    end
+
+    def _ruby_lib(rails_dir, driver)
+      ar_jdbc_dir = File.expand_path('..', File.dirname(__FILE__))
+
+      if driver =~ /postgres/i
+        adapter, driver = 'postgresql', 'postgres'
+      else
+        adapter = driver.downcase
+        driver = adapter
+      end
+
+      [File.join(ar_jdbc_dir, 'lib'),
+       File.join(ar_jdbc_dir, 'test', 'rails'),
+       File.join(ar_jdbc_dir, "jdbc-#{driver}", 'lib'),
+       File.join(ar_jdbc_dir, "activerecord-jdbc#{adapter}-adapter", 'lib'),
+       File.expand_path('activesupport/lib', rails_dir),
+       File.expand_path('activemodel/lib', rails_dir),
+       File.expand_path('activerecord/lib', rails_dir)
+      ].join(':')
+    end
+  
+    def _target(name)
+      case name
+      when /postgres/i
+        'test_jdbcpostgresql'
+      else
+        "test_jdbc#{name.downcase}"
+      end
+    end
+  end
+end

data/src/java/arjdbc/ArJdbcModule.java

@@ -0,0 +1,178 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Karol Bucek.
+ *
+ * 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.
+ */
+package arjdbc;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+
+import org.jruby.NativeException;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * ::ArJdbc
+ *
+ * @author kares
+ */
+public class ArJdbcModule {
+
+    public static RubyModule load(final Ruby runtime) {
+        final RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
+        arJdbc.defineAnnotatedMethods( ArJdbcModule.class );
+        return arJdbc;
+    }
+
+    /**
+     * Load the Java parts for the given adapter spec module, e.g. to load
+     * ArJdbc::MySQL's Java part: <code>ArJdbc.load_java_part :MySQL</code>
+     *
+     * NOTE: this method is not intended to be called twice for a given adapter !
+     * @param context
+     * @param self
+     * @param args ( moduleName, [ connectionClass, moduleClass ] )
+     * @return true
+     */
+    @JRubyMethod(name = "load_java_part", meta = true, required = 1, optional = 2)
+    public static IRubyObject load_java_part(final ThreadContext context,
+        final IRubyObject self, final IRubyObject[] args) {
+
+        String connectionClass = args.length > 1 ? args[1].toString() : null;
+        String moduleClass = args.length > 2 ? args[2].toString() : null;
+
+        final String moduleName = args[0].toString(); // e.g. 'MySQL'
+        final String packagePrefix = "arjdbc." + moduleName.toLowerCase() + "."; // arjdbc.mysql
+
+        // NOTE: due previous (backwards compatible) conventions there are
+        // 2 things we load, the adapter spec module's Java implemented methods
+        // and a custom JdbcConnection class (both are actually optional) e.g. :
+        //
+        //   MySQLModule.load(RubyModule); // 'arjdbc.mysql' package is assumed
+        //   MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(Ruby, RubyClass);
+        //
+
+        String connectionClass2 = null;
+        if (connectionClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'RubyJdbcConnection'
+            connectionClass = packagePrefix + moduleName + "RubyJdbcConnection";
+            connectionClass2 = packagePrefix + moduleName + "JdbcConnection";
+        }
+        if (moduleClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'Module'
+            moduleClass = packagePrefix + moduleName + "Module";
+        }
+
+        final Ruby runtime = context.getRuntime();
+        final RubyModule arJdbc = runtime.getModule("ArJdbc");
+
+        try {
+            final Class<?> module = Class.forName(moduleClass);
+             // MySQLModule.load( arJdbc ) :
+            module.getMethod("load", RubyModule.class).invoke(null, arJdbc);
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (IllegalAccessException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (InvocationTargetException e) {
+            throw newNativeException(runtime, e);
+        }
+
+        try {
+            Class<?> connection = null;
+            try {
+                connection = Class.forName(connectionClass);
+            }
+            catch (ClassNotFoundException e) {
+                if ( connectionClass2 != null ) {
+                    connection = Class.forName(connectionClass2);
+                }
+            }
+            if ( connection != null ) {
+                final String method = "create" + moduleName + "JdbcConnectionClass";
+                // MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(runtime, jdbcConnection)
+                connection.getMethod(method, Ruby.class, RubyClass.class).
+                    invoke(null, runtime, RubyJdbcConnection.getJdbcConnectionClass(runtime));
+            }
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (IllegalAccessException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (InvocationTargetException e) {
+            throw newNativeException(runtime, e);
+        }
+
+        return runtime.getTrue();
+    }
+
+    /**
+     * <code>ArJdbc.modules</code>
+     * @param context
+     * @param self
+     * @return nested constant values that are modules
+     */
+    @JRubyMethod(name = "modules", meta = true)
+    public static IRubyObject modules(final ThreadContext context, final IRubyObject self) {
+        final Ruby runtime = context.getRuntime();
+        final RubyModule arJdbc = (RubyModule) self;
+
+        final Collection<String> constants = arJdbc.getConstantNames();
+        final RubyArray modules = runtime.newArray( constants.size() );
+
+        for ( final String name : constants ) {
+           IRubyObject value = arJdbc.getConstant(name, false);
+           // isModule: return false for Ruby Classes
+           if ( value != null && value.isModule() ) {
+               if ( "MissingFunctionalityHelper".equals(name) ) continue;
+               if ( "SerializedAttributesHelper".equals(name) ) continue;
+               if ( "QuotedPrimaryKeyExtension".equals(name) ) continue;
+               if ( "Util".equals(name) ) continue;
+               if ( "Version".equals(name) ) continue;
+               modules.append(value);
+           }
+        }
+        return modules;
+    }
+
+    private static RaiseException newNativeException(final Ruby runtime, final Throwable cause) {
+        RubyClass nativeClass = runtime.getClass(NativeException.CLASS_NAME);
+        NativeException nativeException = new NativeException(runtime, nativeClass, cause);
+        throw new RaiseException(cause, nativeException);
+    }
+
+}