active_admin_import 5.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba919b0429b44accf46af4dcdc52ef1ddcf691a446cddf1bc434b38982c6b0c2
-  data.tar.gz: b54c35f3d81a3b170a8a27b657f1c0b8137c49716fab6b1ba0717845f1b15649
+  metadata.gz: bdc784c6f8a845b491b0dc93e44b073b548bccc182bb3cf6c26cb9f80e59b587
+  data.tar.gz: 798237101d7d4403ed8fb1d1d4ed466b4b78bc44740e20137887d2c8b6464e3f
 SHA512:
-  metadata.gz: d949ae03350ff838eb97856d4c34afb610708dde36bee45d32b56de0bd1bf48a5e0adb4e67aaa549e1e35393cca146be755258fbc213422ab9a91b299769688e
-  data.tar.gz: 4ddc52d5273f06837f54a3806e56ebdad52c2a60581aa452b196de25885697348b13af8f56e27716ed2234b3771072f3f93e365035cdfc02b1539e7aa8385fb1
+  metadata.gz: '06639b5514e0c5af1f2cfd70f66f7de10b798fc22f9153b4870c0859b3f95fd372cf73f406b15b7df8b3e4d6fc350a911680248e09d15412479c55f092869a0d'
+  data.tar.gz: 1b49c36c911a6eae50d653eafa4063a139b5d901b81264b213ece4bb995158bf7685f62facce2d5d1a69b76fe2735483296a26f9f697f6fad802d562ca3deef5

data/.github/workflows/test.yml

@@ -0,0 +1,162 @@
+name: CI
+on:
+  pull_request:
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  test:
+    name: Ruby ${{ matrix.ruby }} / Rails ${{ matrix.rails }} / AA ${{ matrix.activeadmin }} / SQLite
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.2', '3.3', '3.4']
+        rails: ['7.1.0', '7.2.0', '8.0.0']
+        activeadmin: ['3.2.0', '3.3.0', '3.4.0', '3.5.1']
+        exclude:
+          - rails: '8.0.0'
+            activeadmin: '3.2.0'
+    env:
+      RAILS: ${{ matrix.rails }}
+      AA: ${{ matrix.activeadmin }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rspec spec
+  test-mysql:
+    name: Ruby 3.4 / Rails 8.0.0 / AA 3.5.1 / MySQL 8.0
+    runs-on: ubuntu-latest
+    env:
+      RAILS: '8.0.0'
+      AA: '3.5.1'
+      DB: mysql
+      DB_HOST: 127.0.0.1
+      DB_PORT: 3306
+      DB_USERNAME: root
+      DB_PASSWORD: root
+    services:
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: active_admin_import_test
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h localhost -uroot -proot"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rspec spec
+  test-postgres:
+    name: Ruby 3.4 / Rails 8.0.0 / AA 3.5.1 / PostgreSQL 16
+    runs-on: ubuntu-latest
+    env:
+      RAILS: '8.0.0'
+      AA: '3.5.1'
+      DB: postgres
+      DB_HOST: 127.0.0.1
+      DB_PORT: 5432
+      DB_USERNAME: postgres
+      DB_PASSWORD: postgres
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: active_admin_import_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd="pg_isready -U postgres"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rspec spec
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+      - name: Run tests with coverage
+        run: bundle exec rspec spec
+      - name: Upload coverage
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: coverage/
+
+      - name: Generate badge.json
+        run: |
+          LAST_RUN="coverage/.last_run.json"
+          if [ ! -f "$LAST_RUN" ]; then
+            mkdir -p badge
+            echo '{"schemaVersion":1,"label":"coverage","message":"unknown","color":"lightgrey"}' > badge/badge.json
+            exit 0
+          fi
+          PERCENT=$(ruby -rjson -e "puts JSON.parse(File.read('$LAST_RUN')).dig('result','line').round(1)")
+          PERCENT_NUM=$(ruby -rjson -e "puts JSON.parse(File.read('$LAST_RUN')).dig('result','line')")
+          if ruby -e "exit(($PERCENT_NUM >= 90) ? 0 : 1)"; then COLOR="brightgreen"
+          elif ruby -e "exit(($PERCENT_NUM >= 75) ? 0 : 1)"; then COLOR="green"
+          elif ruby -e "exit(($PERCENT_NUM >= 60) ? 0 : 1)"; then COLOR="yellow"
+          else COLOR="red"; fi
+          mkdir -p badge
+          echo "{\"schemaVersion\":1,\"label\":\"coverage\",\"message\":\"${PERCENT}%\",\"color\":\"${COLOR}\"}" > badge/badge.json
+
+      - name: Upload badge artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-badge
+          path: badge
+
+  deploy-coverage:
+    needs: coverage
+    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Download coverage badge
+        uses: actions/download-artifact@v4
+        with:
+          name: coverage-badge
+          path: .
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: .
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

data/Gemfile

@@ -1,21 +1,27 @@
-# frozen_string_literal: true
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in active_admin_importable.gemspec
 gemspec
 
+default_rails_version = '7.1.0'
+default_activeadmin_version = '3.2.0'
+
+gem 'rails', "~> #{ENV['RAILS'] || default_rails_version}"
+gem 'activeadmin', "~> #{ENV['AA'] || default_activeadmin_version}"
+gem 'sprockets-rails'
+gem 'sass-rails'
 
 group :test do
-  default_rails_version = "~> 5.2.4"
-  rails_version = ENV['RAILS'] || default_rails_version
-  gem 'sassc-rails'
-  gem 'rails', rails_version
+  gem 'simplecov', require: false
   gem 'rspec-rails'
-  gem 'coveralls', require: false # Test coverage website. Go to https://coveralls.io
-  gem "sqlite3", "~> 1.4.0"
-  gem 'launchy'
+  case ENV['DB']
+  when 'mysql'
+    gem 'mysql2'
+  when 'postgres', 'postgresql'
+    gem 'pg'
+  else
+    gem 'sqlite3', '~> 2.0'
+  end
   gem 'database_cleaner'
   gem 'capybara'
-  gem 'poltergeist'
-  gem 'jquery-ui-rails', '~> 5.0'
+  gem 'cuprite'
+  gem 'webrick', require: false
 end

data/README.md

@@ -1,15 +1,13 @@
 # ActiveAdminImport
 
-[![Travis Build   ][build_badge]][build_link]
-[![Coverage Status][coveralls_badge]][coveralls_link]
-[![Code Climate   ][codeclimate_badge]][codeclimate_link]
-[![Gem Version    ][rubygems_badge]][rubygems_link]
-[![License        ][license_badge]][license_link]
+[![Build Status][build_badge]][build_link]
+![Coverage][coverage_badge]
+[![Code Climate][codeclimate_badge]][codeclimate_link]
+[![Gem Version][rubygems_badge]][rubygems_link]
+[![License][license_badge]][license_link]
 
 
-The most fastest and efficient CSV import for Active Admin with support of validations, bulk inserts and encodings handling.
-
-For more about ActiveAdminImport installation and usage, check [Documentation website](http://activeadmin-plugins.github.io/active_admin_import/) and [Wiki pages](https://github.com/activeadmin-plugins/active_admin_import/wiki) for some specific cases and caveats.
+The fastest and most efficient CSV import for Active Admin with support for validations, bulk inserts, and encoding handling.
 
 
 ## Installation
@@ -44,7 +42,7 @@ And then execute:
 #### Basic usage
 
 ```ruby
-ActiveAdmin.register Post
+ActiveAdmin.register Post do
   active_admin_import options
 end
 ```
@@ -68,6 +66,7 @@ Tool                    | Description
 :timestamps             |bool, tells activerecord-import to not add timestamps (if false) even if record timestamps is disabled in ActiveRecord::Base
 :template               |custom template rendering
 :template_object        |object passing to view
+:result_class           |custom `ImportResult` subclass to collect data from each batch (e.g. inserted ids). Must respond to `add(batch_result, qty)` plus the readers used in flash messages (`failed`, `total`, `imported_qty`, `imported?`, `failed?`, `empty?`, `failed_message`).
 :resource_class         |resource class name
 :resource_label         |resource label value
 :plural_resource_label  |pluralized resource label value (default config.plural_resource_label)
@@ -77,9 +76,248 @@ Tool                    | Description
 
 
 
-#### Wiki
+#### Custom ImportResult
+
+To collect extra data from each batch (for example the ids of inserted rows so you can enqueue background jobs against them), pass a subclass of `ActiveAdminImport::ImportResult` via `:result_class`:
+
+```ruby
+class ImportResultWithIds < ActiveAdminImport::ImportResult
+  attr_reader :ids
+
+  def initialize
+    super
+    @ids = []
+  end
+
+  def add(batch_result, qty)
+    super
+    @ids.concat(Array(batch_result.ids))
+  end
+end
+
+ActiveAdmin.register Author do
+  active_admin_import result_class: ImportResultWithIds do |result, options|
+    EnqueueAuthorsJob.perform_later(result.ids) if result.imported?
+    instance_exec(result, options, &ActiveAdminImport::DSL::DEFAULT_RESULT_PROC)
+  end
+end
+```
+
+The action block is invoked via `instance_exec` with `result` and `options` as block arguments, so you can either capture them with `do |result, options|` or read them as locals when no arguments are declared.
+
+Note: which batch-result attributes are populated depends on the database adapter and the import options. `activerecord-import` returns ids reliably on PostgreSQL; on MySQL/SQLite the behavior depends on the adapter and options like `on_duplicate_key_update`. Putting the collection logic in your own subclass keeps these adapter quirks in your application code.
+
+
+#### Authorization
+
+The current user must be authorized to perform imports. With CanCanCan:
+
+```ruby
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    can :import, Post
+  end
+end
+```
+
+
+#### Per-request context
+
+Define an `active_admin_import_context` method on the controller to inject request-derived attributes into every import (current user, parent resource id, request IP, etc.). The returned hash is merged into the import model after form params, so it always wins for the keys it provides:
+
+```ruby
+ActiveAdmin.register PostComment do
+  belongs_to :post
+
+  controller do
+    def active_admin_import_context
+      { post_id: parent.id, request_ip: request.remote_ip }
+    end
+  end
+
+  active_admin_import before_batch_import: ->(importer) {
+    importer.csv_lines.map! { |row| row << importer.model.post_id }
+    importer.headers.merge!(:'Post Id' => :post_id)
+  }
+end
+```
+
+
+#### Examples
+
+##### Files without CSV headers
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: true,
+                      template_object: ActiveAdminImport::Model.new(
+                        hint: "expected header order: body, title, author",
+                        csv_headers: %w[body title author]
+                      )
+end
+```
+
+##### Auto-detect file encoding
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: true,
+                      template_object: ActiveAdminImport::Model.new(force_encoding: :auto)
+end
+```
+
+##### Force a specific (non-UTF-8) encoding
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: true,
+                      template_object: ActiveAdminImport::Model.new(
+                        hint: "file is encoded in ISO-8859-1",
+                        force_encoding: "ISO-8859-1"
+                      )
+end
+```
+
+##### Disallow ZIP upload
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: true,
+                      template_object: ActiveAdminImport::Model.new(
+                        hint: "upload a CSV file",
+                        allow_archive: false
+                      )
+end
+```
+
+##### Skip CSV columns
+
+Useful when the CSV file has columns that don't exist on the table. Available since 3.1.0.
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import before_batch_import: ->(importer) {
+    importer.batch_slice_columns(['name', 'last_name'])
+  }
+end
+```
+
+Tip: pass `Post.column_names` to keep only the columns that exist on the table.
+
+##### Resolve associations on the fly
+
+Replace an `Author name` column in the CSV with the matching `author_id` before insert:
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: true,
+                      headers_rewrites: { 'Author name': :author_id },
+                      before_batch_import: ->(importer) {
+                        names = importer.values_at(:author_id)
+                        mapping = Author.where(name: names).pluck(:name, :id).to_h
+                        importer.batch_replace(:author_id, mapping)
+                      }
+end
+```
+
+##### Update existing records by id
+
+Delete colliding rows just before each batch insert:
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import before_batch_import: ->(importer) {
+    Post.where(id: importer.values_at('id')).delete_all
+  }
+end
+```
+
+For databases that support upserts you can use `:on_duplicate_key_update` instead.
+
+##### Tune batch size
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: false,
+                      csv_options: { col_sep: ";" },
+                      batch_size: 1000
+end
+```
+
+##### Import into an intermediate table
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: false,
+                      csv_options: { col_sep: ";" },
+                      resource_class: ImportedPost,                # write to a staging table
+                      before_import: ->(_) { ImportedPost.delete_all },
+                      after_import: ->(_) {
+                        Post.transaction do
+                          Post.delete_all
+                          Post.connection.execute("INSERT INTO posts (SELECT * FROM imported_posts)")
+                        end
+                      },
+                      back: ->(_) { config.namespace.resource_for(Post).route_collection_path }
+end
+```
+
+##### Allow user input for CSV options (custom template)
+
+```ruby
+ActiveAdmin.register Post do
+  active_admin_import validate: false,
+                      template: 'admin/posts/import',
+                      template_object: ActiveAdminImport::Model.new(
+                        hint: "you can configure CSV options",
+                        csv_options: { col_sep: ";", row_sep: nil, quote_char: nil }
+                      )
+end
+```
+
+`app/views/admin/posts/import.html.erb`:
+
+```erb
+<p><%= raw(@active_admin_import_model.hint) %></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 %>
+```
+
+##### Inspecting the importer in batch callbacks
+
+Both `before_batch_import` and `after_batch_import` receive the `Importer` instance:
+
+```ruby
+active_admin_import before_batch_import: ->(importer) {
+  importer.file        # the uploaded file
+  importer.resource    # the ActiveRecord class being imported into
+  importer.options     # the resolved options hash
+  importer.headers     # CSV headers (mutable)
+  importer.csv_lines   # parsed CSV rows for the current batch (mutable)
+  importer.model       # the template_object instance
+}
+```
 
-[Check various examples](https://github.com/activeadmin-plugins/active_admin_import/wiki)
 
 ## Dependencies
 
@@ -91,16 +329,15 @@ Tool                  | Description
 [rchardet]: https://github.com/jmhodges/rchardet
 [activerecord-import]: https://github.com/zdennis/activerecord-import
 
-[build_badge]: https://travis-ci.org/activeadmin-plugins/active_admin_import.svg?branch=master
-[build_link]: https://travis-ci.org/activeadmin-plugins/active_admin_import
-[coveralls_badge]: https://coveralls.io/repos/activeadmin-plugins/active_admin_import/badge.svg
-[coveralls_link]: https://coveralls.io/github/activeadmin-plugins/active_admin_import
+[build_badge]: https://github.com/activeadmin-plugins/active_admin_import/actions/workflows/test.yml/badge.svg
+[build_link]: https://github.com/activeadmin-plugins/active_admin_import/actions
+[coverage_badge]: https://img.shields.io/endpoint?url=https://activeadmin-plugins.github.io/active_admin_import/badge.json
 [codeclimate_badge]: https://codeclimate.com/github/activeadmin-plugins/active_admin_import/badges/gpa.svg
 [codeclimate_link]: https://codeclimate.com/github/activeadmin-plugins/active_admin_import
 [rubygems_badge]: https://badge.fury.io/rb/active_admin_import.svg
 [rubygems_link]: https://rubygems.org/gems/active_admin_import
-[license_badge]: http://img.shields.io/:license-mit-blue.svg
-[license_link]: http://Fivell.mit-license.org
+[license_badge]: https://img.shields.io/:license-mit-blue.svg
+[license_link]: https://Fivell.mit-license.org
 
 
 ## Contributing

data/Rakefile

@@ -1,8 +1,5 @@
-# frozen_string_literal: true
-require 'bundler'
+require "bundler"
 require 'rake'
 Bundler.setup
 Bundler::GemHelper.install_tasks
-
-# Import all our rake tasks
 FileList['tasks/**/*.rake'].each { |task| import task }

data/active_admin_import.gemspec

@@ -7,16 +7,16 @@ Gem::Specification.new do |gem|
   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.homepage = 'https://github.com/activeadmin-plugins/active_admin_import'
   gem.license = 'MIT'
+  gem.required_ruby_version = '>= 3.1.0'
   gem.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   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.add_runtime_dependency 'activerecord-import', '>= 0.27'
+  gem.add_runtime_dependency 'activerecord-import', '>= 2.0'
   gem.add_runtime_dependency 'rchardet', '>= 1.6'
   gem.add_runtime_dependency 'rubyzip', '>= 1.2'
-  gem.add_dependency 'activeadmin', '>= 1.0.0'
+  gem.add_dependency 'activeadmin', '>= 3.0', '< 4.0'
 end

data/lib/active_admin_import/dsl.rb

@@ -25,6 +25,22 @@ module ActiveAdminImport
   # +plural_resource_label+:: pluralized resource label value (default config.plural_resource_label)
   #
   module DSL
+    CONTEXT_METHOD = :active_admin_import_context
+
+    def self.prepare_import_model(template_object, controller, params: nil)
+      model = template_object.is_a?(Proc) ? template_object.call : template_object
+      if params
+        params_key = ActiveModel::Naming.param_key(model.class)
+        model.assign_attributes(params[params_key].try(:deep_symbolize_keys) || {})
+      end
+      return model unless controller.respond_to?(CONTEXT_METHOD, true)
+      context = controller.send(CONTEXT_METHOD)
+      return model unless context.is_a?(Hash)
+      context = context.merge(file: model.file) if model.respond_to?(:file) && !context.key?(:file)
+      model.assign_attributes(context)
+      model
+    end
+
     DEFAULT_RESULT_PROC = lambda do |result, options|
       model_name = options[:resource_label].downcase
       plural_model_name = options[:plural_resource_label].downcase
@@ -54,11 +70,10 @@ module ActiveAdminImport
       options.assert_valid_keys(*Options::VALID_OPTIONS)
 
       options = Options.options_for(config, options)
-      params_key = ActiveModel::Naming.param_key(options[:template_object])
 
       collection_action :import, method: :get do
         authorize!(ActiveAdminImport::Auth::IMPORT, active_admin_config.resource_class)
-        @active_admin_import_model = options[:template_object]
+        @active_admin_import_model = ActiveAdminImport::DSL.prepare_import_model(options[:template_object], self)
         render template: options[:template]
       end
 
@@ -75,8 +90,9 @@ module ActiveAdminImport
         authorize!(ActiveAdminImport::Auth::IMPORT, active_admin_config.resource_class)
         _params = params.respond_to?(:to_unsafe_h) ? params.to_unsafe_h : params
         params = ActiveSupport::HashWithIndifferentAccess.new _params
-        @active_admin_import_model = options[:template_object]
-        @active_admin_import_model.assign_attributes(params[params_key].try(:deep_symbolize_keys) || {})
+        @active_admin_import_model = ActiveAdminImport::DSL.prepare_import_model(
+          options[:template_object], self, params: params
+        )
         # go back to form
         return render template: options[:template] unless @active_admin_import_model.valid?
         @importer = Importer.new(
@@ -88,12 +104,13 @@ module ActiveAdminImport
           result = @importer.import
 
           if block_given?
-            instance_eval(&block)
+            instance_exec result, options, &block
           else
             instance_exec result, options, &DEFAULT_RESULT_PROC
           end
         rescue ActiveRecord::Import::MissingColumnError,
                NoMethodError,
+               ArgumentError,
                ActiveRecord::StatementInvalid,
                CSV::MalformedCSVError,
                ActiveAdminImport::Exception => e

data/lib/active_admin_import/import_result.rb

@@ -33,11 +33,21 @@ module ActiveAdminImport
       limit = options[:limit] || failed.count
       failed.first(limit).map do |record|
         errors = record.errors
-        failed_values = errors.keys.map do |key|
+        failed_values = attribute_names_for(errors).map do |key|
           key == :base ? nil : record.public_send(key)
         end
         errors.full_messages.zip(failed_values).map { |ms| ms.compact.join(' - ') }.join(', ')
       end.join(' ; ')
     end
+
+    private
+
+    def attribute_names_for(errors)
+      if Gem::Version.new(Rails.version) >= Gem::Version.new('7.0')
+        errors.attribute_names
+      else
+        errors.keys
+      end
+    end
   end
 end

data/lib/active_admin_import/importer.rb

@@ -18,7 +18,8 @@ module ActiveAdminImport
       :headers_rewrites,
       :batch_size,
       :batch_transaction,
-      :csv_options
+      :csv_options,
+      :result_class
     ].freeze
 
     def initialize(resource, model, options)
@@ -29,7 +30,7 @@ module ActiveAdminImport
     end
 
     def import_result
-      @import_result ||= ImportResult.new
+      @import_result ||= (options[:result_class] || ImportResult).new
     end
 
     def file

data/lib/active_admin_import/model.rb

@@ -37,7 +37,7 @@ module ActiveAdminImport
     validate :file_contents_present, if: ->(me) { me.file.present? }
 
     before_validation :unzip_file, if: ->(me) { me.archive? && me.allow_archive? }
-    before_validation :encode_file, if: ->(me) { me.force_encoding? && me.file.present? }
+    after_validation :encode_file, if: ->(me) { me.errors.empty? && me.force_encoding? && me.file.present? }
 
     attr_reader :attributes
 
@@ -48,6 +48,7 @@ module ActiveAdminImport
     end
 
     def assign_attributes(args = {}, new_record = false)
+      args[:file] = nil unless args.key?(:file)
       @attributes.merge!(args)
       @new_record = new_record
       args.keys.each do |key|
@@ -103,6 +104,8 @@ module ActiveAdminImport
 
     def encode_file
       data = File.read(file_path)
+      return if data.empty?
+
       File.open(file_path, 'w') do |f|
         f.write(encode(data))
       end