active_admin_import 5.1.0 → 7.0.0

data/lib/active_admin_import/dsl.rb

@@ -25,11 +25,29 @@ module ActiveAdminImport
   # +plural_resource_label+:: pluralized resource label value (default config.plural_resource_label)
   #
   module DSL
+    CONTEXT_METHOD = :active_admin_import_context
+
+    ACTIVE_ADMIN_V4 = Gem::Version.new(ActiveAdmin::VERSION) >= Gem::Version.new('4.0.0.beta1')
+
+    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
       if result.empty?
-        flash[:warning] = I18n.t('active_admin_import.file_empty_error')
+        flash[ACTIVE_ADMIN_V4 ? :alert : :warning] = I18n.t('active_admin_import.file_empty_error')
       else
         if result.failed?
           flash[:error] = I18n.t(
@@ -57,11 +75,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
 
@@ -69,7 +83,8 @@ module ActiveAdminImport
         if authorized?(ActiveAdminImport::Auth::IMPORT, active_admin_config.resource_class)
           link_to(
             I18n.t('active_admin_import.import_model', plural_model: options[:plural_resource_label]),
-            action: :import
+            { action: :import },
+            options[:action_item_html_options]
           )
         end
       end
@@ -78,13 +93,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 +107,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,12 +16,14 @@ module ActiveAdminImport
       :ignore,
       :template,
       :template_object,
+      :result_class,
       :resource_class,
       :resource_label,
       :plural_resource_label,
       :error_limit,
       :headers_rewrites,
-      :if
+      :if,
+      :action_item_html_options
     ].freeze
 
     def self.options_for(config, options = {})
@@ -38,7 +40,10 @@ module ActiveAdminImport
         plural_resource_label: config.plural_resource_label,
         error_limit: 5,
         headers_rewrites: {},
-        if: true
+        if: true,
+        # AA 4's built-in action_items hardcode this class for Tailwind styling
+        # (lib/active_admin/resource/action_items.rb). It's a no-op on AA 3.
+        action_item_html_options: { class: 'action-item-button' }
       }.deep_merge(options)
     end
   end

data/lib/active_admin_import/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveAdminImport
-  VERSION = '5.1.0'
+  VERSION = '7.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
@@ -41,8 +41,8 @@ describe 'import', type: :feature do
   end
 
   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
+    attach_file(ImportFormSelectors.file_input_id, File.expand_path("./spec/fixtures/files/#{name}.#{ext}"))
+    find_button(ImportFormSelectors.import_button_text).click
   end
 
   context 'posts index' do
@@ -118,7 +118,7 @@ describe 'import', type: :feature do
             # reload page
             visit '/admin/posts/import'
             # submit form without file
-            find_button('Import').click
+            find_button(ImportFormSelectors.import_button_text).click
           end
 
           it 'should render validation error' do
@@ -171,7 +171,7 @@ describe 'import', type: :feature 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
+      find_link(ImportFormSelectors.import_link_text).click
       expect(current_path).to eq('/admin/authors/import')
     end
   end
@@ -228,14 +228,14 @@ describe 'import', type: :feature do
     end
 
     it 'has valid form' do
-      form = find('#new_active_admin_import_model')
+      form = find(ImportFormSelectors.form_css)
       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')
+      file_input = form.find(ImportFormSelectors.file_input_css)
       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')
+      submit_input = form.find(ImportFormSelectors.submit_css)
+      expect(submit_input[:value]).to eq(ImportFormSelectors.import_button_text)
       expect(submit_input[:type]).to eq('submit')
     end
 
@@ -261,7 +261,7 @@ describe 'import', type: :feature do
 
       context 'when no file' do
         it 'should render error' do
-          find_button('Import').click
+          find_button(ImportFormSelectors.import_button_text).click
           expect(Author.count).to eq(0)
           expect(page).to have_content I18n.t('active_admin_import.no_file_error')
         end
@@ -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(ImportFormSelectors.import_button_text).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,44 +11,36 @@ require 'bundler'
 Bundler.setup
 
 ENV['RAILS_ENV'] = 'test'
-# Ensure the Active Admin load path is happy
 require 'rails'
+require 'test_app_paths'
 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['RAILS_ROOT'] = TestAppPaths.app_root
 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
 
 require 'rspec/rails'
 require 'support/admin'
+require 'support/import_form_selectors'
 require 'capybara/rails'
 require 'capybara/rspec'
-require 'capybara/poltergeist'
-
-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'])
-end
 
-Capybara.javascript_driver = :poltergeist
+# Specs exercise ActiveAdmin through Capybara's default rack_test driver — no
+# JavaScript or real browser is needed, so no Cuprite/Chrome or app server.
+Capybara.default_driver = :rack_test
 
 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/import_form_selectors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Formtastic 6 (AA 4) keeps the same DOM IDs as Formtastic 4 (AA 3) for this
+# form, so one selector set serves both — branch here if a future AA shifts an ID.
+module ImportFormSelectors
+  module_function
+
+  SELECTORS = {
+    form_id: 'new_active_admin_import_model',
+    file_input_id: 'active_admin_import_model_file',
+    file_input_css: 'input#active_admin_import_model_file',
+    submit_css: '#active_admin_import_model_submit_action input',
+    import_button_text: 'Import',
+    import_link_text: 'Import Authors'
+  }.freeze
+
+  def form_id            = SELECTORS[:form_id]
+  def form_css           = "##{form_id}"
+  def file_input_id      = SELECTORS[:file_input_id]
+  def file_input_css     = SELECTORS[:file_input_css]
+  def submit_css         = SELECTORS[:submit_css]
+  def import_button_text = SELECTORS[:import_button_text]
+  def import_link_text   = SELECTORS[:import_link_text]
+end

data/spec/support/rails_template.rb

@@ -1,29 +1,71 @@
-# frozen_string_literal: true
-# Rails template to build the sample app for specs
+create_file "app/assets/config/manifest.js", skip: true
 
-generate :model, 'author name:string{10}:uniq last_name:string birthday:date'
-generate :model, 'post title:string:uniq body:text author:references'
+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") %>
 
-# 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'
+    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
 
-# 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"
+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'
 
-# 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__)"
+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  has_many :post_comments\n", before: 'end'
 
-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'))
 
+aa_v4 = ENV['AA']&.start_with?('4')
+
 generate :'active_admin:install --skip-users'
-generate :'formtastic:install'
 
-run 'rm -r test'
-run 'rm -r spec'
+if aa_v4
+  # `active_admin:assets` swaps AA 3's Sprockets SCSS/JS for AA 4's Tailwind CSS
+  # stub. We don't compile it — specs assert on DOM and flash text, not styling,
+  # so the stub suffices and no Node is needed. `builds/` satisfies cssbundling-rails.
+  generate :'active_admin:assets'
+  run 'mkdir -p app/assets/builds'
+else
+  generate :'formtastic:install'
+end
 
+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/spec/support/test_app_paths.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module TestAppPaths
+  module_function
+
+  def app_dir_name
+    "rails-#{Rails::VERSION::STRING}-#{ENV['DB'] || 'sqlite'}-aa#{ENV['AA'] || 'default'}"
+  end
+
+  # Absolute path under spec/rails/, used as RAILS_ROOT.
+  def app_root
+    File.expand_path("../rails/#{app_dir_name}", __dir__)
+  end
+end

data/tasks/test.rake

@@ -1,7 +1,30 @@
-# frozen_string_literal: true
-desc 'Creates a test rails app for the specs to run against'
+require_relative '../spec/support/test_app_paths'
+
+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
+  aa_v4 = ENV['AA']&.start_with?('4')
+
+  puts "[setup] ActiveAdmin: #{ENV['AA'] || '(Gemfile default)'} / Rails: #{Rails::VERSION::STRING} / DB: #{rails_db}"
+
+  rails_new_opts = %W(
+    --skip-turbolinks
+    --skip-spring
+    --skip-bootsnap
+    -d #{rails_db}
+    -m
+    spec/support/rails_template.rb
+  )
+  # v4 drops sprockets-rails (see Gemfile), so skip the asset pipeline to
+  # avoid the auto-generated `config/initializers/assets.rb` crashing at boot.
+  rails_new_opts.unshift('--skip-asset-pipeline') if aa_v4
+
+  system "bundle exec rails new spec/rails/#{TestAppPaths.app_dir_name} #{rails_new_opts.join(' ')}"
 end