Empact-activerecord-import 0.3.5 → 0.4.0

data/README.markdown

@@ -2,7 +2,7 @@
 
 activerecord-import is a library for bulk inserting data using ActiveRecord. 
 
-For more information on activerecord-import please see its wiki: http://wiki.github.com/zdennis/activerecord-import/
+For more information on activerecord-import please see its wiki: https://github.com/zdennis/activerecord-import/wiki
 
 # License
 

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.4.0

data/lib/activerecord-import.rb

@@ -2,15 +2,15 @@ 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)
+      ActiveSupport.run_load_hooks(:active_record_connection_established, connection_pool)
     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)
+ActiveSupport.on_load(:active_record_connection_established) do |connection_pool|
+  if !ActiveRecord.const_defined?(:Import) || !ActiveRecord::Import.respond_to?(:load_from_connection_pool)
     require File.join File.dirname(__FILE__),  "activerecord-import/base"
   end
-  ActiveRecord::Import.load_from_connection connection
+  ActiveRecord::Import.require_adapter connection_pool.spec.config[:adapter]
 end

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

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

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

@@ -2,5 +2,5 @@ require "active_record/connection_adapters/mysql_adapter"
 require "activerecord-import/adapters/mysql_adapter"
 
 class ActiveRecord::ConnectionAdapters::MysqlAdapter
-  include ActiveRecord::Import::MysqlAdapter::InstanceMethods
-end
+  include ActiveRecord::Import::MysqlAdapter
+end

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

@@ -2,6 +2,6 @@ require "active_record/connection_adapters/postgresql_adapter"
 require "activerecord-import/adapters/postgresql_adapter"
 
 class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-  include ActiveRecord::Import::PostgreSQLAdapter::InstanceMethods
+  include ActiveRecord::Import::PostgreSQLAdapter
 end
 

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

@@ -2,6 +2,6 @@ require "active_record/connection_adapters/sqlite3_adapter"
 require "activerecord-import/adapters/sqlite3_adapter"
 
 class ActiveRecord::ConnectionAdapters::Sqlite3Adapter
-  include ActiveRecord::Import::Sqlite3Adapter::InstanceMethods
+  include ActiveRecord::Import::Sqlite3Adapter
 end
 

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

@@ -45,7 +45,7 @@ module ActiveRecord::Import::AbstractAdapter
       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 = values.sum {|value| value.size }
+      values_in_bytes = values.sum {|value| value.bytesize }
 
       # the number of bytes (commas) it will take to comma separate our values
       comma_separated_bytes = values.size-1

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

@@ -1,59 +1,53 @@
 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 the maximum number of bytes that the server will allow
-    # in a single packet
-    def max_allowed_packet # :nodoc:
-      result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
-      # original Mysql gem responds to #fetch_row while Mysql2 responds to #first
-      val = result.respond_to?(:fetch_row) ? result.fetch_row[1] : result.first[1]
-      val.to_i
-    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
+  include ActiveRecord::Import::ImportSupport
+  include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
+
+  # Returns the maximum number of bytes that the server will allow
+  # in a single packet
+  def max_allowed_packet # :nodoc:
+    result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+    # original Mysql gem responds to #fetch_row while Mysql2 responds to #first
+    val = result.respond_to?(:fetch_row) ? result.fetch_row[1] : result.first[1]
+    val.to_i
+  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( ',' )
+  # 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
-  
-    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( ',')
+    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
 
-    #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')
+  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

@@ -1,13 +1,7 @@
 module ActiveRecord::Import::PostgreSQLAdapter
-  module InstanceMethods
-    def self.included(klass)
-      klass.instance_eval do
-        include ActiveRecord::Import::ImportSupport
-      end
-    end
+  include ActiveRecord::Import::ImportSupport
 
-    def next_value_for_sequence(sequence_name)
-      %{nextval('#{sequence_name}')}
-    end
+  def next_value_for_sequence(sequence_name)
+    %{nextval('#{sequence_name}')}
   end
 end

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

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

data/lib/activerecord-import/base.rb

@@ -1,28 +1,24 @@
-require "pathname"
-require "active_record"
-require "active_record/version"
-
 module ActiveRecord::Import
-  AdapterPath = File.join File.expand_path(File.dirname(__FILE__)), "/active_record/adapters"
+  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")
+  def self.base_adapter(adapter)
+    case adapter
+    when 'mysqlspatial' then 'mysql'
+    when 'spatialite' then 'sqlite3'
+    when 'postgis' then 'postgresql'
+    else adapter
+    end
   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
+  # Loads the import functionality for a specific database adapter
+  def self.require_adapter(adapter)
+    require File.join(AdapterPath, "abstract_adapter")
+    require File.join(AdapterPath, "#{base_adapter(adapter)}_adapter")
   end
 end
 
 
-this_dir = Pathname.new File.dirname(__FILE__)
-require this_dir.join("import").to_s
-require this_dir.join("active_record/adapters/abstract_adapter").to_s
-require this_dir.join("synchronize").to_s
+this_dir = File.dirname(__FILE__)
+require File.join(this_dir, "import")
+require File.join(this_dir, "active_record/adapters/abstract_adapter")
+require File.join(this_dir, "synchronize")

data/lib/activerecord-import/import.rb

@@ -1,17 +1,28 @@
-require "ostruct"
-
 module ActiveRecord::Import::ConnectionAdapters ; end
 
 module ActiveRecord::Import #:nodoc:
   class Result < Struct.new(:failed_instances, :num_inserts)
   end
 
+  # use tz as set in ActiveRecord::Base
+  tproc = lambda do
+    ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+  end
+
+  TIME_COLUMNS = {
+    :create => { "created_on" => tproc ,
+                 "created_at" => tproc },
+    :update => { "updated_on" => tproc ,
+                 "updated_at" => tproc }
+  }
+  TIME_COLUMN_NAMES = TIME_COLUMNS[:create].keys + TIME_COLUMNS[:update].keys
+
   module ImportSupport #:nodoc:
     def supports_import? #:nodoc:
       true
     end
   end
-  
+
   module OnDuplicateKeyUpdateSupport #:nodoc:
     def supports_on_duplicate_key_update? #:nodoc:
       true
@@ -21,44 +32,28 @@ end
 
 class ActiveRecord::Base
   class << self
-
-    # use tz as set in ActiveRecord::Base
-    tproc = lambda do
-      ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
-    end
-    
-    AREXT_RAILS_COLUMNS = {
-      :create => { "created_on" => tproc ,
-                   "created_at" => tproc },
-      :update => { "updated_on" => tproc ,
-                   "updated_at" => tproc }
-    }
-    AREXT_RAILS_COLUMN_NAMES = AREXT_RAILS_COLUMNS[:create].keys + AREXT_RAILS_COLUMNS[:update].keys
-  
     # Returns true if the current database connection adapter
     # supports import functionality, otherwise returns false.
     def supports_import?
-      connection.supports_import?
-    rescue NoMethodError
-      false
+      connection.respond_to?(:supports_import?) \
+        && connection.supports_import?
     end
 
     # Returns true if the current database connection adapter
     # supports on duplicate key update functionality, otherwise
     # returns false.
     def supports_on_duplicate_key_update?
-      connection.supports_on_duplicate_key_update?
-    rescue NoMethodError
-      false
+      connection.respond_to?(:supports_on_duplicate_key_update?) \
+        && connection.supports_on_duplicate_key_update?
     end
-    
-    # Imports a collection of values to the database.  
+
+    # Imports a collection of values to the database.
     #
     # This is more efficient than using ActiveRecord::Base#create or
     # ActiveRecord::Base#save multiple times. This method works well if
     # you want to create more than one record at a time and do not care
     # about having ActiveRecord objects returned for each record
-    # inserted. 
+    # inserted.
     #
     # This can be used with or without validations. It does not utilize
     # the ActiveRecord::Callbacks during creation/modification while
@@ -68,9 +63,9 @@ class ActiveRecord::Base
     #  Model.import array_of_models
     #  Model.import column_names, array_of_values
     #  Model.import column_names, array_of_values, options
-    # 
+    #
     # ==== Model.import array_of_models
-    # 
+    #
     # With this form you can call _import_ passing in an array of model
     # objects that you want updated.
     #
@@ -102,9 +97,9 @@ class ActiveRecord::Base
     # * +timestamps+ - true|false, tells import to not add timestamps \
     #   (if false) even if record timestamps is disabled in ActiveRecord::Base
     #
-    # == Examples  
+    # == Examples
     #  class BlogPost < ActiveRecord::Base ; end
-    #  
+    #
     #  # Example using array of model objects
     #  posts = [ BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT',
     #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT2',
@@ -114,7 +109,7 @@ class ActiveRecord::Base
     #  # Example using column_names and array_of_values
     #  columns = [ :author_name, :title ]
     #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
-    #  BlogPost.import columns, values 
+    #  BlogPost.import columns, values
     #
     #  # Example using column_names, array_of_value and options
     #  columns = [ :author_name, :title ]
@@ -136,8 +131,8 @@ class ActiveRecord::Base
     #
     # == On Duplicate Key Update (MySQL only)
     #
-    # The :on_duplicate_key_update option can be either an Array or a Hash. 
-    # 
+    # The :on_duplicate_key_update option can be either an Array or a Hash.
+    #
     # ==== Using an Array
     #
     # The :on_duplicate_key_update option can be an array of column
@@ -152,9 +147,9 @@ class ActiveRecord::Base
     # to model attribute name mappings. This gives you finer grained
     # control over what fields are updated with what attributes on your
     # model. Below is an example:
-    #   
-    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title } 
-    #  
+    #
+    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title }
+    #
     # = Returns
     # This returns an object which responds to +failed_instances+ and +num_inserts+.
     # * failed_instances - an array of objects that fails validation and were not committed to the database. An empty array if no validation is performed.
@@ -167,14 +162,9 @@ class ActiveRecord::Base
 
       # assume array of model objects
       if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
-        if args.length == 2
-          models = args.last
-          column_names = args.first
-        else
-          models = args.first
-          column_names = self.column_names.dup
-        end
-        
+        models = args.pop
+        column_names = args.first || self.column_names.dup
+
         array_of_attributes = models.map do |model|
           # this next line breaks sqlite.so with a segmentation fault
           # if model.new_record? || options[:on_duplicate_key_update]
@@ -221,26 +211,27 @@ class ActiveRecord::Base
         synchronize( options[:synchronize], sync_keys)
       end
 
-      return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
+      return_obj.num_inserts ||= 0
       return_obj
     end
-    
-    # TODO import_from_table needs to be implemented. 
+
+    # TODO import_from_table needs to be implemented.
     def import_from_table( options ) # :nodoc:
+      raise NotImplementedError, 'import_from_table needs to be implemented'
     end
-    
+
     # Imports the passed in +column_names+ and +array_of_attributes+
     # given the passed in +options+ Hash with validations. Returns an
-    # object with the methods +failed_instances+ and +num_inserts+. 
-    # +failed_instances+ is an array of instances that failed validations. 
+    # object with the methods +failed_instances+ and +num_inserts+.
+    # +failed_instances+ is an array of instances that failed validations.
     # +num_inserts+ is the number of inserts it took to import the data. See
     # ActiveRecord::Base.import for more information on
     # +column_names+, +array_of_attributes+ and +options+.
     def import_with_validations( column_names, array_of_attributes, options={} )
       failed_instances = []
-    
+
       # create instances for each of our column/value sets
-      arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )    
+      arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )
 
       # keep track of the instance and the position it is currently at. if this fails
       # validation we'll use the index to remove it from the array_of_attributes
@@ -251,14 +242,14 @@ class ActiveRecord::Base
         if not instance.valid?
           array_of_attributes[ i ] = nil
           failed_instances << instance
-        end    
+        end
       end
       array_of_attributes.compact!
-      
+
       num_inserts = array_of_attributes.empty? ? 0 : import_without_validations_or_callbacks( column_names, array_of_attributes, options )
       ActiveRecord::Import::Result.new(failed_instances, num_inserts)
     end
-    
+
     # Imports the passed in +column_names+ and +array_of_attributes+
     # given the passed in +options+ Hash. This will return the number
     # of insert operations it took to create these records without
@@ -280,11 +271,13 @@ class ActiveRecord::Base
       else
         # generate the sql
         post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
-        
+
         # perform the inserts
-        number_inserted = connection.insert_many( [ insert_sql, post_sql_statements ].flatten, 
-                                                  values_sql,
-                                                  "#{self.class.name} Create Many Without Validations Or Callbacks" )
+        number_inserted = connection.insert_many(
+          [ insert_sql, post_sql_statements ].flatten,
+          values_sql,
+          "#{self.class.name} Create Many Without Validations Or Callbacks"
+        )
       end
       number_inserted
     end
@@ -294,13 +287,17 @@ class ActiveRecord::Base
     # Returns SQL the VALUES for an INSERT statement given the passed in +columns+
     # and +array_of_attributes+.
     def values_sql_for_columns_and_attributes(columns, array_of_attributes)   # :nodoc:
+      # connection gets called a *lot* in this high intensity loop.
+      # Reuse the same one w/in the loop, otherwise it would keep being re-retreived (= lots of time for large imports)
+      connection_memo = connection
       array_of_attributes.map do |arr|
         my_values = arr.each_with_index.map do |val,j|
           column = columns[j]
-          if !sequence_name.blank? && column.name == primary_key && val.nil?
-             connection.next_value_for_sequence(sequence_name)
+          # be sure to query sequence_name *last*, only if cheaper tests fail, because it's costly
+          if val.nil? && column.name == primary_key && !sequence_name.blank?
+            connection_memo.next_value_for_sequence(sequence_name)
           else
-            connection.quote(column.type_cast(val), column)
+            connection_memo.quote(val, column) # no need for column.type_cast(val) - quote already does type casting
           end
         end
         "(#{my_values.join(',')})"
@@ -308,7 +305,7 @@ class ActiveRecord::Base
     end
 
     def add_special_rails_stamps( column_names, array_of_attributes, options )
-      AREXT_RAILS_COLUMNS[:create].each_pair do |key, blk|
+      ActiveRecord::Import::TIME_COLUMNS[:create].each_pair do |key, blk|
         if self.column_names.include?(key)
           value = blk.call
           if index=column_names.index(key)
@@ -321,7 +318,7 @@ class ActiveRecord::Base
         end
       end
 
-      AREXT_RAILS_COLUMNS[:update].each_pair do |key, blk|
+      ActiveRecord::Import::TIME_COLUMNS[:update].each_pair do |key, blk|
         if self.column_names.include?(key)
           value = blk.call
           if index=column_names.index(key)
@@ -331,11 +328,13 @@ class ActiveRecord::Base
             column_names << key
             array_of_attributes.each { |arr| arr << value }
           end
-          
+
           if supports_on_duplicate_key_update?
-            if options[:on_duplicate_key_update]
-              options[:on_duplicate_key_update] << key.to_sym if options[:on_duplicate_key_update].is_a?(Array)
-              options[:on_duplicate_key_update][key.to_sym] = key.to_sym if options[:on_duplicate_key_update].is_a?(Hash)
+            case options[:on_duplicate_key_update]
+            when Array
+              options[:on_duplicate_key_update] << key.to_sym
+            when Hash
+              options[:on_duplicate_key_update][key.to_sym] = key.to_sym
             else
               options[:on_duplicate_key_update] = [ key.to_sym ]
             end
@@ -343,13 +342,13 @@ class ActiveRecord::Base
         end
       end
     end
-    
+
     # Returns an Array of Hashes for the passed in +column_names+ and +array_of_attributes+.
     def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
       array_of_attributes.map do |attributes|
         Hash[attributes.each_with_index.map {|attr, c| [column_names[c], attr] }]
       end
     end
-    
+
   end
 end

data/lib/activerecord-import/synchronize.rb

@@ -1,10 +1,10 @@
 module ActiveRecord # :nodoc:
   class Base # :nodoc:
-      
+
     # Synchronizes the passed in ActiveRecord instances with data
     # from the database. This is like calling reload on an individual
-    # ActiveRecord instance but it is intended for use on multiple instances. 
-    # 
+    # ActiveRecord instance but it is intended for use on multiple instances.
+    #
     # This uses one query for all instance updates and then updates existing
     # instances rather sending one query for each instance
     #
@@ -14,7 +14,7 @@ module ActiveRecord # :nodoc:
     # <.. out of system changes occur to change author name from Zach to Zachary..>
     # Post.synchronize posts
     # posts.first.author # => "Zachary" instead of Zach
-    # 
+    #
     # # Synchronizing using custom key fields
     # posts = Post.find_by_author("Zach")
     # <.. out of system changes occur to change the address of author 'Zach' to 1245 Foo Ln ..>
@@ -26,11 +26,11 @@ module ActiveRecord # :nodoc:
 
       conditions = {}
       order = ""
-      
+
       key_values = keys.map { |key| instances.map(&"#{key}".to_sym) }
       keys.zip(key_values).each { |key, values| conditions[key] = values }
       order = keys.map{ |key| "#{key} ASC" }.join(",")
-      
+
       klass = instances.first.class
 
       fresh_instances = klass.find( :all, :conditions=>conditions, :order=>order )
@@ -38,7 +38,7 @@ module ActiveRecord # :nodoc:
         matched_instance = fresh_instances.detect do |fresh_instance|
           keys.all?{ |key| fresh_instance.send(key) == instance.send(key) }
         end
-        
+
         if matched_instance
           instance.clear_aggregation_cache
           instance.clear_association_cache

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Empact-activerecord-import
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-26 00:00:00.000000000Z
+date: 2012-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2151988300 !ruby/object:Gem::Requirement
+  requirement: &70265403670100 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151988300
+  version_requirements: *70265403670100
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2151971820 !ruby/object:Gem::Requirement
+  requirement: &70265403669060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151971820
+  version_requirements: *70265403669060
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2151967900 !ruby/object:Gem::Requirement
+  requirement: &70265403667660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,18 +44,18 @@ dependencies:
         version: 1.4.0
   type: :development
   prerelease: false
-  version_requirements: *2151967900
+  version_requirements: *70265403667660
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2151962680 !ruby/object:Gem::Requirement
+  requirement: &70265403666900 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151962680
+  version_requirements: *70265403666900
 description: Extraction of the ActiveRecord::Base#import functionality from ar-extensions
   for Rails 3 and beyond
 email: ben.woosley@gmail.com
@@ -95,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2232322125532575640
+      hash: 328182919252473110
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Bulk-loading extension for ActiveRecord