neo-activerecord-jdbc-adapter 5.0.pre2

data/lib/arjdbc/util/serialized_attributes.rb

@@ -0,0 +1,98 @@
+module ArJdbc
+  module Util
+    # Gets included into `ActiveRecord::Base` to support sending LOB values
+    # in a separate update SQL statement for DB adapters that need this.
+    module SerializedAttributes
+
+      # protected
+
+      def update_lob_columns
+        klass = self.class
+        return unless type = klass.lob_type # e.g. /blob/i
+        connection = klass.connection
+        if connection.respond_to?(:update_lob_values?)
+          return false unless connection.update_lob_values?
+        end
+        klass.columns.each do |column|
+          next if column.sql_type !~ type
+          next if ( value = dump_column_value(column) ).nil?
+          if connection.respond_to?(:update_lob_value?)
+            next unless connection.update_lob_value?(value, column)
+          end
+          connection.update_lob_value(self, column, value)
+        end
+      end
+
+      private
+
+      def dump_column_value(column)
+        SerializedAttributes.dump_column_value(self, column)
+      end
+
+      if defined? ActiveRecord::Type::Serialized # ArJdbc::AR42
+
+      def self.dump_column_value(record, column)
+        value = record[ column.name.to_s ]
+        column.cast_type.type_cast_for_database(value)
+      end
+
+      else
+
+      def self.dump_column_value(record, column)
+        value = record[ name = column.name.to_s ]
+        if record.class.respond_to?(:serialized_attributes)
+          if coder = record.class.serialized_attributes[name]
+            value = coder.respond_to?(:dump) ? coder.dump(value) : value.to_yaml
+          end
+        else
+          if record.respond_to?(:unserializable_attribute?)
+            value = value.to_yaml if record.unserializable_attribute?(name, column)
+          else
+            value = value.to_yaml if value.is_a?(Hash)
+          end
+        end
+        value
+      end
+
+      end
+
+      def self.setup(lob_type = nil, after_save_alias = nil)
+        ActiveRecord::Base.send :include, self # include SerializedAttributes
+        ActiveRecord::Base.lob_type = lob_type unless lob_type.nil?
+        if after_save_alias
+          ActiveRecord::Base.class_eval do
+            alias_method after_save_alias, 'update_lob_columns'
+          end
+          ActiveRecord::Base.after_save after_save_alias
+        else
+          ActiveRecord::Base.after_save 'update_lob_columns'
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def lob_type
+          @lob_type ||= begin
+            if superclass.respond_to?(:lob_type)
+              superclass.lob_type
+            else
+              /blob|clob/i
+            end
+          end
+        end
+
+        def lob_type=(type)
+          @lob_type = type
+        end
+
+      end
+
+    end
+  end
+  # @private only due backwards compatibility
+  SerializedAttributesHelper = Util::SerializedAttributes
+end

data/lib/arjdbc/util/table_copier.rb

@@ -0,0 +1,110 @@
+module ArJdbc
+  module Util
+    module TableCopier
+
+      # taken from SQLite adapter, code loosely based on http://git.io/P7tFQA
+
+      # Performs changes for table by first copying (and preserving contents)
+      # into another (temporary) table, than alters and copies all data back.
+      def alter_table(table_name, options = {})
+        table_name = table_name.to_s.downcase
+        altered_table_name = "a#{table_name}"
+        caller = lambda { |definition| yield definition if block_given? }
+
+        transaction do
+          # A temporary table might improve performance here, but
+          # it doesn't seem to maintain indices across the whole move.
+          move_table(table_name, altered_table_name, options)
+          move_table(altered_table_name, table_name, &caller)
+        end
+      end
+
+      # Move a table into another while preserving all content.
+      # @see #copy_table
+      def move_table(from, to, options = {}, &block)
+        copy_table(from, to, options, &block)
+        drop_table(from)
+      end
+
+      # @see #copy_table_contents
+      # @see #copy_table_indexes
+      def copy_table(from, to, options = {})
+        from_primary_key = primary_key(from)
+        create_table(to, options.merge(:id => false)) do |definition|
+          @definition = definition
+          @definition.primary_key(from_primary_key) if from_primary_key.present?
+          columns(from).each do |column|
+            column_name = options[:rename] ?
+              (options[:rename][column.name] ||
+               options[:rename][column.name.to_sym] ||
+               column.name) : column.name
+
+            next if column_name == from_primary_key
+
+            @definition.column(column_name, column.type,
+              :limit => column.limit, :default => column.default,
+              :precision => column.precision, :scale => column.scale,
+              :null => column.null)
+          end
+          yield @definition if block_given?
+        end
+
+        copy_table_indexes(from, to, options[:rename] || {})
+        copy_table_contents(from, to,
+          @definition.columns.map {|column| column.name},
+          options[:rename] || {})
+      end
+
+      # Copies indexes for a given table.
+      def copy_table_indexes(from, to, rename = {})
+        indexes(from).each do |index|
+          name = index.name.downcase
+          if to == "a#{from}"
+            name = "t#{name}"
+          elsif from == "a#{to}"
+            name = name[1..-1]
+          end
+
+          to_column_names = columns(to).map(&:name)
+          columns = index.columns.map { |column| rename[column] || column }
+          columns = columns.select { |column| to_column_names.include?(column) }
+
+          unless columns.empty?
+            # index name can't be the same
+            opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), :internal => true }
+            opts[:unique] = true if index.unique
+            add_index(to, columns, opts)
+          end
+        end
+      end
+
+      # Copies the content of a table into another.
+      def copy_table_contents(from, to, columns, rename = {})
+        column_mappings = Hash[ columns.map { |name| [name, name] } ]
+        rename.each { |a| column_mappings[a.last] = a.first }
+        from_columns = columns(from).collect {|col| col.name}
+        columns = columns.find_all{ |col| from_columns.include?(column_mappings[col]) }
+        quoted_columns = columns.map { |col| quote_column_name(col) } * ','
+
+        quoted_to = quote_table_name(to)
+
+        raw_column_mappings = Hash[ columns(from).map { |c| [c.name, c] } ]
+
+        execute("SELECT * FROM #{quote_table_name(from)}", 'Copy Table').each do |row|
+          sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
+
+          column_values = columns.map do |col|
+            quote(row[column_mappings[col]], raw_column_mappings[col])
+          end
+
+          sql << column_values * ', '
+          sql << ')'
+          exec_insert sql, 'Copy Table', []
+        end
+      end
+
+    end
+  end
+  # @private @deprecated backwards compatibility
+  MissingFunctionalityHelper = Util::TableCopier
+end

data/lib/arjdbc/version.rb

@@ -0,0 +1,8 @@
+module ArJdbc
+  VERSION = "5.0.pre2"
+  # @deprecated
+  module Version
+    # @private 1.2.x compatibility
+    VERSION = ArJdbc::VERSION
+  end
+end

data/lib/generators/jdbc/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates stubs that ensure AR-JDBC is bootstrapped in your Rails application.
+
+Example:
+    ./script/generate jdbc
+
+    This will create:
+        config/initializers/jdbc.rb
+	    lib/tasks/jdbc.rake

data/lib/generators/jdbc/jdbc_generator.rb

@@ -0,0 +1,17 @@
+class JdbcGenerator < Rails::Generators::Base
+  def self.source_root
+    @source_root ||= File.expand_path('../../../../rails_generators/templates', __FILE__)
+  end
+
+  def create_jdbc_files
+    directory '.', '.'
+  end
+
+  def self.desc(description=nil)
+    return super if description
+    "Description:\n" <<
+    "  Creates stubs that ensure AR-JDBC is bootstrapped in your Rails application.\n" <<
+    "  NOTE: you should not need this if you're on Rails >= 3.0 (using Bundler) ..."
+  end
+
+end

data/lib/jdbc_adapter.rb

@@ -0,0 +1,2 @@
+require 'arjdbc'
+ArJdbc.deprecate "require 'arjdbc' instead of 'jdbc_adapter'"

data/lib/jdbc_adapter/rake_tasks.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/tasks.rb'
+
+require 'arjdbc'
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' instead of 'jdbc_adapter/rake_tasks.rb'"

data/lib/jdbc_adapter/version.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/version'
+
+require 'arjdbc'
+ArJdbc.deprecate "require 'arjdbc/version' instead of 'jdbc_adapter/version'"

data/pom.xml

@@ -0,0 +1,114 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jruby.rails</groupId>
+  <artifactId>activerecord-jdbc</artifactId>
+  <packaging>jar</packaging>
+  <version>IDE-SNAPSHOT</version>
+  <name>activerecord-jdbc</name>
+  <description>
+    This POM for ActiveRecord-JDBC is just for bootstrapping IDEs.
+  </description>
+  <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
+
+  <properties>
+    <jruby.version>9.1.6.0</jruby.version>
+  </properties>
+
+  <issueManagement>
+    <system>GitHub</system>
+    <url>http://github.com/jruby/activerecord-jdbc-adapter/issues</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git://github.com/jruby/activerecord-jdbc-adapter.git</connection>
+    <developerConnection>scm:git:git@github.com:jruby/activerecord-jdbc-adapter.git</developerConnection>
+    <url>https://github.com/jruby/activerecord-jdbc-adapter</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>BSD</name>
+      <url>http://www.opensource.org/licenses/bsd-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+    <license>
+      <name>MIT License</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <!--
+  <repositories>
+    <repository>
+      <id>codehaus</id>
+      <name>Codehaus Repository</name>
+      <releases>
+        <enabled>true</enabled>
+      </releases>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+      <url>http://repository.codehaus.org</url>
+    </repository>
+  </repositories>-->
+
+  <developers>
+    <developer>
+      <id>nicksieger</id>
+      <name>Nick Sieger</name>
+      <email>nicksieger@gmail.com</email>
+    </developer>
+    <developer>
+      <id>kares</id>
+      <name>Karol Bucek</name>
+      <email>self@kares.org</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby-complete</artifactId>
+      <version>${jruby.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <version>9.2-1003-jdbc4</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+
+    <sourceDirectory>src/java</sourceDirectory>
+    <resources>
+        <resource>
+            <directory>lib</directory>
+        </resource>
+    </resources>
+    <!--
+    <testSourceDirectory>test/java</testSourceDirectory>-->
+    <testResources>
+        <testResource>
+            <directory>test</directory>
+        </testResource>
+    </testResources>
+
+    <outputDirectory>pkg/classes</outputDirectory>
+
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.5.1</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+    </plugins>
+
+  </build>
+
+</project>

data/rails_generators/jdbc_generator.rb

@@ -0,0 +1,15 @@
+class JdbcGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'config/initializers'
+      m.template 'config/initializers/jdbc.rb', File.join('config', 'initializers', 'jdbc.rb')
+      m.directory 'lib/tasks'
+      m.template 'lib/tasks/jdbc.rake', File.join('lib', 'tasks', 'jdbc.rake')
+    end
+  end
+
+  protected
+  def banner
+    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails (2.x) application."
+  end
+end

data/rails_generators/templates/config/initializers/jdbc.rb

@@ -0,0 +1,10 @@
+# This file was generated by the "jdbc" generator, which is provided by the 
+# activerecord-jdbc-adapter gem.
+#
+# This file allows the JDBC adapters to be hooked into ActiveRecord such that 
+# you don't have to change anything else in your Rails application.
+# 
+# NOTE: This is only needed on Rails 2.x - without Bundler since when you're
+# using Bundler than `gem 'activerecord-jdbc-adapter'` will automatically 
+# `require 'arjdbc'` by default (unless you set it to `require: false`).
+require 'arjdbc' if defined?(JRUBY_VERSION)

data/rails_generators/templates/lib/tasks/jdbc.rake

@@ -0,0 +1,11 @@
+# This file was generated by the "jdbc" generator, which is provided by the 
+# activerecord-jdbc-adapter gem.
+#
+# This file allows you to use Rails' various db:* tasks with the JDBC adapters.
+# 
+# NOTE: Only needed on Rails 2.x and it's fine to delete this file otherwise,
+# since on Rails 3.x AR-JDBC provides a Railtie that loads the Rake tasks.
+if defined?(JRUBY_VERSION)
+  require 'arjdbc'
+  require 'arjdbc/tasks'
+end

data/rakelib/01-tomcat.rake

@@ -0,0 +1,51 @@
+namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
+
+  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_VERSION = '7.0.54'
+
+  DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
+
+  #tomcat_jar = "tomcat-embed-core.jar"
+  #tomcat_uri = "#{TOMCAT_MAVEN_REPO}/embed/tomcat-embed-core/#{TOMCAT_VERSION}/tomcat-embed-core-#{TOMCAT_VERSION}.jar"
+
+  catalina_jar = "tomcat-catalina.jar"
+  catalina_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-catalina/#{TOMCAT_VERSION}/tomcat-catalina-#{TOMCAT_VERSION}.jar"
+
+  juli_jar = "tomcat-juli.jar"
+  juli_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-juli/#{TOMCAT_VERSION}/tomcat-juli-#{TOMCAT_VERSION}.jar"
+
+  task :download do
+    require 'open-uri'; require 'tmpdir'
+
+    temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+    FileUtils.mkdir temp_dir
+
+    downloads = Hash.new
+    downloads[juli_jar] = juli_uri
+    downloads[catalina_jar] = catalina_uri
+
+    Dir.chdir(temp_dir) do
+      FileUtils.mkdir DOWNLOAD_DIR unless File.exist?(DOWNLOAD_DIR)
+      downloads.each do |jar, uri|
+        puts "downloading #{uri}"
+        file = open(uri)
+        FileUtils.cp file.path, File.join(DOWNLOAD_DIR, jar)
+      end
+    end
+
+    FileUtils.rm_r temp_dir
+  end
+
+  task :check do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    unless File.exist?(jar_path)
+      Rake::Task['tomcat-jndi:download'].invoke
+    end
+  end
+
+  task :clear do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    rm jar_path if File.exist?(jar_path)
+  end
+
+end