bulkrax 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dd5afb5469da9e5d574a3a91a86a3257d8dbb04d2f8682e80a7399fe16f0e75
-  data.tar.gz: 69033280eb68fb73f6a71ace05cb105b6545989ebfa128ae424bd30d59e59392
+  metadata.gz: 12d2cd4f6112d69872499fefcc5338743445c5ee922389451724591372907935
+  data.tar.gz: 56ca7cb3fea0d47218695ce42870f4c892f3eb622b71ef062d57ac103adcdd9c
 SHA512:
-  metadata.gz: fbfb807b6aff8eba148835953075366a889fbf020a135f63cf30d16a505a7312270192cfba136f0bc5f631d5c31c171f8a1fa33f7489ef173507b932c2d8589c
-  data.tar.gz: a00f7efef15d1a1ec402ed05f359f33c1d765a6e31cb62cdef42bc3867f43fc31f4ba277495b8ddcea456b252d45a8a3409389e99fa70def26f51b1e45ac78ab
+  metadata.gz: e79423222d13be800ecb7758dd0d75a87b78082b7c7d0d90a059d6bcf80a0ccd4897b0ae6301da62ebc7dd62efa6962c1a3bf64a49d0a69456d1f2e7b49ff50d
+  data.tar.gz: 0c65a81da9f1a6825f31fb4c4047bceb30557663a88ef3b593ede7b1fa125f950d4d675068c0f74268e18ce21caa8ceddf493febca4436ed2ff1d68486ebe8da

data/README.md

@@ -16,7 +16,7 @@ gem 'bulkrax', git: 'https://github.com/samvera-labs/bulkrax.git'
 
 And then execute:
 ```bash
-$ bundle update
+$ bundle install
 $ rails generate bulkrax:install
 ```
 

data/app/controllers/bulkrax/exporters_controller.rb

@@ -51,9 +51,12 @@ module Bulkrax
       if @exporter.save
         if params[:commit] == 'Create and Export'
           # Use perform now for export
-          Bulkrax::ExporterJob.perform_now(@exporter.id)
+          Bulkrax::ExporterJob.perform_later(@exporter.id)
+          message = 'Exporter was successfully created. A download link will appear once it completes.'
+        else
+          message = 'Exporter was successfully created.'
         end
-        redirect_to exporters_path, notice: 'Exporter was successfully created.'
+        redirect_to exporters_path, notice: message
       else
         render :new
       end
@@ -63,8 +66,13 @@ module Bulkrax
     def update
       field_mapping_params
       if @exporter.update(exporter_params)
-        Bulkrax::ExporterJob.perform_now(@exporter.id) if params[:commit] == 'Update and Re-Export All Items'
-        redirect_to exporters_path, notice: 'Exporter was successfully updated.'
+        if params[:commit] == 'Update and Re-Export All Items'
+          Bulkrax::ExporterJob.perform_later(@exporter.id)
+          message = 'Exporter was successfully updated. A download link will appear once it completes.'
+        else
+          'Exporter was successfully updated.'
+        end
+        redirect_to exporters_path, notice: message
       else
         render :edit
       end

data/app/controllers/bulkrax/importers_controller.rb

@@ -113,23 +113,9 @@ module Bulkrax
       if @importer.update(importer_params)
         files_for_import(file, cloud_files) unless file.nil? && cloud_files.nil?
         # do not perform the import
-        if params[:commit] == 'Update Importer'
-        # do nothing
-        # OAI-only - selective re-harvest
-        elsif params[:commit] == 'Update and Harvest Updated Items'
-          Bulkrax::ImporterJob.perform_later(@importer.id, true)
-        elsif params[:commit] == 'Update All (update metadata and update files)'
-          @importer.parser_fields['update_files'] = true
-          @importer.save
-          Bulkrax::ImporterJob.perform_later(@importer.id)
-          # Perform a full metadata and files re-import; do the same for an OAI re-harvest of all items
-        elsif params[:commit] == ('Update and Replace (update metadata and replace files)' || 'Update and Re-Harvest All Items')
-          @importer.parser_fields['replace_files'] = true
-          @importer.save
-          Bulkrax::ImporterJob.perform_later(@importer.id)
-        # In all other cases, perform a metadata-only re-import
-        else
-          Bulkrax::ImporterJob.perform_later(@importer.id)
+        unless params[:commit] == 'Update Importer'
+          set_files_parser_fields
+          Bulkrax::ImporterJob.send(@importer.parser.perform_method, @importer.id, update_harvest)
         end
         if api_request?
           json_response('updated', :ok, 'Importer was successfully updated.')
@@ -310,6 +296,25 @@ module Bulkrax
         redirect_to path, notice: message
       end
     end
+
+    # update methods (for commit deciphering)
+    def update_harvest
+      # OAI-only - selective re-harvest
+      params[:commit] == 'Update and Harvest Updated Items'
+    end
+
+    def set_files_parser_fields
+      if params[:commit] == 'Update Metadata and Files'
+        @importer.parser_fields['update_files'] = true
+      elsif params[:commit] == ('Update and Replace Files' || 'Update and Re-Harvest All Items')
+        @importer.parser_fields['replace_files'] = true
+      elsif params[:commit] == 'Update and Harvest Updated Items'
+        return
+      else
+        @importer.parser_fields['metadata_only'] = true
+      end
+      @importer.save
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/app/factories/bulkrax/object_factory.rb

@@ -5,20 +5,30 @@ module Bulkrax
     extend ActiveModel::Callbacks
     include Bulkrax::FileFactory
     define_model_callbacks :save, :create
-    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier
+    attr_reader :attributes, :object, :source_identifier_value, :klass, :replace_files, :update_files, :work_identifier, :collection_field_mapping
 
     # rubocop:disable Metrics/ParameterLists
-    def initialize(attributes:, source_identifier_value:, work_identifier:, replace_files: false, user: nil, klass: nil, update_files: false)
+    def initialize(attributes:, source_identifier_value:, work_identifier:, collection_field_mapping:, replace_files: false, user: nil, klass: nil, update_files: false)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
       @replace_files = replace_files
       @update_files = update_files
       @user = user || User.batch_user
       @work_identifier = work_identifier
+      @collection_field_mapping = collection_field_mapping
       @source_identifier_value = source_identifier_value
       @klass = klass || Bulkrax.default_work_type.constantize
     end
     # rubocop:enable Metrics/ParameterLists
 
+    # update files is set, replace files is set or this is a create
+    def with_files
+      update_files || replace_files || !object
+    end
+
     def run
       arg_hash = { id: attributes[:id], name: 'UPDATE', klass: klass }
       @object = find
@@ -36,6 +46,7 @@ module Bulkrax
       self.run
       # Create the error exception if the object is not validly saved for some reason
       raise ActiveFedora::RecordInvalid, object if !object.persisted? || object.changed?
+      object
     end
 
     def update
@@ -49,7 +60,7 @@ module Bulkrax
     end
 
     def find
-      return find_by_id if attributes[:id]
+      return find_by_id if attributes[:id].present?
       return search_by_identifier if attributes[work_identifier].present?
     end
 
@@ -116,52 +127,33 @@ module Bulkrax
     end
 
     def create_collection(attrs)
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
       attrs = collection_type(attrs)
-      object.members = members
-      object.member_of_collections = member_of_collections
+      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
+      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
       object.attributes = attrs
       object.apply_depositor_metadata(@user)
       object.save!
     end
 
     def update_collection(attrs)
-      object.members = members
-      object.member_of_collections = member_of_collections
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      persist_collection_memberships(parent: object, child: find_collection(attributes[:child_collection_id])) if attributes[:child_collection_id].present?
+      persist_collection_memberships(parent: find_collection(attributes[collection_field_mapping]), child: object) if attributes[collection_field_mapping].present?
       object.attributes = attrs
       object.save!
     end
 
-    # Collections don't respond to member_of_collections_attributes or member_of_collection_ids=
-    #   or member_ids=
-    # Add them directly with members / member_of_collections
-    # collection should be in the form  { id: collection_id }
-    # and collections [{ id: collection_id }]
-    # member_ids comes from
-    # @todo - consider performance implications although we wouldn't expect a Collection to be a member of many Collections
-    def members
-      ms = object.members.to_a
-      [:children].each do |atat|
-        next if attributes[atat].blank?
-        ms.concat(
-          Array.wrap(
-            find_collection(attributes[atat])
-          )
-        )
-      end
-      ms.flatten.compact.uniq
-    end
-
-    def member_of_collections
-      ms = object.member_of_collection_ids.to_a.map { |id| find_collection(id) }
-      [:collection, :collections].each do |atat|
-        next if attributes[atat].blank?
-        ms.concat(
-          Array.wrap(
-            find_collection(attributes[atat])
-          )
-        )
-      end
-      ms.flatten.compact.uniq
+    # Add child to parent's #member_collections
+    # Add parent to child's #member_of_collections
+    def persist_collection_memberships(parent:, child:)
+      ::Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent, child: child)
     end
 
     def find_collection(id)
@@ -187,44 +179,35 @@ module Bulkrax
     # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
     def create_attributes
       return transform_attributes if klass == Collection
-      if attributes[:collection].present?
-        transform_attributes.except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })
-      elsif attributes[:collections].present?
-        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
-          ids[index] = { id: element }
-        end
-        transform_attributes.except(:collections).merge(member_of_collections_attributes: collection_ids)
-      else
-        transform_attributes
-      end
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      transform_attributes.except(:collections, :collection, collection_field_mapping)
     end
 
     # Strip out the :collection key, and add the member_of_collection_ids,
     # which is used by Hyrax::Actors::AddAsMemberOfCollectionsActor
     def attribute_update
       return transform_attributes.except(:id) if klass == Collection
-      if attributes[:collection].present?
-        transform_attributes.except(:id).except(:collection).merge(member_of_collections_attributes: { 0 => { id: collection.id } })
-      elsif attributes[:collections].present?
-        collection_ids = attributes[:collections].each.with_index.each_with_object({}) do |(element, index), ids|
-          ids[index] = element
-        end
-        transform_attributes.except(:id).except(:collections).merge(member_of_collections_attributes: collection_ids)
-      else
-        transform_attributes.except(:id)
-      end
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      transform_attributes.except(:id, :collections, :collection, collection_field_mapping)
     end
 
     # Override if we need to map the attributes from the parser in
     # a way that is compatible with how the factory needs them.
     def transform_attributes
-      attributes.slice(*permitted_attributes)
-                .merge(file_attributes(update_files))
+      @transform_attributes = attributes.slice(*permitted_attributes)
+      @transform_attributes.merge!(file_attributes(update_files)) if with_files
+      @transform_attributes
     end
 
     # 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) + %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id]
+      klass.properties.keys.map(&:to_sym) + %i[id edit_users edit_groups read_groups visibility work_members_attributes admin_set_id member_of_collections_attributes]
     end
   end
 end

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  # Responsible for creating parent-child relationships between Works and Collections.
+  #
+  # Handles three kinds of relationships:
+  # - Work to Collection
+  # - Collection to Collection
+  # - Work to Work
+  #
+  # These can be established from either side of the relationship (i.e. from parent to child or from child to parent).
+  # This job only creates one relationship at a time. If a record needs multiple parents or children or both, individual
+  # jobs should be run for each of those relationships.
+  #
+  # NOTE: In the context of this job, "record" is used to generically refer
+  #       to either an instance of a Work or an instance of a Collection.
+  # NOTE: In the context of this job, "identifier" is used to generically refer
+  #       to either a record's ID or an Bulkrax::Entry's source_identifier.
+  class CreateRelationshipsJob < ApplicationJob
+    queue_as :import
+
+    attr_accessor :base_entry, :child_record, :parent_record, :importer_run
+
+    # @param entry_identifier [String] source_identifier of the base Bulkrax::Entry the job was triggered from (see #build_for_importer)
+    # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @param child_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @param importer_run [Bulkrax::ImporterRun] current importer run (needed to properly update counters)
+    #
+    # The entry_identifier is used to lookup the @base_entry for the job (a.k.a. the entry the job was called from).
+    # The @base_entry defines the context of the relationship (e.g. "this entry (@base_entry) should have a parent").
+    # Whether the @base_entry is the parent or the child in the relationship is determined by the presence of a
+    # parent_identifier or child_identifier param. For example, if a parent_identifier is passed, we know @base_entry
+    # is the child in the relationship, and vice versa if a child_identifier is passed.
+    def perform(entry_identifier:, parent_identifier: nil, child_identifier: nil, importer_run:)
+      @base_entry = Entry.find_by(identifier: entry_identifier)
+      @importer_run = importer_run
+      if parent_identifier.present?
+        @child_record = find_record(entry_identifier)
+        @parent_record = find_record(parent_identifier)
+      elsif child_identifier.present?
+        @parent_record = find_record(entry_identifier)
+        @child_record = find_record(child_identifier)
+      else
+        raise ::StandardError, %("#{entry_identifier}" needs either a child or a parent to create a relationship)
+      end
+
+      if @child_record.blank? || @parent_record.blank?
+        reschedule(
+          entry_identifier: entry_identifier,
+          parent_identifier: parent_identifier,
+          child_identifier: child_identifier,
+          importer_run: importer_run
+        )
+        return false # stop current job from continuing to run after rescheduling
+      end
+
+      create_relationship
+    rescue ::StandardError => e
+      base_entry.status_info(e)
+      importer_run.increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    private
+
+    def create_relationship
+      if parent_record.is_a?(::Collection) && child_record.is_a?(::Collection)
+        collection_parent_collection_child
+      elsif parent_record.is_a?(::Collection) && curation_concern?(child_record)
+        collection_parent_work_child
+      elsif curation_concern?(parent_record) && child_record.is_a?(::Collection)
+        raise ::StandardError, 'a Collection may not be assigned as a child of a Work'
+      else
+        work_parent_work_child
+      end
+    end
+
+    # This method allows us to create relationships with preexisting records (by their ID) OR
+    # with records that are concurrently being imported (by their Bulkrax::Entry source_identifier).
+    #
+    # @param identifier [String] Work/Collection ID or Bulkrax::Entry source_identifier
+    # @return [Work, Collection, nil] Work or Collection if found, otherwise nil
+    def find_record(identifier)
+      record = Entry.find_by(identifier: identifier)
+      record ||= ::Collection.where(id: identifier).first
+      if record.blank?
+        available_work_types.each do |work_type|
+          record ||= work_type.where(id: identifier).first
+        end
+      end
+      record = record.factory.find if record.is_a?(Entry)
+
+      record
+    end
+
+    # Check if the record is a Work
+    def curation_concern?(record)
+      available_work_types.include?(record.class)
+    end
+
+    # @return [Array<Class>] list of work type classes
+    def available_work_types
+      # If running in a Hyku app, do not reference disabled work types
+      @available_work_types ||= if defined?(::Hyku)
+                                  ::Site.instance.available_works.map(&:constantize)
+                                else
+                                  ::Hyrax.config.curation_concerns
+                                end
+    end
+
+    def user
+      @user ||= importer_run.importer.user
+    end
+
+    # Work-Collection membership is added to the child as member_of_collection_ids
+    # This is adding the reverse relationship, from the child to the parent
+    def collection_parent_work_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = { id: child_record.id, member_of_collections_attributes: { 0 => { id: parent_record.id } } }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: child_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    # Collection-Collection membership is added to the as member_ids
+    def collection_parent_collection_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = { id: parent_record.id, child_collection_id: child_record.id }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: parent_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    # Work-Work membership is added to the parent as member_ids
+    def work_parent_work_child
+      ActiveSupport::Deprecation.warn(
+        'Creating Collections using the collection_field_mapping will no longer be supported as of Bulkrax version 3.0.' \
+        ' Please configure Bulkrax to use related_parents_field_mapping and related_children_field_mapping instead.'
+      )
+      attrs = {
+        id: parent_record.id,
+        work_members_attributes: { 0 => { id: child_record.id } }
+      }
+      ObjectFactory.new(
+        attributes: attrs,
+        source_identifier_value: nil, # sending the :id in the attrs means the factory doesn't need a :source_identifier_value
+        work_identifier: base_entry.parser.work_identifier,
+        collection_field_mapping: base_entry.parser.collection_field_mapping,
+        replace_files: false,
+        user: user,
+        klass: parent_record.class
+      ).run
+      # TODO: add counters for :processed_parents and :failed_parents
+      importer_run.increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
+    end
+
+    def reschedule(entry_identifier:, parent_identifier:, child_identifier:, importer_run:)
+      CreateRelationshipsJob.set(wait: 10.minutes).perform_later(
+        entry_identifier: entry_identifier,
+        parent_identifier: parent_identifier,
+        child_identifier: child_identifier,
+        importer_run: importer_run
+      )
+    end
+  end
+end

data/app/jobs/bulkrax/delete_work_job.rb

@@ -8,8 +8,12 @@ module Bulkrax
     def perform(entry, importer_run)
       work = entry.factory.find
       work&.delete
-      importer_run.increment!(:deleted_records)
-      importer_run.decrement!(:enqueued_records)
+      ImporterRun.find(importer_run.id).increment!(:deleted_records)
+      ImporterRun.find(importer_run.id).decrement!(:enqueued_records)
+      entry.save!
+      entry.importer.current_run = ImporterRun.find(importer_run.id)
+      entry.importer.record_status
+      entry.status_info("Deleted", ImporterRun.find(importer_run.id))
     end
     # rubocop:enable Rails/SkipsModelValidations
   end

data/app/jobs/bulkrax/export_work_job.rb

@@ -26,12 +26,14 @@ module Bulkrax
         # rubocop:enable Rails/SkipsModelValidations
       end
       exporter_run = ExporterRun.find(args[1])
-      return if exporter_run.enqueued_records.positive?
+      return entry if exporter_run.enqueued_records.positive?
       if exporter_run.failed_records.positive?
         exporter_run.exporter.status_info('Complete (with failures)')
       else
         exporter_run.exporter.status_info('Complete')
       end
+
+      return entry
     end
   end
 end

data/app/jobs/bulkrax/exporter_job.rb

@@ -8,6 +8,7 @@ module Bulkrax
       exporter = Exporter.find(exporter_id)
       exporter.export
       exporter.write
+      exporter.save
       true
     end
   end

data/app/jobs/bulkrax/{import_work_collection_job.rb → import_collection_job.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Bulkrax
-  class ImportWorkCollectionJob < ApplicationJob
+  class ImportCollectionJob < ApplicationJob
     queue_as :import
 
     # rubocop:disable Rails/SkipsModelValidations
@@ -28,7 +28,7 @@ module Bulkrax
       collection          = entry.factory.find
       permission_template = Hyrax::PermissionTemplate.find_or_create_by!(source_id: collection.id)
 
-      Hyrax::PermissionTemplateAccess.create!(
+      Hyrax::PermissionTemplateAccess.find_or_create_by!(
         permission_template_id: permission_template.id,
         agent_id: user.user_key,
         agent_type: 'user',

data/app/jobs/bulkrax/importer_job.rb

@@ -6,17 +6,32 @@ module Bulkrax
 
     def perform(importer_id, only_updates_since_last_import = false)
       importer = Importer.find(importer_id)
+
       importer.current_run
+      unzip_imported_file(importer.parser)
       import(importer, only_updates_since_last_import)
+      update_current_run_counters(importer)
       schedule(importer) if importer.schedulable?
     end
 
     def import(importer, only_updates_since_last_import)
       importer.only_updates = only_updates_since_last_import || false
       return unless importer.valid_import?
+
       importer.import_collections
       importer.import_works
-      importer.create_parent_child_relationships unless importer.validate_only
+    end
+
+    def unzip_imported_file(parser)
+      return unless parser.file? && parser.zip?
+
+      parser.unzip(parser.parser_fields['import_file_path'])
+    end
+
+    def update_current_run_counters(importer)
+      importer.current_run.total_work_entries = importer.limit || importer.parser.works_total
+      importer.current_run.total_collection_entries = importer.parser.collections_total
+      importer.current_run.save!
     end
 
     def schedule(importer)

data/app/matchers/bulkrax/application_matcher.rb

@@ -20,9 +20,9 @@ module Bulkrax
         return unless content.send(self.if[0], Regexp.new(self.if[1]))
       end
 
-      @result = content.to_s.gsub(/\s/, ' ') # remove any line feeds and tabs
-      @result.strip!
-      process_split
+      # @result will evaluate to an empty string for nil content values
+      @result = content.to_s.gsub(/\s/, ' ').strip # remove any line feeds and tabs
+      process_split if @result.present?
       @result = @result[0] if @result.is_a?(Array) && @result.size == 1
       process_parse
       return @result
@@ -54,7 +54,10 @@ module Bulkrax
     end
 
     def parse_remote_files(src)
-      { url: src.strip } if src.present?
+      return if src.blank?
+      src.strip!
+      name = Bulkrax::Importer.safe_uri_filename(src)
+      { url: src, file_name: name }
     end
 
     def parse_language(src)
@@ -63,14 +66,14 @@ module Bulkrax
     end
 
     def parse_subject(src)
-      string = src.to_s.strip.downcase
+      string = src.strip.downcase
       return if string.blank?
 
       string.slice(0, 1).capitalize + string.slice(1..-1)
     end
 
     def parse_types(src)
-      src.to_s.strip.titleize
+      src.strip.titleize
     end
 
     # Allow for mapping a model field to the work type or collection

data/app/models/bulkrax/csv_collection_entry.rb

@@ -6,14 +6,16 @@ module Bulkrax
       Collection
     end
 
-    def build_metadata
-      self.parsed_metadata = self.raw_metadata
-      add_local
-      return self.parsed_metadata
+    # Use identifier set by CsvParser#unique_collection_identifier, which falls back
+    # on the Collection's first title if record[source_identifier] is not present
+    def add_identifier
+      self.parsed_metadata[work_identifier] = self.identifier
     end
 
-    def collections_created?
-      true
+    def add_collection_type_gid
+      return if self.parsed_metadata['collection_type_gid'].present?
+
+      self.parsed_metadata['collection_type_gid'] = ::Hyrax::CollectionType.find_or_create_default_collection_type.gid
     end
   end
 end