importo 2.0.5 → 3.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6005b4d69612846b48c464ea6dfe53d763498518201576610e26e5ee7b99a1a9
-  data.tar.gz: bf6b4711e93260528cb440217588155dd815874666e7296715e2878559153001
+  metadata.gz: 208e74497d020c5798661a0c0280d0952ab0a2381ede5317e3460f57b6ea8aa2
+  data.tar.gz: 78d02a8842863216adc84411c2ee71bd16202f40b7c50734248cf35aaa76a244
 SHA512:
-  metadata.gz: 3728c3639169ec860471b1a80f3b293c4ee987748f0004f26978a9f716ef1b9ad69ac48bb49a7cc2a42b90083ca89322100aab6ba3164b329accdb3a036a19d2
-  data.tar.gz: 047d674853e4facae068811e41579bc3c01af12ef9680c06151a80816bc8d0639e809607763d9be76d96cfb00a392236d623186887b22716ea2d0e63fabd81d8
+  metadata.gz: d954737dd202b1e068fdcae143e06f49a3cb7515d04b7da85bc0111c80cbeed7f384a6bf3ba968a0a742bfe76efbc6d554af9bc57b01777be3756968b8ae8e88
+  data.tar.gz: 8796b9d5746d0995e8cff516f30eb1662598ee3d34f5c4fd32c19d0604e379ffa79cae747a15b4502e4b0ecef59eed0662fda3bd42f0d4d0dee5fdd030c93fe1

data/README.md

@@ -26,9 +26,11 @@ class ProductsImporter < ApplicationImporter
   column attribute: :id
 
   # attributes
-  column attribute: :name
-  column attribute: :number
+  column attribute: :name, required: true
   column attribute: :description, strip_tags: false
+  column attribute: :number, export: { format: 'text', value: ->(record) { record.number }, example: 'FLAG-NLD-001' }, style: {b: true}
+  column attribute: :expires_on, export: { format: 'dd/mm/yyyy h:mm'}
+  column name: :price, export: { format: 'number', value: ->(record) { record.price } }
   column attribute: :images do |value|
     value.split(',').map do |image|
       uri = URI.parse(image)
@@ -36,12 +38,14 @@ class ProductsImporter < ApplicationImporter
       { filename: File.basename(uri.to_s), io: URI.open(uri) }
     end
   end
+  column name: :kitting_component_product, delay: ->(value) {value.present? ? 5 : 0 }
 
   def export_scope
     Current.account.products
   end
 end
 ```
+export args for column is optional, format takes excel custom format codes default is General  
 
 You should add translations to your locale files:
 
@@ -62,12 +66,22 @@ en:
         number: Number
         description: Description
         images: Images
-      explanation:
-        id: Record-id, only needed if you want to update an existing record
+        kitting_component_product: Component Product
+      # Shown in note in import sheet
       hint:
         id: 36 characters, existing of hexadecimal numbers, separated by dashes
         images: Allows multiple image urls, separated by comma
-      introduction: null
+      # Below items are show in explanation sheet
+      explanation:
+        id: Record-id, only needed if you want to update an existing record
+      example:
+        id: 12345678-1234-1234-1234-123456789012
+        name: TEST-123
+        number: TEST-123
+        description: Test product
+      value:
+        id: Optional
+
 ```
 
 ## Installation
@@ -78,6 +92,9 @@ Add this line to your application's Gemfile:
 gem 'importo'
 ```
 
+Importo depends on Sidekiq Pro's batch functionality, 
+though you can use [sidekiq-batch](https://github.com/entdec/sidekiq-batch) as a drop-in for that.
+
 And then execute:
 
 ```bash

data/Rakefile

@@ -1,39 +1,38 @@
 # frozen_string_literal: true
 
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 
-require 'rdoc/task'
+require "rdoc/task"
 
 RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Importo'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "Importo"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
-load 'rails/tasks/engine.rake'
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
 
-load 'rails/tasks/statistics.rake'
+load "rails/tasks/statistics.rake"
 
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
 
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
 
 task default: :test
 
 # Adds the Auxilium semver task
-spec = Gem::Specification.find_by_name 'auxilium'
+spec = Gem::Specification.find_by_name "auxilium"
 load "#{spec.gem_dir}/lib/tasks/semver.rake"
-

data/app/controllers/concerns/maintenance_standards.rb

@@ -11,7 +11,7 @@ module MaintenanceStandards
   #
   def flash_and_redirect(result, path, notice, error, render_action = :edit)
     if result
-      if params[:commit] == 'continue'
+      if params[:commit] == "continue"
         flash.now[:notice] = notice
       else
         redirect_to(path, notice: notice) && return

data/app/controllers/importo/imports_controller.rb

@@ -11,22 +11,22 @@ module Importo
     def create
       unless import_params
         @import = Import.new(kind: params[:kind], locale: I18n.locale)
-        flash[:error] = t('.flash.no_file')
+        Signum.error(Current.user, text: t('.flash.no_file'))
         render :new
         return
       end
-      @import = Import.new(import_params.merge(locale: I18n.locale, importo_ownable: Importo.config.current_import_owner))
+      @import = Import.new(import_params.merge(locale: I18n.locale,
+                                               importo_ownable: Importo.config.current_import_owner.call))
       if @import.valid? && @import.schedule!
-        flash[:notice] = t('.flash.success', id: @import.id)
-        redirect_to action: :index
+        redirect_to importo.new_import_path(params[:kind] || @import.kind)
       else
-        flash[:error] = t('.flash.error')
+        Signum.error(Current.user, text: t('.flash.error', error: @import.errors&.full_messages&.join('.')))
         render :new
       end
     end
 
     def undo
-      @import = Import.where(importo_ownable: Importo.config.current_import_owner).find(params[:id])
+      @import = Import.where(importo_ownable: Importo.config.current_import_owner.call).find(params[:id])
       if @import.can_revert? && @import.revert
         redirect_to action: :index, notice: 'Import reverted'
       else
@@ -35,8 +35,8 @@ module Importo
     end
 
     def destroy
-      @import = Import.where(importo_ownable: Importo.config.current_import_owner).find(params[:id])
-      redirect_to(action: :index, alert: 'Not allowed') && return unless Importo.config.admin_can_destroy(@import)
+      @import = Import.find(params[:id])
+      redirect_to(action: :index, alert: 'Not allowed') && return unless Importo.config.admin_can_destroy.call(@import)
 
       @import.destroy
       redirect_to action: :index
@@ -44,22 +44,25 @@ module Importo
 
     def sample
       import = Import.new(kind: params[:kind], locale: I18n.locale)
-      send_data import.importer.sample_file.read, type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', filename: import.importer.file_name('sample')
+      send_data import.importer.sample_file.read,
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', filename: import.importer.file_name('sample')
     end
 
     def export
       import = Import.new(kind: params[:kind], locale: I18n.locale)
-      send_data import.importer.export_file.read, type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', filename: import.importer.file_name('export')
+      send_data import.importer.export_file.read,
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', filename: import.importer.file_name('export')
     end
 
     def index
-      @imports = Importo.config.admin_visible_imports.order(created_at: :desc).limit(50)
+      @imports = Importo.config.admin_visible_imports.call.order(created_at: :desc).limit(50)
     end
 
     private
 
     def import_params
-      params.require(:import).permit(:original, :kind, :column_overrides, column_overrides: params.dig(:import, :column_overrides)&.keys)
+      params.require(:import).permit(:original, :kind, :column_overrides,
+                                     column_overrides: params.dig(:import, :column_overrides)&.keys)
     end
   end
 end

data/app/helpers/importo/application_helper.rb

@@ -2,16 +2,16 @@
 
 module Importo
   module ApplicationHelper
-    def respond_to_missing?(method)
-      method.ends_with?('_url') || method.ends_with?('_path')
-    end
-
-    def method_missing(method, *args, &block)
-      if main_app.respond_to?(method)
-        main_app.send(method, *args)
-      else
-        super
-      end
-    end
+    # def respond_to_missing?(method)
+    #   method.ends_with?('_url') || method.ends_with?('_path')
+    # end
+    #
+    # def method_missing(method, *args, &block)
+    #   if main_app.respond_to?(method)
+    #     main_app.send(method, *args)
+    #   else
+    #     super
+    #   end
+    # end
   end
 end

data/app/importers/concerns/exportable.rb

@@ -1,7 +1,6 @@
-
 # frozen_string_literal: true
 
-require 'active_support/concern'
+require "active_support/concern"
 
 module Exportable
   extend ActiveSupport::Concern
@@ -14,7 +13,9 @@ module Exportable
   end
 
   def sample_data
-    [export_columns.map { |_, c| c.options[:example] || '' }]
+    sample_data = []
+    100.times { sample_data << export_columns.map { |_, c| c.options[:example] || "" } }
+    sample_data
   end
 
   #
@@ -38,15 +39,16 @@ module Exportable
 
   def export_row(record)
     export_columns.map do |_, c|
-      value = ''
+      value = ""
 
       if c.options[:attribute]
-        if record.respond_to?(c.options[:attribute])
+        if c.options[:export]&.key?(:value)
+          value = c.options[:export][:value].call(record) if c.options[:export][:value].is_a?(Proc)
+        elsif record.respond_to?(c.options[:attribute])
           value = record.send(c.options[:attribute])
           value = value&.body&.to_html if value.is_a?(ActionText::RichText)
         end
-
-        value ||= record.attributes[c.options[:attribute].to_s]
+        value ||= record.attributes[c.options[:attribute].to_s] if value.nil?
       end
 
       value
@@ -59,9 +61,9 @@ module Exportable
     workbook = xls.workbook
     sheet = workbook.add_worksheet(name: friendly_name&.pluralize || model.name.demodulize.pluralize)
     workbook.styles do |style|
-      introduction_style = style.add_style(bg_color: 'E2EEDA')
-      header_style = style.add_style(b: true, bg_color: 'A8D08E', border: { style: :thin, color: '000000' })
-      header_required_style = style.add_style(b: true, bg_color: 'A8D08E', fg_color: 'C00100', border: { style: :thin, color: '000000' })
+      introduction_style = style.add_style(bg_color: "E2EEDA")
+      header_style = style.add_style(b: true, bg_color: "A8D08E", border: {style: :thin, color: "000000"})
+      header_required_style = style.add_style(b: true, bg_color: "A8D08E", fg_color: "C00100", border: {style: :thin, color: "000000"})
 
       # Introduction
       introduction.each_with_index do |intro, i|
@@ -75,14 +77,19 @@ module Exportable
 
       export_columns.each.with_index do |f, i|
         field = f.last
-        sheet.add_comment ref: "#{nr_to_col(i)}#{introduction.count + 1}", author: '', text: field.hint, visible: false if field.hint.present?
+        sheet.add_comment ref: "#{nr_to_col(i)}#{introduction.count + 1}", author: "", text: field.hint, visible: false if field.hint.present?
+      end
+      styles = export_columns.map do |_, c|
+        if c.options.dig(:export, :format) == "number" || (c.options.dig(:export, :format).nil? && c.options.dig(:export, :example).is_a?(Numeric))
+          number = workbook.styles.add_style format_code: "#"
+        elsif c.options.dig(:export, :format) == "text" || (c.options.dig(:export, :format).nil? && c.options.dig(:export, :example).is_a?(String))
+          text = workbook.styles.add_style format_code: "@"
+        elsif c.options.dig(:export, :format)
+          workbook.styles.add_style format_code: c.options.dig(:export, :format).to_s
+        else
+          workbook.styles.add_style format_code: "General"
+        end
       end
-
-      number = workbook.styles.add_style format_code: '#'
-      text = workbook.styles.add_style format_code: '@'
-
-      styles = export_columns.map { |_, c| c.options[:example].is_a?(Numeric) ? number : text }
-
       # Examples
       data_rows.each do |data|
         sheet.add_row data, style: styles
@@ -91,15 +98,15 @@ module Exportable
 
     sheet.column_info[0].width = 10
 
-    sheet = workbook.add_worksheet(name: I18n.t('importo.sheet.explanation.name'))
+    sheet = workbook.add_worksheet(name: I18n.t("importo.sheet.explanation.name"))
 
     workbook.styles do |style|
-      introduction_style = style.add_style(bg_color: 'E2EEDA')
-      header_style = style.add_style(b: true, bg_color: 'A8D08E', border: { style: :thin, color: '000000' })
+      introduction_style = style.add_style(bg_color: "E2EEDA")
+      header_style = style.add_style(b: true, bg_color: "A8D08E", border: {style: :thin, color: "000000"})
 
       column_style = style.add_style(b: true)
-      required_style = style.add_style(b: true, fg_color: 'C00100')
-      wrap_style = workbook.styles.add_style alignment: { wrap_text: true }
+      required_style = style.add_style(b: true, fg_color: "C00100")
+      wrap_style = workbook.styles.add_style alignment: {wrap_text: true}
 
       # Introduction
       introduction.each_with_index do |intro, i|
@@ -109,10 +116,10 @@ module Exportable
       end
 
       # Header row
-      sheet.add_row [I18n.t('importo.sheet.explanation.column'), I18n.t('importo.sheet.explanation.explanation')], style: [header_style] * 2
+      sheet.add_row [I18n.t("importo.sheet.explanation.column"), I18n.t("importo.sheet.explanation.value"), I18n.t("importo.sheet.explanation.explanation"), I18n.t("importo.sheet.explanation.example")], style: [header_style] * 4
       export_columns.each do |_, c|
         styles = [c.options[:required] ? required_style : column_style, wrap_style]
-        sheet.add_row [c.name, c.explanation], style: styles
+        sheet.add_row [c.name, c.value, c.explanation, c.example], style: styles
       end
     end
 

data/app/importers/concerns/importable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
+require "active_support/concern"
 
 module Importable
   extend ActiveSupport::Concern
@@ -14,15 +14,13 @@ module Importable
   end
 
   def convert_values(row)
-    return row if row.instance_variable_get('@importo_converted_values')
+    return row if row.instance_variable_get(:@importo_converted_values)
 
-    row.instance_variable_set('@importo_converted_values', true)
+    row.instance_variable_set(:@importo_converted_values, true)
 
-    cols_to_populate = columns.select do |_, v|
-      v.options[:attribute].present?
-    end
+    columns.each do |k, col|
+      next if col.proc.blank? || row[k].nil?
 
-    cols_to_populate.each do |k, col|
       attr = col.options[:attribute]
 
       row[k] = import.column_overrides[col.attribute] if import.column_overrides[col.attribute]
@@ -52,26 +50,36 @@ module Importable
   # It wil try and find the record by id, or initialize a new record with it's attributes set based on the mapping from columns
   #
   def populate(row, record = nil)
-    raise 'No attributes set for columns' unless columns.any? { |_, v| v.options[:attribute].present? }
+    raise "No attributes set for columns" unless columns.any? { |_, v| v.options[:attribute].present? }
 
     row = convert_values(row)
 
     result = if record
-               record
-             else
-               raise 'No model set' unless model
+      record
+    else
+      raise "No model set" unless model
 
-               model.find_or_initialize_by(id: row['id'])
-             end
+      model.find_or_initialize_by(id: row["id"])
+    end
 
     attributes = {}
     cols_to_populate = columns.select do |_, v|
       v.options[:attribute].present?
     end
 
+    cols_to_populate = cols_to_populate.deep_symbolize_keys
+
     cols_to_populate.each do |k, col|
       attr = col.options[:attribute]
-      attributes = set_attribute(attributes, attr, row[k]) if row[k].present?
+
+      next unless row.key? k
+      next if !row[k].present? && col.options[:default].nil?
+
+      attributes = if !row[k].present? && !col.options[:default].nil?
+        set_attribute(attributes, attr, col.options[:default])
+      else
+        set_attribute(attributes, attr, row[k])
+      end
     end
 
     result.assign_attributes(attributes)
@@ -80,89 +88,163 @@ module Importable
   end
 
   #
-  # Mangle the record before saving
+  # Callbakcs
   #
+  def before_build(_record, _row)
+  end
+
+  def around_build(_record, _row)
+    yield
+  end
+
+  def after_build(_record, _row)
+  end
+
   def before_save(_record, _row)
-    # Implement optionally in child class to mangle
   end
 
-  #
-  # Any updates that have to be done after saving
-  #
+  def around_save(_record, _row)
+    yield
+  end
+
   def after_save(_record, _row)
-    # Implement optionally in child class to perform other updates
+  end
+
+  def before_validate(_record, _row)
+  end
+
+  def around_validate(_record, _row)
+    yield
+  end
+
+  def after_validate(_record, _row)
   end
 
   #
   # Does the actual import
   #
   def import!
-    raise ArgumentError, 'Invalid data structure' unless structure_valid?
-
-    results = loop_data_rows do |attributes, index|
-      process_data_row(attributes, index)
+    raise ArgumentError, "Invalid data structure" unless structure_valid?
+
+    batch = Sidekiq::Batch.new
+    batch.description = "#{import.original.filename} - #{import.kind}"
+    batch.on(:success, Importo::ImportJobCallback, import_id: import.id)
+
+    batch.jobs do
+      column_with_delay = columns.select { |k, v| v.delay.present? }
+      loop_data_rows do |attributes, index|
+        if column_with_delay.present?
+          delay = column_with_delay.map do |k, v|
+            next unless attributes[k].present?
+            v.delay.call(attributes[k])
+          end.compact
+        end
+        Importo::ImportJob.set(wait_until: (delay.max * index).seconds.from_now).perform_async(JSON.dump(attributes), index, import.id) if delay.present?
+        Importo::ImportJob.perform_async(JSON.dump(attributes), index, import.id) unless delay.present?
+      end
     end
-    @import.result.attach(io: results_file, filename: @import.importer.file_name('results'),
-                          content_type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
-
-    @import.result_message = I18n.t('importo.importers.result_message', nr: results.compact.count, of: results.count,
-                                                                        start_row: data_start_row)
-    @import.complete!
 
     true
-  rescue StandardError => e
+  rescue => e
     @import.result_message = "Exception: #{e.message}"
-    Rails.logger.error "Importo exception: #{e.message} backtrace #{e.backtrace.join(';')}"
+    Rails.logger.error "Importo exception: #{e.message} backtrace #{e.backtrace.join(";")}"
     @import.failure!
 
     false
   end
 
-  private
-
-  ##
-  # Overridable failure method
-  #
-  def failure(_row, _record, index, exception)
-    Rails.logger.error "#{exception.message} processing row #{index}: #{exception.backtrace.join(';')}"
-  end
-
-  def process_data_row(attributes, index)
+  def process_data_row(attributes, index, last_attempt: true)
     record = nil
     row_hash = Digest::SHA256.base64digest(attributes.inspect)
     duplicate_import = nil
 
-    begin
-      ActiveRecord::Base.transaction(requires_new: true) do
+    run_callbacks :row_import do
+      record = nil
+
+      ActiveRecord::Base.transaction do
         register_result(index, hash: row_hash, state: :processing)
 
-        record = build(attributes)
-        record.validate!
-        before_save(record, attributes)
-        record.save!
-        after_save(record, attributes)
+        before_build(record, attributes)
+        around_build(record, attributes) do
+          record = build(attributes)
+        end
+        after_build(record, attributes)
+
+        before_validate(record, attributes)
+        around_validate(record, attributes) do
+          record.validate!
+        end
+        after_validate(record, attributes)
+
+        model.with_advisory_lock(:importo) do
+          before_save(record, attributes)
+          around_save(record, attributes) do
+            record.save!
+          end
+          after_save(record, attributes)
+        end
+
         duplicate_import = duplicate?(row_hash, record.id)
         raise Importo::DuplicateRowError if duplicate_import
 
         register_result(index, class: record.class.name, id: record.id, state: :success)
       end
-      record
-    rescue Importo::DuplicateRowError
-      record_id = duplicate_import.results.find { |data| data['hash'] == row_hash }['id']
-      register_result(index, id: record_id, state: :duplicate,
-                             message: "Row already imported successfully on #{duplicate_import.created_at.to_date}")
-      nil
-    rescue StandardError => e
-      errors = record.respond_to?(:errors) && record.errors.full_messages.join(', ')
-      error_message = "#{e.message} (#{e.backtrace.first.split('/').last})"
-      failure(attributes, record, index, e)
-      register_result(index, class: record.class.name, state: :failure, message: error_message, errors: errors)
-      nil
     end
+
+    record
+  rescue Importo::DuplicateRowError
+    record_id = duplicate_import.results.find { |data| data["hash"] == row_hash }["id"]
+    register_result(index, id: record_id, state: :duplicate,
+      message: "Row already imported successfully on #{duplicate_import.created_at.to_date}")
+
+    run_callbacks(:row_import, :after)
+    nil
+  rescue Importo::RetryError => e
+    raise e unless last_attempt
+
+    errors = record.respond_to?(:errors) && record.errors.full_messages.join(", ")
+    error_message = "#{e.message} (#{e.backtrace.first.split("/").last})"
+    failure(attributes, record, index, e)
+    register_result(index, class: record.class.name, state: :failure, message: error_message, errors: errors)
+    nil
+  rescue => e
+    # We rescue ActiveRecord::RecordNotUnique here, due to how transactions work, some row imports may have started the transaction and the current row doesn't see the results
+    raise Importo::RetryError.new("ActiveRecord::RecordNotUnique", 2) if !last_attempt && e.is_a?(ActiveRecord::RecordNotUnique)
+    errors = record.respond_to?(:errors) && record.errors.full_messages.join(", ")
+    error_message = "#{e.message} (#{e.backtrace.first.split("/").last})"
+    failure(attributes, record, index, e)
+    register_result(index, class: record.class.name, state: :failure, message: error_message, errors: errors)
+    run_callbacks(:row_import, :after)
+    nil
+  end
+
+  private
+
+  ##
+  # Overridable failure method
+  #
+  def failure(_row, _record, index, exception)
+    Rails.logger.error "#{exception.message} processing row #{index}: #{exception.backtrace.join(";")}"
   end
 
   def set_attribute(hash, path, value)
-    tmp_hash = path.to_s.split('.').reverse.inject(value) { |h, s| { s => h } }
+    tmp_hash = path.to_s.split(".").reverse.inject(value) { |h, s| {s => h} }
     hash.deep_merge(tmp_hash)
   end
+
+  # Only when the block returns a record created in this import, it returns that record, otherwise nil
+  #
+  #  record ||= only_current_import! do
+  #    User.find_by(email: row[:email].downcase) if row[:email].present?
+  #  end
+  #
+  # Only if the user was created this import will the block return the user found.
+  #
+  # @return [Object]
+  def only_current_import!(&block)
+    ActiveRecord::Base.uncached do
+      record = yield
+      record if record && @import.results.where("details->>'state' = ?", "success").where("details->>'id' = ? ", record.id).exists?
+    end
+  end
 end

data/app/importers/concerns/importer_dsl.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
+require "active_support/concern"
 
 module ImporterDsl
   extend ActiveSupport::Concern
@@ -31,19 +31,11 @@ module ImporterDsl
     #
     # @param [Object] args
     # @param [Object] block which will filter the results before storing the value in the attribute, this is useful for lookups or reformatting
-    def column(*args, &block)
-      options = args.extract_options!
-
-      name = args[0]
-      name ||= options[:name]
-      name ||= options[:attribute]
-
-      hint = args[1]
-      hint ||= options[:hint]
-
-      options[:scope] = self.name.underscore.to_s.tr('/', '.').to_sym
-
-      columns[name] = Importo::ImportColumn.new(name, hint, options[:explanation], options, &block)
+    def column(**options, &block)
+      column_name ||= options[:name]
+      column_name ||= options[:attribute]
+      options[:scope] = name.to_s.underscore.to_s.tr("/", ".").to_sym
+      columns[column_name] = Importo::ImportColumn.new(name: column_name, **options, &block)
     end
 
     def model(model = nil)