active_admin_import 5.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ba0d9c89bd483eef55da51f9a06ec6327c4bbfffa79abc8431e578bb347c26
-  data.tar.gz: 9c13aefd9dc6397c7fee814ca4f4f7251d9cfb8c399249570acf902b928eacab
+  metadata.gz: bdc784c6f8a845b491b0dc93e44b073b548bccc182bb3cf6c26cb9f80e59b587
+  data.tar.gz: 798237101d7d4403ed8fb1d1d4ed466b4b78bc44740e20137887d2c8b6464e3f
 SHA512:
-  metadata.gz: bad8987eeac221884549f9c36d28ced4afc5ed02ee6b65cbf68436053d1ac19644d270e3c20b10aa00b4eb7117289d030e8970036331e803716be6ac10a4bd8c
-  data.tar.gz: 3c8dd843c7fbdb989417a9a0a2611f0c66759f4662c02ed101d37bf36d51f15ecf4b88c49353599f4df5e978f6e19a36eab17cab8be4b65e985594665afc3080
+  metadata.gz: '06639b5514e0c5af1f2cfd70f66f7de10b798fc22f9153b4870c0859b3f95fd372cf73f406b15b7df8b3e4d6fc350a911680248e09d15412479c55f092869a0d'
+  data.tar.gz: 1b49c36c911a6eae50d653eafa4063a139b5d901b81264b213ece4bb995158bf7685f62facce2d5d1a69b76fe2735483296a26f9f697f6fad802d562ca3deef5

data/.github/workflows/test.yml

@@ -1,43 +1,162 @@
-name: Test
-
+name: CI
 on:
-  - push
-  - pull_request
+  pull_request:
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
 
 jobs:
-  build:
+  test:
+    name: Ruby ${{ matrix.ruby }} / Rails ${{ matrix.rails }} / AA ${{ matrix.activeadmin }} / SQLite
     runs-on: ubuntu-latest
-
     strategy:
+      fail-fast: false
       matrix:
-        ruby_version:
-          - '2.6'
-          - '2.7'
-          - '3.0'
-        rails_version:
-          - '5.2.6'
-          - '6.0.4'
-          - '6.1.4'
-          - '7.0.0'
+        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:
-          - ruby_version: '3.0'
-            rails_version: '5.2.6'
-          - ruby_version: '2.6'
-            rails_version: '7.0.0'
-
-    name: Ruby ${{ matrix.ruby_version }} / Rails ${{ matrix.rails_version }}
-
+          - rails: '8.0.0'
+            activeadmin: '3.2.0'
     env:
-      RAILS: ${{ matrix.rails_version }}
-
+      RAILS: ${{ matrix.rails }}
+      AA: ${{ matrix.activeadmin }}
     steps:
-      - uses: actions/checkout@v2
-
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: ${{ matrix.ruby_version }}
+          ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-
-      - name: Test
+      - 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
 
-[![Build Status   ][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
 
@@ -93,14 +331,13 @@ Tool                  | Description
 
 [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
-[coveralls_badge]: https://coveralls.io/repos/activeadmin-plugins/active_admin_import/badge.svg
-[coveralls_link]: https://coveralls.io/github/activeadmin-plugins/active_admin_import
+[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
@@ -57,11 +73,7 @@ module ActiveAdminImport
 
       collection_action :import, method: :get do
         authorize!(ActiveAdminImport::Auth::IMPORT, active_admin_config.resource_class)
-        @active_admin_import_model = if options[:template_object].is_a?(Proc)
-                                       options[:template_object].call
-                                     else
-                                       options[:template_object]
-                                     end
+        @active_admin_import_model = ActiveAdminImport::DSL.prepare_import_model(options[:template_object], self)
         render template: options[:template]
       end
 
@@ -78,13 +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 = if options[:template_object].is_a?(Proc)
-                                       options[:template_object].call
-                                     else
-                                       options[:template_object]
-                                     end
-        params_key = ActiveModel::Naming.param_key(@active_admin_import_model.class)
-        @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(
@@ -96,7 +104,7 @@ 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

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|

data/lib/active_admin_import/options.rb

@@ -16,6 +16,7 @@ module ActiveAdminImport
       :ignore,
       :template,
       :template_object,
+      :result_class,
       :resource_class,
       :resource_label,
       :plural_resource_label,

data/lib/active_admin_import/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveAdminImport
-  VERSION = '5.1.0'
+  VERSION = '6.0.0'
 end

data/spec/fixtures/files/author_invalid_format.txt

@@ -0,0 +1,2 @@
+Name,Last name,Birthday
+John,Doe,1986-05-01

data/spec/fixtures/files/post_comments.csv

@@ -0,0 +1,3 @@
+"Body"
+"First comment"
+"Second comment"

data/spec/import_spec.rb

@@ -27,7 +27,7 @@ describe 'import', type: :feature do
     zip_file = File.expand_path("./spec/fixtures/files/#{name}.zip")
 
     begin
-      Zip::File.open(zip_file, Zip::File::CREATE) do |z|
+      Zip::File.open(zip_file, create: true) do |z|
         z.add "#{name}.csv", File.expand_path("./spec/fixtures/files/#{name}.csv")
       end
       instance_eval &block
@@ -588,4 +588,147 @@ describe 'import', type: :feature do
       expect { add_author_resource(options) }.to raise_error(ArgumentError)
     end
   end
+
+  context 'when submitting empty form after validation error' do
+    let(:options) { {} }
+
+    before do
+      add_author_resource(options)
+      visit '/admin/authors/import'
+    end
+
+    it 'should NOT reuse cached file from previous submission' do
+      expect do
+        upload_file!(:author_broken_header)
+        expect(page).to have_content("can't write unknown attribute")
+      end.not_to change { Author.count }
+
+      # Second submission without selecting a file
+      expect do
+        find_button('Import').click
+        expect(page).to have_content(I18n.t('active_admin_import.no_file_error'))
+      end.not_to change { Author.count }
+    end
+  end
+
+  context 'when importing file with invalid format and auto force_encoding' do
+    let(:options) { { template_object: ActiveAdminImport::Model.new(force_encoding: :auto) } }
+
+    before do
+      add_author_resource(options)
+      visit '/admin/authors/import'
+    end
+
+    it 'should reject invalid file format before encoding' do
+      expect do
+        upload_file!(:author_invalid_format, 'txt')
+        expect(page).to have_content I18n.t('active_admin_import.file_format_error')
+      end.not_to change { Author.count }
+    end
+  end
+
+  context 'with active_admin_import_context defined on the controller' do
+    before { Author.create!(name: 'John', last_name: 'Doe') }
+
+    let(:author) { Author.take }
+
+    context 'when context returns request-derived attributes' do
+      before do
+        author_id = author.id
+        add_post_resource(
+          template_object: ActiveAdminImport::Model.new(author_id: author_id),
+          before_batch_import: lambda do |importer|
+            ip = importer.model.request_ip
+            a_id = importer.model.author_id
+            importer.csv_lines.map! { |row| row << ip << a_id }
+            importer.headers.merge!(:'Request Ip' => :request_ip, :'Author Id' => :author_id)
+          end,
+          controller_block: proc do
+            def active_admin_import_context
+              { request_ip: request.remote_ip }
+            end
+          end
+        )
+        visit '/admin/posts/import'
+        upload_file!(:posts_for_author)
+      end
+
+      it 'merges the context into the import model so callbacks see it' do
+        expect(page).to have_content 'Successfully imported 2 posts'
+        expect(Post.count).to eq(2)
+        Post.all.each do |post|
+          expect(post.request_ip).to eq('127.0.0.1')
+          expect(post.author_id).to eq(author.id)
+        end
+      end
+    end
+
+    context 'when context returns parent id for a nested belongs_to resource' do
+      let(:post) { Post.create!(title: 'A post', body: 'body', author: author) }
+
+      before do
+        add_nested_post_comment_resource(
+          before_batch_import: lambda do |importer|
+            importer.csv_lines.map! { |row| row << importer.model.post_id }
+            importer.headers.merge!(:'Post Id' => :post_id)
+          end,
+          controller_block: proc do
+            def active_admin_import_context
+              { post_id: parent.id }
+            end
+          end
+        )
+        visit "/admin/posts/#{post.id}/post_comments/import"
+        upload_file!(:post_comments)
+      end
+
+      it 'automatically assigns the parent post_id to every imported comment' do
+        expect(page).to have_content 'Successfully imported 2 post comments'
+        expect(PostComment.count).to eq(2)
+        expect(PostComment.where(post_id: post.id).count).to eq(2)
+      end
+    end
+  end
+
+  # PG-only: activerecord-import populates `result.ids` reliably on PostgreSQL
+  # via RETURNING. On MySQL/SQLite the array is not populated by default, so
+  # the assertion would not be meaningful there. The :result_class option
+  # itself works on every adapter — this spec just demonstrates the canonical
+  # PR #191 use case (collecting inserted ids) on the adapter that supports it.
+  if ENV['DB'] == 'postgres'
+    context 'with custom result_class (PostgreSQL)' do
+      # Subclass that captures inserted ids alongside the standard counters.
+      # Lives in user-land so the gem itself stays free of adapter-specific
+      # quirks around RETURNING. This is the example documented in the README.
+      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
+
+      before do
+        add_author_resource(result_class: ImportResultWithIds) do |result, _options|
+          # Expose the captured ids on the flash so the test asserts via the
+          # rendered page rather than closure capture.
+          flash[:notice] = "Imported ids: [#{result.ids.sort.join(',')}]"
+        end
+        visit '/admin/authors/import'
+        upload_file!(:authors)
+      end
+
+      it 'collects the ids of inserted records via the custom subclass' do
+        expect(Author.count).to eq(2)
+        expected = "Imported ids: [#{Author.pluck(:id).sort.join(',')}]"
+        expect(page).to have_content(expected)
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
-# frozen_string_literal: true
-require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH << File.expand_path('../support', __FILE__)
@@ -10,22 +11,18 @@ require 'bundler'
 Bundler.setup
 
 ENV['RAILS_ENV'] = 'test'
-# Ensure the Active Admin load path is happy
 require 'rails'
 ENV['RAILS'] = Rails.version
-ENV['RAILS_ROOT'] = File.expand_path("../rails/rails-#{ENV['RAILS']}", __FILE__)
-# Create the test app if it doesn't exists
+ENV['DB'] ||= 'sqlite'
+ENV['RAILS_ROOT'] = File.expand_path("../rails/rails-#{ENV['RAILS']}-#{ENV['DB']}", __FILE__)
 system 'rake setup' unless File.exist?(ENV['RAILS_ROOT'])
 
 require 'active_model'
-# require ActiveRecord to ensure that Ransack loads correctly
 require 'active_record'
 require 'action_view'
 require 'active_admin'
 ActiveAdmin.application.load_paths = [ENV['RAILS_ROOT'] + '/app/admin']
 require ENV['RAILS_ROOT'] + '/config/environment.rb'
-# Disabling authentication in specs so that we don't have to worry about
-# it allover the place
 ActiveAdmin.application.authentication_method = false
 ActiveAdmin.application.current_user_method = false
 
@@ -33,21 +30,20 @@ require 'rspec/rails'
 require 'support/admin'
 require 'capybara/rails'
 require 'capybara/rspec'
-require 'capybara/poltergeist'
+require 'capybara/cuprite'
 
-Capybara.register_driver :poltergeist do |app|
-  Capybara::Poltergeist::Driver.new(app, js_errors: true,
-                                         timeout: 80,
-                                         debug: true,
-                                         phantomjs_options: ['--debug=no', '--load-images=no'])
+Capybara.server = :webrick
+Capybara.register_driver :cuprite do |app|
+  Capybara::Cuprite::Driver.new(app, headless: true, window_size: [1280, 800])
 end
-
-Capybara.javascript_driver = :poltergeist
+Capybara.javascript_driver = :cuprite
+Capybara.default_max_wait_time = 5
 
 RSpec.configure do |config|
   config.use_transactional_fixtures = false
 
   config.before(:suite) do
+    ActiveRecord::Migration.maintain_test_schema!
     DatabaseCleaner.strategy = :truncation
     DatabaseCleaner.clean_with(:truncation)
   end

data/spec/support/admin.rb

@@ -8,8 +8,24 @@ def add_author_resource(options = {}, &block)
 end
 
 def add_post_resource(options = {}, &block)
+  cb = options.delete(:controller_block)
   ActiveAdmin.register Post do
     config.filters = false
+    controller(&cb) if cb
+    active_admin_import(options, &block)
+  end
+  Rails.application.reload_routes!
+end
+
+def add_nested_post_comment_resource(options = {}, &block)
+  cb = options.delete(:controller_block)
+  ActiveAdmin.register Post do
+    config.filters = false
+  end
+  ActiveAdmin.register PostComment do
+    config.filters = false
+    belongs_to :post
+    controller(&cb) if cb
     active_admin_import(options, &block)
   end
   Rails.application.reload_routes!

data/spec/support/rails_template.rb

@@ -1,29 +1,60 @@
-# frozen_string_literal: true
-# Rails template to build the sample app for specs
+create_file "app/assets/config/manifest.js", skip: true
+
+db = ENV['DB'] || 'sqlite'
+case db
+when 'mysql'
+  remove_file 'config/database.yml'
+  create_file 'config/database.yml', <<~YAML
+    default: &default
+      adapter: mysql2
+      encoding: utf8mb4
+      pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+      host: <%= ENV.fetch("DB_HOST", "127.0.0.1") %>
+      port: <%= ENV.fetch("DB_PORT", 3306) %>
+      username: <%= ENV.fetch("DB_USERNAME", "root") %>
+      password: <%= ENV.fetch("DB_PASSWORD", "root") %>
+
+    test:
+      <<: *default
+      database: active_admin_import_test
+  YAML
+when 'postgres', 'postgresql'
+  remove_file 'config/database.yml'
+  create_file 'config/database.yml', <<~YAML
+    default: &default
+      adapter: postgresql
+      encoding: unicode
+      pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+      host: <%= ENV.fetch("DB_HOST", "127.0.0.1") %>
+      port: <%= ENV.fetch("DB_PORT", 5432) %>
+      username: <%= ENV.fetch("DB_USERNAME", "postgres") %>
+      password: <%= ENV.fetch("DB_PASSWORD", "postgres") %>
+
+    test:
+      <<: *default
+      database: active_admin_import_test
+  YAML
+end
+
+generate :model, 'author name:string{10}:uniq last_name:string birthday:date --force'
+generate :model, 'post title:string:uniq body:text request_ip:string author:references --force'
+generate :model, 'post_comment body:text post:references --force'
 
-generate :model, 'author name:string{10}:uniq last_name:string birthday:date'
-generate :model, 'post title:string:uniq body:text author:references'
-
-# Add validation
 inject_into_file 'app/models/author.rb', "  validates_presence_of :name\n  validates_uniqueness_of :last_name\n", before: 'end'
-inject_into_file 'app/models/post.rb', "  validates_presence_of :author\n", before: 'end'
-
-# Configure default_url_options in test environment
-inject_into_file 'config/environments/test.rb', "  config.action_mailer.default_url_options = { :host => 'example.com' }\n", after: "config.cache_classes = true\n"
+inject_into_file 'app/models/post.rb', "  validates_presence_of :author\n  has_many :post_comments\n", before: 'end'
 
-# Add our local Active Admin to the load path
-inject_into_file 'config/environment.rb', "\n$LOAD_PATH.unshift('#{File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))}')\nrequire \"active_admin\"\n", after: "require File.expand_path('../application', __FILE__)"
-
-run 'rm Gemfile'
+# Add our local Active Admin to the load path (Rails 7.1+)
+gsub_file "config/environment.rb",
+  'require_relative "application"',
+  "require_relative \"application\"\n$LOAD_PATH.unshift('#{File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))}')\nrequire \"active_admin\"\n"
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 generate :'active_admin:install --skip-users'
 generate :'formtastic:install'
 
-run 'rm -r test'
-run 'rm -r spec'
-
+run 'rm -rf test'
 route "root :to => 'admin/dashboard#index'"
+rake 'db:create db:migrate'
 
-rake 'db:migrate'
+run 'rm -f Gemfile Gemfile.lock'

data/tasks/test.rake

@@ -1,7 +1,21 @@
-# frozen_string_literal: true
-desc 'Creates a test rails app for the specs to run against'
+desc "Creates a test rails app for the specs to run against"
 task :setup do
   require 'rails/version'
-  system('mkdir spec/rails') unless File.exist?('spec/rails')
-  system "bundle exec rails new spec/rails/rails-#{Rails::VERSION::STRING} -m spec/support/rails_template.rb --skip-spring  --skip-turbolinks  --skip-bootsnap"
+
+  db = ENV['DB'] || 'sqlite'
+  rails_db = case db
+             when 'mysql' then 'mysql'
+             when 'postgres', 'postgresql' then 'postgresql'
+             else 'sqlite3'
+             end
+
+  rails_new_opts = %W(
+    --skip-turbolinks
+    --skip-spring
+    --skip-bootsnap
+    -d #{rails_db}
+    -m
+    spec/support/rails_template.rb
+  )
+  system "bundle exec rails new spec/rails/rails-#{Rails::VERSION::STRING}-#{db} #{rails_new_opts.join(' ')}"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_admin_import
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Igor Fedoronchuk
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-import
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rchardet
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +57,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: The most efficient way to import for Active Admin
 email:
 - fedoronchuk@gmail.com
@@ -76,7 +81,6 @@ files:
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rubocop.yml"
-- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -108,6 +112,7 @@ files:
 - spec/fixtures/files/author.csv
 - spec/fixtures/files/author_broken_header.csv
 - spec/fixtures/files/author_invalid.csv
+- spec/fixtures/files/author_invalid_format.txt
 - spec/fixtures/files/authors.csv
 - spec/fixtures/files/authors_bom.csv
 - spec/fixtures/files/authors_invalid_db.csv
@@ -120,6 +125,7 @@ files:
 - spec/fixtures/files/authors_with_tabs.tsv
 - spec/fixtures/files/empty.csv
 - spec/fixtures/files/only_headers.csv
+- spec/fixtures/files/post_comments.csv
 - spec/fixtures/files/posts.csv
 - spec/fixtures/files/posts_for_author.csv
 - spec/fixtures/files/posts_for_author_no_headers.csv
@@ -131,11 +137,10 @@ files:
 - spec/support/admin.rb
 - spec/support/rails_template.rb
 - tasks/test.rake
-homepage: http://github.com/Fivell/active_admin_import
+homepage: https://github.com/activeadmin-plugins/active_admin_import
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -143,41 +148,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.6.2
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
 summary: ActiveAdmin import based on activerecord-import gem.
-test_files:
-- spec/fixtures/files/author.csv
-- spec/fixtures/files/author_broken_header.csv
-- spec/fixtures/files/author_invalid.csv
-- spec/fixtures/files/authors.csv
-- spec/fixtures/files/authors_bom.csv
-- spec/fixtures/files/authors_invalid_db.csv
-- spec/fixtures/files/authors_invalid_model.csv
-- spec/fixtures/files/authors_no_headers.csv
-- spec/fixtures/files/authors_values_exceeded_headers.csv
-- spec/fixtures/files/authors_win1251_win_endline.csv
-- spec/fixtures/files/authors_with_ids.csv
-- spec/fixtures/files/authors_with_semicolons.csv
-- spec/fixtures/files/authors_with_tabs.tsv
-- spec/fixtures/files/empty.csv
-- spec/fixtures/files/only_headers.csv
-- spec/fixtures/files/posts.csv
-- spec/fixtures/files/posts_for_author.csv
-- spec/fixtures/files/posts_for_author_no_headers.csv
-- spec/import_result_spec.rb
-- spec/import_spec.rb
-- spec/model_spec.rb
-- spec/spec_helper.rb
-- spec/support/active_model_lint.rb
-- spec/support/admin.rb
-- spec/support/rails_template.rb
+test_files: []

data/CHANGELOG.md

@@ -1,33 +0,0 @@
-# Changelog
-## [5.0.0] - 2021-11-16
-- Ruby 3 compatibility added #190  | @clinejj
-- Support for a non UTF-8 file when zip uploading #185| @naokirin 
-- Rails 6 supported #183 | @pnghai
-- Drop ruby 2.4 support #192 | @Fivell
-
-
-## [4.2.0] - 2020-02-05
-- generic exception for import added #175 | @linqueta
-
-## [4.1.2] - 2019-12-16
-- allow application/octet-stream content-type #172 | @dmitry-sinina
-- Allow activerecord-import >= 0.27 #171 | @sagium 
-
-## [4.1.1] - 2019-09-20
-- Fix column slicing #168 | @doredesign
-- Handle errors on base #163
-
-## [4.1.0] - 2019-01-15
-- Upgrade dependencies: `activerecord-import` to >=0.27.1 | @jkowens
-
-## [4.0.0] - 2018-07-19
-- Adde German translation | @morris-frank
-- Remove support for Ruby 2.1 and Rails 4
-
-## [3.1.0] - 2018-04-10
-- Lower dependency of ActiveAdmin to >= 1.0.0.pre2
-- Add possibility to skip columns/values in CSV (batch_slice_columns method)
-
-[Unreleased]: https://github.com/activeadmin-plugins/active_admin_import/compare/v4.0.0...HEAD
-[4.0.0]: https://github.com/activeadmin-plugins/active_admin_import/compare/v3.1.0...v4.0.0
-[3.1.0]: https://github.com/activeadmin-plugins/active_admin_import/compare/3.0.0...v3.1.0