bulkrax 9.4.0 → 9.4.2

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_helpers.rb

@@ -46,14 +46,20 @@ module Bulkrax
       end
 
       def build_valid_validation_headers(mapping_manager, field_analyzer, all_models, mappings, field_metadata)
-        svc = ValidationContext.new(
+        svc = Bulkrax::CsvParser::ValidationContext.new(
           mapping_manager: mapping_manager,
           field_analyzer: field_analyzer,
           all_models: all_models,
           mappings: mappings
         )
         all_cols = CsvTemplate::ColumnBuilder.new(svc).all_columns
-        all_cols - CsvTemplate::CsvBuilder::IGNORED_PROPERTIES
+        # ColumnBuilder only emits the first `from:` alias per non-property key
+        # (core/file/relationship). Accept every alias so a CSV using a
+        # non-primary alias like `file` (when mappings are `from: ['item', 'file']`)
+        # isn't flagged unrecognised. Property-level aliases are handled
+        # separately by find_unrecognized_validation_headers via mapped_to_key.
+        non_property_aliases = non_property_mapping_aliases(mappings)
+        (all_cols + non_property_aliases).uniq - CsvTemplate::CsvBuilder::IGNORED_PROPERTIES
       rescue StandardError => e
         Rails.logger.error("CsvParser.validate_csv: error building valid headers – #{e.message}")
         standard = %w[model source_identifier parents children file]
@@ -62,6 +68,20 @@ module Bulkrax
         (standard + model_fields).uniq
       end
 
+      # Returns every `from:` alias for mapping keys that describe non-property
+      # columns (core/file/relationship). These keys are fixed by the descriptor
+      # rather than discovered per-model, so every alias is unambiguously valid.
+      def non_property_mapping_aliases(mappings)
+        descriptor = CsvTemplate::ColumnDescriptor.new
+        non_property_keys = descriptor.core_columns +
+                            CsvTemplate::ColumnDescriptor::COLUMN_DESCRIPTIONS[:files].flat_map(&:keys) +
+                            CsvTemplate::ColumnDescriptor::COLUMN_DESCRIPTIONS[:relationships].flat_map(&:keys)
+        non_property_keys.flat_map do |key|
+          entry = mappings[key]
+          entry.is_a?(Hash) ? Array(entry["from"]) : []
+        end
+      end
+
       def find_missing_required_headers(headers, field_metadata, mapping_manager)
         csv_keys = headers.map { |h| mapping_manager.mapped_to_key(h).sub(/_\d+\z/, '') }.uniq
         missing = []
@@ -73,11 +93,23 @@ module Bulkrax
         missing.uniq
       end
 
-      def find_unrecognized_validation_headers(headers, valid_headers)
+      # A header is considered recognised if it appears in valid_headers or
+      # if it matches any alias in a known property's `from` array. The real
+      # importer (CsvParser#missing_elements) scans every `from` entry when
+      # matching incoming columns, so the validator has to use the same rule
+      # — otherwise a CSV that imports cleanly gets flagged for columns like
+      # `creator` when the mapping declares `creator: { from: ['author', 'creator'] }`.
+      def find_unrecognized_validation_headers(headers, valid_headers, mapping_manager: nil, field_metadata: nil)
+        known_property_keys = (field_metadata || {}).values.flat_map { |m| Array(m[:properties]) }.to_set
         checker = DidYouMean::SpellChecker.new(dictionary: valid_headers)
-        headers
-          .reject { |h| h.blank? || valid_headers.include?(h) || valid_headers.include?(h.sub(/_\d+\z/, '')) }
-          .index_with { |h| checker.correct(h).first }
+        unrecognized = headers.reject do |h|
+          next true if h.blank?
+          base = h.sub(/_\d+\z/, '')
+          next true if valid_headers.include?(h) || valid_headers.include?(base)
+          mapped_key = mapping_manager&.mapped_to_key(base)
+          mapped_key && known_property_keys.include?(mapped_key)
+        end
+        unrecognized.index_with { |h| checker.correct(h).first }
       end
 
       def find_empty_column_positions(headers, raw_csv)
@@ -120,25 +152,12 @@ module Bulkrax
         }
       end
 
-      def apply_rights_statement_validation_override!(result, missing_required)
-        only_rights = missing_required.present? &&
-                      missing_required.all? { |h| h[:field].to_s == 'rights_statement' }
-        return unless only_rights && !result[:isValid]
-        return if result[:headers].blank?
-        return if result[:missingFiles]&.any?
-
-        result[:isValid]     = true
-        result[:hasWarnings] = true
-      end
-
       # Assembles the final result hash returned to the guided import UI.
       def assemble_result(headers:, missing_required:, header_issues:, row_errors:, csv_data:, file_validator:, collections:, works:, file_sets:, notices: []) # rubocop:disable Metrics/ParameterLists
-        row_error_entries   = row_errors.select { |e| e[:severity] == 'error' }
-        row_warning_entries = row_errors.select { |e| e[:severity] == 'warning' }
-        has_errors   = missing_required.any? || headers.blank? || csv_data.empty? ||
-                       file_validator.missing_files.any? || row_error_entries.any?
-        has_warnings = header_issues[:unrecognized].any? || header_issues[:empty_columns].any? ||
-                       file_validator.possible_missing_files? || row_warning_entries.any? || notices.any?
+        is_valid, has_warnings = determine_validity(
+          headers: headers, missing_required: missing_required, header_issues: header_issues,
+          row_errors: row_errors, csv_data: csv_data, file_validator: file_validator, notices: notices
+        )
 
         {
           headers: headers,
@@ -147,7 +166,7 @@ module Bulkrax
           unrecognized: header_issues[:unrecognized],
           emptyColumns: header_issues[:empty_columns],
           rowCount: csv_data.length,
-          isValid: !has_errors,
+          isValid: is_valid,
           hasWarnings: has_warnings,
           rowErrors: row_errors,
           collections: collections,
@@ -161,6 +180,27 @@ module Bulkrax
         }
       end
 
+      # Returns [is_valid, has_warnings] for the assembled result.
+      # rights_statement can be supplied on Step 2, so a CSV missing ONLY the
+      # rights_statement column is valid-with-warnings rather than a blocker;
+      # the display formatter styles that case as a warning accordion.
+      def determine_validity(headers:, missing_required:, header_issues:, row_errors:, csv_data:, file_validator:, notices:) # rubocop:disable Metrics/ParameterLists
+        row_error_entries   = row_errors.select { |e| e[:severity] == 'error' }
+        row_warning_entries = row_errors.select { |e| e[:severity] == 'warning' }
+
+        only_rights_missing = missing_required.present? &&
+                              missing_required.all? { |h| h[:field].to_s == 'rights_statement' }
+        blocking_missing_required = missing_required.any? && !only_rights_missing
+
+        has_errors   = blocking_missing_required || headers.blank? || csv_data.empty? ||
+                       file_validator.missing_files.any? || row_error_entries.any?
+        has_warnings = header_issues[:unrecognized].any? || header_issues[:empty_columns].any? ||
+                       file_validator.possible_missing_files? || row_warning_entries.any? ||
+                       notices.any? || only_rights_missing
+
+        [!has_errors, has_warnings]
+      end
+
       # Builds the find_record lambda used by row validators and hierarchy extraction.
       def build_find_record
         all_mappings = Bulkrax.field_mappings['Bulkrax::CsvParser'] || {}
@@ -205,19 +245,11 @@ module Bulkrax
       end
 
       def resolve_parent_split_pattern(mappings)
-        split_val = mappings.dig('parents', 'split') || mappings.dig(:parents, :split)
-        return nil if split_val.blank?
-        return Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON if split_val == true
-
-        split_val
+        Bulkrax::SplitPatternCoercion.coerce(mappings.dig('parents', 'split') || mappings.dig(:parents, :split))
       end
 
       def resolve_children_split_pattern(mappings)
-        split_val = mappings.dig('children', 'split') || mappings.dig(:children, :split)
-        return nil if split_val.blank?
-        return Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON if split_val == true
-
-        split_val
+        Bulkrax::SplitPatternCoercion.coerce(mappings.dig('children', 'split') || mappings.dig(:children, :split))
       end
 
       # Builds a graph of { source_identifier => [parent_ids] } from all CSV records.
@@ -264,8 +296,9 @@ module Bulkrax
       end
 
       def split_or_single(value, split_pattern)
-        if split_pattern
-          value.to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+        coerced = Bulkrax::SplitPatternCoercion.coerce(split_pattern)
+        if coerced
+          value.to_s.split(coerced).map(&:strip).reject(&:blank?)
         elsif value.present?
           [value.to_s.strip]
         else

data/app/parsers/concerns/bulkrax/csv_parser/csv_validation_hierarchy.rb

@@ -5,7 +5,7 @@ module Bulkrax
     # Hierarchy-building helpers for CsvValidation. Handles extracting and
     # categorising items from parsed CSV data for the guided import tree view.
     module CsvValidationHierarchy
-      def extract_validation_items(csv_data, all_ids = Set.new, find_record = nil, parent_split_pattern: nil, child_split_pattern: '|')
+      def extract_validation_items(csv_data, all_ids = Set.new, find_record = nil, parent_split_pattern: nil, child_split_pattern: Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON)
         child_to_parents = build_child_to_parents_map(csv_data, child_split_pattern: child_split_pattern)
         collections = []
         works       = []
@@ -19,7 +19,7 @@ module Bulkrax
         [collections, works, file_sets]
       end
 
-      def build_child_to_parents_map(csv_data, child_split_pattern: '|')
+      def build_child_to_parents_map(csv_data, child_split_pattern: Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON)
         Hash.new { |h, k| h[k] = [] }.tap do |map|
           csv_data.each do |item|
             next if item[:source_identifier].blank?
@@ -31,7 +31,7 @@ module Bulkrax
         end
       end
 
-      def categorise_validation_item(item, child_to_parents, all_ids, collections, works, file_sets, find_record = nil, parent_split_pattern: nil, child_split_pattern: '|') # rubocop:disable Metrics/ParameterLists
+      def categorise_validation_item(item, child_to_parents, all_ids, collections, works, file_sets, find_record = nil, parent_split_pattern: nil, child_split_pattern: Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON) # rubocop:disable Metrics/ParameterLists
         item_id   = item[:source_identifier]
         model_str = item[:model].to_s
 
@@ -51,7 +51,7 @@ module Bulkrax
         item_id  = item[:source_identifier]
         title    = item[:raw_row]['title'] || item_id
         parents  = collect_relationship_ids(item[:parent],   item[:raw_row], 'parents',  split_pattern: opts[:parent])
-        children = collect_relationship_ids(item[:children], item[:raw_row], 'children', split_pattern: opts[:child] || '|')
+        children = collect_relationship_ids(item[:children], item[:raw_row], 'children', split_pattern: opts[:child] || Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON)
 
         {
           id: item_id,
@@ -65,12 +65,14 @@ module Bulkrax
         }
       end
 
-      def parse_relationship_field(value, split_pattern: '|')
+      def parse_relationship_field(value, split_pattern: Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON)
         return [] if value.blank?
-        value.to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+
+        pattern = Bulkrax::SplitPatternCoercion.coerce(split_pattern) || Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON
+        value.to_s.split(pattern).map(&:strip).reject(&:blank?)
       end
 
-      def collect_relationship_ids(base_value, raw_row, column, split_pattern: '|')
+      def collect_relationship_ids(base_value, raw_row, column, split_pattern: Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON)
         base_ids = parse_relationship_field(base_value, split_pattern: split_pattern)
         suffix_pattern = /\A#{Regexp.escape(column)}_\d+\z/
         suffix_ids = raw_row

data/app/services/bulkrax/csv_template/file_validator.rb

@@ -46,7 +46,7 @@ module Bulkrax
         @referenced_files ||= @csv_data.flat_map do |item|
           next [] if item[:file].blank?
 
-          item[:file].split(Bulkrax.multi_value_element_split_on).map { |f| File.basename(f.strip) }
+          item[:file].split(Bulkrax::CsvParser.file_split_pattern).map { |f| File.basename(f.strip) }
         end.compact
       end
 

data/app/services/bulkrax/csv_template/mapping_manager.rb

@@ -6,8 +6,16 @@ module Bulkrax
     class MappingManager
       attr_reader :mappings
 
-      def initialize
-        @mappings = load_mappings
+      # @param include_generated [Boolean] when false, excludes mapping entries
+      #   flagged `generated: true` (system-maintained fields like
+      #   date_uploaded, depositor, source_identifier). Template generation
+      #   passes +false+ so the downloadable template doesn't expose
+      #   system columns; import validation uses the default +true+ so that
+      #   user-configured mappings like `rights_statement` (which Bulkrax
+      #   ships with `generated: true`) are still recognised when the CSV
+      #   uses one of their `from:` aliases.
+      def initialize(include_generated: true)
+        @mappings = load_mappings(include_generated: include_generated)
       end
 
       def mapped_to_key(column_str)
@@ -45,10 +53,11 @@ module Bulkrax
 
       private
 
-      def load_mappings
-        Bulkrax.field_mappings["Bulkrax::CsvParser"].reject do |_key, value|
-          value["generated"] == true
-        end
+      def load_mappings(include_generated:)
+        raw = Bulkrax.field_mappings["Bulkrax::CsvParser"]
+        return raw if include_generated
+
+        raw.reject { |_key, value| value["generated"] == true }
       end
     end
   end

data/app/services/bulkrax/csv_template/split_formatter.rb

@@ -9,6 +9,8 @@ module Bulkrax
 
         if split_value == true
           parse_pattern(Bulkrax.multi_value_element_split_on.source)
+        elsif split_value.is_a?(Regexp)
+          parse_pattern(split_value.source)
         elsif split_value.is_a?(String)
           parse_pattern(split_value)
         else
@@ -34,9 +36,14 @@ module Bulkrax
       end
 
       def format_message(chars)
-        formatted = chars.chars.then do |c|
-          c.length > 1 ? "#{c[0..-2].join(' ')}, or #{c.last}" : c.first
-        end
+        list = chars.chars
+        # Use spaces rather than commas between delimiters so the message
+        # stays unambiguous when one of the delimiters IS a comma.
+        formatted = if list.length <= 1
+                      list.first || chars # no extractable chars → surface as-is
+                    else
+                      "#{list[0..-2].join(' ')} or #{list.last}"
+                    end
         "Split multiple values with #{formatted}"
       end
     end

data/app/services/bulkrax/split_pattern_coercion.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # Coerces a stored split pattern into a Regexp suitable for String#split.
+  #
+  # Bulkrax field mappings are persisted as JSON in several host applications
+  # (e.g. Hyku), so the `split` value for a mapping can show up in several
+  # forms. This module is the single place that normalises them:
+  #
+  # * nil / blank           → `nil` (caller should treat as "no split")
+  # * already a Regexp      → returned unchanged
+  # * `true`                → {Bulkrax.multi_value_element_split_on}
+  # * String, any content   → `Regexp.new(str)` — the String is treated as a
+  #                           regex source, matching the long-standing
+  #                           contract in {Bulkrax::ApplicationMatcher}.
+  #                           `"\\|"` → `/\|/`; a serialised regex like
+  #                           `"(?-mix:\\s*[;|]\\s*)"` rebuilds into an
+  #                           equivalent Regexp.
+  # * invalid regex source  → `nil` (we neither raise nor hand back an
+  #                           unusable value to String#split).
+  # * any other type        → `nil` (likewise — never returns something
+  #                           String#split can't accept).
+  #
+  # Import, validation, and hierarchy code paths all route through here so
+  # the behaviour is consistent regardless of how the mapping was persisted.
+  #
+  # @param split_val [nil, true, Regexp, String, Object] the configured split
+  # @return [nil, Regexp] a pattern ready for String#split, or nil when
+  #   no usable pattern can be derived from the input.
+  module SplitPatternCoercion
+    def self.coerce(split_val)
+      return nil if split_val.blank?
+      return Bulkrax.multi_value_element_split_on if split_val == true
+      return split_val if split_val.is_a?(Regexp)
+      return nil unless split_val.is_a?(String)
+
+      Regexp.new(split_val)
+    rescue RegexpError
+      nil
+    end
+  end
+end

data/app/services/bulkrax/stepper_response_formatter.rb

@@ -338,7 +338,8 @@ module Bulkrax
         message = [message, error[:suggestion]].compact.join(' ') if error[:suggestion].present?
         {
           field: I18n.t('bulkrax.importer.guided_import.stepper_response_formatter.row_errors_issue.row_label', row: error[:row], column: error[:column]),
-          message: message
+          message: message,
+          category: error[:category]
         }
       end
     end

data/app/services/bulkrax/validation_error_csv_builder.rb

@@ -4,9 +4,18 @@ require 'csv'
 
 module Bulkrax
   # Builds a CSV string containing all validation errors from a guided import.
+  #
+  # Output columns, in order:
+  #   1. row        — 1-based row number from the source CSV (blank for file-level rows)
+  #   2. errors     — all error messages for that row, joined with " | "
+  #   3. categories — distinct validator categories for that row's errors (e.g.
+  #                   "missing_required_value | invalid_parent_reference"),
+  #                   joined with " | "; blank for file-level rows
+  #   4..N. the original CSV headers, carrying the raw cell values
+  #
   # File-level errors (missing required columns, unrecognized headers, empty
   # columns, missing files) appear first as summary rows with a blank `row`
-  # cell. Row-level errors follow, one output row per errored data row.
+  # and `categories` cell. Row-level errors follow, one output row per data row.
   #
   # Usage:
   #   csv = Bulkrax::ValidationErrorCsvBuilder.build(
@@ -21,10 +30,21 @@ module Bulkrax
   #     }
   #   )
   class ValidationErrorCsvBuilder
+    I18N_BASE = 'bulkrax.importer.guided_import.validation.validation_error_csv_builder'
+    private_constant :I18N_BASE
+
     # @param headers [Array<String>] original CSV headers in order
     # @param csv_data [Array<Hash>] one entry per data row; each hash has
     #   :raw_row (String-keyed hash of column=>value)
-    # @param row_errors [Array<Hash>] each hash has :row (Integer) and :message (String)
+    # @param row_errors [Array<Hash>] each hash describes a single row-level
+    #   validation result with the following keys:
+    #   - :row [Integer] 1-based source row number (header is row 1)
+    #   - :message [String] human-readable error/warning message
+    #   - :category [String, nil] validator category slug used to populate the
+    #     `categories` output column (e.g. 'missing_required_value',
+    #     'invalid_parent_reference'); omitted/nil categories are dropped
+    #   - :severity, :column, :value, :suggestion, :source_identifier — not
+    #     emitted by this builder but commonly present on the same hash
     # @param file_errors [Hash] file-level issues:
     #   - :missing_required [Array<Hash>] each hash has :model and :field
     #   - :unrecognized [Hash] column_name => suggestion_or_nil
@@ -47,17 +67,19 @@ module Bulkrax
       blank_data    = Array.new(@headers.length)
 
       CSV.generate(force_quotes: false) do |csv|
-        csv << ['row', 'errors'] + @headers
+        csv << ['row', 'errors', 'categories'] + @headers
 
         file_level_error_rows.each do |message|
-          csv << [nil, message] + blank_data
+          csv << [nil, message, nil] + blank_data
         end
 
         @csv_data.each_with_index do |record, index|
           row_number = index + 2 # header is row 1; first data row is row 2
-          error_messages = errors_by_row[row_number]&.map { |e| e[:message] }&.join(' | ')
+          row_errors = errors_by_row[row_number]
+          error_messages   = row_errors&.map { |e| e[:message] }&.join(' | ')
+          error_categories = row_errors&.map { |e| e[:category] }&.compact&.uniq&.join(' | ')
           raw_row = record[:raw_row] || {}
-          csv << [row_number, error_messages] + @headers.map { |h| raw_row[h] }
+          csv << [row_number, error_messages, error_categories] + @headers.map { |h| raw_row[h] }
         end
       end
     end
@@ -76,21 +98,23 @@ module Bulkrax
       messages = []
 
       Array(@file_errors[:missing_required]).each do |entry|
-        messages << "Missing required column '#{entry[:field]}' (#{entry[:model]})"
+        messages << I18n.t("#{I18N_BASE}.missing_required_column", field: entry[:field], model: entry[:model])
       end
 
       Hash(@file_errors[:unrecognized]).each do |col, suggestion|
-        msg = "Unrecognized column '#{col}'"
-        msg += " (did you mean '#{suggestion}'?)" if suggestion.present?
-        messages << msg
+        messages << if suggestion.present?
+                      I18n.t("#{I18N_BASE}.unrecognized_column_with_suggestion", column: col, suggestion: suggestion)
+                    else
+                      I18n.t("#{I18N_BASE}.unrecognized_column", column: col)
+                    end
       end
 
       Array(@file_errors[:empty_columns]).each do |pos|
-        messages << "Column #{pos + 2} has no header and will be ignored during import"
+        messages << I18n.t("#{I18N_BASE}.empty_column", column: pos + 2)
       end
 
       Array(@file_errors[:missing_files]).each do |filename|
-        messages << "Missing file: #{filename}"
+        messages << I18n.t("#{I18N_BASE}.missing_file", filename: filename)
       end
 
       messages

data/app/validators/bulkrax/csv_row/child_reference.rb

@@ -37,7 +37,8 @@ module Bulkrax
       end
 
       def self.collect_child_ids(record, context)
-        split_pattern = context[:child_split_pattern] || '|'
+        split_pattern = Bulkrax::SplitPatternCoercion.coerce(context[:child_split_pattern]) ||
+                        Bulkrax::DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON
         children_column = context[:children_column] || 'children'
 
         base_ids = record[:children].to_s.split(split_pattern).map(&:strip).reject(&:blank?)

data/app/validators/bulkrax/csv_row/parent_reference.rb

@@ -34,7 +34,7 @@ module Bulkrax
       end
 
       def self.collect_parent_ids(record, context)
-        split_pattern = context[:parent_split_pattern]
+        split_pattern = Bulkrax::SplitPatternCoercion.coerce(context[:parent_split_pattern])
         parent_column = context[:parent_column] || 'parents'
 
         base_ids = if split_pattern

data/app/validators/bulkrax/csv_row/required_values.rb

@@ -17,7 +17,7 @@ module Bulkrax
         return if metadata.blank?
 
         add_default_work_type_warning(context, record, row_index, model) if using_default
-        add_missing_required_value_errors(context, record, row_index, metadata)
+        add_missing_required_value_errors(context, record, row_index, metadata, context[:mapping_manager])
       end
 
       def self.add_default_work_type_warning(context, record, row_index, model)
@@ -38,9 +38,11 @@ module Bulkrax
       end
       private_class_method :add_default_work_type_warning
 
-      def self.add_missing_required_value_errors(context, record, row_index, metadata)
+      def self.add_missing_required_value_errors(context, record, row_index, metadata, mapping_manager)
         (metadata[:required_terms] || []).each do |field|
-          next if record[:raw_row].any? { |key, value| normalize_header(key.to_s) == field && value.present? }
+          column_present = record[:raw_row].keys.any? { |key| resolve_header(key.to_s, mapping_manager) == field }
+          next unless column_present
+          next if record[:raw_row].any? { |key, value| resolve_header(key.to_s, mapping_manager) == field && value.present? }
 
           context[:errors] << {
             row: row_index,
@@ -56,6 +58,18 @@ module Bulkrax
       end
       private_class_method :add_missing_required_value_errors
 
+      # Resolves a raw CSV header into its mapping key so that `from:` aliases
+      # are honoured (e.g. a column named `rights` satisfies the requirement
+      # for `rights_statement` when the mapping declares
+      # `rights_statement: { from: ['rights', 'rights_statement', ...] }`).
+      # Numeric suffixes (e.g. `title_1`) are stripped before lookup so they
+      # satisfy the unsuffixed required field.
+      def self.resolve_header(header, mapping_manager)
+        base = normalize_header(header)
+        mapping_manager ? mapping_manager.mapped_to_key(base) : base
+      end
+      private_class_method :resolve_header
+
       def self.normalize_header(header)
         header.sub(/_\d+\z/, '')
       end

data/app/views/bulkrax/exporters/edit.html.erb

@@ -1,5 +1,5 @@
 <% provide :page_header do %>
-  <h1><span class="fa fa-edit" aria-hidden="true"></span> Edit Exporter</h1>
+  <h1><span class="fa fa-edit" aria-hidden="true"></span> <%= t('bulkrax.headings.edit_exporter') %></h1>
 <% end %>
 
 <div class="row">

data/app/views/bulkrax/exporters/index.html.erb

@@ -1,5 +1,5 @@
 <% provide :page_header do %>
-  <h1><span class="fa fa-cloud-download" aria-hidden="true"></span> Exporters</h1>
+  <h1><span class="fa fa-cloud-download" aria-hidden="true"></span> <%= t('bulkrax.headings.exporters') %></h1>
   <div class="pull-right">
     <%= link_to new_exporter_path, class: 'btn btn-primary', data: { turbolinks: false } do %>
       <span class="fa fa-edit" aria-hidden="true"></span> <%= t(:'helpers.action.exporter.new') %>
@@ -11,6 +11,8 @@
   <meta name="turbolinks-cache-control" content="no-cache">
 <% end %>
 
+<%= render 'bulkrax/shared/datatable_i18n' %>
+
 <div class="panel card panel-default">
   <div class="panel-body card-body">
     <div class="table-responsive">

data/app/views/bulkrax/exporters/new.html.erb

@@ -1,5 +1,5 @@
 <% provide :page_header do %>
-  <h1><span class="fa fa-edit" aria-hidden="true"></span> New Exporter</h1>
+  <h1><span class="fa fa-edit" aria-hidden="true"></span> <%= t('bulkrax.headings.new_exporter') %></h1>
 <% end %>
 
 <div class="row">

data/app/views/bulkrax/exporters/show.html.erb

@@ -9,7 +9,7 @@
 
     <% if File.exist?(@exporter.exporter_export_zip_path) %>
       <%= simple_form_for @exporter, method: :get, url: exporter_download_path(@exporter), html: { class: 'form-inline bulkrax-p-align' } do |form| %>
-        <strong>Download:</strong>
+        <strong><%= t('bulkrax.exporter.labels.download') %>:</strong>
         <%= render 'downloads', exporter: @exporter, form: form %>
         <%= form.button :submit, value: t('helpers.action.exporter.download'), data: { disable_with: false } %>
       <% end %>

data/app/views/bulkrax/guided_imports/new.html.erb

@@ -520,6 +520,13 @@
                 </div>
               </div>
 
+              <div class="review-section review-errors" style="display: none;">
+                <h4><%= t('bulkrax.importer.guided_import.step3.section_errors') %></h4>
+                <div class="review-errors-list">
+                  <!-- Will be populated by JS -->
+                </div>
+              </div>
+
               <div class="review-section review-warnings" style="display: none;">
                 <h4><%= t('bulkrax.importer.guided_import.step3.section_warnings') %></h4>
                 <div class="review-warnings-list">

data/app/views/bulkrax/importers/_edit_item_buttons.html.erb

@@ -2,12 +2,12 @@
   <div class="modal-dialog" role="document">
     <div class="modal-content">
       <div class="modal-body">
-        <h5>Options for Updating an Entry</h5>
+        <h5><%= t('bulkrax.importer.edit_form.entry_modal_title') %></h5>
         <hr />
-        <p>Rebuild metadata and files.</p>
+        <p><%= t('bulkrax.importer.edit_form.entry_rebuild_hint') %></p>
         <%= link_to t('helpers.action.importer.build'), item_entry_path(item, e), method: :patch, class: 'btn btn-primary'  %>
         <hr />
-        <p>Remove existing work and then recreate the works metadata and files.</p>
+        <p><%= t('bulkrax.importer.edit_form.entry_remove_and_recreate_hint') %></p>
         <%= link_to t('helpers.action.importer.remove_and_build'), item_entry_path(item, e, destroy_first: true), method: :patch, class: 'btn btn-primary'  %>
       </div>
       <div class="modal-footer">

data/app/views/bulkrax/importers/index.html.erb

@@ -16,6 +16,8 @@
   <meta name="turbolinks-cache-control" content="no-cache">
 <% end %>
 
+<%= render 'bulkrax/shared/datatable_i18n' %>
+
 <div class="panel card panel-default">
   <div class="panel-body card-body">
     <div class="table-responsive">

data/app/views/bulkrax/importers/new.html.erb

@@ -1,5 +1,5 @@
 <% provide :page_header do %>
-  <h1><span class="fa fa-edit" aria-hidden="true"></span> New Importer</h1>
+  <h1><span class="fa fa-edit" aria-hidden="true"></span> <%= t('bulkrax.headings.new_importer') %></h1>
 <% end %>
 <div class="row">
   <div class="col-md-12">

data/app/views/bulkrax/importers/show.html.erb

@@ -1,3 +1,5 @@
+<%= render 'bulkrax/shared/datatable_i18n' %>
+
 <div class="col-xs-12 main-header d-flex justify-content-between align-items-center">
   <h1><span class="fa fa-cloud-upload" aria-hidden="true"></span> Importer: <%= @importer.name %></h1>
   <div class="pull-right">
@@ -58,7 +60,7 @@
     <div class="accordion-container">
       <div class="accordion-heading" role="tab" id="parser-fields-heading">
         <a class="accordion-title" role="button" data-toggle="collapse" data-target="#parser-fields-importer-show" aria-expanded="true" aria-controls="parser-fields-importer-show">
-          Parser fields:
+          <%= t('bulkrax.importer.labels.parser_fields') %>:
         </a>
         <a role="button" data-toggle="collapse" data-target="#parser-fields-importer-show" aria-expanded="true" aria-controls="parser-fields-importer-show">
           <div class="accordion-icon fa fa-times-circle" aria-hidden="true"></div>

data/app/views/bulkrax/shared/_datatable_i18n.html.erb

@@ -0,0 +1,3 @@
+<script>
+  window.BulkraxI18n = Object.assign({}, window.BulkraxI18n || {}, { datatable: <%= raw json_escape(I18n.t('bulkrax.datatable').to_json) %> });
+</script>