activerecord-jdbc-alt-adapter 50.3.0-java

data/rakelib/rails.rake

@@ -0,0 +1,223 @@
+namespace :rails do
+
+  %w(MySQL SQLite3 PostgreSQL MSSQL).each do |adapter|
+
+    desc "Run Rails ActiveRecord tests with #{adapter} (JDBC)"
+    task "test_#{adapter = adapter.downcase}" do
+      puts "Use TESTOPTS=\"--verbose\" to pass --verbose to runners." if ARGV.include? '--verbose'
+
+      if ENV['RAILS']
+        ar_path = File.join(ENV['RAILS'], 'activerecord')
+      end
+
+      unless ar_path && File.exist?(ar_path)
+        ar_path = `bundle info --path activerecord`.lines.last.chomp
+      end
+
+      unless File.exist? ar_test_dir = File.join(ar_path, 'test')
+        raise "can not directly load Rails tests;" +
+              " try setting a local repository path e.g. export RAILS=`pwd`/../rails;" +
+              " failed guess: #{ar_path}"
+      end
+
+      driver = "jdbc-#{ENV['DRIVER'] ? ENV['DRIVER'].downcase : (adapter =~ /postgres/i ? 'postgres' : adapter)}"
+      adapter = 'mysql2' if adapter.eql?('mysql')
+
+      # Overriding adapter and driver (maybe we can change later only to mssql)
+      if adapter.eql? 'mssql'
+        adapter = 'sqlserver'
+        ENV['DRIVER'] = 'sqlserver'
+      end
+
+      root_dir = File.expand_path('..', File.dirname(__FILE__))
+      env = {}
+      env['ARCONFIG'] = ENV['ARCONFIG'] || File.join(root_dir, 'test/rails', 'config.yml')
+      env['ARCONN'] = adapter
+      env['BUNDLE_GEMFILE'] = ENV['BUNDLE_GEMFILE'] || File.join(root_dir, 'Gemfile') # use AR-JDBC's with Rails tests
+      env['EXCLUDE_DIR'] = File.join(root_dir, 'test/rails/excludes', adapter) # minitest-excludes
+
+      libs = [
+          File.join(root_dir, 'lib'),
+          File.join(root_dir, driver, 'lib'),
+          File.join(root_dir, 'test/rails'),
+          ar_test_dir
+      ]
+
+      test_files_finder = lambda do
+        Dir.chdir(ar_path) do # taken from Rails' *activerecord/Rakefile* :
+          ( Dir.glob("test/cases/**/*_test.rb").reject { |x| x =~ /\/adapters\// } +
+            Dir.glob("test/cases/adapters/#{adapter}/**/*_test.rb") )
+        end
+      end
+
+      task_stub = Class.new(Rake::TestTask) { def define; end }.new # no-op define
+      test_loader_code = task_stub.run_code # :rake test-loader
+
+      ruby_opts_string = "-I\"#{libs.join(File::PATH_SEPARATOR)}\""
+      ruby_opts_string += " -C \"#{ar_path}\""
+      ruby_opts_string += " -rbundler/setup"
+      ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
+      file_list = ENV["TEST"] ? FileList[ ENV["TEST"] ] : test_files_finder.call
+      file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
+      # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct
+      option_list = ( ENV["TESTOPTS"] || ENV["TESTOPT"] || ENV["TEST_OPTS"] || '' )
+
+      args = "#{ruby_opts_string} #{test_loader_code} #{file_list_string} #{option_list}"
+      env_sh env, "#{FileUtils::RUBY} #{args}" do |ok, status|
+        if !ok && status.respond_to?(:signaled?) && status.signaled?
+          raise SignalException.new(status.termsig)
+        elsif !ok
+          fail "Command failed with status (#{status.exitstatus})"
+        end
+      end
+    end
+    task :test_mysql2 => :test_mysql
+
+    FileUtils.module_eval do
+
+      def env_sh(env, *cmd, &block)
+        options = (Hash === cmd.last) ? cmd.pop : {}
+        shell_runner = block_given? ? block : create_shell_runner(cmd)
+        set_verbose_option(options)
+        options[:noop] ||= Rake::FileUtilsExt.nowrite_flag
+        Rake.rake_check_options options, :noop, :verbose
+
+        cmd = env.map { |k,v| "#{k}=\"#{v}\"" }.join(' ') + ' ' + cmd.join(' ')
+        Rake.rake_output_message cmd if options[:verbose]
+
+        unless options[:noop]
+          res = Kernel.system(cmd)
+          status = $?
+          status = Rake::PseudoStatus.new(1) if !res && status.nil?
+          shell_runner.call(res, status)
+        end
+      end
+
+      def env_system(env, cmd)
+        Kernel.system(env.map { |k,v| "#{k}=\"#{v}\"" }.join(' ') + ' ' + cmd)
+      end
+
+    end
+
+  end
+
+  namespace :db do
+    namespace :mysql do
+      desc 'Build the MySQL test databases'
+      task :build do
+        config = ARTest.config['connections']['mysql2']
+        %x( mysql --user=#{config['arunit']['username']} --password=#{config['arunit']['password']} -e "create DATABASE #{config['arunit']['database']} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+        %x( mysql --user=#{config['arunit2']['username']} --password=#{config['arunit2']['password']} -e "create DATABASE #{config['arunit2']['database']} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+      end
+
+      desc 'Drop the MySQL test databases'
+      task :drop do
+        config = ARTest.config['connections']['mysql2']
+        %x( mysqladmin --user=#{config['arunit']['username']} --password=#{config['arunit']['password']} -f drop #{config['arunit']['database']} )
+        %x( mysqladmin --user=#{config['arunit2']['username']} --password=#{config['arunit2']['password']} -f drop #{config['arunit2']['database']} )
+      end
+
+      desc 'Rebuild the MySQL test databases'
+      task :rebuild => [:drop, :build]
+    end
+
+    namespace :postgresql do
+      desc 'Build the PostgreSQL test databases'
+      task :build do
+        config = ARTest.config['connections']['postgresql']
+        %x( createdb -E UTF8 -T template0 #{config['arunit']['database']} )
+        %x( createdb -E UTF8 -T template0 #{config['arunit2']['database']} )
+
+        # prepare hstore
+        if %x( createdb --version ).strip.gsub(/(.*)(\d\.\d\.\d)$/, "\\2") < "9.1.0"
+          puts "Please prepare hstore data type. See http://www.postgresql.org/docs/current/static/hstore.html"
+        end
+      end
+
+      desc 'Drop the PostgreSQL test databases'
+      task :drop do
+        config = ARTest.config['connections']['postgresql']
+        %x( dropdb #{config['arunit']['database']} )
+        %x( dropdb #{config['arunit2']['database']} )
+      end
+
+      desc 'Rebuild the PostgreSQL test databases'
+      task :rebuild => [:drop, :build]
+    end
+  end
+
+  # NOTE: we expect to, hopefully, not be using these anymore - delete at WILL!
+  namespace :test do
+    task :all do
+      driver = ENV['DRIVER'] || ENV['ADAPTER']
+      raise "need a DRIVER (DRIVER=mysql)" unless driver
+      rails_dir = _rails_dir
+      ENV['ARCONFIG'] = File.join(_ar_jdbc_dir, 'test', 'rails', 'config.yml')
+
+      Dir.chdir(File.join(rails_dir, 'activerecord')) do
+        sh FileUtils::RUBY, '-S', 'rake',
+           "RUBYLIB=#{_ruby_lib(rails_dir, driver)}",
+           _target(driver)
+      end
+    end
+
+    %w(MySQL SQLite3 Postgres).each do |adapter|
+      task adapter.downcase do
+        ENV['ADAPTER'] = adapter
+        Rake::Task['rails:test:all'].invoke
+      end
+
+      namespace adapter.downcase do
+        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 _ar_jdbc_dir
+      @ar_jdbc_dir ||= File.expand_path('..', File.dirname(__FILE__))
+    end
+
+    def _rails_dir
+      rails_dir = ENV['RAILS'] || File.join('..', 'rails')
+      unless File.directory? rails_dir
+        raise "can't find RAILS source at '#{rails_dir}' (maybe set ENV['RAILS'])"
+      end
+      rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
+      File.expand_path(rails_dir)
+    end
+
+    def _ruby_lib(rails_dir, driver)
+      ar_jdbc_dir = _ar_jdbc_dir
+
+      if driver =~ /postgres/i
+        adapter, driver = 'postgresql', 'postgres'
+      else
+        adapter, driver = driver.downcase, 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_postgresql'
+      else
+        "test_jdbc#{name.downcase}"
+      end
+    end
+
+  end
+end

data/src/java/arjdbc/ArJdbcModule.java

@@ -0,0 +1,276 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013-2014 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 java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import static arjdbc.jdbc.RubyJdbcConnection.getJdbcConnection;
+
+/**
+ * ::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;
+    }
+
+    public static RubyModule get(final Ruby runtime) {
+        return runtime.getModule("ArJdbc");
+    }
+
+    public static void warn(final ThreadContext context, final String message) {
+        final Ruby runtime = context.runtime;
+        get(runtime).callMethod(context, "warn", runtime.newString(message));
+    }
+
+    /**
+     * 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) {
+        final Ruby runtime = context.getRuntime();
+
+        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);
+        //
+
+        if (moduleClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'Module'
+            moduleClass = packagePrefix + moduleName + "Module";
+        }
+
+        final Class<?> module;
+        try {
+            module = Class.forName(moduleClass);
+            // new convention MySQLModule.load( Ruby runtime ) :
+            try {
+                invokeStatic(runtime, module, "load", Ruby.class, runtime);
+            }
+            catch (NoSuchMethodException e) {
+                // old convention MySQLModule.load( RubyModule arJdbc ) :
+                invokeStatic(runtime, module, "load", RubyModule.class, get(runtime));
+            }
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException e) {
+            throw newNativeException(runtime, e);
+        }
+
+        String connectionClass2 = null;
+        if (connectionClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'RubyJdbcConnection'
+            connectionClass = packagePrefix + moduleName + "RubyJdbcConnection";
+            connectionClass2 = packagePrefix + moduleName + "JdbcConnection";
+        }
+
+        try {
+            Class<?> connection = null;
+            try {
+                connection = Class.forName(connectionClass);
+            }
+            catch (ClassNotFoundException e) {
+                if ( connectionClass2 != null ) {
+                    connection = Class.forName(connectionClass2);
+                }
+            }
+            if ( connection != null ) {
+                // convention e.g. MySQLRubyJdbcConnection.load( Ruby runtime ) :
+                try {
+                    invokeStatic(runtime, connection, "load", Ruby.class, runtime);
+                }
+                catch (NoSuchMethodException e) {
+                    // "old" e.g. MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(runtime, jdbcConnection)
+                    connection.getMethod("create" + moduleName + "JdbcConnectionClass", Ruby.class, RubyClass.class).
+                        invoke(null, runtime, getJdbcConnection(runtime));
+                }
+            }
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException | IllegalAccessException | 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 ) {
+           final IRubyObject constant = arJdbc.getConstant(name, false);
+           // isModule: return false for Ruby Classes
+           if ( constant != null && constant.isModule() ) {
+               if ( "Util".equals(name) ) continue;
+               if ( "SerializedAttributesHelper".equals(name) ) continue; // deprecated
+               if ( "Version".equals(name) ) continue; // deprecated
+               modules.append( constant );
+           }
+        }
+        return modules;
+    }
+
+    // JDBC "driver" gem helper(s) :
+
+    @JRubyMethod(name = "load_driver", meta = true)
+    public static IRubyObject load_driver(final ThreadContext context, final IRubyObject self,
+        final IRubyObject const_name) { // e.g. load_driver(:MySQL)
+        IRubyObject loaded = loadDriver(context, self, const_name.toString());
+        return loaded == null ? context.nil : loaded;
+    }
+
+    // NOTE: probably useless - only to be useful for the pooled runtime mode when jar at WEB-INF/lib
+    static final Map<Ruby, Map<String, Boolean>> loadedDrivers = new WeakHashMap<Ruby, Map<String, Boolean>>(8);
+
+    private static IRubyObject loadDriver(final ThreadContext context, final IRubyObject self,
+        final String constName) {
+        final Ruby runtime = context.runtime;
+        // look for "cached" loading result :
+        Map<String, Boolean> loadedMap = loadedDrivers.get(runtime);
+        if ( loadedMap == null ) {
+            synchronized (ArJdbcModule.class) {
+                loadedMap = loadedDrivers.get(runtime);
+                if ( loadedMap == null ) {
+                    loadedMap = new HashMap<String, Boolean>(4);
+                    loadedDrivers.put(runtime, loadedMap);
+                }
+            }
+        }
+
+        final Boolean driverLoaded = loadedMap.get(constName);
+        if ( driverLoaded != null ) {
+            if ( driverLoaded.booleanValue() ) return runtime.getFalse();
+            return runtime.getNil();
+        }
+
+        try { // require 'jdbc/mysql'
+            final byte[] name = new byte[5 + constName.length()]; // 'j','d','b','c','/'
+            name[0] = 'j'; name[1] = 'd'; name[2] = 'b'; name[3] = 'c'; name[4] = '/';
+            for ( int i = 0; i < constName.length(); i++ ) {
+                name[ 5 + i ] = (byte) Character.toLowerCase( constName.charAt(i) );
+            }
+            final RubyString strName = RubyString.newString(runtime, new ByteList(name, false));
+            self.callMethod(context, "require", strName); // require 'jdbc/mysql'
+        }
+        catch (RaiseException e) { // LoadError
+            synchronized (loadedMap) {
+                loadedMap.put(constName, Boolean.FALSE);
+            }
+            return null;
+        }
+
+        final RubyModule jdbc = runtime.getModule("Jdbc");
+        if ( jdbc != null ) { // Jdbc::MySQL
+            final RubyModule constant = (RubyModule) jdbc.getConstantAt(constName);
+            if ( constant != null ) { // ::Jdbc::MySQL.load_driver :
+                if ( constant.respondsTo("load_driver") ) {
+                    IRubyObject result = constant.callMethod("load_driver");
+                    synchronized (loadedMap) {
+                        loadedMap.put(constName, Boolean.TRUE);
+                    }
+                    return result;
+                }
+            }
+        }
+
+        synchronized (loadedMap) {
+            loadedMap.put(constName, Boolean.FALSE);
+        }
+        return null;
+    }
+
+    private static Object invokeStatic(final Ruby runtime,
+        final Class<?> klass, final String name, final Class<?> argType, final Object arg)
+        throws NoSuchMethodException {
+        try {
+            return klass.getMethod(name, argType).invoke(null, arg);
+        }
+        catch (IllegalAccessException | InvocationTargetException e) {
+            throw newNativeException(runtime, e);
+        }
+    }
+
+    private static RaiseException newNativeException(final Ruby runtime, final Throwable cause) {
+        final RaiseException error = runtime.newRuntimeError(cause.toString());
+        error.initCause(cause);
+        return error;
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject with_meta_data_from_data_source_if_any(final ThreadContext context,
+        final IRubyObject self, final IRubyObject config, final Block block) {
+        return RubyJdbcConnection.with_meta_data_from_data_source_if_any(context, self, config, block);
+    }
+
+}