bulkrax 9.3.5 → 9.4.0

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Detects circular parent-child relationships in the CSV.
+    # A circular reference occurs when following the parent chain from any record
+    # eventually leads back to itself (e.g. A→B→C→A).
+    #
+    # The validator builds a directed graph (child → parents) from all records on
+    # first invocation and caches the set of all record ids involved in any cycle.
+    # Subsequent per-row calls simply check membership in that set.
+    #
+    # Requires context key:
+    #   :relationship_graph  – Hash { source_identifier => [parent_ids] } built by
+    #                          run_row_validators before iterating rows.
+    module CircularReference
+      def self.call(record, row_index, context)
+        cycle_ids = context[:circular_reference_ids] ||= detect_cycle_ids(context[:relationship_graph] || {})
+        return unless cycle_ids.include?(record[:source_identifier])
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: record[:source_identifier],
+          severity: 'error',
+          category: 'circular_reference',
+          column: 'parents',
+          value: record[:source_identifier],
+          message: I18n.t('bulkrax.importer.guided_import.validation.circular_reference_validator.errors.message',
+                          value: record[:source_identifier]),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.circular_reference_validator.errors.suggestion')
+        }
+      end
+
+      # Returns the set of all source identifiers that participate in at least one cycle.
+      # Uses recursive DFS with a per-branch ancestry set to detect back-edges.
+      def self.detect_cycle_ids(graph)
+        all_nodes = graph.keys.to_set | graph.values.flatten.to_set
+        visited   = Set.new
+        cycle_ids = Set.new
+
+        all_nodes.each do |node|
+          next if visited.include?(node)
+          dfs(node, graph, visited, [], cycle_ids)
+        end
+
+        cycle_ids
+      end
+      private_class_method :detect_cycle_ids
+
+      def self.dfs(node, graph, visited, ancestors, cycle_ids) # rubocop:disable Metrics/MethodLength
+        visited.add(node)
+        ancestors.push(node)
+
+        (graph[node] || []).each do |neighbor|
+          if ancestors.include?(neighbor)
+            # Back-edge found: mark every node in the cycle path
+            cycle_start = ancestors.index(neighbor)
+            ancestors[cycle_start..].each { |n| cycle_ids.add(n) }
+            cycle_ids.add(neighbor)
+          elsif !visited.include?(neighbor)
+            dfs(neighbor, graph, visited, ancestors, cycle_ids)
+          end
+        end
+
+        ancestors.pop
+      end
+      private_class_method :dfs
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that controlled vocabulary values in each row are valid according
+    # to the QA authority for that field.
+    module ControlledVocabulary
+      def self.call(record, row_index, context) # rubocop:disable Metrics/MethodLength
+        field_metadata = context[:field_metadata]
+        return if field_metadata.blank?
+
+        model = record[:model]
+        metadata = field_metadata[model]
+        return if metadata.blank?
+
+        controlled_terms = metadata[:controlled_vocab_terms] || []
+        return if controlled_terms.blank?
+
+        controlled_terms.each do |field|
+          value = record[:raw_row][field]
+          next if value.blank?
+
+          authority = load_authority(field)
+          next if authority.nil?
+
+          term = authority.find(value)
+          next unless term.blank? || term.dig('active') == false
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'invalid_controlled_value',
+            column: field,
+            value: value,
+            message: I18n.t('bulkrax.importer.guided_import.validation.controlled_vocabulary_validator.errors.message',
+                            value: value, field: field),
+            suggestion: suggestion(value, authority)
+          }
+        end
+      end
+
+      def self.load_authority(field)
+        Qa::Authorities::Local.subauthority_for(field.pluralize)
+      rescue Qa::InvalidSubAuthority
+        begin
+          Qa::Authorities::Local.subauthority_for(field)
+        rescue Qa::InvalidSubAuthority
+          nil
+        end
+      end
+      private_class_method :load_authority
+
+      def self.suggestion(value, authority)
+        suggestion = DidYouMean::SpellChecker.new(dictionary: dictionary_for(authority)).correct(value).first
+        return fallback_suggestion if suggestion.nil?
+
+        I18n.t('bulkrax.importer.guided_import.validation.did_you_mean', suggestion: suggestion)
+      end
+      private_class_method :suggestion
+
+      def self.fallback_suggestion
+        I18n.t('bulkrax.importer.guided_import.validation.controlled_vocabulary_validator.errors.suggestion')
+      end
+      private_class_method :fallback_suggestion
+
+      def self.dictionary_for(authority)
+        authority.all.filter_map { |term| term['label'] if term['active'] == true }.uniq
+      end
+      private_class_method :dictionary_for
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row has a unique source_identifier.
+    # Uses context[:seen_ids] (Hash: id => first_seen_row_number) to detect duplicates.
+    module DuplicateIdentifier
+      def self.call(record, row_index, context)
+        source_id = record[:source_identifier]
+        return if source_id.blank? && Bulkrax.fill_in_blank_source_identifiers.present?
+
+        source_id_label = context[:source_identifier] || 'source_identifier'
+        first_row = context[:seen_ids][source_id]
+
+        if first_row
+          add_duplicate_error(context, row_index, source_id, source_id_label, first_row)
+        else
+          context[:seen_ids][source_id] = row_index
+          add_existing_warning(context, row_index, source_id, source_id_label)
+        end
+      end
+
+      def self.add_duplicate_error(context, row_index, source_id, source_id_label, first_row)
+        context[:errors] << {
+          row: row_index,
+          source_identifier: source_id,
+          severity: 'error',
+          category: 'duplicate_source_identifier',
+          column: source_id_label,
+          value: source_id,
+          message: I18n.t('bulkrax.importer.guided_import.validation.duplicate_identifier_validator.errors.message',
+                          value: source_id,
+                          field: source_id_label,
+                          original_row: first_row),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.duplicate_identifier_validator.errors.suggestion',
+                             field: source_id_label)
+        }
+      end
+      private_class_method :add_duplicate_error
+
+      def self.add_existing_warning(context, row_index, source_id, source_id_label)
+        find_record = context[:find_record_by_source_identifier]
+        return unless find_record&.call(source_id)
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: source_id,
+          severity: 'warning',
+          category: 'existing_source_identifier',
+          column: source_id_label,
+          value: source_id,
+          message: I18n.t('bulkrax.importer.guided_import.validation.existing_source_identifier_validator.warnings.message',
+                          value: source_id,
+                          field: source_id_label),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.existing_source_identifier_validator.warnings.suggestion',
+                             field: source_id_label)
+        }
+      end
+      private_class_method :add_existing_warning
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row has a value for source_identifier unless
+    # fill_in_blank_source_identifiers is configured (in which case Bulkrax
+    # will generate one automatically).
+    module MissingSourceIdentifier
+      def self.call(record, row_index, context)
+        return if Bulkrax.fill_in_blank_source_identifiers.present?
+        return if record[:source_identifier].present?
+
+        source_id_label = context[:source_identifier] || 'source_identifier'
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: nil,
+          severity: 'error',
+          category: 'missing_source_identifier',
+          column: source_id_label,
+          value: nil,
+          message: I18n.t('bulkrax.importer.guided_import.validation.missing_source_identifier_validator.errors.message',
+                          field: source_id_label),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.missing_source_identifier_validator.errors.suggestion',
+                             field: source_id_label)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that any parent references in a row point to source identifiers
+    # that exist either elsewhere in the same CSV or as existing repository records.
+    # Uses context[:all_ids] (Set of all source identifiers) to validate references
+    # within the CSV, and context[:find_record_by_source_identifier] (callable) to
+    # look up existing records in the same way the importer does at runtime.
+    # Uses context[:parent_split_pattern] (String/Regexp, may be nil) for multi-value splitting.
+    module ParentReference
+      def self.call(record, row_index, context)
+        all_ids = context[:all_ids]
+        find_record = context[:find_record_by_source_identifier]
+
+        collect_parent_ids(record, context).each do |parent_id|
+          next if all_ids.include?(parent_id)
+          next if find_record&.call(parent_id)
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'invalid_parent_reference',
+            column: 'parent',
+            value: parent_id,
+            message: I18n.t('bulkrax.importer.guided_import.validation.parent_reference_validator.errors.message',
+                            value: parent_id,
+                            field: 'source_identifier'),
+            suggestion: I18n.t('bulkrax.importer.guided_import.validation.parent_reference_validator.errors.suggestion')
+          }
+        end
+      end
+
+      def self.collect_parent_ids(record, context)
+        split_pattern = context[:parent_split_pattern]
+        parent_column = context[:parent_column] || 'parents'
+
+        base_ids = if split_pattern
+                     record[:parent].to_s.split(split_pattern).map(&:strip).reject(&:blank?)
+                   elsif record[:parent].present?
+                     [record[:parent].to_s.strip]
+                   else
+                     []
+                   end
+
+        suffix_pattern = /\A#{Regexp.escape(parent_column)}_\d+\z/
+        suffix_ids = record[:raw_row]
+                     .select { |k, _| k.to_s.match?(suffix_pattern) }
+                     .values
+                     .map(&:to_s).map(&:strip).reject(&:blank?)
+
+        (base_ids + suffix_ids).uniq
+      end
+      private_class_method :collect_parent_ids
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvRow
+    ##
+    # Validates that each row provides a value for every required field of its model.
+    # Numeric suffixes on column names are normalised before checking
+    # (e.g. 'title_1' satisfies the 'title' requirement).
+    module RequiredValues
+      def self.call(record, row_index, context)
+        field_metadata = context[:field_metadata]
+        return if field_metadata.blank?
+
+        using_default = record[:model].blank?
+        model         = record[:model].presence || Bulkrax.default_work_type
+        metadata      = field_metadata[model]
+        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)
+      end
+
+      def self.add_default_work_type_warning(context, record, row_index, model)
+        # Suppress per-row warning when a file-level notice already covers all rows.
+        return if context[:notices]&.any? { |n| n[:field] == 'model' }
+
+        context[:errors] << {
+          row: row_index,
+          source_identifier: record[:source_identifier],
+          severity: 'warning',
+          category: 'default_work_type_used',
+          column: 'model',
+          value: nil,
+          message: I18n.t('bulkrax.importer.guided_import.validation.default_work_type_validator.warnings.message',
+                          default_work_type: model),
+          suggestion: I18n.t('bulkrax.importer.guided_import.validation.default_work_type_validator.warnings.suggestion')
+        }
+      end
+      private_class_method :add_default_work_type_warning
+
+      def self.add_missing_required_value_errors(context, record, row_index, metadata)
+        (metadata[:required_terms] || []).each do |field|
+          next if record[:raw_row].any? { |key, value| normalize_header(key.to_s) == field && value.present? }
+
+          context[:errors] << {
+            row: row_index,
+            source_identifier: record[:source_identifier],
+            severity: 'error',
+            category: 'missing_required_value',
+            column: field,
+            value: nil,
+            message: I18n.t('bulkrax.importer.guided_import.validation.required_field_validator.errors.message', field: field),
+            suggestion: I18n.t('bulkrax.importer.guided_import.validation.required_field_validator.errors.suggestion', field: field)
+          }
+        end
+      end
+      private_class_method :add_missing_required_value_errors
+
+      def self.normalize_header(header)
+        header.sub(/_\d+\z/, '')
+      end
+    end
+  end
+end