active_admin_import 3.0.0.pre → 3.0.0

data/lib/active_admin_import/engine.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
 require 'rails'
 
 module ActiveAdminImport
   class Engine < ::Rails::Engine
-
     config.mount_at = '/'
-
   end
-end
+end

data/lib/active_admin_import/import_result.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdminImport
   class ImportResult
     attr_reader :failed, :total
@@ -16,12 +17,12 @@ module ActiveAdminImport
       total - failed.count
     end
 
-    def has_imported?
+    def imported?
       imported_qty > 0
     end
 
-    def has_failed?
-      @failed.any?
+    def failed?
+      failed.any?
     end
 
     def empty?
@@ -29,11 +30,11 @@ module ActiveAdminImport
     end
 
     def failed_message(options = {})
-      limit = options.fetch(:limit, failed.count)
-      failed.first(limit).map{|record|
+      limit = options[:limit] || failed.count
+      failed.first(limit).map do |record|
         errors = record.errors
-        (errors.full_messages.zip errors.keys.map{|k| record.send k}).map{|ms| ms.join(' - ')}.join(', ')
-      }.join(" ; ")
+        (errors.full_messages.zip errors.keys.map { |k| record.send k }).map { |ms| ms.join(' - ') }.join(', ')
+      end.join(' ; ')
     end
   end
-end
+end

data/lib/active_admin_import/importer.rb

@@ -1,23 +1,23 @@
+# frozen_string_literal: true
 require 'csv'
 module ActiveAdminImport
   class Importer
-
     attr_reader :resource, :options, :result, :model
     attr_accessor :csv_lines, :headers
 
     OPTIONS = [
-        :validate,
-        :on_duplicate_key_update,
-        :ignore,
-        :timestamps,
-        :before_import,
-        :after_import,
-        :before_batch_import,
-        :after_batch_import,
-        :headers_rewrites,
-        :batch_size,
-        :batch_transaction,
-        :csv_options
+      :validate,
+      :on_duplicate_key_update,
+      :ignore,
+      :timestamps,
+      :before_import,
+      :after_import,
+      :before_batch_import,
+      :after_batch_import,
+      :headers_rewrites,
+      :batch_size,
+      :batch_transaction,
+      :csv_options
     ].freeze
 
     def initialize(resource, model, options)
@@ -55,7 +55,7 @@ module ActiveAdminImport
       index = header_index(header_key)
       csv_lines.map! do |line|
         from = line[index]
-        line[index] = options[from] if options.has_key?(from)
+        line[index] = options[from] if options.key?(from)
         line
       end
     end
@@ -71,7 +71,8 @@ module ActiveAdminImport
     protected
 
     def process_file
-      lines, batch_size = [], options[:batch_size].to_i
+      lines = []
+      batch_size = options[:batch_size].to_i
       File.open(file.path) do |f|
         # capture headers if not exist
         prepare_headers { CSV.parse(f.readline, @csv_options).first }
@@ -109,7 +110,7 @@ module ActiveAdminImport
     end
 
     def assign_options(options)
-      @options = {batch_size: 1000, validate: true}.merge(options.slice(*OPTIONS))
+      @options = { batch_size: 1000, validate: true }.merge(options.slice(*OPTIONS))
       detect_csv_options
     end
 
@@ -118,8 +119,7 @@ module ActiveAdminImport
                        model.csv_options
                      else
                        options[:csv_options] || {}
-                     end.reject { |_, value| value.blank? }
+                     end.reject { |_, value| value.nil? || value == "" }
     end
-
   end
 end

data/lib/active_admin_import/model.rb

@@ -1,17 +1,36 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'rchardet'
+require 'zip'
 
 module ActiveAdminImport
   class Model
-
     include ActiveModel::Model
     include ActiveModel::Validations
     include ActiveModel::Validations::Callbacks
 
+    module CONST
+      ZIP_TYPE = 'application/zip'.freeze
+      TMP_FILE = 'active-admin-import-unzipped'.freeze
+      CSV_TYPES = %w(
+        text/csv
+        text/x-csv
+        text/x-comma-separated-values
+        text/comma-separated-values
+        application/csv
+        application/vnd.ms-excel
+        application/vnd.msexcel
+        text/tsv
+        text/x-tsv
+        text/tab-separated-values
+        text/x-tab-separated-values
+      ).freeze
+    end
+
     validates :file, presence: {
-      message: ->(*_){ I18n.t("active_admin_import.no_file_error") }
-    }, unless: ->(me){ me.new_record? }
+      message: ->(*_) { I18n.t('active_admin_import.no_file_error') }
+    }, unless: ->(me) { me.new_record? }
 
     validate :correct_content_type, if: ->(me) { me.file.present? }
     validate :file_contents_present, if: ->(me) { me.file.present? }
@@ -21,7 +40,7 @@ module ActiveAdminImport
 
     attr_reader :attributes
 
-    def initialize(args={})
+    def initialize(args = {})
       @new_record = true
       @attributes = {}
       assign_attributes(default_attributes.merge(args), true)
@@ -44,21 +63,21 @@ module ActiveAdminImport
         allow_archive: true,
         csv_headers: [],
         file: nil,
-        force_encoding: "UTF-8",
-        hint: ""
+        force_encoding: 'UTF-8',
+        hint: ''
       }
     end
 
     def allow_archive?
-      !!attributes[:allow_archive]
+      attributes[:allow_archive].present?
     end
 
     def new_record?
-      !!@new_record
+      @new_record.present?
     end
 
     def force_encoding?
-      !!attributes[:force_encoding]
+      attributes[:force_encoding].present?
     end
 
     def persisted?
@@ -66,10 +85,10 @@ module ActiveAdminImport
     end
 
     def archive?
-      file_type == 'application/zip'
+      file_type == CONST::ZIP_TYPE
     end
 
-    alias :to_hash :attributes
+    alias to_hash attributes
 
     protected
 
@@ -90,32 +109,27 @@ module ActiveAdminImport
 
     def unzip_file
       Zip::File.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
-        self.file << data
-        self.file.close
+        self.file = Tempfile.new(CONST::TMP_FILE)
+        data = zip_file.entries.select(&:file?).first.get_input_stream.read
+        file << data
+        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'
-      ]
+      CONST::CSV_TYPES
     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
+      return if file.blank? ||
+          file.is_a?(Tempfile) ||
+          (csv_allowed_types.include? file_type)
+      errors.add(:file, I18n.t('active_admin_import.file_format_error'))
     end
 
     def file_contents_present
-      errors.add(:file, I18n.t('active_admin_import.file_empty_error')) if File.zero?(file_path)
+      return unless File.zero?(file_path)
+      errors.add(:file, I18n.t('active_admin_import.file_empty_error'))
     end
 
     def file_type
@@ -126,10 +140,8 @@ module ActiveAdminImport
       end
     end
 
-    protected
-
     def define_methods_for(attr_name)
-      #generate methods for instance object by attributes
+      # generate methods for instance object by attributes
       singleton_class.class_eval do
         define_set_method(attr_name)
         define_get_method(attr_name)
@@ -143,7 +155,7 @@ module ActiveAdminImport
         invalid: :replace, undef: :replace, universal_newline: true
       )
       begin
-        data.sub("\xEF\xBB\xBF", '')  # bom
+        data.sub("\xEF\xBB\xBF", '') # bom
       rescue StandardError => _
         data
       end
@@ -168,15 +180,14 @@ module ActiveAdminImport
 
     class <<self
       def define_set_method(attr_name)
-        define_method(attr_name) { self.attributes[attr_name] } unless method_defined? attr_name
+        return if method_defined? attr_name
+        define_method(attr_name) { attributes[attr_name] }
       end
 
       def define_get_method(attr_name)
-        define_method("#{attr_name}=") { |new_value| @attributes[attr_name] = new_value } unless method_defined? "#{attr_name}="
+        return if method_defined? "#{attr_name}="
+        define_method("#{attr_name}=") { |new_value| @attributes[attr_name] = new_value }
       end
     end
-
   end
 end
-
-

data/lib/active_admin_import/options.rb

@@ -1,44 +1,45 @@
+# frozen_string_literal: true
 module ActiveAdminImport
-
   module Options
     VALID_OPTIONS = [
-        :back,
-        :csv_options,
-        :validate,
-        :batch_size,
-        :batch_transaction,
-        :before_import,
-        :after_import,
-        :before_batch_import,
-        :after_batch_import,
-        :on_duplicate_key_update,
-        :timestamps,
-        :ignore,
-        :template,
-        :template_object,
-        :resource_class,
-        :resource_label,
-        :plural_resource_label,
-        :headers_rewrites
+      :back,
+      :csv_options,
+      :validate,
+      :batch_size,
+      :batch_transaction,
+      :before_import,
+      :after_import,
+      :before_batch_import,
+      :after_batch_import,
+      :on_duplicate_key_update,
+      :timestamps,
+      :ignore,
+      :template,
+      :template_object,
+      :resource_class,
+      :resource_label,
+      :plural_resource_label,
+      :error_limit,
+      :headers_rewrites,
+      :if
     ].freeze
 
-
-    def self.options_for(config, options= {})
-      options[:template_object] = ActiveAdminImport::Model.new  unless options.has_key? :template_object
+    def self.options_for(config, options = {})
+      unless options.key? :template_object
+        options[:template_object] = ActiveAdminImport::Model.new
+      end
 
       {
-          back: {action: :import},
-          csv_options: {},
-          template: "admin/import",
-          resource_class: config.resource_class,
-          resource_label: config.resource_label,
-          plural_resource_label: config.plural_resource_label,
-          headers_rewrites: {}
+        back: { action: :import },
+        csv_options: {},
+        template: 'admin/import',
+        resource_class: config.resource_class,
+        resource_label: config.resource_label,
+        plural_resource_label: config.plural_resource_label,
+        error_limit: 5,
+        headers_rewrites: {},
+        if: true
       }.deep_merge(options)
-
-
-
     end
-
   end
 end

data/lib/active_admin_import/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdminImport
-  VERSION = "3.0.0.pre"
+  VERSION = '3.0.0'
 end

data/spec/fixtures/files/authors_with_tabs.tsv

@@ -0,0 +1,3 @@
+Name	Last name	Birthday
+John	Doe	1986-05-01
+Jane	Roe	1988-11-16

data/spec/import_result_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe ActiveAdminImport::ImportResult do
-  context "failed_message" do
+  context 'failed_message' do
     let(:import_result) { ActiveAdminImport::ImportResult.new }
 
     before do
@@ -10,23 +11,28 @@ describe ActiveAdminImport::ImportResult do
 
       @result = double \
         failed_instances: [
-          Author.create(name: 'Jim', last_name: "Doe"), # {:last_name=>["has already been taken"]}
-          Author.create(name: nil,   last_name: 'Doe')  # {:name=>["can't be blank"], :last_name=>["has already been taken"]}
+          # {:last_name=>["has already been taken"]}
+          Author.create(name: 'Jim', last_name: 'Doe'),
+          # {:name=>["can't be blank"], :last_name=>["has already been taken"]}
+          Author.create(name: nil,   last_name: 'Doe')
         ]
     end
 
-    it "should work without any failed instances" do
-      expect(import_result.failed_message).to eq("")
+    it 'should work without any failed instances' do
+      expect(import_result.failed_message).to eq('')
     end
 
-    it "should work" do
+    it 'should work' do
       import_result.add(@result, 4)
-      expect(import_result.failed_message).to eq("Last name has already been taken - Doe ; Name can't be blank - , Last name has already been taken - Doe")
+      expect(import_result.failed_message)
+        .to eq(
+          "Last name has already been taken - Doe ; Name can't be blank - , Last name has already been taken - Doe"
+        )
     end
 
-    it "should work on limit param" do
+    it 'should work on limit param' do
       import_result.add(@result, 4)
-      expect(import_result.failed_message(limit: 1)).to eq("Last name has already been taken - Doe")
+      expect(import_result.failed_message(limit: 1)).to eq('Last name has already been taken - Doe')
     end
   end
 end

data/spec/import_spec.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe 'import', type: :feature do
-
   shared_examples 'successful inserts' do |encoding, csv_file_name|
     let(:options) do
       attributes = { force_encoding: encoding }
@@ -12,8 +12,8 @@ describe 'import', type: :feature do
       upload_file!(csv_file_name)
     end
 
-    it "should import file with many records" do
-      expect(page).to have_content "Successfully imported 2 authors"
+    it 'should import file with many records' do
+      expect(page).to have_content 'Successfully imported 2 authors'
       expect(Author.count).to eq(2)
       Author.all.each do |author|
         expect(author).to be_valid
@@ -24,7 +24,6 @@ describe 'import', type: :feature do
   end
 
   def with_zipped_csv(name, &block)
-
     zip_file = File.expand_path("./spec/fixtures/files/#{name}.zip")
 
     begin
@@ -33,115 +32,119 @@ describe 'import', type: :feature do
       end
       instance_eval &block
     ensure
-      File.delete zip_file rescue nil
+      begin
+        File.delete zip_file
+      rescue
+        nil
+      end
     end
   end
 
-  def upload_file!(name, ext='csv')
+  def upload_file!(name, ext = 'csv')
     attach_file('active_admin_import_model_file', File.expand_path("./spec/fixtures/files/#{name}.#{ext}"))
     find_button('Import').click
   end
 
-  context "posts index" do
+  context 'posts index' do
     before do
-      Author.create!(name: "John", last_name: "Doe")
-      Author.create!(name: "Jane", last_name: "Roe")
+      Author.create!(name: 'John', last_name: 'Doe')
+      Author.create!(name: 'Jane', last_name: 'Roe')
     end
 
-    context "for csv for particular author" do
+    context 'for csv for particular author' do
       let(:author) { Author.take }
 
       shared_examples 'successful inserts for author' do
-        it "should use predefined author_id" do
+        it 'should use predefined author_id' do
           expect(Post.where(author_id: author.id).count).to eq(Post.count)
         end
 
-        it "should be imported" do
+        it 'should be imported' do
           expect(Post.count).to eq(2)
-          expect(page).to have_content "Successfully imported 2 posts"
+          expect(page).to have_content 'Successfully imported 2 posts'
         end
       end
 
-      context "no headers" do
+      context 'no headers' do
         before do
           add_post_resource(template_object: ActiveAdminImport::Model.new(author_id: author.id,
                                                                           csv_headers: [:title, :body, :author_id]),
                             validate: true,
-                            before_batch_import: ->(importer) do
+                            before_batch_import: lambda do |importer|
                               importer.csv_lines.map! { |row| row << importer.model.author_id }
                             end
-          )
+                           )
 
-          visit "/admin/posts/import"
+          visit '/admin/posts/import'
           upload_file!(:posts_for_author_no_headers)
         end
         include_examples 'successful inserts for author'
       end
 
-      context "with headers" do
+      context 'with headers' do
         before do
           add_post_resource(template_object: ActiveAdminImport::Model.new(author_id: author.id),
                             validate: true,
-                            before_batch_import: ->(importer) do
+                            before_batch_import: lambda do |importer|
                               importer.csv_lines.map! { |row| row << importer.model.author_id }
-                              importer.headers.merge!({ :'Author Id' => :author_id })
+                              importer.headers.merge!(:'Author Id' => :author_id)
                             end
-          )
+                           )
 
-          visit "/admin/posts/import"
+          visit '/admin/posts/import'
           upload_file!(:posts_for_author)
         end
         include_examples 'successful inserts for author'
       end
     end
 
-    context "for csv with author name" do
+    context 'for csv with author name' do
       before do
         add_post_resource(
-            validate: true,
-            template_object: ActiveAdminImport::Model.new,
-            headers_rewrites: { :'Author Name' => :author_id },
-            before_batch_import: ->(importer) do
-              authors_names = importer.values_at(:author_id)
-              # replacing author name with author id
-              authors = Author.where(name: authors_names).pluck(:name, :id)
-              #{"Jane" => 2, "John" => 1}
-              options = Hash[*authors.flatten]
-              importer.batch_replace(:author_id, options)
-            end
+          validate: true,
+          template_object: ActiveAdminImport::Model.new,
+          headers_rewrites: { :'Author Name' => :author_id },
+          before_batch_import: lambda do |importer|
+            authors_names = importer.values_at(:author_id)
+            # replacing author name with author id
+            authors = Author.where(name: authors_names).pluck(:name, :id)
+            # {"Jane" => 2, "John" => 1}
+            options = Hash[*authors.flatten]
+            importer.batch_replace(:author_id, options)
+          end
         )
-        visit "/admin/posts/import"
+        visit '/admin/posts/import'
         upload_file!(:posts)
       end
 
-      it "should resolve author_id by author name" do
+      it 'should resolve author_id by author name' do
         Post.all.each do |post|
           expect(Author.where(id: post.author.id)).to be_present
         end
       end
 
-      it "should be imported" do
+      it 'should be imported' do
         expect(Post.count).to eq(2)
-        expect(page).to have_content "Successfully imported 2 posts"
+        expect(page).to have_content 'Successfully imported 2 posts'
       end
     end
   end
 
-  context "authors index" do
+  context 'authors index' do
     before do
       add_author_resource
     end
 
-    it "should navigate to import page" do
-      #todo: removing this causes  undefined method `ransack' for #<ActiveRecord::Relation []>
+    it 'should navigate to import page' do
+      # TODO: removing this causes  undefined method `ransack' for #<ActiveRecord::Relation []>
       allow_any_instance_of(Admin::AuthorsController).to receive(:find_collection).and_return(Author.all)
       visit '/admin/authors'
       find_link('Import Authors').click
-      expect(current_path).to eq("/admin/authors/import")
+      expect(current_path).to eq('/admin/authors/import')
     end
   end
 
-  context "with custom block" do
+  context 'with custom block' do
     before do
       add_author_resource({}) do
         flash[:notice] = 'some custom message'
@@ -149,44 +152,42 @@ describe 'import', type: :feature do
       visit '/admin/authors/import'
     end
 
-    it "should display notice from custom block" do
+    it 'should display notice from custom block' do
       upload_file!(:author)
-      expect(page).to have_content "some custom message"
+      expect(page).to have_content 'some custom message'
     end
-
   end
 
-  context "authors already exist" do
+  context 'authors already exist' do
     before do
-      Author.create!(id: 1, name: "Jane", last_name: "Roe")
-      Author.create!(id: 2, name: "John", last_name: "Doe")
+      Author.create!(id: 1, name: 'Jane', last_name: 'Roe')
+      Author.create!(id: 2, name: 'John', last_name: 'Doe')
     end
 
-    context "having authors with the same Id" do
+    context 'having authors with the same Id' do
       before do
         add_author_resource(
-            before_batch_import: ->(importer) do
-              Author.where(id: importer.values_at("id")).delete_all
-            end
+          before_batch_import: lambda do |importer|
+            Author.where(id: importer.values_at('id')).delete_all
+          end
         )
-        visit "/admin/authors/import"
+        visit '/admin/authors/import'
         upload_file!(:authors_with_ids)
       end
 
-      it "should replace authors" do
-        expect(page).to have_content "Successfully imported 2 authors"
+      it 'should replace authors' do
+        expect(page).to have_content 'Successfully imported 2 authors'
         expect(Author.count).to eq(2)
       end
 
-      it "should replace authors by id" do
-        expect(Author.find(1).name).to eq("John")
-        expect(Author.find(2).name).to eq("Jane")
+      it 'should replace authors by id' do
+        expect(Author.find(1).name).to eq('John')
+        expect(Author.find(2).name).to eq('Jane')
       end
     end
   end
 
-  context "with valid options" do
-
+  context 'with valid options' do
     let(:options) { {} }
 
     before do
@@ -194,32 +195,31 @@ describe 'import', type: :feature do
       visit '/admin/authors/import'
     end
 
-    it "has valid form" do
+    it 'has valid form' do
       form = find('#new_active_admin_import_model')
-      expect(form['action']).to eq("/admin/authors/do_import")
-      expect(form['enctype']).to eq("multipart/form-data")
-      file_input = form.find("input#active_admin_import_model_file")
-      expect(file_input[:type]).to eq("file")
+      expect(form['action']).to eq('/admin/authors/do_import')
+      expect(form['enctype']).to eq('multipart/form-data')
+      file_input = form.find('input#active_admin_import_model_file')
+      expect(file_input[:type]).to eq('file')
       expect(file_input.value).to be_blank
-      submit_input = form.find("#active_admin_import_model_submit_action input")
-      expect(submit_input[:value]).to eq("Import")
-      expect(submit_input[:type]).to eq("submit")
+      submit_input = form.find('#active_admin_import_model_submit_action input')
+      expect(submit_input[:value]).to eq('Import')
+      expect(submit_input[:type]).to eq('submit')
     end
 
-    context "with hint defined" do
+    context 'with hint defined' do
       let(:options) do
-        { template_object: ActiveAdminImport::Model.new(hint: "hint") }
+        { template_object: ActiveAdminImport::Model.new(hint: 'hint') }
       end
-      it "renders hint at upload page" do
+      it 'renders hint at upload page' do
         expect(page).to have_content options[:template_object].hint
       end
     end
 
-    context "when importing file" do
-
+    context 'when importing file' do
       [:empty, :only_headers].each do |file|
         context "when #{file} file" do
-          it "should render warning" do
+          it 'should render warning' do
             upload_file!(file)
             expect(page).to have_content I18n.t('active_admin_import.file_empty_error')
             expect(Author.count).to eq(0)
@@ -227,142 +227,143 @@ describe 'import', type: :feature do
         end
       end
 
-      context "when no file" do
-        it "should render error" do
+      context 'when no file' do
+        it 'should render error' do
           find_button('Import').click
           expect(Author.count).to eq(0)
           expect(page).to have_content I18n.t('active_admin_import.no_file_error')
         end
       end
 
-      context "auto detect encoding" do
+      context 'auto detect encoding' do
         include_examples 'successful inserts',
                          :auto,
                          :authors_win1251_win_endline
       end
 
-      context "Win1251" do
+      context 'Win1251' do
         include_examples 'successful inserts',
                          'windows-1251',
                          :authors_win1251_win_endline
       end
 
-      context "BOM" do
-        it "should import file with many records" do
+      context 'BOM' do
+        it 'should import file with many records' do
           upload_file!(:authors_bom)
-          expect(page).to have_content "Successfully imported 2 authors"
+          expect(page).to have_content 'Successfully imported 2 authors'
           expect(Author.count).to eq(2)
         end
       end
 
-      context "with headers" do
-        it "should import file with many records" do
+      context 'with headers' do
+        it 'should import file with many records' do
           upload_file!(:authors)
-          expect(page).to have_content "Successfully imported 2 authors"
+          expect(page).to have_content 'Successfully imported 2 authors'
           expect(Author.count).to eq(2)
         end
 
-        it "should import file with 1 record" do
+        it 'should import file with 1 record' do
           upload_file!(:author)
-          expect(page).to have_content "Successfully imported 1 author"
+          expect(page).to have_content 'Successfully imported 1 author'
           expect(Author.count).to eq(1)
         end
       end
 
-      context "without headers" do
-        context "with known csv headers" do
+      context 'without headers' do
+        context 'with known csv headers' do
           let(:options) do
             attributes = { csv_headers: ['Name', 'Last name', 'Birthday'] }
             { template_object: ActiveAdminImport::Model.new(attributes) }
           end
 
-          it "should import file" do
+          it 'should import file' do
             upload_file!(:authors_no_headers)
-            expect(page).to have_content "Successfully imported 2 authors"
+            expect(page).to have_content 'Successfully imported 2 authors'
             expect(Author.count).to eq(2)
           end
         end
 
-        context "with unknown csv headers" do
-          it "should render error" do
+        context 'with unknown csv headers' do
+          it 'should render error' do
             upload_file!(:authors_no_headers)
-            expect(page).to have_content "Error:"
+            expect(page).to have_content 'Error:'
             expect(Author.count).to eq(0)
           end
         end
       end
 
-      context "with invalid data insert on DB constraint" do
+      context 'with invalid data insert on DB constraint' do
         # :name field has an uniq index
-        it "should render error" do
+        it 'should render error' do
           upload_file!(:authors_invalid_db)
-          expect(page).to have_content "Error:"
+          expect(page).to have_content 'Error:'
           expect(Author.count).to eq(0)
         end
       end
 
-      context "with invalid data insert on model validation" do
+      context 'with invalid data insert on model validation' do
         let(:options) { { validate: true } }
 
         before do
-          Author.create!(name: "John", last_name: "Doe")
+          Author.create!(name: 'John', last_name: 'Doe')
         end
 
-        it "should render both successful and failed message" do
+        it 'should render both successful and failed message' do
           upload_file!(:authors_invalid_model)
-          expect(page).to have_content "Failed to import 1 author"
-          expect(page).to have_content "Successfully imported 1 author"
+          expect(page).to have_content 'Failed to import 1 author'
+          expect(page).to have_content 'Successfully imported 1 author'
+          expect(page).to have_content 'Last name has already been taken - Doe'
           expect(Author.count).to eq(2)
         end
 
-        context "use batch_transaction to make transaction work on model validation" do
+        context 'use batch_transaction to make transaction work on model validation' do
           let(:options) { { validate: true, batch_transaction: true } }
 
-          it "should render only the failed message" do
+          it 'should render only the failed message' do
             upload_file!(:authors_invalid_model)
-            expect(page).to     have_content "Failed to import 1 author"
-            expect(page).to_not have_content "Successfully imported"
+            expect(page).to     have_content 'Failed to import 1 author'
+            expect(page).to_not have_content 'Successfully imported'
             expect(Author.count).to eq(1)
           end
         end
       end
 
-      context "with invalid records" do
-        context "with validation" do
-          it "should render error" do
+      context 'with invalid records' do
+        context 'with validation' do
+          it 'should render error' do
             upload_file!(:author_invalid)
-            expect(page).to have_content "Failed to import 1 author"
+            expect(page).to have_content 'Failed to import 1 author'
             expect(Author.count).to eq(0)
           end
         end
 
-        context "without validation" do
+        context 'without validation' do
           let(:options) { { validate: false } }
-          it "should render error" do
+          it 'should render error' do
             upload_file!(:author_invalid)
-            expect(page).to have_content "Successfully imported 1 author"
+            expect(page).to have_content 'Successfully imported 1 author'
             expect(Author.count).to eq(1)
           end
         end
       end
 
-      context "when zipped" do
-        context "when allowed" do
-          it "should import file" do
+      context 'when zipped' do
+        context 'when allowed' do
+          it 'should import file' do
             with_zipped_csv(:authors) do
               upload_file!(:authors, :zip)
-              expect(page).to have_content "Successfully imported 2 authors"
+              expect(page).to have_content 'Successfully imported 2 authors'
               expect(Author.count).to eq(2)
             end
           end
         end
 
-        context "when not allowed" do
+        context 'when not allowed' do
           let(:options) do
             attributes = { allow_archive: false }
             { template_object: ActiveAdminImport::Model.new(attributes) }
           end
-          it "should render error" do
+          it 'should render error' do
             with_zipped_csv(:authors) do
               upload_file!(:authors, :zip)
               expect(page).to have_content I18n.t('active_admin_import.file_format_error')
@@ -372,43 +373,56 @@ describe 'import', type: :feature do
         end
       end
 
-      context "with different header attribute names" do
+      context 'with different header attribute names' do
         let(:options) do
           { headers_rewrites: { :'Second name' => :last_name } }
         end
 
-        it "should import file" do
+        it 'should import file' do
           upload_file!(:author_broken_header)
-          expect(page).to have_content "Successfully imported 1 author"
+          expect(page).to have_content 'Successfully imported 1 author'
           expect(Author.count).to eq(1)
         end
       end
 
-      context "with semicolons separator" do
+      context 'with semicolons separator' do
         let(:options) do
-          attributes = { csv_options: { col_sep: ";" } }
+          attributes = { csv_options: { col_sep: ';' } }
           { template_object: ActiveAdminImport::Model.new(attributes) }
         end
 
-        it "should import file" do
+        it 'should import file' do
           upload_file!(:authors_with_semicolons)
-          expect(page).to have_content "Successfully imported 2 authors"
+          expect(page).to have_content 'Successfully imported 2 authors'
+          expect(Author.count).to eq(2)
+        end
+      end
+
+      context 'with tab separator' do
+        let(:options) do
+          attributes = { csv_options: { col_sep: "\t" } }
+          { template_object: ActiveAdminImport::Model.new(attributes) }
+        end
+
+        it 'should import file' do
+          upload_file!(:authors_with_tabs, 'tsv')
+          expect(page).to have_content 'Successfully imported 2 authors'
           expect(Author.count).to eq(2)
         end
       end
     end
 
-    context "with callback procs options" do
+    context 'with callback procs options' do
       let(:options) do
         {
-            before_import: ->(_) { true },
-            after_import: ->(_) { true },
-            before_batch_import: ->(_) { true },
-            after_batch_import: ->(_) { true }
+          before_import: ->(_) { true },
+          after_import: ->(_) { true },
+          before_batch_import: ->(_) { true },
+          after_batch_import: ->(_) { true }
         }
       end
 
-      it "should call each callback" do
+      it 'should call each callback' do
         expect(options[:before_import]).to receive(:call).with(kind_of(ActiveAdminImport::Importer))
         expect(options[:after_import]).to receive(:call).with(kind_of(ActiveAdminImport::Importer))
         expect(options[:before_batch_import]).to receive(:call).with(kind_of(ActiveAdminImport::Importer))
@@ -417,16 +431,13 @@ describe 'import', type: :feature do
         expect(Author.count).to eq(2)
       end
     end
-
   end
 
-  context "with invalid options" do
+  context 'with invalid options' do
     let(:options) { { invalid_option: :invalid_value } }
 
-    it "should raise TypeError" do
+    it 'should raise TypeError' do
       expect { add_author_resource(options) }.to raise_error(ArgumentError)
     end
-
   end
-
 end