activerecord-import 0.1.0 → 0.2.0

data/README.markdown

@@ -1,29 +1,8 @@
 # activerecord-import
 
-activerecord-import is a library for bulk inserting data using ActiveRecord. By default with ActiveRecord, in order to insert multiple records you have to perform individual save operations on each model, like so:
+activerecord-import is a library for bulk inserting data using ActiveRecord. 
 
-    10.times do |i|
-      Book.create! :name => "book #{i}"
-    end
-    
-This may work fine if all you have is 10 records, but if you have hundreds, thousands, or millions of records it can turn into a nightmare. This is where activerecord-import comes into play. Here's the equivalent behaviour using the #import method:
-
-    books = []
-    10.times{ |i| books << Book.new(:name => "book #{i}") }
-    Book.import books
-    
-Pretty slick, eh? 
-
-Maybe, just maybe you're thinking, why do I have do instantiate ActiveRecord objects? Will that perform validations? What if I don't want validations? What if I want to take advantage of features like MySQL's on duplicate key update? Well, activerecord-import handles all of these cases and more! 
-
-For more documentation on the matter you can refer to two places:
-
-1. activerecord-import github wiki: http://wiki.github.com/zdennis/activerecord-import/
-1. the tests in the code base
-
-# Upgrading from ar-extensions
-
-This library replaces the ar-extensions library and is compatible with Rails 3. It provides the exact same API for importing data, but it does not include any additional ar-extensions functionality.
+For more information on activerecord-import please see its wiki: http://wiki.github.com/zdennis/activerecord-import/
 
 # License
 

data/README.textile

@@ -0,0 +1,62 @@
+h1. activerecord-import
+
+activerecord-import is a library for bulk inserting data using ActiveRecord. 
+
+h2. Why activerecord-import?
+
+Because plain-vanilla, out-of-the-box ActiveRecord doesn't provide support for inserting large amounts of data efficiently. With vanilla ActiveRecord you would have to perform individual save operations on each model:
+
+<pre>
+10.times do |i|
+  Book.create! :name => "book #{i}"
+end
+</pre> 
+
+This may work fine if all you have is 10 records, but if you have hundreds, thousands, or millions of records it can turn into a nightmare. This is where activerecord-import comes into play. 
+
+h2. An Introductory Example
+
+Here's an example with equivalent behaviour using the @#import@ method:
+
+<pre>
+books = []
+10.times do |i| 
+  books << Book.new(:name => "book #{i}")
+end
+Book.import books
+</pre>
+
+This call to import does whatever is most efficient for the underlying database adapter.  Pretty slick, eh?
+
+h2. Features
+
+Here's a list of some of the high-level features that activerecord-import provides:
+
+* activerecord-import can work with raw columns and arrays of values (fastest)
+* activerecord-import works with model objects (faster)
+* activerecord-import can perform validations (fast)
+* activerecord-import can perform on duplicate key updates (requires mysql)
+
+
+h1. Upgrading from ar-extensions
+
+activerecord-import replaces the ar-extensions library and is compatible with Rails 3. It provides the exact same API for importing data, but it does not include any additional ar-extensions functionality.
+
+h1. License
+
+This is licensed under the ruby license. 
+
+h1. Author
+
+Zach Dennis (zach.dennis@gmail.com)
+
+h1. Contributors
+
+* Blythe Dunham
+* Gabe da Silveira
+* Henry Work
+* James Herdman
+* Marcus Crafter
+* Thibaud Guillaume-Gentil
+* Mark Van Holstyn 
+* Victor Costan

data/Rakefile

@@ -1,10 +1,11 @@
-require 'rubygems'
+require "bundler"
+Bundler.setup
+
 require 'rake'
 require 'rake/testtask'
 
 begin
   require 'jeweler'
-  require 'bundler'
   Jeweler::Tasks.new do |gem|
     gem.name = "activerecord-import"
     gem.summary = %Q{Bulk-loading extension for ActiveRecord}
@@ -13,7 +14,11 @@ begin
     gem.homepage = "http://github.com/zdennis/activerecord-import"
     gem.authors = ["Zach Dennis"]
     gem.files = FileList["VERSION", "Rakefile", "README*", "lib/**/*"]
-    gem.add_bundler_dependencies
+
+    bundler = Bundler.load
+    bundler.dependencies_for(:default).each do |dependency|
+      gem.add_dependency dependency.name, *dependency.requirements_list
+    end
 
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
@@ -31,7 +36,7 @@ namespace :display do
 end
 task :default => ["display:notice"]
 
-ADAPTERS = %w(mysql postgresql sqlite3)
+ADAPTERS = %w(mysql mysql2 postgresql sqlite3)
 ADAPTERS.each do |adapter|
   namespace :test do
     desc "Runs #{adapter} database tests."

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/activerecord-import.rb

@@ -0,0 +1,16 @@
+class ActiveRecord::Base
+  class << self
+    def establish_connection_with_activerecord_import(*args)
+      establish_connection_without_activerecord_import(*args)
+      ActiveSupport.run_load_hooks(:active_record_connection_established, connection)
+    end
+    alias_method_chain :establish_connection, :activerecord_import
+  end
+end
+
+ActiveSupport.on_load(:active_record_connection_established) do |connection|
+  if !ActiveRecord.const_defined?(:Import) || !ActiveRecord::Import.respond_to?(:load_from_connection)
+    require File.join File.dirname(__FILE__),  "activerecord-import/base"
+  end
+  ActiveRecord::Import.load_from_connection connection
+end

data/lib/activerecord-import/active_record/adapters/abstract_adapter.rb

@@ -1,146 +1,10 @@
+require "activerecord-import/adapters/abstract_adapter"
+
 module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     class AbstractAdapter # :nodoc:
-      NO_MAX_PACKET = 0
-      QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
-      
-      def next_value_for_sequence(sequence_name)
-        %{#{sequence_name}.nextval}
-      end
-      
-      # +sql+ can be a single string or an array. If it is an array all 
-      # elements that are in position >= 1 will be appended to the final SQL.
-      def insert_many( sql, values, *args ) # :nodoc:
-        # the number of inserts default
-        number_of_inserts = 0
-        
-        base_sql,post_sql = if sql.is_a?( String )
-          [ sql, '' ]
-        elsif sql.is_a?( Array )
-          [ sql.shift, sql.join( ' ' ) ]
-        end
-        
-        sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size 
-
-        # the number of bytes the requested insert statement values will take up
-        values_in_bytes = self.class.sum_sizes( *values )
-        
-        # the number of bytes (commas) it will take to comma separate our values
-        comma_separated_bytes = values.size-1
-        
-        # the total number of bytes required if this statement is one statement
-        total_bytes = sql_size + values_in_bytes + comma_separated_bytes
-        
-        max = max_allowed_packet
-        
-        # if we can insert it all as one statement
-        if NO_MAX_PACKET == max or total_bytes < max
-          number_of_inserts += 1
-          sql2insert = base_sql + values.join( ',' ) + post_sql
-          insert( sql2insert, *args )
-        else
-          value_sets = self.class.get_insert_value_sets( values, sql_size, max )
-          value_sets.each do |values|
-            number_of_inserts += 1
-            sql2insert = base_sql + values.join( ',' ) + post_sql
-            insert( sql2insert, *args )
-          end
-        end
-
-        number_of_inserts
-      end
-
-      def pre_sql_statements(options)
-        sql = []
-        sql << options[:pre_sql] if options[:pre_sql]
-        sql << options[:command] if options[:command]
-        sql << "IGNORE" if options[:ignore]
-
-        #add keywords like IGNORE or DELAYED
-        if options[:keywords].is_a?(Array)
-          sql.concat(options[:keywords])
-        elsif options[:keywords]
-          sql << options[:keywords].to_s
-        end
-
-        sql
-      end
-
-      # Synchronizes the passed in ActiveRecord instances with the records in
-      # the database by calling +reload+ on each instance.
-      def after_import_synchronize( instances )
-        instances.each { |e| e.reload }
-      end
-
-      # Returns an array of post SQL statements given the passed in options.
-      def post_sql_statements( table_name, options ) # :nodoc:
-        post_sql_statements = []
-        if options[:on_duplicate_key_update]
-          post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update] )
-        end
-
-        #custom user post_sql
-        post_sql_statements << options[:post_sql] if options[:post_sql]
-
-        #with rollup
-        post_sql_statements << rollup_sql if options[:rollup]
-
-        post_sql_statements
-      end
-
-
-      # Generates the INSERT statement used in insert multiple value sets.
-      def multiple_value_sets_insert_sql(table_name, column_names, options) # :nodoc:
-        "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{table_name} (#{column_names.join(',')}) VALUES "
-      end  
-
-      # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
-      # and +array_of_attributes+.
-      def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
-        values = []
-        array_of_attributes.each do |arr|
-          my_values = []
-          arr.each_with_index do |val,j|
-            my_values << quote( val, columns[j] )
-          end
-          values << my_values
-        end   
-        values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
-      end
-
-      # Returns the sum of the sizes of the passed in objects. This should
-      # probably be moved outside this class, but to where?
-      def self.sum_sizes( *objects ) # :nodoc:
-        objects.inject( 0 ){|sum,o| sum += o.size }
-      end
-            
-      # Returns the maximum number of bytes that the server will allow
-      # in a single packet
-      def max_allowed_packet
-        NO_MAX_PACKET
-      end
-      
-      def self.get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
-        value_sets = []          
-        arr, current_arr_values_size, current_size = [], 0, 0
-        values.each_with_index do |val,i|
-          comma_bytes = arr.size
-          sql_size_thus_far = sql_size + current_size + val.size + comma_bytes
-          if NO_MAX_PACKET == max_bytes or sql_size_thus_far <= max_bytes
-            current_size += val.size            
-            arr << val
-          else
-            value_sets << arr
-            arr = [ val ]
-            current_size = val.size
-          end
-          
-          # if we're on the last iteration push whatever we have in arr to value_sets
-          value_sets << arr if i == (values.size-1)
-        end
-        [ *value_sets ]
-      end     
-    
+      extend ActiveRecord::Import::AbstractAdapter::ClassMethods
+      include ActiveRecord::Import::AbstractAdapter::InstanceMethods
     end
   end
 end

data/lib/activerecord-import/active_record/adapters/mysql2_adapter.rb

@@ -0,0 +1,6 @@
+require "active_record/connection_adapters/mysql2_adapter"
+require "activerecord-import/adapters/mysql_adapter"
+
+class ActiveRecord::ConnectionAdapters::Mysql2Adapter
+  include ActiveRecord::Import::MysqlAdapter::InstanceMethods
+end

data/lib/activerecord-import/active_record/adapters/mysql_adapter.rb

@@ -1,47 +1,6 @@
 require "active_record/connection_adapters/mysql_adapter"
+require "activerecord-import/adapters/mysql_adapter"
 
 class ActiveRecord::ConnectionAdapters::MysqlAdapter
-  include ActiveRecord::Extensions::Import::ImportSupport  
-  include ActiveRecord::Extensions::Import::OnDuplicateKeyUpdateSupport
-    
-  # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
-  # in +args+. 
-  def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
-    sql = ' ON DUPLICATE KEY UPDATE '
-    arg = args.first
-    if arg.is_a?( Array )
-      sql << sql_for_on_duplicate_key_update_as_array( table_name, arg )
-    elsif arg.is_a?( Hash )
-      sql << sql_for_on_duplicate_key_update_as_hash( table_name, arg )
-    elsif arg.is_a?( String )
-      sql << arg
-    else
-      raise ArgumentError.new( "Expected Array or Hash" )
-    end
-    sql
-  end
-
-  def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
-    results = arr.map do |column|
-      qc = quote_column_name( column )
-      "#{table_name}.#{qc}=VALUES(#{qc})"        
-    end
-    results.join( ',' )
-  end
-  
-  def sql_for_on_duplicate_key_update_as_hash( table_name, hsh ) # :nodoc:
-    sql = ' ON DUPLICATE KEY UPDATE '
-    results = hsh.map do |column1, column2|
-      qc1 = quote_column_name( column1 )
-      qc2 = quote_column_name( column2 )
-      "#{table_name}.#{qc1}=VALUES( #{qc2} )"
-    end
-    results.join( ',')
-  end
-
-  #return true if the statement is a duplicate key record error
-  def duplicate_key_update_error?(exception)# :nodoc:
-    exception.is_a?(ActiveRecord::StatementInvalid) && exception.to_s.include?('Duplicate entry')
-  end
-
-end
+  include ActiveRecord::Import::MysqlAdapter::InstanceMethods
+end

data/lib/activerecord-import/active_record/adapters/postgresql_adapter.rb

@@ -1,11 +1,7 @@
 require "active_record/connection_adapters/postgresql_adapter"
+require "activerecord-import/adapters/postgresql_adapter"
 
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    class PostgreSQLAdapter # :nodoc:
-      def next_value_for_sequence(sequence_name)
-        %{nextval('#{sequence_name}')}
-      end
-    end
-  end
+class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  include ActiveRecord::Import::PostgreSQLAdapter::InstanceMethods
 end
+

data/lib/activerecord-import/active_record/adapters/sqlite3_adapter.rb

@@ -1,11 +1,7 @@
 require "active_record/connection_adapters/sqlite3_adapter"
+require "activerecord-import/adapters/sqlite3_adapter"
 
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    class Sqlite3Adapter # :nodoc:
-      def next_value_for_sequence(sequence_name)
-        %{nextval('#{sequence_name}')}
-      end
-    end
-  end
+class ActiveRecord::ConnectionAdapters::Sqlite3Adapter
+  include ActiveRecord::Import::Sqlite3Adapter::InstanceMethods
 end
+

data/lib/activerecord-import/adapters/abstract_adapter.rb

@@ -0,0 +1,145 @@
+module ActiveRecord::Import::AbstractAdapter
+  NO_MAX_PACKET = 0
+  QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
+    
+  module ClassMethods
+    # Returns the sum of the sizes of the passed in objects. This should
+    # probably be moved outside this class, but to where?
+    def sum_sizes( *objects ) # :nodoc:
+      objects.inject( 0 ){|sum,o| sum += o.size }
+    end
+
+    def get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
+      value_sets = []          
+      arr, current_arr_values_size, current_size = [], 0, 0
+      values.each_with_index do |val,i|
+        comma_bytes = arr.size
+        sql_size_thus_far = sql_size + current_size + val.size + comma_bytes
+        if NO_MAX_PACKET == max_bytes or sql_size_thus_far <= max_bytes
+          current_size += val.size            
+          arr << val
+        else
+          value_sets << arr
+          arr = [ val ]
+          current_size = val.size
+        end
+      
+        # if we're on the last iteration push whatever we have in arr to value_sets
+        value_sets << arr if i == (values.size-1)
+      end
+      [ *value_sets ]
+    end
+  end
+  
+  module InstanceMethods
+    def next_value_for_sequence(sequence_name)
+      %{#{sequence_name}.nextval}
+    end
+  
+    # +sql+ can be a single string or an array. If it is an array all 
+    # elements that are in position >= 1 will be appended to the final SQL.
+    def insert_many( sql, values, *args ) # :nodoc:
+      # the number of inserts default
+      number_of_inserts = 0
+    
+      base_sql,post_sql = if sql.is_a?( String )
+        [ sql, '' ]
+      elsif sql.is_a?( Array )
+        [ sql.shift, sql.join( ' ' ) ]
+      end
+    
+      sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size 
+
+      # the number of bytes the requested insert statement values will take up
+      values_in_bytes = self.class.sum_sizes( *values )
+    
+      # the number of bytes (commas) it will take to comma separate our values
+      comma_separated_bytes = values.size-1
+    
+      # the total number of bytes required if this statement is one statement
+      total_bytes = sql_size + values_in_bytes + comma_separated_bytes
+    
+      max = max_allowed_packet
+    
+      # if we can insert it all as one statement
+      if NO_MAX_PACKET == max or total_bytes < max
+        number_of_inserts += 1
+        sql2insert = base_sql + values.join( ',' ) + post_sql
+        insert( sql2insert, *args )
+      else
+        value_sets = self.class.get_insert_value_sets( values, sql_size, max )
+        value_sets.each do |values|
+          number_of_inserts += 1
+          sql2insert = base_sql + values.join( ',' ) + post_sql
+          insert( sql2insert, *args )
+        end
+      end
+
+      number_of_inserts
+    end
+
+    def pre_sql_statements(options)
+      sql = []
+      sql << options[:pre_sql] if options[:pre_sql]
+      sql << options[:command] if options[:command]
+      sql << "IGNORE" if options[:ignore]
+
+      #add keywords like IGNORE or DELAYED
+      if options[:keywords].is_a?(Array)
+        sql.concat(options[:keywords])
+      elsif options[:keywords]
+        sql << options[:keywords].to_s
+      end
+
+      sql
+    end
+
+    # Synchronizes the passed in ActiveRecord instances with the records in
+    # the database by calling +reload+ on each instance.
+    def after_import_synchronize( instances )
+      instances.each { |e| e.reload }
+    end
+
+    # Returns an array of post SQL statements given the passed in options.
+    def post_sql_statements( table_name, options ) # :nodoc:
+      post_sql_statements = []
+      if options[:on_duplicate_key_update]
+        post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update] )
+      end
+
+      #custom user post_sql
+      post_sql_statements << options[:post_sql] if options[:post_sql]
+
+      #with rollup
+      post_sql_statements << rollup_sql if options[:rollup]
+
+      post_sql_statements
+    end
+
+
+    # Generates the INSERT statement used in insert multiple value sets.
+    def multiple_value_sets_insert_sql(table_name, column_names, options) # :nodoc:
+      "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{table_name} (#{column_names.join(',')}) VALUES "
+    end  
+
+    # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
+    # and +array_of_attributes+.
+    def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
+      values = []
+      array_of_attributes.each do |arr|
+        my_values = []
+        arr.each_with_index do |val,j|
+          my_values << quote( val, columns[j] )
+        end
+        values << my_values
+      end   
+      values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
+    end
+        
+    # Returns the maximum number of bytes that the server will allow
+    # in a single packet
+    def max_allowed_packet
+      NO_MAX_PACKET
+    end
+  end
+end

data/lib/activerecord-import/adapters/mysql_adapter.rb

@@ -0,0 +1,50 @@
+module ActiveRecord::Import::MysqlAdapter
+  module InstanceMethods
+    def self.included(klass)
+      klass.instance_eval do
+        include ActiveRecord::Import::ImportSupport  
+        include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
+      end
+    end
+  
+    # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
+    # in +args+. 
+    def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
+      sql = ' ON DUPLICATE KEY UPDATE '
+      arg = args.first
+      if arg.is_a?( Array )
+        sql << sql_for_on_duplicate_key_update_as_array( table_name, arg )
+      elsif arg.is_a?( Hash )
+        sql << sql_for_on_duplicate_key_update_as_hash( table_name, arg )
+      elsif arg.is_a?( String )
+        sql << arg
+      else
+        raise ArgumentError.new( "Expected Array or Hash" )
+      end
+      sql
+    end
+
+    def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
+      results = arr.map do |column|
+        qc = quote_column_name( column )
+        "#{table_name}.#{qc}=VALUES(#{qc})"        
+      end
+      results.join( ',' )
+    end
+  
+    def sql_for_on_duplicate_key_update_as_hash( table_name, hsh ) # :nodoc:
+      sql = ' ON DUPLICATE KEY UPDATE '
+      results = hsh.map do |column1, column2|
+        qc1 = quote_column_name( column1 )
+        qc2 = quote_column_name( column2 )
+        "#{table_name}.#{qc1}=VALUES( #{qc2} )"
+      end
+      results.join( ',')
+    end
+
+    #return true if the statement is a duplicate key record error
+    def duplicate_key_update_error?(exception)# :nodoc:
+      exception.is_a?(ActiveRecord::StatementInvalid) && exception.to_s.include?('Duplicate entry')
+    end
+  end
+end

data/lib/activerecord-import/adapters/postgresql_adapter.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Import::PostgreSQLAdapter
+  module InstanceMethods
+    def next_value_for_sequence(sequence_name)
+      %{nextval('#{sequence_name}')}
+    end
+  end
+end

data/lib/activerecord-import/adapters/sqlite3_adapter.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Import::Sqlite3Adapter
+  module InstanceMethods
+    def next_value_for_sequence(sequence_name)
+      %{nextval('#{sequence_name}')}
+    end
+  end
+end

data/lib/activerecord-import/base.rb

@@ -2,15 +2,26 @@ require "pathname"
 require "active_record"
 require "active_record/version"
 
-module ActiveRecord::Extensions
+module ActiveRecord::Import
   AdapterPath = File.join File.expand_path(File.dirname(__FILE__)), "/active_record/adapters"
-  
+
+  # Loads the import functionality for a specific database adapter
   def self.require_adapter(adapter)
     require File.join(AdapterPath,"/abstract_adapter")
     require File.join(AdapterPath,"/#{adapter}_adapter")
   end
+
+  # Loads the import functionality for the passed in ActiveRecord connection
+  def self.load_from_connection(connection)
+    import_adapter = "ActiveRecord::Import::#{connection.class.name.demodulize}::InstanceMethods"
+    unless connection.class.ancestors.map(&:name).include?(import_adapter)
+      config = connection.instance_variable_get :@config
+      require_adapter config[:adapter]
+    end
+  end
 end
 
+
 this_dir = Pathname.new File.dirname(__FILE__)
 require this_dir.join("import")
 require this_dir.join("active_record/adapters/abstract_adapter")

data/lib/activerecord-import/import.rb

@@ -1,8 +1,8 @@
 require "ostruct"
 
-module ActiveRecord::Extensions::ConnectionAdapters ; end
+module ActiveRecord::Import::ConnectionAdapters ; end
 
-module ActiveRecord::Extensions::Import #:nodoc:
+module ActiveRecord::Import #:nodoc:
   module ImportSupport #:nodoc:
     def supports_import? #:nodoc:
       true

data/lib/activerecord-import/mysql.rb

@@ -1,2 +1,8 @@
-require File.join File.dirname(__FILE__),  "base"
-ActiveRecord::Extensions.require_adapter "mysql"
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/mysql2.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/postgresql.rb

@@ -1,2 +1,8 @@
-require File.join File.dirname(__FILE__),  "base"
-ActiveRecord::Extensions.require_adapter "postgresql"
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/sqlite3.rb

@@ -1,2 +1,8 @@
-require File.join File.dirname(__FILE__),  "base"
-ActiveRecord::Extensions.require_adapter "sqlite3"
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/test/adapters/mysql2.rb

@@ -0,0 +1 @@
+ENV["ARE_DB"] = "mysql2"

data/test/mysql/import_test.rb

@@ -1,118 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require "activerecord-import/mysql"
 
-describe "#import with :on_duplicate_key_update option (mysql specific functionality)" do
-  extend ActiveSupport::TestCase::MySQLAssertions
-  
-  asssertion_group(:should_support_on_duplicate_key_update) do
-    should_not_update_fields_not_mentioned
-    should_update_foreign_keys
-    should_not_update_created_at_on_timestamp_columns
-    should_update_updated_at_on_timestamp_columns
-  end
-  
-  macro(:perform_import){ raise "supply your own #perform_import in a context below" }
-  macro(:updated_topic){ Topic.find(@topic) }
-  
-  context "given columns and values with :validation checks turned off" do
-    let(:columns){  %w( id title author_name author_email_address parent_id ) }
-    let(:values){ [ [ 99, "Book", "John Doe", "john@doe.com", 17 ] ] }
-    let(:updated_values){ [ [ 99, "Book - 2nd Edition", "Author Should Not Change", "johndoe@example.com", 57 ] ] }
-  
-    macro(:perform_import) do |*opts|
-      Topic.import columns, updated_values, opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
-    end
-    
-    setup do
-      Topic.import columns, values, :validate => false
-      @topic = Topic.find 99
-    end
-    
-    context "using string column names" do
-      let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using symbol column names" do
-      let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-    
-    context "using string hash map" do
-      let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using string hash map, but specifying column mismatches" do
-      let(:update_columns){ { "title" => "author_email_address", "author_email_address" => "title", "parent_id" => "parent_id" } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned_with_hash_mappings
-    end
-  
-    context "using symbol hash map" do
-      let(:update_columns){ { :title => :title, :author_email_address => :author_email_address, :parent_id => :parent_id } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using symbol hash map, but specifying column mismatches" do
-      let(:update_columns){ { :title => :author_email_address, :author_email_address => :title, :parent_id => :parent_id } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned_with_hash_mappings
-    end
-  end
-  
-  context "given array of model instances with :validation checks turned off" do
-    macro(:perform_import) do |*opts|
-      @topic.title = "Book - 2nd Edition"
-      @topic.author_name = "Author Should Not Change"
-      @topic.author_email_address = "johndoe@example.com"
-      @topic.parent_id = 57
-      Topic.import [@topic], opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
-    end
-    
-    setup do
-      @topic = Generate(:topic, :id => 99, :author_name => "John Doe", :parent_id => 17)
-    end
-    
-    context "using string column names" do
-      let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using symbol column names" do
-      let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-    
-    context "using string hash map" do
-      let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using string hash map, but specifying column mismatches" do
-      let(:update_columns){ { "title" => "author_email_address", "author_email_address" => "title", "parent_id" => "parent_id" } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned_with_hash_mappings
-    end
-  
-    context "using symbol hash map" do
-      let(:update_columns){ { :title => :title, :author_email_address => :author_email_address, :parent_id => :parent_id } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned
-    end
-  
-    context "using symbol hash map, but specifying column mismatches" do
-      let(:update_columns){ { :title => :author_email_address, :author_email_address => :title, :parent_id => :parent_id } }
-      should_support_on_duplicate_key_update
-      should_update_fields_mentioned_with_hash_mappings
-    end
-  end
-  
-end
+require "test/support/mysql/assertions"
+require "test/support/mysql/import_examples"
+
+should_support_mysql_import_functionality

data/test/mysql2/import_test.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+require "test/support/mysql/assertions"
+require "test/support/mysql/import_examples"
+
+should_support_mysql_import_functionality

data/test/support/active_support/test_case_extensions.rb

@@ -0,0 +1,67 @@
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  self.use_transactional_fixtures = true
+  
+  class << self
+    def assertion(name, &block)
+      mc = class << self ; self ; end
+      mc.class_eval do
+        define_method(name) do
+          it(name, &block)
+        end
+      end
+    end
+    
+    def asssertion_group(name, &block)
+      mc = class << self ; self ; end
+      mc.class_eval do
+        define_method(name, &block)
+      end
+    end
+
+    def macro(name, &block)
+      class_eval do
+        define_method(name, &block)
+      end
+    end
+    
+    def describe(description, toplevel=nil, &blk)
+      text = toplevel ? description : "#{name} #{description}"
+      klass = Class.new(self)
+
+      klass.class_eval <<-RUBY_EVAL
+        def self.name
+          "#{text}"
+        end
+      RUBY_EVAL
+
+      # do not inherit test methods from the superclass
+      klass.class_eval do
+        instance_methods.grep(/^test.+/) do |method|
+          undef_method method
+        end
+      end
+
+      klass.instance_eval &blk
+    end
+    alias_method :context, :describe
+    
+    def let(name, &blk)
+      values = {}
+      define_method(name) do
+        return values[name] if values.has_key?(name)
+        values[name] = instance_eval(&blk)
+      end
+    end
+    
+    def it(description, &blk)
+      define_method("test: #{name} #{description}", &blk)
+    end
+  end
+  
+end
+
+def describe(description, &blk)
+  ActiveSupport::TestCase.describe(description, true, &blk)
+end
+

data/test/support/mysql/import_examples.rb

@@ -0,0 +1,117 @@
+def should_support_mysql_import_functionality
+  describe "#import with :on_duplicate_key_update option (mysql specific functionality)" do
+    extend ActiveSupport::TestCase::MySQLAssertions
+  
+    asssertion_group(:should_support_on_duplicate_key_update) do
+      should_not_update_fields_not_mentioned
+      should_update_foreign_keys
+      should_not_update_created_at_on_timestamp_columns
+      should_update_updated_at_on_timestamp_columns
+    end
+  
+    macro(:perform_import){ raise "supply your own #perform_import in a context below" }
+    macro(:updated_topic){ Topic.find(@topic) }
+  
+    context "given columns and values with :validation checks turned off" do
+      let(:columns){  %w( id title author_name author_email_address parent_id ) }
+      let(:values){ [ [ 99, "Book", "John Doe", "john@doe.com", 17 ] ] }
+      let(:updated_values){ [ [ 99, "Book - 2nd Edition", "Author Should Not Change", "johndoe@example.com", 57 ] ] }
+  
+      macro(:perform_import) do |*opts|
+        Topic.import columns, updated_values, opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
+      end
+    
+      setup do
+        Topic.import columns, values, :validate => false
+        @topic = Topic.find 99
+      end
+    
+      context "using string column names" do
+        let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using symbol column names" do
+        let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+    
+      context "using string hash map" do
+        let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using string hash map, but specifying column mismatches" do
+        let(:update_columns){ { "title" => "author_email_address", "author_email_address" => "title", "parent_id" => "parent_id" } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned_with_hash_mappings
+      end
+  
+      context "using symbol hash map" do
+        let(:update_columns){ { :title => :title, :author_email_address => :author_email_address, :parent_id => :parent_id } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using symbol hash map, but specifying column mismatches" do
+        let(:update_columns){ { :title => :author_email_address, :author_email_address => :title, :parent_id => :parent_id } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned_with_hash_mappings
+      end
+    end
+  
+    context "given array of model instances with :validation checks turned off" do
+      macro(:perform_import) do |*opts|
+        @topic.title = "Book - 2nd Edition"
+        @topic.author_name = "Author Should Not Change"
+        @topic.author_email_address = "johndoe@example.com"
+        @topic.parent_id = 57
+        Topic.import [@topic], opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
+      end
+    
+      setup do
+        @topic = Generate(:topic, :id => 99, :author_name => "John Doe", :parent_id => 17)
+      end
+    
+      context "using string column names" do
+        let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using symbol column names" do
+        let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+    
+      context "using string hash map" do
+        let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using string hash map, but specifying column mismatches" do
+        let(:update_columns){ { "title" => "author_email_address", "author_email_address" => "title", "parent_id" => "parent_id" } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned_with_hash_mappings
+      end
+  
+      context "using symbol hash map" do
+        let(:update_columns){ { :title => :title, :author_email_address => :author_email_address, :parent_id => :parent_id } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned
+      end
+  
+      context "using symbol hash map, but specifying column mismatches" do
+        let(:update_columns){ { :title => :author_email_address, :author_email_address => :title, :parent_id => :parent_id } }
+        should_support_on_duplicate_key_update
+        should_update_fields_mentioned_with_hash_mappings
+      end
+    end
+  
+  end
+end

data/test/test_helper.rb

@@ -11,98 +11,29 @@ ENV["RAILS_ENV"] = "test"
 require "bundler"
 Bundler.setup
 
+require "logger"
 require "rails"
 require "rails/test_help"
+require "active_record"
 require "active_record/fixtures"
 require "active_support/test_case"
 
 require "delorean"
-
-require "active_record"
-require "logger"
-
 require "ruby-debug"
 
-# load test helpers
 class MyApplication < Rails::Application ; end
 adapter = ENV["ARE_DB"] || "sqlite3"
 
-# load the library
-require "activerecord-import/#{adapter}"
-
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-  self.use_transactional_fixtures = true
-  
-  class << self
-    def assertion(name, &block)
-      mc = class << self ; self ; end
-      mc.class_eval do
-        define_method(name) do
-          it(name, &block)
-        end
-      end
-    end
-    
-    def asssertion_group(name, &block)
-      mc = class << self ; self ; end
-      mc.class_eval do
-        define_method(name, &block)
-      end
-    end
-
-    def macro(name, &block)
-      class_eval do
-        define_method(name, &block)
-      end
-    end
-    
-    def describe(description, toplevel=nil, &blk)
-      text = toplevel ? description : "#{name} #{description}"
-      klass = Class.new(self)
-
-      klass.class_eval <<-RUBY_EVAL
-        def self.name
-          "#{text}"
-        end
-      RUBY_EVAL
-
-      # do not inherit test methods from the superclass
-      klass.class_eval do
-        instance_methods.grep(/^test.+/) do |method|
-          undef_method method
-        end
-      end
-
-      klass.instance_eval &blk
-    end
-    alias_method :context, :describe
-    
-    def let(name, &blk)
-      values = {}
-      define_method(name) do
-        return values[name] if values.has_key?(name)
-        values[name] = instance_eval(&blk)
-      end
-    end
-    
-    def it(description, &blk)
-      define_method("test: #{name} #{description}", &blk)
-    end
-  end
-  
-end
-
-def describe(description, &blk)
-  ActiveSupport::TestCase.describe(description, true, &blk)
-end
-
-FileUtils.mkdir_p'log'
+FileUtils.mkdir_p 'log'
 ActiveRecord::Base.logger = Logger.new("log/test.log")
 ActiveRecord::Base.logger.level = Logger::DEBUG
 ActiveRecord::Base.configurations["test"] = YAML.load(test_dir.join("database.yml").open)[adapter]
+
+
+require "activerecord-import"
 ActiveRecord::Base.establish_connection "test"
 
+
 ActiveSupport::Notifications.subscribe(/active_record.sql/) do |event, _, _, _, hsh|
   ActiveRecord::Base.logger.info hsh[:sql]
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-import
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Zach Dennis
@@ -15,26 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-10 00:00:00 -04:00
+date: 2010-09-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  type: :runtime
   prerelease: false
   version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7712042
+        hash: 416656576
         segments: 
         - 3
         - 0
-        - 0
-        - rc
-        version: 3.0.0.rc
-  requirement: *id001
+        - 0rc
+        version: 3.0.0rc
   name: rails
-  type: :runtime
+  requirement: *id001
 description: Extraction of the ActiveRecord::Base#import functionality from ar-extensions for Rails 3 and beyond
 email: zach.dennis@gmail.com
 executables: []
@@ -43,21 +42,31 @@ extensions: []
 
 extra_rdoc_files: 
 - README.markdown
+- README.textile
 files: 
 - README.markdown
+- README.textile
 - Rakefile
 - VERSION
+- lib/activerecord-import.rb
 - lib/activerecord-import/active_record/adapters/abstract_adapter.rb
+- lib/activerecord-import/active_record/adapters/mysql2_adapter.rb
 - lib/activerecord-import/active_record/adapters/mysql_adapter.rb
 - lib/activerecord-import/active_record/adapters/postgresql_adapter.rb
 - lib/activerecord-import/active_record/adapters/sqlite3_adapter.rb
+- lib/activerecord-import/adapters/abstract_adapter.rb
+- lib/activerecord-import/adapters/mysql_adapter.rb
+- lib/activerecord-import/adapters/postgresql_adapter.rb
+- lib/activerecord-import/adapters/sqlite3_adapter.rb
 - lib/activerecord-import/base.rb
 - lib/activerecord-import/import.rb
 - lib/activerecord-import/mysql.rb
+- lib/activerecord-import/mysql2.rb
 - lib/activerecord-import/postgresql.rb
 - lib/activerecord-import/sqlite3.rb
 - test/active_record/connection_adapter_test.rb
 - test/adapters/mysql.rb
+- test/adapters/mysql2.rb
 - test/adapters/postgresql.rb
 - test/adapters/sqlite3.rb
 - test/import_test.rb
@@ -65,12 +74,15 @@ files:
 - test/models/group.rb
 - test/models/topic.rb
 - test/mysql/import_test.rb
+- test/mysql2/import_test.rb
 - test/schema/generic_schema.rb
 - test/schema/mysql_schema.rb
 - test/schema/version.rb
+- test/support/active_support/test_case_extensions.rb
 - test/support/factories.rb
 - test/support/generate.rb
 - test/support/mysql/assertions.rb
+- test/support/mysql/import_examples.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/zdennis/activerecord-import
@@ -109,6 +121,7 @@ summary: Bulk-loading extension for ActiveRecord
 test_files: 
 - test/active_record/connection_adapter_test.rb
 - test/adapters/mysql.rb
+- test/adapters/mysql2.rb
 - test/adapters/postgresql.rb
 - test/adapters/sqlite3.rb
 - test/import_test.rb
@@ -116,10 +129,13 @@ test_files:
 - test/models/group.rb
 - test/models/topic.rb
 - test/mysql/import_test.rb
+- test/mysql2/import_test.rb
 - test/schema/generic_schema.rb
 - test/schema/mysql_schema.rb
 - test/schema/version.rb
+- test/support/active_support/test_case_extensions.rb
 - test/support/factories.rb
 - test/support/generate.rb
 - test/support/mysql/assertions.rb
+- test/support/mysql/import_examples.rb
 - test/test_helper.rb