bulkrax 9.4.3 → 9.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0ebf01b08e16d2685b07a6682b16ea626055ac658567f0095bd06236f04c3e3
-  data.tar.gz: 40b9e50553238f34638283c9779a92068024e44851bc204d85a25a3dd885eff5
+  metadata.gz: dd9cb038733c14b67261147e37dfe9087776846d22f327b3985761e58267c129
+  data.tar.gz: 46f82669413a304c2c8f511368f7a51e088908bf387fa617234597b26bea07e7
 SHA512:
-  metadata.gz: 61a4646632807ed415a2d58bbe1f2825f32b239b71f84bfce9f6dc594f25f871f987a030aad6488d9c1f0ccdff6d9a6151d86f8fccbe8bfbc9dcd6e9759ee9fa
-  data.tar.gz: c3108f3d01ef67dc45c5f6672ca4d555f35ad51c9594cfd02e4e7b365de4857498882c291bb56b64a10ca261e72c94b1fb8f45d18a35163b9c486722930fd835
+  metadata.gz: fe9ef3f4391865d4f95f74fd2eb4f8e95f529963fbbd2d6439f907ace1908a5c70249d59f73c15593f2d237f3f653d945a458e50e3beaf3727928f6529614d76
+  data.tar.gz: 4413721e9203032f1bb03add7072ece3c58ec7ec8afcd51b103180b53ca8808df87de0c2793c6101646a8e7285058234cc76628e46c213eda4a62adbacb97b0f

data/app/factories/bulkrax/object_factory_interface.rb

@@ -468,7 +468,24 @@ module Bulkrax
     # Regardless of what the Parser gives us, these are the properties we are
     # prepared to accept.
     def permitted_attributes
-      klass.properties.keys.map(&:to_sym) + base_permitted_attributes
+      bare = klass.properties.keys.map(&:to_sym) + base_permitted_attributes
+      bare + nested_attributes_keys(bare)
+    end
+
+    # Permits `*_attributes` virtual keys when the corresponding bare property
+    # is itself permitted. Field mappings declaring `nested_attributes: true`
+    # (see Bulkrax::HasMatchers#set_parsed_object_data) emit data under keys
+    # like `redirects_attributes`; without this, the slice in
+    # #transform_attributes would drop them and downstream form populators
+    # would receive nothing.
+    def nested_attributes_keys(bare_permitted)
+      bare_set = bare_permitted.map(&:to_sym).to_set
+      attributes.keys.filter_map do |key|
+        key_str = key.to_s
+        next unless key_str.end_with?('_attributes')
+        bare_name = key_str.sub(/_attributes\z/, '').to_sym
+        key.to_sym if bare_set.include?(bare_name)
+      end.uniq
     end
 
     # Return a copy of the given attributes, such that all values that are empty

data/app/factories/bulkrax/valkyrie_object_factory.rb

@@ -498,14 +498,15 @@ module Bulkrax
     #
     # @return [Array<Symbols>]
     def permitted_attributes
-      @permitted_attributes ||= (
-        base_permitted_attributes + if klass.respond_to?(:schema)
-                                      admin_set_id = attributes[:admin_set_id] || attributes['admin_set_id']
-                                      Bulkrax::ValkyrieObjectFactory.schema_properties(klass: klass, admin_set_id: admin_set_id)
-                                    else
-                                      klass.properties.keys.map(&:to_sym)
-                                    end
-      ).uniq
+      @permitted_attributes ||= begin
+        bare = base_permitted_attributes + if klass.respond_to?(:schema)
+                                             admin_set_id = attributes[:admin_set_id] || attributes['admin_set_id']
+                                             Bulkrax::ValkyrieObjectFactory.schema_properties(klass: klass, admin_set_id: admin_set_id)
+                                           else
+                                             klass.properties.keys.map(&:to_sym)
+                                           end
+        (bare + nested_attributes_keys(bare)).uniq
+      end
     end
 
     def update_work(attrs)

data/app/models/bulkrax/csv_entry.rb

@@ -329,15 +329,14 @@ module Bulkrax
     end
 
     def object_metadata(data)
-      # NOTE: What is `d` in this case:
-      #
-      #  "[{\"single_object_first_name\"=>\"Fake\", \"single_object_last_name\"=>\"Fakerson\", \"single_object_position\"=>\"Leader, Jester, Queen\", \"single_object_language\"=>\"english\"}]"
-      #
-      # The above is a stringified version of a Ruby string.  Using eval is a very bad idea as it
-      # will execute the value of `d` within the full Ruby interpreter context.
-      #
-      # TODO: Would it be possible to store this as a non-string?  Maybe the actual Ruby Array and Hash?
-      data = data.map { |d| eval(d) }.flatten # rubocop:disable Security/Eval
+      # Each `d` may be either a stringified Ruby hash literal (legacy
+      # ActiveFedora persistence) or a plain Hash (Valkyrie/Postgres
+      # JSONB). For the legacy stringified form we eval to recover the
+      # hash; for plain Hashes we pass through. Using eval is a very bad
+      # idea as it will execute the value of `d` within the full Ruby
+      # interpreter context — only do it when we know the input is a
+      # stringified hash.
+      data = data.map { |d| d.is_a?(Hash) ? d : eval(d) }.flatten # rubocop:disable Security/Eval
 
       data.each_with_index do |obj, index|
         next if obj.nil?

data/app/models/concerns/bulkrax/has_matchers.rb

@@ -38,7 +38,7 @@ module Bulkrax
 
         if object_name
           Rails.logger.info("Bulkrax Column automatically matched object #{node_name}, #{node_content}")
-          parsed_metadata[object_name] ||= object_multiple ? [{}] : {}
+          init_object_container(object_name, object_multiple)
         end
 
         value = if matcher
@@ -60,6 +60,30 @@ module Bulkrax
       mapping&.[](field)&.[]('object')
     end
 
+    # When any field-mapping sibling under `object_name` carries
+    # `nested_attributes: true`, Bulkrax routes the imported data through
+    # `parsed_metadata["#{object_name}_attributes"]` as a numbered-key hash
+    # (with `_destroy: 'false'` per row) — the shape consumed by Reform's
+    # nested-attributes machinery and other `*_attributes`-style populators.
+    def nested_attributes_object?(object_name)
+      return false unless mapping.is_a?(Hash) && object_name.present?
+      mapping.any? { |_, cfg| cfg.is_a?(Hash) && cfg['object'] == object_name && cfg['nested_attributes'] }
+    end
+
+    def parsed_object_target_key(object_name)
+      nested_attributes_object?(object_name) ? "#{object_name}_attributes" : object_name
+    end
+
+    def init_object_container(object_name, object_multiple)
+      target_key = parsed_object_target_key(object_name)
+      default = if object_multiple
+                  nested_attributes_object?(object_name) ? {} : [{}]
+                else
+                  {}
+                end
+      parsed_metadata[target_key] ||= default
+    end
+
     def set_parsed_data(name, value)
       return parsed_metadata[name] = value unless multiple?(name)
 
@@ -69,22 +93,33 @@ module Bulkrax
     end
 
     def set_parsed_object_data(object_multiple, object_name, name, index, value)
-      if object_multiple
-        index ||= 0
-        parsed_metadata[object_name][index] ||= {}
-        parsed_metadata[object_name][index][name] ||= []
-        if value.is_a?(Array)
-          parsed_metadata[object_name][index][name] += value
-        else
-          parsed_metadata[object_name][index][name] = value
-        end
+      target_key = parsed_object_target_key(object_name)
+      target = object_target_for(target_key, object_name, object_multiple, index)
+      assign_object_value(target, name, value)
+    end
+
+    # Resolve the hash slot that `name` should be written into, initializing
+    # any intermediate containers. Returns the leaf hash so the caller can
+    # assign the value with a single statement.
+    def object_target_for(target_key, object_name, object_multiple, index)
+      return parsed_metadata[target_key] unless object_multiple
+
+      idx = index || 0
+      if nested_attributes_object?(object_name)
+        parsed_metadata[target_key][idx.to_s] ||= { '_destroy' => 'false' }
+        parsed_metadata[target_key][idx.to_s]
       else
-        parsed_metadata[object_name][name] ||= []
-        if value.is_a?(Array)
-          parsed_metadata[object_name][name] += value
-        else
-          parsed_metadata[object_name][name] = value
-        end
+        parsed_metadata[target_key][idx] ||= {}
+        parsed_metadata[target_key][idx]
+      end
+    end
+
+    def assign_object_value(target, name, value)
+      target[name] ||= []
+      if value.is_a?(Array)
+        target[name] += value
+      else
+        target[name] = value
       end
     end
 

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

@@ -84,7 +84,15 @@ module Bulkrax
           all_models    = field_metadata.keys
           valid_headers = build_valid_validation_headers(mapping_manager, field_analyzer,
                                                          all_models, mappings, field_metadata)
-          suffixed      = headers.select { |h| h.match?(/_\d+\z/) }
+          # Only allow a suffixed header (e.g. `creator_1`, `redirect_path_2`)
+          # when its base name is itself recognised. The blanket allow that
+          # used to live here let through any *_<digits> column, which masked
+          # typos in numbered columns at validation time even though the real
+          # importer would fail to map them.
+          known_property_keys = (field_metadata || {}).values.flat_map { |m| Array(m[:properties]) }.to_set
+          suffixed = headers.select do |h|
+            h.match?(/_\d+\z/) && header_base_recognized?(h, valid_headers, mapping_manager, known_property_keys)
+          end
           valid_headers = (valid_headers + suffixed).uniq
 
           {
@@ -96,6 +104,20 @@ module Bulkrax
           }
         end
 
+        # Mirrors the recognition rule used by
+        # find_unrecognized_validation_headers: a header's base name is
+        # recognised if it appears in valid_headers directly or if its
+        # mapping_manager#mapped_to_key resolves to a known model property.
+        # known_property_keys is precomputed by check_headers so this can be
+        # called per-header without rebuilding the set each time.
+        def header_base_recognized?(header, valid_headers, mapping_manager, known_property_keys)
+          base = header.sub(/_\d+\z/, '')
+          return true if valid_headers.include?(base)
+
+          mapped_key = mapping_manager&.mapped_to_key(base)
+          mapped_key.present? && known_property_keys.include?(mapped_key)
+        end
+
         def extract_hierarchy_items(csv_data, all_ids, find_record, mappings)
           extract_validation_items(
             csv_data, all_ids, find_record,

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

@@ -35,12 +35,22 @@ module Bulkrax
         properties = field_lists
                      .flat_map { |item| item.values.flat_map { |config| config["properties"] || [] } }
                      .uniq
-                     .map { |property| @service.mapping_manager.key_to_mapped_column(property) }
+                     .flat_map { |property| columns_for_property(property) }
                      .uniq
 
         (properties - required_columns).sort
       end
 
+      # When a property is the target of one or more `object:` field mappings,
+      # emit each of those mappings' `from:` columns (e.g. redirect_path,
+      # redirect_canonical, redirect_sequence) rather than the bare property
+      # name (redirects). Otherwise fall back to the standard 1:1 mapping.
+      def columns_for_property(property)
+        nested = @service.mapping_manager.object_columns_for(property)
+        return nested if nested.any?
+        [@service.mapping_manager.key_to_mapped_column(property)]
+      end
+
       def relationship_columns
         [
           @service.mapping_manager.find_by_flag("related_children_field_mapping", 'children'),

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

@@ -26,6 +26,28 @@ module Bulkrax
         @mappings.dig(key, "from")&.first || key
       end
 
+      # Returns the `object:` value for a given mapping key, or nil. Mirrors
+      # the importer-side `Bulkrax::HasMatchers#get_object_name` for callers
+      # working with the template-side mapping manager.
+      def get_object_name(key)
+        @mappings.dig(key, "object")
+      end
+
+      # Returns the column names that target a given object name via the
+      # `object:` field-mapping pattern. The template generator uses this to
+      # emit the per-child columns (e.g. redirect_path, redirect_canonical,
+      # redirect_sequence) instead of the bare property name (redirects).
+      # Numbering is intentionally omitted — the template shows the column
+      # shape once; CSV rows can repeat the column with numeric suffixes
+      # (e.g. redirect_path_1, redirect_path_2) at import time.
+      def object_columns_for(object_name)
+        @mappings
+          .select { |_k, v| v.is_a?(Hash) && v["object"] == object_name }
+          .values
+          .flat_map { |v| Array(v["from"]) }
+          .uniq
+      end
+
       def find_by_flag(field_name, default)
         @mappings.find { |_k, v| v[field_name] == true }&.first || default
       end

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

@@ -12,9 +12,16 @@ module Bulkrax
       def determine_value(column, model_name, field_list)
         key = @service.mapping_manager.mapped_to_key(column)
         required_terms = field_list.dig(model_name, 'required_terms')
+        properties = field_list.dig(model_name, "properties") || []
+        object_name = @service.mapping_manager.get_object_name(key)
 
-        if field_list.dig(model_name, "properties")&.include?(key)
+        if properties.include?(key)
           mark_required_or_optional(key, required_terms)
+        elsif object_name && properties.include?(object_name)
+          # Column belongs to an `object:` mapping (e.g. `redirect_path` → object
+          # `redirects`). Treat the column as required/optional based on the
+          # parent property's required-terms list.
+          mark_required_or_optional(object_name, required_terms)
         elsif special_column?(column, key)
           special_value(column, key, model_name, required_terms)
         end

data/lib/bulkrax/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  VERSION = '9.4.3'
+  VERSION = '9.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 9.4.3
+  version: 9.5.0
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-29 00:00:00.000000000 Z
+date: 2026-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails