active_admin_import 2.0.1 → 2.1.0.rc1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODA4MTJlNTI0ODA4ZWUxZDcwODU4NjRhOWI4NzNlNzliNTE2MzliNA==
+  data.tar.gz: !binary |-
+    ZjkzY2M0MWZiOTk4OGNhZDg4ODllYWJiNjQyYjgyYWNiMWRlNzUzZg==
+SHA512:
+  metadata.gz: !binary |-
+    M2I5NTVkM2Y4NTI5MzgzNGMxNDU5MTYxYjc5NjY4MzU1Yzc5NTVkNjE3MDAx
+    MzQyMmFlMTgyNTRjMGJkNDYzZGFhZTM2MzJlOGRjZDcyNGQzYTFlMDgwMjYz
+    MjlhMjE2NGUwZDU1NjM4ZTNhZDM5ZGFkYTk3NzY3ZThiY2I0NWU=
+  data.tar.gz: !binary |-
+    MzQzZWNjYTkxYmM1NmE3NjBhNmUzOTIzM2Y2YjZkMWJkZWI1NDg1NTFiMjU4
+    ODM3NzRhNmE1M2FiM2I0OGFmMzM0OGZkNDhjNDE4MjJlNTlkZGY2ZmQzNGRm
+    MTI3ZjlkOTFiMDlmYmFjYjVhN2VjOGFkOGVmMjMwNDlhNDc0MDQ=

data/README.md

@@ -1,25 +1,42 @@
-# ActiveAdminImport
+# ActiveAdminImport 
 The most fastest and efficient CSV import for Active Admin (based on activerecord-import gem) 
 with support of validations and bulk inserts 
 
 
-#Links
-https://github.com/gregbell/active_admin
+Current master works with AA 0-6-stable branch
 
-https://github.com/zdennis/activerecord-import
+#Why yet another import for ActiveAdmin ? Now with activerecord-import ....
+
+    "Because plain-vanilla, out-of-the-box ActiveRecord doesn’t provide support for inserting large amounts of data efficiently"
+
+cool features of activerecord-import
+
+    activerecord-import can perform validations (fast)
+    activerecord-import can perform on duplicate key updates (requires mysql)
 
 
+#So active_admin_import features
+
+    Encoding handling
+    Support importing with ZIP file
+    Two step importing (see example2)
+    CSV options
+    Ability to prepend CSV headers automatically
+    Bulk import (activerecord-import)
+    Ability to customize template 
+    Callbacks support
+    and more ....
+
 #Options
 
     # +back+:: resource action to redirect after processing
-    # +col_sep+:: column separator used for CSV parsing
+    # +csv_options+:: hash with column separator, row separator, etc 
     # +validate+:: true|false, means perfoem validations or not
     # +batch_size+:: integer value of max  record count inserted by 1 query/transaction
     # +before_import+:: proc for before import action, hook called with  importer object
     # +after_import+:: proc for after import action, hook called with  importer object
     # +before_batch_import+:: proc for before each batch action, called with  importer object
     # +after_batch_import+:: proc for after each batch action, called with  importer object
-    # +fetch_extra_options_from_params+:: params  available in callbacks ( importer.extra_options proprty hash ) 
     # +on_duplicate_key_update+:: an Array or Hash, tells activerecord-import to use MySQL's ON DUPLICATE KEY UPDATE ability.
     # +timestamps+::  true|false, tells activerecord-import to not add timestamps (if false) even if record timestamps is disabled in ActiveRecord::Base
     # +ignore+::  true|false, tells activerecord-import toto use MySQL's INSERT IGNORE ability
@@ -33,24 +50,23 @@ https://github.com/zdennis/activerecord-import
 
 
 
-Default options values
-
-    :back => :import,
-    :col_sep => ',',
-    :template => "admin/import",
-    :template_object => ActiveAdminImport::Model.new,
-    :fetch_extra_options_from_params => [],
-    :resource_class => nil,
-    :resource_label => nil,
+#Default options values
+    
+    back: {action: :import},
+    csv_options: {},
+    template: "admin/import",
+    fetch_extra_options_from_params: [],
+    resource_class: config.resource_class,
+    resource_label:  config.resource_label,
+    plural_resource_label: config.plural_resource_label,
     
 
-#Example
+#Example1 
   
     ActiveAdmin.register Post  do
        active_admin_import :validate => false,
-                            :col_sep => ',',
-                            :back => :index ,
-                            :before_import => proc{|importer|  resource.delete_all},
+                            :csv_options => {:col_sep => ";" },
+                            :before_import => proc{ Post.delete_all},
                             :batch_size => 1000
     
     
@@ -58,6 +74,113 @@ Default options values
 
 
 
+#Example2 Importing to mediate table with insert select operation after import completion
+
+This config allows to replace data without downtime
+
+    ActiveAdmin.register Post  do
+        active_admin_import :validate => false,
+            :csv_options => {:col_sep => ";" },
+            :resource_class => ImportedPost ,  # we import data into another resource
+            :before_import => proc{ ImportedPost.delete_all },
+            :after_import => proc{
+                Post.transaction do
+                    Post.delete_all
+                    Post.connection.execute("INSERT INTO posts (SELECT * FROM import_posts)")
+                end
+            },
+            :back => proc { config.namespace.resource_for(Post).route_collection_path } # redirect to post index
+    end
+
+
+
+#Example3 Importing file without headers, but we always know file format, so we can predefine it
+
+    ActiveAdmin.register Post  do
+        active_admin_import :validate => true,
+            :template_object => ActiveAdminImport::Model.new(
+                :hint => "file will be imported with such header format: 'body','title','author'",
+                :csv_headers => ["body","title","author"] 
+            )
+    end
+
+ 
+#Example4 Importing without forcing to UTF-8 and disallow archives
+
+    ActiveAdmin.register Post  do
+        active_admin_import :validate => true,
+            :template_object => ActiveAdminImport::Model.new(
+                :hint => "file will be encoded to ISO-8859-1",
+                :force_encoding => "ISO-8859-1",
+                :allow_archive => false  
+            )
+    end
+
+
+
+#Example5 Callbacks for each bulk insert iteration
+
+    ActiveAdmin.register Post  do
+        active_admin_import :validate => true,
+        :before_batch_import => proc { |import|
+           import.file #current file used
+           import.resource #ActiveRecord class to import to
+           import.options # options
+           import.result # result before bulk iteration
+           import.headers # CSV headers
+           import.csv_lines #lines to import
+           import.model #template_object instance
+        },
+        :before_batch_import => proc{ |import|
+        
+        }
+    end
+    
+    
+#Example6 dynamic CSV options, template overriding
+
+1) put overrided template to app/views/import.html.erb
+
+
+    <p>
+      <small> <%= raw(@active_admin_import_model.hint) %> </small>
+    </p>
+    <%= semantic_form_for @active_admin_import_model, url: {action: :do_import}, html: {multipart: true} do |f| %>
+        <%= f.inputs do %>
+            <%= f.input :file, as: :file %>
+        <% end %>
+        <%= f.inputs "CSV options", :for => [:csv_options, OpenStruct.new(@active_admin_import_model.csv_options)] do |csv| %>
+            <% csv.with_options :input_html => {:style => 'width:40px;'} do |opts| %>
+                <%= opts.input :col_sep %>
+                <%= opts.input :row_sep %>
+                <%= opts.input :quote_char %>
+            <% end %>
+        <% end %>
+    
+        <%= f.actions do %>
+            <%= f.action :submit, label: t("active_admin_import.import_btn"), button_html: {disable_with: t("active_admin_import.import_btn_disabled")} %>
+        <% end %>
+    <% end %>
+    
+
+
+2) call method with following parameters
+
+    ActiveAdmin.register Post  do
+        active_admin_import :validate => false,
+                          :template => 'import' ,
+                          :template_object => ActiveAdminImport::Model.new(
+                              :hint => "specify CSV options"
+                              :csv_options => {:col_sep => ";", :row_sep => nil, :quote_char => nil} 
+                          )
+    end                      
+
+
+#Links
+https://github.com/gregbell/active_admin
+
+https://github.com/zdennis/activerecord-import
+
 #Source Doc
-http://rubydoc.info/gems/active_admin_import/2.0.0/
+http://rubydoc.info/gems/active_admin_import/2.1.0/
 

data/active_admin_import.gemspec

@@ -2,18 +2,22 @@
 require File.expand_path('../lib/active_admin_import/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Igor Fedoronchuk"]
-  gem.email         = ["fedoronchuk@gmail.com"]
-  gem.description   = "The most efficient way to import for Active Admin"
-  gem.summary       = "ActiveAdmin import based on activerecord-import gem."
-  gem.homepage      = "http://github.com/Fivell/active_admin_import"
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "active_admin_import"
+  gem.authors = ["Igor Fedoronchuk"]
+  gem.email = ["fedoronchuk@gmail.com"]
+  gem.description = "The most efficient way to import for Active Admin"
+  gem.summary = "ActiveAdmin import based on activerecord-import gem."
+  gem.homepage = "http://github.com/Fivell/active_admin_import"
+  gem.license = 'MIT'
+  gem.files = `git ls-files`.split($\)
+  gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name = "active_admin_import"
   gem.require_paths = ["lib"]
-  gem.version       = ActiveAdminImport::VERSION
+  gem.version = ActiveAdminImport::VERSION << '.rc1'
+
+  gem.add_runtime_dependency 'activerecord-import',  '~> 0.4', '>= 0.4.1'
+  gem.add_runtime_dependency 'activeadmin', '~> 0.6', '>= 0.6.0'
+  gem.add_runtime_dependency 'zip', '~> 1.0', '>= 1.0.0'
+
 
-  gem.add_runtime_dependency('activerecord-import','0.3.0')
 end

data/app/views/admin/import.html.erb

@@ -1,11 +1,11 @@
-    <p>
-       <small> <%= raw(@active_admin_import_model.hint)  %> </small>
-    </p>
-<%= semantic_form_for @active_admin_import_model ,  :url => {:action => :do_import}, :html => {:multipart => true} do |f| %>
+<p>
+  <small> <%= raw(@active_admin_import_model.hint) %> </small>
+</p>
+<%= semantic_form_for @active_admin_import_model, url: {action: :do_import}, html: {multipart: true} do |f| %>
     <%= f.inputs do %>
-    <%= f.input :file, :as=>:file %>
+        <%= f.input :file, as: :file %>
+    <% end %>
+    <%= f.actions do %>
+        <%= f.action :submit, label: t("active_admin_import.import_btn"), button_html: {disable_with: t("active_admin_import.import_btn_disabled")} %>
     <% end %>
-     <%= f.actions do %>
-    <%= f.action :submit , :label =>t("active_admin_import.import_btn") ,:button_html => { :disable_with => t("active_admin_import.import_btn_disabled") }%>
-        <% end %>
 <% end %>

data/lib/active_admin_import/dsl.rb

@@ -1,12 +1,12 @@
 module ActiveAdminImport
   module DSL
-
-
     # Declares import functionality
     #
     # Options
     # +back+:: resource action to redirect after processing
-    # +col_sep+:: column separator used for CSV parsing
+    # +col_sep+:: column separator used for CSV parsing (deprecated)
+    # +row_sep+:: column separator used for CSV parsing  (deprecated)
+    # +csv_options+:: hash to override default CSV options
     # +validate+:: true|false, means perfoem validations or not
     # +batch_size+:: integer value of max  record count inserted by 1 query/transaction
     # +before_import+:: proc for before import action, hook called with  importer object
@@ -15,83 +15,64 @@ module ActiveAdminImport
     # +after_batch_import+:: proc for after each batch action, called with  importer object
     # +on_duplicate_key_update+:: an Array or Hash, tells activerecord-import to use MySQL's ON DUPLICATE KEY UPDATE ability.
     # +timestamps+::  true|false, tells activerecord-import to not add timestamps (if false) even if record timestamps is disabled in ActiveRecord::Base
-    # +ignore+::  true|false, tells activerecord-import toto use MySQL's INSERT IGNORE ability
-    # +fetch_extra_options_from_params+:: params values available in callbacks in importer.extra_options hash
+    # +ignore+::  true|false, tells activerecord-import to use MySQL's INSERT IGNORE ability
     # +template+:: custom template rendering
     # +template_object+:: object passing to view
-    # +resource_class+:: resource class name
-    # +resource_label+:: resource label value
+    # +resource_class+:: resource class name, override to import to another table (default config.resource_class)
+    # +resource_label+:: resource label value (default config.resource_label)
+    # +plural_resource_label+:: plaralized resource label value (default config.plural_resource_label)
     #
     def active_admin_import options = {}
       default_options = {
-          :back => :import,
-          :col_sep => ',',
-          :template => "admin/import",
-          :template_object => ActiveAdminImport::Model.new,
-          :fetch_extra_options_from_params => [],
-          :resource_class => nil,
-          :resource_label => nil,
-          :headers_rewrites => {}
-
-
+          back: {action: :import},
+          csv_options: {},
+          template: "admin/import",
+          fetch_extra_options_from_params: [],
+          resource_class: config.resource_class,
+          resource_label:  config.resource_label,
+          plural_resource_label: config.plural_resource_label,
+          headers_rewrites: {}
       }
-      options = default_options.merge(options)
+      options = default_options.deep_merge(options)
+      options[:template_object] =  ActiveAdminImport::Model.new if options[:template_object].blank?
       params_key = ActiveModel::Naming.param_key(options[:template_object])
 
-
-      collection_action :import, :method => :get do
+      collection_action :import, method: :get do
         @active_admin_import_model = options[:template_object]
-        render :template => options[:template]
+        render template: options[:template]
       end
 
-
-      action_item :only => :index do
-        link_to(I18n.t('active_admin_import.import_model',
-                :model => (options[:resource_label] || active_admin_config.resource_name)),
-                        :action => 'import')
+      action_item only: :index do
+        link_to(I18n.t('active_admin_import.import_model', model: options[:resource_label]), action: 'import')
       end
 
+      collection_action :do_import, method: :post do
 
-      collection_action :do_import, :method => :post do
-        if params[params_key].blank?
-          flash[:alert] =  I18n.t('active_admin_import.no_file_error')
-          return redirect_to :back
-        end
-        content_types_allow = [
-            'text/csv',
-            'text/x-csv',
-            'text/comma-separated-values',
-            'application/csv',
-            'application/vnd.ms-excel',
-            'application/vnd.msexcel'
-        ]
-        unless params[params_key]['file'].try(:content_type) && params[params_key]['file'].content_type.in?(content_types_allow)
-          flash[:alert] = I18n.t('active_admin_import.file_format_error')
-          return redirect_to :back
-        end
-
-        importer = Importer.new((options[:resource_class] || active_admin_config.resource_class),
-                                params[params_key][:file],
-                                options,
-                                params[params_key].to_hash.slice(*options[:fetch_extra_options_from_params])
+        @active_admin_import_model =  options[:template_object]
+        @active_admin_import_model.assign_attributes(params[params_key].try(:deep_symbolize_keys) || {})
+        #go back to form
+        return render template: options[:template] unless @active_admin_import_model.valid?
+        
+        importer = Importer.new(options[:resource_class],
+                                @active_admin_import_model,
+                                options
         )
         result = importer.import
-
+        model_name =  options[:resource_label].downcase
+        plural_model_name = options[:resource_label].downcase
         flash[:notice] =  I18n.t('active_admin_import.imported',
-                                    :count=> result[:imported].to_i,
-                                    :model => (options[:resource_label] || active_admin_config.resource_label).downcase,
-                                    :plural_model =>  (options[:resource_label].present? ? options[:resource_label].to_s.pluralize : active_admin_config.plural_resource_label).downcase
-
-                                ) if  result[:imported].to_i > 0
+                                    count: result[:imported].to_i,
+                                    model: model_name,
+                                    plural_model: plural_model_name
+                                ) if result[:imported].to_i > 0
 
         flash[:error] =  I18n.t('active_admin_import.failed',
-                                    :count=> result[:failed].count,
-                                    :model => (options[:resource_label] || active_admin_config.resource_label).downcase,
-                                     :plural_model =>  (options[:resource_label].present? ? options[:resource_label].to_s.pluralize : active_admin_config.plural_resource_label).downcase
-
+                                    count: result[:failed].count,
+                                    model: model_name,
+                                    plural_model: plural_model_name
                                 ) if  result[:failed].count > 0
 
-        redirect_to :action => options[:back]
+        redirect_to options[:back]
       end
 
     end

data/lib/active_admin_import/importer.rb

@@ -2,65 +2,68 @@ require 'csv'
 module ActiveAdminImport
   class Importer
 
-    attr_reader :resource, :file, :options , :extra_options , :result ,
-    :cycle_data, :headers , :csv_lines
+    attr_reader :resource,  :options, :result, :headers, :csv_lines, :model
 
     def store
       result = @resource.transaction do
         options[:before_batch_import].call(self) if options[:before_batch_import].is_a?(Proc)
 
-
         result = resource.import headers.values, csv_lines, {
-            :validate => options[:validate],
-            :on_duplicate_key_update => options[:on_duplicate_key_update],
-            :ignore => options[:ignore],
-            :timestamps => options[:timestamps]
+            validate: options[:validate],
+            on_duplicate_key_update: options[:on_duplicate_key_update],
+            ignore: options[:ignore],
+            timestamps: options[:timestamps]
         }
         options[:after_batch_import].call(self) if options[:after_batch_import].is_a?(Proc)
         result
       end
-      {:imported => csv_lines.count -  result.failed_instances.count , :failed => result.failed_instances}
+      {imported: csv_lines.count - result.failed_instances.count, failed: result.failed_instances}
     end
 
+    #
     def prepare_headers(headers)
-      @headers =  Hash[headers.zip(headers.map { |el| el.underscore.gsub(/\s+/, '_') })]
+      @headers = Hash[headers.zip(headers.map { |el| el.underscore.gsub(/\s+/, '_') })]
       @headers.merge!(options[:headers_rewrites])
       @headers
     end
 
-    def initialize resource, file, options , extra_options = nil
+    def initialize(resource, model, options)
       @resource = resource
-      @file = file
-      @options = {
-          :col_sep => ',',
-          :batch_size => 1000,
-          :validate => true
-      }.merge(options)
-      @headers = []
-      @result= {
-        :failed => [],
-        :imported => 0
-      }
-      @extra_options = extra_options
-      @csv_options = @options.slice(:col_sep, :row_sep)
+      @model = model
+      @options = {batch_size: 1000, validate: true}.merge(options)
+      @headers = model.respond_to?(:csv_headers) ? model.csv_headers : []
+      @result= {failed: [], imported: 0}
+      if @options.has_key?(:col_sep) || @options.has_key?(:row_sep)
+        ActiveSupport::Deprecation.warn "row_sep and col_sep options are deprecated, use csv_options to override default CSV options"
+        @csv_options = @options.slice(:col_sep, :row_sep)
+      else
+        @csv_options = @options[:csv_options] || {}
+      end
+      #override csv options from model if it respond_to csv_options
+      @csv_options =  model.csv_options if model.respond_to?(:csv_options)
+      @csv_options.reject! {| key, value | value.blank? }
+
+    end
+
+    def file
+      @model.file
     end
 
     def cycle(lines)
-       @csv_lines = CSV.parse(lines.join, @csv_options)
-       @result.merge!(self.store){|key,val1,val2| val1+val2}
+      @csv_lines = CSV.parse(lines.join, @csv_options)
+      @result.merge!(self.store) { |key, val1, val2| val1+val2 }
     end
 
     def import
       options[:before_import].call(self) if options[:before_import].is_a?(Proc)
       lines = []
       batch_size = options[:batch_size].to_i
-      IO.foreach(file.path) do |line|
-        next if line.blank?
-        if headers.empty?
-          prepare_headers(CSV.parse(line, @csv_options).first)
-        else
+      File.open(file.path) do |f|
+        # capture headers if not exist
+        prepare_headers(headers.any? ? headers : CSV.parse(f.readline, @csv_options).first)
+        f.each_line do |line|
           lines << line
-          if lines.size >= batch_size
+          if lines.size == batch_size || f.eof?
             cycle lines
             lines = []
           end

data/lib/active_admin_import/model.rb

@@ -2,26 +2,120 @@ module ActiveAdminImport
   class Model
     extend ActiveModel::Naming
     include ActiveModel::Conversion
-    
-    attr_accessor :file
-    attr_accessor :hint 
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+
+    validates :file, presence: {message: Proc.new { I18n.t('active_admin_import.no_file_error') }},
+              unless: proc { |me| me.new_record? }
+
+    validate :correct_content_type
+
+    before_validation :uncompress_file, if: proc { |me| me.archive? && me.allow_archive?  }
+    before_validation :encode_file,  if: proc { |me| me.force_encoding? && me.file.present? }
+
     attr_reader :attributes
-    
-    def initialize(attributes={})
-      self.hint= attributes.delete(:hint)
-      @attributes = attributes
-      @attributes.each do |key,value|
-              #generate methods for instance object by attributes
-              singleton_class.class_eval do
-                define_method(key) { self.attributes[key] } unless method_defined? key
-                define_method("#{key}=") { |new_value|  @attributes[key] = new_value } unless method_defined? "#{key}="
-              end
+
+    def initialize(args={})
+      @new_record = true
+      @attributes = {}
+      assign_attributes(default_attributes.merge(args), true)
+    end
+
+    def assign_attributes(args = {}, new_record = false)
+      @attributes.merge!(args)
+      @new_record = new_record
+      args.keys.each do |key|
+        key = key.to_sym
+        #generate methods for instance object by attributes
+        singleton_class.class_eval do
+          define_method(key) { self.attributes[key] } unless method_defined? key
+          define_method("#{key}=") { |new_value| @attributes[key] = new_value } unless method_defined? "#{key}="
         end
+      end if args.is_a?(Hash)
+    end
+
+    def read_attribute_for_validation(key)
+      @attributes[key.to_sym]
+    end
+
+    def default_attributes
+      {hint: '', file: nil, csv_headers: [], allow_archive: true, force_encoding: 'UTF-8'}
+    end
+
+    def allow_archive?
+      !!@attributes[:allow_archive]
+    end
+
+    def new_record?
+      !!@new_record
+    end
+
+    def force_encoding?
+      !!@attributes[:force_encoding]
+    end
+
+    def to_hash
+      @attributes
     end
 
     def persisted?
       false
     end
 
+    def archive?
+      file_type == 'application/zip'
+    end
+
+    protected
+
+    def file_path
+      if file.is_a? ActionDispatch::Http::UploadedFile
+        file.tempfile.path
+      else
+        file.path
+      end
+    end
+
+    def encode_file
+      data = File.read(file_path).encode(force_encoding, invalid: :replace, undef: :replace)
+      File.open(file_path, 'w') do |f|
+          f.write(data)
+      end
+    end
+
+    def uncompress_file
+      Zip::ZipFile.open(file_path) do |zip_file|
+        self.file = Tempfile.new("active-admin-import-unzipped")
+        data = zip_file.entries.select { |f| f.file? }.first.get_input_stream.read
+        data = data.encode(force_encoding, invalid: :replace, undef: :replace) if self.force_encoding?
+        self.file << data
+        self.file.close
+      end
+    end
+
+
+    def csv_allowed_types
+      [
+          'text/csv',
+          'text/x-csv',
+          'text/comma-separated-values',
+          'application/csv',
+          'application/vnd.ms-excel',
+          'application/vnd.msexcel'
+      ]
+    end
+
+
+    def correct_content_type
+      unless file.blank? || file.is_a?(Tempfile)
+        errors.add(:file, I18n.t('active_admin_import.file_format_error')) unless csv_allowed_types.include? file_type
+      end
+    end
+
+    def file_type
+      file.try(:content_type).try(:chomp)
+    end
   end
 end
+
+

data/lib/active_admin_import/version.rb

@@ -1,3 +1,3 @@
 module ActiveAdminImport
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,27 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: active_admin_import
 version: !ruby/object:Gem::Version
-  version: 2.0.1
-  prerelease: 
+  version: 2.1.0.rc1
 platform: ruby
 authors:
 - Igor Fedoronchuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-11 00:00:00.000000000 Z
+date: 2014-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-import
-  requirement: &70227838555100 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - =
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: activeadmin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: zip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70227838555100
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: The most efficient way to import for Active Admin
 email:
 - fedoronchuk@gmail.com
@@ -45,28 +93,28 @@ files:
 - lib/active_admin_import/model.rb
 - lib/active_admin_import/version.rb
 homepage: http://github.com/Fivell/active_admin_import
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ActiveAdmin import based on activerecord-import gem.
 test_files: []
 has_rdoc: