bulkrax 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49a1f0ccc806cf73a7872a634c8c2819dac62f98f0a9dc163e7ada8931d9b1fe
-  data.tar.gz: ecf5c8ad3e4864110665cfb5c6c5f6329e3b868414815bba163646db839400e7
+  metadata.gz: 490e0f170cc1128c00c467c3cc344db627d027a3b857d53dfa33b97805567d4b
+  data.tar.gz: 7290801bacea707b7398e674a17acf56e7a770cfb3bea20958169588a4404175
 SHA512:
-  metadata.gz: df394e4fbbc6ca0a71eb595c075c5181d24098b1ab889ff185da10991ec01c2eaf60239658564838b67df4c0a421306de923d2eab4bbeffafb31321acb9ba1ff
-  data.tar.gz: 35b691e96d0e59f83efadc35364283239f7f741ab4bf9d859756dacc8483e380090512cd10bf3b6ec4ce81936d00c88eb4d1ed96742c384e0f3082028ffdcf45
+  metadata.gz: a6f5486405e2d2eb7f6c0c49b17ed0926e55a701368e42c93db9b009a5f663682ec4141fe1dd58d0dde132fa747010ada7cd22187b81d60a7e8b6b23cbf2e24d
+  data.tar.gz: d56a8780ef074d412ac7406d3f3ddb39b34b17bbe43c61a64bebe06f39952a1d62cbf2dbd01a7012bcd776686def03c5a5e6c556cc1384284c2dea8a89f3eec2

data/app/controllers/bulkrax/entries_controller.rb

@@ -5,10 +5,10 @@ require_dependency "oai"
 
 module Bulkrax
   class EntriesController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     before_action :authenticate_user!
     before_action :check_permissions
-    with_themed_layout 'dashboard'
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     def show
       if params[:importer_id].present?
@@ -23,6 +23,7 @@ module Bulkrax
       @importer = Importer.find(params[:importer_id])
       @entry = Entry.find(params[:id])
 
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Importers', bulkrax.importers_path
@@ -35,6 +36,7 @@ module Bulkrax
       @exporter = Exporter.find(params[:exporter_id])
       @entry = Entry.find(params[:id])
 
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Exporters', bulkrax.exporters_path

data/app/controllers/bulkrax/exporters_controller.rb

@@ -4,24 +4,26 @@ require_dependency "bulkrax/application_controller"
 
 module Bulkrax
   class ExportersController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     include Bulkrax::DownloadBehavior
     before_action :authenticate_user!
     before_action :check_permissions
     before_action :set_exporter, only: [:show, :edit, :update, :destroy]
-    with_themed_layout 'dashboard'
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     # GET /exporters
     def index
       @exporters = Exporter.all
 
-      add_exporter_breadcrumbs
+      add_exporter_breadcrumbs if defined?(::Hyrax)
     end
 
     # GET /exporters/1
     def show
-      add_exporter_breadcrumbs
-      add_breadcrumb @exporter.name
+      if defined?(::Hyrax)
+        add_exporter_breadcrumbs
+        add_breadcrumb @exporter.name
+      end
 
       @work_entries = @exporter.entries.where(type: @exporter.parser.entry_class.to_s).page(params[:work_entries_page]).per(30)
       @collection_entries = @exporter.entries.where(type: @exporter.parser.collection_entry_class.to_s).page(params[:collections_entries_page]).per(30)
@@ -31,16 +33,18 @@ module Bulkrax
     # GET /exporters/new
     def new
       @exporter = Exporter.new
-
+      return unless defined?(::Hyrax)
       add_exporter_breadcrumbs
       add_breadcrumb 'New'
     end
 
     # GET /exporters/1/edit
     def edit
-      add_exporter_breadcrumbs
-      add_breadcrumb @exporter.name, bulkrax.exporter_path(@exporter.id)
-      add_breadcrumb 'Edit'
+      if defined?(::Hyrax)
+        add_exporter_breadcrumbs
+        add_breadcrumb @exporter.name, bulkrax.exporter_path(@exporter.id)
+        add_breadcrumb 'Edit'
+      end
 
       # Correctly populate export_source_collection input
       @collection = Collection.find(@exporter.export_source) if @exporter.export_source.present? && @exporter.export_from == 'collection'

data/app/controllers/bulkrax/importers_controller.rb

@@ -6,7 +6,7 @@ require_dependency 'oai'
 module Bulkrax
   # rubocop:disable Metrics/ClassLength
   class ImportersController < ApplicationController
-    include Hyrax::ThemedLayoutController
+    include Hyrax::ThemedLayoutController if defined?(::Hyrax)
     include Bulkrax::DownloadBehavior
     include Bulkrax::API
     include Bulkrax::ValidationHelper
@@ -16,14 +16,14 @@ module Bulkrax
     before_action :authenticate_user!, unless: -> { api_request? }
     before_action :check_permissions
     before_action :set_importer, only: [:show, :edit, :update, :destroy]
-    with_themed_layout 'dashboard'
+    with_themed_layout 'dashboard' if defined?(::Hyrax)
 
     # GET /importers
     def index
       @importers = Importer.all
       if api_request?
         json_response('index')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
       end
     end
@@ -32,7 +32,7 @@ module Bulkrax
     def show
       if api_request?
         json_response('show')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb @importer.name
 
@@ -47,7 +47,7 @@ module Bulkrax
       @importer = Importer.new
       if api_request?
         json_response('new')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb 'New'
       end
@@ -57,7 +57,7 @@ module Bulkrax
     def edit
       if api_request?
         json_response('edit')
-      else
+      elsif defined?(::Hyrax)
         add_importer_breadcrumbs
         add_breadcrumb @importer.name, bulkrax.importer_path(@importer.id)
         add_breadcrumb 'Edit'
@@ -159,6 +159,7 @@ module Bulkrax
     # GET /importer/1/upload_corrected_entries
     def upload_corrected_entries
       @importer = Importer.find(params[:importer_id])
+      return unless defined?(::Hyrax)
       add_breadcrumb t(:'hyrax.controls.home'), main_app.root_path
       add_breadcrumb t(:'hyrax.dashboard.breadcrumbs.admin'), hyrax.dashboard_path
       add_breadcrumb 'Importers', bulkrax.importers_path

data/app/helpers/bulkrax/application_helper.rb

@@ -3,7 +3,7 @@ require 'coderay'
 
 module Bulkrax
   module ApplicationHelper
-    include ::Hyrax::HyraxHelperBehavior
+    include ::Hyrax::HyraxHelperBehavior if defined?(::Hyrax)
 
     def coderay(value, opts)
       CodeRay

data/app/helpers/bulkrax/importers_helper.rb

@@ -2,9 +2,9 @@
 
 module Bulkrax
   module ImportersHelper
-    # borrowd from batch-importer https://github.com/samvera-labs/hyrax-batch_ingest/blob/main/app/controllers/hyrax/batch_ingest/batches_controller.rb
+    # borrowed from batch-importer https://github.com/samvera-labs/hyrax-batch_ingest/blob/main/app/controllers/hyrax/batch_ingest/batches_controller.rb
     def available_admin_sets
-      # Restrict available_admin_sets to only those current user can desposit to.
+      # Restrict available_admin_sets to only those current user can deposit to.
       @available_admin_sets ||= Hyrax::Collections::PermissionsService.source_ids_for_deposit(ability: current_ability, source_type: 'admin_set').map do |admin_set_id|
         [AdminSet.find(admin_set_id).title.first, admin_set_id]
       end

data/app/jobs/bulkrax/create_relationships_job.rb

@@ -17,12 +17,29 @@ module Bulkrax
   # 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
+    ##
+    # @api public
+    # @since v5.0.1
+    #
+    # Once we've created the relationships, should we then index the works's file_sets to ensure
+    # that we have the proper indexed values.  This can help set things like `is_page_of_ssim` for
+    # IIIF manifest and search results of file sets.
+    #
+    # @note As of v5.0.1 the default behavior is to not perform this.  That preserves past
+    #       implementations.  However, we might determine that we want to change the default
+    #       behavior.  Which would likely mean a major version change.
+    #
+    # @example
+    #   # In config/initializers/bulkrax.rb
+    #   Bulkrax::CreateRelationshipsJob.update_child_records_works_file_sets = true
+    #
+    # @see https://github.com/scientist-softserv/louisville-hyku/commit/128a9ef
+    class_attribute :update_child_records_works_file_sets, default: false
+
     include DynamicRecordLookup
 
     queue_as :import
 
-    attr_accessor :child_records, :child_entry, :parent_record, :parent_entry, :importer_run_id
-
     # @param parent_identifier [String] Work/Collection ID or Bulkrax::Entry source_identifiers
     # @param importer_run [Bulkrax::ImporterRun] current importer run (needed to properly update counters)
     #
@@ -31,82 +48,81 @@ module Bulkrax
     # 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.
+    #
+    # rubocop:disable Metrics/MethodLength
     def perform(parent_identifier:, importer_run_id:) # rubocop:disable Metrics/AbcSize
-      pending_relationships = Bulkrax::PendingRelationship.find_each.select do |rel|
-        rel.importer_run_id == importer_run_id && rel.parent_id == parent_identifier
-      end.sort_by(&:order)
-
-      @importer_run_id = importer_run_id
-      @parent_entry, @parent_record = find_record(parent_identifier, importer_run_id)
-      @child_records = { works: [], collections: [] }
-      pending_relationships.each do |rel|
-        raise ::StandardError, %("#{rel}" needs either a child or a parent to create a relationship) if rel.child_id.nil? || rel.parent_id.nil?
-        @child_entry, child_record = find_record(rel.child_id, importer_run_id)
-        if child_record
-          child_record.is_a?(::Collection) ? @child_records[:collections] << child_record : @child_records[:works] << child_record
+      importer_run = Bulkrax::ImporterRun.find(importer_run_id)
+      ability = Ability.new(importer_run.user)
+
+      parent_entry, parent_record = find_record(parent_identifier, importer_run_id)
+
+      number_of_successes = 0
+      number_of_failures = 0
+      errors = []
+
+      ActiveRecord::Base.uncached do
+        Bulkrax::PendingRelationship.where(parent_id: parent_identifier, importer_run_id: importer_run_id)
+                                    .ordered.find_each do |rel|
+          process(relationship: rel, importer_run_id: importer_run_id, parent_record: parent_record, ability: ability)
+          number_of_successes += 1
+        rescue => e
+          number_of_failures += 1
+          errors << e
         end
       end
 
-      if (child_records[:collections].blank? && child_records[:works].blank?) || parent_record.nil?
+      # save record if members were added
+      parent_record.save! if @parent_record_members_added
+
+      # rubocop:disable Rails/SkipsModelValidations
+      if errors.present?
+        importer_run.increment!(:failed_relationships, number_of_failures)
+        parent_entry&.set_status_info(errors.last, importer_run)
+
+        # TODO: This can create an infinite job cycle, consider a time to live tracker.
         reschedule({ parent_identifier: parent_identifier, importer_run_id: importer_run_id })
         return false # stop current job from continuing to run after rescheduling
+      else
+        Bulkrax::ImporterRun.find(importer_run_id).increment!(:processed_relationships, number_of_successes)
       end
-      @parent_entry ||= Bulkrax::Entry.where(identifier: parent_identifier,
-                                             importerexporter_id: ImporterRun.find(importer_run_id).importer_id,
-                                             importerexporter_type: "Bulkrax::Importer").first
-      create_relationships
-      pending_relationships.each(&:destroy)
-    rescue ::StandardError => e
-      parent_entry ? parent_entry.status_info(e) : child_entry.status_info(e)
-      Bulkrax::ImporterRun.find(importer_run_id).increment!(:failed_relationships) # rubocop:disable Rails/SkipsModelValidations
+      # rubocop:enable Rails/SkipsModelValidations
     end
+    # rubocop:enable Metrics/MethodLength
 
     private
 
-    def create_relationships
-      if parent_record.is_a?(::Collection)
-        collection_parent_work_child unless child_records[:works].empty?
-        collection_parent_collection_child unless child_records[:collections].empty?
-      else
-        work_parent_work_child unless child_records[:works].empty?
-        raise ::StandardError, 'a Collection may not be assigned as a child of a Work' if child_records[:collections].present?
-      end
-    end
+    def process(relationship:, importer_run_id:, parent_record:, ability:)
+      raise "#{relationship} needs a child to create relationship" if relationship.child_id.nil?
+      raise "#{relationship} needs a parent to create relationship" if relationship.parent_id.nil?
 
-    def user
-      @user ||= Bulkrax::ImporterRun.find(importer_run_id).importer.user
-    end
+      _child_entry, child_record = find_record(relationship.child_id, importer_run_id)
+      raise "#{relationship} could not find child record" unless child_record
 
-    # 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
-      child_work_ids = child_records[:works].map(&:id)
-      parent_record.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
+      raise "Cannot add child collection (ID=#{relationship.child_id}) to parent work (ID=#{relationship.parent_id})" if child_record.collection? && parent_record.work?
 
-      parent_record.add_member_objects(child_work_ids)
-      ImporterRun.find(importer_run_id).increment!(:processed_relationships, child_work_ids.count) # rubocop:disable Rails/SkipsModelValidations
+      ability.authorize!(:edit, child_record)
+
+      # We could do this outside of the loop, but that could lead to odd counter failures.
+      ability.authorize!(:edit, parent_record)
+
+      parent_record.is_a?(Collection) ? add_to_collection(child_record, parent_record) : add_to_work(child_record, parent_record)
+
+      child_record.file_sets.each(&:update_index) if update_child_records_works_file_sets? && child_record.respond_to?(:file_sets)
+      relationship.destroy
     end
 
-    # Collection-Collection membership is added to the as member_ids
-    def collection_parent_collection_child
-      child_records[:collections].each do |child_record|
-        ::Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent_record, child: child_record)
-        ImporterRun.find(importer_run_id).increment!(:processed_relationships) # rubocop:disable Rails/SkipsModelValidations
-      end
+    def add_to_collection(child_record, parent_record)
+      child_record.member_of_collections << parent_record
+      child_record.save!
     end
 
-    # Work-Work membership is added to the parent as member_ids
-    def work_parent_work_child
-      records_hash = {}
-      child_records[:works].each_with_index do |child_record, i|
-        records_hash[i] = { id: child_record.id }
-      end
-      attrs = { work_members_attributes: records_hash }
-      parent_record.try(:reindex_extent=, Hyrax::Adapters::NestingIndexAdapter::LIMITED_REINDEX)
-      env = Hyrax::Actors::Environment.new(parent_record, Ability.new(user), attrs)
+    def add_to_work(child_record, parent_record)
+      return true if parent_record.ordered_members.to_a.include?(child_record)
 
-      Hyrax::CurationConcern.actor.update(env)
-      ImporterRun.find(importer_run_id).increment!(:processed_relationships, child_records[:works].count) # rubocop:disable Rails/SkipsModelValidations
+      parent_record.ordered_members << child_record
+      @parent_record_members_added = true
+      # TODO: Do we need to save the child record?
+      child_record.save!
     end
 
     def reschedule(parent_identifier:, importer_run_id:)

data/app/jobs/bulkrax/delete_job.rb

@@ -13,7 +13,7 @@ module Bulkrax
       entry.save!
       entry.importer.current_run = ImporterRun.find(importer_run.id)
       entry.importer.record_status
-      entry.status_info("Deleted", ImporterRun.find(importer_run.id))
+      entry.set_status_info("Deleted", ImporterRun.find(importer_run.id))
     end
     # rubocop:enable Rails/SkipsModelValidations
   end

data/app/jobs/bulkrax/export_work_job.rb

@@ -29,9 +29,9 @@ module Bulkrax
       return entry if exporter_run.enqueued_records.positive?
 
       if exporter_run.failed_records.positive?
-        exporter_run.exporter.status_info('Complete (with failures)')
+        exporter_run.exporter.set_status_info('Complete (with failures)')
       else
-        exporter_run.exporter.status_info('Complete')
+        exporter_run.exporter.set_status_info('Complete')
       end
 
       return entry

data/app/jobs/bulkrax/import_file_set_job.rb

@@ -41,7 +41,7 @@ module Bulkrax
         ImportFileSetJob.set(wait: (entry.import_attempts + 1).minutes).perform_later(entry_id, importer_run_id)
       else
         ImporterRun.find(importer_run_id).decrement!(:enqueued_records) # rubocop:disable Rails/SkipsModelValidations
-        entry.status_info(e)
+        entry.set_status_info(e)
       end
     end
 

data/app/jobs/bulkrax/importer_job.rb

@@ -13,7 +13,7 @@ module Bulkrax
       update_current_run_counters(importer)
       schedule(importer) if importer.schedulable?
     rescue CSV::MalformedCSVError => e
-      importer.status_info(e)
+      importer.set_status_info(e)
     end
 
     def import(importer, only_updates_since_last_import)

data/app/models/bulkrax/exporter.rb

@@ -69,7 +69,7 @@ module Bulkrax
     end
 
     def workflow_status_list
-      Sipity::WorkflowState.all.map { |s| [s.name&.titleize, s.name] }.uniq
+      Sipity::WorkflowState.all.map { |s| [s.name&.titleize, s.name] }.uniq if defined?(::Hyrax)
     end
 
     # If field_mapping is empty, setup a default based on the export_properties
@@ -84,12 +84,20 @@ module Bulkrax
     end
 
     def export_from_list
-      [
-        [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
-        [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],
-        [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype'],
-        [I18n.t('bulkrax.exporter.labels.all'), 'all']
-      ]
+      if defined?(::Hyrax)
+        [
+          [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
+          [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],
+          [I18n.t('bulkrax.exporter.labels.worktype'), 'worktype'],
+          [I18n.t('bulkrax.exporter.labels.all'), 'all']
+        ]
+      else
+        [
+          [I18n.t('bulkrax.exporter.labels.importer'), 'importer'],
+          [I18n.t('bulkrax.exporter.labels.collection'), 'collection'],
+          [I18n.t('bulkrax.exporter.labels.all'), 'all']
+        ]
+      end
     end
 
     def export_type_list

data/app/models/bulkrax/importer.rb

@@ -15,7 +15,7 @@ module Bulkrax
     has_many :entries, as: :importerexporter, dependent: :destroy
 
     validates :name, presence: true
-    validates :admin_set_id, presence: true
+    validates :admin_set_id, presence: true if defined?(::Hyrax)
     validates :parser_klass, presence: true
 
     delegate :valid_import?, :write_errored_entries_file, :visibility, to: :parser
@@ -47,12 +47,12 @@ module Bulkrax
       if importer_run.failed_records.positive?
         if importer_run.invalid_records.present?
           e = Bulkrax::ImportFailed.new('Failed with Invalid Records', importer_run.invalid_records.split("\n"))
-          importer_run.importer.status_info(e)
+          importer_run.importer.set_status_info(e)
         else
-          importer_run.importer.status_info('Complete (with failures)')
+          importer_run.importer.set_status_info('Complete (with failures)')
         end
       else
-        importer_run.importer.status_info('Complete')
+        importer_run.importer.set_status_info('Complete')
       end
     end
 

data/app/models/bulkrax/importer_run.rb

@@ -9,5 +9,11 @@ module Bulkrax
     def parents
       pending_relationships.pluck(:parent_id).uniq
     end
+
+    def user
+      # An importer might not have a user, the CLI ingest need not assign a user.  As such, we
+      # fallback to the configured user.
+      importer.user || Bulkrax.fallback_user_for_importer_exporter_processing
+    end
   end
 end

data/app/models/bulkrax/oai_entry.rb

@@ -9,6 +9,15 @@ module Bulkrax
 
     delegate :record, to: :raw_record
 
+    # @api private
+    #
+    # Included to assist in testing; namely so that you can copy down an OAI entry, store it locally,
+    # and then manually construct an {OAI::GetRecordResponse}.
+    #
+    # @see Bulkrax::EntrySpecHelper.oai_entry_for
+    attr_writer :raw_record
+
+    # @return [OAI::GetRecordResponse]
     def raw_record
       @raw_record ||= client.get_record(identifier: identifier, metadata_prefix: parser.parser_fields['metadata_prefix'])
     end
@@ -28,7 +37,7 @@ module Bulkrax
     def build_metadata
       self.parsed_metadata = {}
       self.parsed_metadata[work_identifier] = [record.header.identifier]
-      self.raw_metadata = { xml: record.metadata.to_s }
+      self.raw_metadata = { record: record.metadata.to_s, header: record.header.to_s }
 
       # We need to establish the #factory_class before we proceed with the metadata.  See
       # https://github.com/samvera-labs/bulkrax/issues/702 for further details.
@@ -91,7 +100,8 @@ module Bulkrax
     # If OAI-PMH doesn't return setSpec in the headers for GetRecord, use parser.collection_name
     #   in this case, if 'All' is selected, records will not be added to a collection.
     def find_collection_ids
-      return self.collection_ids if collections_created?
+      return self.collection_ids if defined?(@called_find_collection_ids)
+
       if sets.blank? || parser.collection_name != 'all'
         collection = find_collection(importerexporter.unique_collection_identifier(parser.collection_name))
         self.collection_ids << collection.id if collection.present? && !self.collection_ids.include?(collection.id)
@@ -101,6 +111,8 @@ module Bulkrax
           self.collection_ids << c.id if c.present? && !self.collection_ids.include?(c.id)
         end
       end
+
+      @called_find_collection_ids = true
       return self.collection_ids
     end
   end

data/app/models/bulkrax/pending_relationship.rb

@@ -3,5 +3,9 @@
 module Bulkrax
   class PendingRelationship < ApplicationRecord
     belongs_to :importer_run
+
+    # Ideally we wouldn't have a column named "order", as it is a reserved SQL term.  However, if we
+    # quote the column, all is well...for the application.
+    scope :ordered, -> { order("#{quoted_table_name}.#{connection.quote_column_name('order')}") }
   end
 end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Bulkrax
+  # TODO: Extract methods to class methods; there's no reason for these methods to be a mixin.
+  # TODO: Add specs to test in isolation
   module DynamicRecordLookup
     # Search entries, collections, and every available work type for a record that
     # has the provided identifier.

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

@@ -33,16 +33,21 @@ module Bulkrax
       current_status&.created_at
     end
 
-    def status_info(e = nil, current_run = nil)
+    def set_status_info(e = nil, current_run = nil)
+      runnable = current_run || last_run
       if e.nil?
-        self.statuses.create!(status_message: 'Complete', runnable: current_run || last_run)
+        self.statuses.create!(status_message: 'Complete', runnable: runnable)
       elsif e.is_a?(String)
-        self.statuses.create!(status_message: e, runnable: current_run || last_run)
+        self.statuses.create!(status_message: e, runnable: runnable)
       else
-        self.statuses.create!(status_message: 'Failed', runnable: current_run || last_run, error_class: e.class.to_s, error_message: e.message, error_backtrace: e.backtrace)
+        self.statuses.create!(status_message: 'Failed', runnable: runnable, error_class: e.class.to_s, error_message: e.message, error_backtrace: e.backtrace)
       end
     end
 
+    alias status_info set_status_info
+
+    deprecation_deprecate status_info: "Favor Bulkrax::StatusInfo.set_status_info.  We will be removing .status_info in Bulkrax v6.0.0"
+
     # api compatible with previous error structure
     def last_error
       return unless current_status && current_status.error_class.present?

data/app/parsers/bulkrax/bagit_parser.rb

@@ -143,7 +143,7 @@ module Bulkrax
           begin
             bag.add_file(file_name, file.path) if bag.bag_files.select { |b| b.include?(file_name) }.blank?
           rescue => e
-            entry.status_info(e)
+            entry.set_status_info(e)
             status_info(e)
           end
         end

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

@@ -11,7 +11,7 @@
     </div>
   <% end %>
 
-  <%= form.input :name, label: t('bulkrax.exporter.labels.name') %>
+  <%= form.input :name, label: t('bulkrax.exporter.labels.name'), input_html: { class: 'form-control' } %>
 
   <%= form.hidden_field :user_id, value: current_user.id %>
 
@@ -19,20 +19,22 @@
     collection:  form.object.export_type_list,
     label: t('bulkrax.exporter.labels.export_type'),
     required: true,
-    prompt: 'Please select an export type' %>
+    prompt: 'Please select an export type',
+    input_html: { class: 'form-control' } %>
 
   <%= form.input :export_from,
     collection: form.object.export_from_list,
     label: t('bulkrax.exporter.labels.export_from'),
     required: true,
-    prompt: 'Please select an export source' %>
+    prompt: 'Please select an export source',
+    input_html: { class: 'form-control' } %>
 
   <%= form.input :export_source_importer,
     label: t('bulkrax.exporter.labels.importer'),
     required: true,
     prompt: 'Select from the list',
     label_html: { class: 'importer export-source-option hidden' },
-    input_html: { class: 'importer export-source-option hidden' },
+    input_html: { class: 'importer export-source-option hidden form-control' },
     collection:  form.object.importers_list.sort %>
 
   <%= form.input :export_source_collection,
@@ -42,7 +44,7 @@
     placeholder: @collection&.title&.first,
     label_html: { class: 'collection export-source-option hidden' },
     input_html: {
-      class: 'collection export-source-option hidden',
+      class: 'collection export-source-option hidden form-control',
       data: {
         'autocomplete-url' => '/authorities/search/collections',
         'autocomplete' => 'collection'
@@ -50,18 +52,22 @@
     }
   %>
 
-  <%= form.input :export_source_worktype,
+  <%  if defined?(::Hyrax) %>
+    <%= form.input :export_source_worktype,
     label: t('bulkrax.exporter.labels.worktype'),
     required: true,
     prompt: 'Select from the list',
     label_html: { class: 'worktype export-source-option hidden' },
-    input_html: { class: 'worktype export-source-option hidden' },
+    input_html: { class: 'worktype export-source-option hidden form-control' },
     collection: Hyrax.config.curation_concerns.map {|cc| [cc.to_s, cc.to_s] } %>
+  <% end %>
+  
 
   <%= form.input :limit,
     as: :integer,
     hint: 'leave blank or 0 for all records',
-    label: t('bulkrax.exporter.labels.limit') %>
+    label: t('bulkrax.exporter.labels.limit'),
+    input_html: { class: 'form-control' } %>
 
   <%= form.input :generated_metadata?,
                  as: :boolean,
@@ -76,26 +82,36 @@
   <%= form.input :date_filter,
                  as: :boolean,
                  label: t('bulkrax.exporter.labels.filter_by_date') %>
+
   <div id="date_filter_picker" class="hidden">
     <%= form.input :start_date,
                    as: :date,
-                   label: t('bulkrax.exporter.labels.start_date') %>
+                   label: t('bulkrax.exporter.labels.start_date'),
+                   input_html: { class: 'form-control' } %>
 
     <%= form.input :finish_date,
                    as: :date,
-                   label: t('bulkrax.exporter.labels.finish_date') %>
+                   label: t('bulkrax.exporter.labels.finish_date'),
+                   input_html: { class: 'form-control' } %>
   </div>
-  <%= form.input :work_visibility,
-                 collection: form.object.work_visibility_list,
-                 label: t('bulkrax.exporter.labels.visibility') %>
+  <% if defined?(::Hyrax) %>
+    <%= form.input :work_visibility,
+                   collection: form.object.work_visibility_list,
+                  label: t('bulkrax.exporter.labels.visibility'),
+                  input_html: { class: 'form-control' } %>
+  <% end %>
 
-  <%= form.input :workflow_status,
-                 collection: form.object.workflow_status_list,
-                 label: t('bulkrax.exporter.labels.status') %>
+  <% if defined?(::Hyrax) %>
+    <%= form.input :workflow_status,
+                  collection: form.object.workflow_status_list,
+                  label: t('bulkrax.exporter.labels.status'),
+                  input_html: { class: 'form-control' } %>
+  <% end %>
 
   <%= form.input :parser_klass,
     collection: Bulkrax.parsers.map {|p| [p[:name], p[:class_name], {'data-partial' => p[:partial]}] if p[:class_name].constantize.export_supported? }.compact,
-    label: t('bulkrax.exporter.labels.export_format') %>
+    label: t('bulkrax.exporter.labels.export_format'),
+    input_html: { class: 'form-control' } %>
 </div>
 
 <%# Find definitions for the functions called in this script in

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

@@ -4,7 +4,7 @@
 
 <div class="row">
   <div class="col-md-12">
-    <div class="panel panel-default tabs">
+    <div class="panel panel-default tabs exporter-form">
       <%= simple_form_for @exporter do |form| %>
         <%= render 'form', exporter: @exporter, form: form %>
         <div class="panel-footer">

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

@@ -4,7 +4,7 @@
 
 <div class="row">
   <div class="col-md-12">
-    <div class="panel panel-default tabs">
+    <div class="panel panel-default tabs exporter-form">
       <%= simple_form_for @exporter do |form| %>
         <%= render 'form', exporter: @exporter, form: form %>
         <div class="panel-footer">

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

@@ -11,17 +11,17 @@
     </div>
   <% end %>
 
-  <%= form.input :name %>
+  <%= form.input :name, input_html: { class: 'form-control' } %>
 
-  <%= form.input :admin_set_id, collection: available_admin_sets %>
+  <%= form.input :admin_set_id, collection: available_admin_sets if defined?(::Hyrax) %>
 
   <%= form.hidden_field :user_id, value: current_user.id %>
 
-  <%= form.input :frequency, collection: form.object.class.frequency_enums %>
+  <%= form.input :frequency, collection: form.object.class.frequency_enums, input_html: { class: 'form-control' } %>
 
-  <%= form.input :limit, as: :integer, hint: 'leave blank or 0 for all records' %>
+  <%= form.input :limit, as: :integer, hint: 'leave blank or 0 for all records', input_html: { class: 'form-control'} %>
 
-  <%= form.input :parser_klass, collection: Bulkrax.parsers.map {|p| [p[:name], p[:class_name], {'data-partial' => p[:partial]}]}, label: "Parser" %>
+  <%= form.input :parser_klass, collection: Bulkrax.parsers.map {|p| [p[:name], p[:class_name], {'data-partial' => p[:partial]}]}, label: "Parser", input_html: { class: 'form-control' } %>
 
   <%= form.fields_for :parser_fields do |fi| %>
     <div class='parser_fields'>

data/lib/bulkrax/entry_spec_helper.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'oai'
+require 'xml/libxml'
+
+module Bulkrax
+  ##
+  # The purpose of this module is to provide some testing facilities for those that include the
+  # Bulkrax gem in their application.
+  #
+  # This module came about through a desire to expose a quick means of vetting the accuracy of the
+  # different parsers.
+  module EntrySpecHelper
+    ##
+    # @api public
+    # @since v5.0.1
+    #
+    # The purpose of this method is encapsulate the logic of creating the appropriate Bulkrax::Entry
+    # object based on the given data, identifier, and parser_class_name.
+    #
+    # From that entry, you should be able to test how {Bulkrax::Entry#build_metadata} populates the
+    # {Bulkrax::Entry#parsed_metadata} variable.  Other uses may emerge.
+    #
+    # @param data [Object] the data that we use to populate the raw metadata.  Due to implementation
+    #        details of each entry, the data will be of different formats.
+    #
+    # @param identifier [String, Integer] The identifier of the entry.  This might also be found in
+    #        the metadata of the entry, but for instantiation purposes we need this value.
+    # @param parser_class_name [String] The name of the parser class you're wanting to test.
+    # @param type [Sybmol] The type of entry (e.g. :entry, :collection, :file_set) for testing.
+    # @param options [Hash<Symbol,Object>] these are to be passed along into the instantiation of
+    #        the various classes.  See implementation details.
+    #
+    # @return [Bulkrax::Entry]
+    def self.entry_for(data:, identifier:, parser_class_name:, type: :entry, **options)
+      importer = importer_for(parser_class_name: parser_class_name, **options)
+      entry_type_method_name = ENTRY_TYPE_TO_METHOD_NAME_MAP.fetch(type)
+      entry_class = importer.parser.public_send(entry_type_method_name)
+
+      # Using an instance of the entry_class to dispatch to different
+      entry_for_dispatch = entry_class.new
+
+      # Using the {is_a?} test we get the benefit of inspecting an object's inheritance path
+      # (e.g. ancestry).  The logic, as implemented, also provides a mechanism for folks in their
+      # applications to add a {class_name_entry_for}; something that I suspect isn't likely
+      # but given the wide variety of underlying needs I could see happening and I want to encourage
+      # patterned thinking to fold that different build method into this structure.
+      key = entry_class_to_symbol_map.keys.detect { |class_name| entry_for_dispatch.is_a?(class_name.constantize) }
+
+      # Yes, we'll raise an error if we didn't find a corresponding key.  And that's okay.
+      symbol = entry_class_to_symbol_map.fetch(key)
+
+      send("build_#{symbol}_entry_for",
+           importer: importer,
+           identifier: identifier,
+           entry_class: entry_class,
+           data: data,
+           **options)
+    end
+
+    ENTRY_TYPE_TO_METHOD_NAME_MAP = {
+      entry: :entry_class,
+      collection: :collection_entry_class,
+      file_set: :file_set_entry_class
+    }.freeze
+
+    DEFAULT_ENTRY_CLASS_TO_SYMBOL_MAP = {
+      'Bulkrax::OaiEntry' => :oai,
+      'Bulkrax::XmlEntry' => :xml,
+      'Bulkrax::CsvEntry' => :csv
+    }.freeze
+
+    # Present implementations of entry classes tend to inherit from the below listed class names.
+    # We're not looking to register all descendents of the {Bulkrax::Entry} class, but instead find
+    # the ancestor where there is significant deviation.
+    def self.entry_class_to_symbol_map
+      @entry_class_to_symbol_map || DEFAULT_ENTRY_CLASS_TO_SYMBOL_MAP
+    end
+
+    def self.entry_class_to_symbol_map=(value)
+      @entry_class_to_symbol_map = value
+    end
+
+    def self.importer_for(parser_class_name:, parser_fields: {}, **options)
+      # Ideally, we could pass in the field_mapping.  However, there is logic that ignores the
+      # parser's field_mapping and directly asks for Bulkrax's field_mapping (e.g. model_mapping
+      # method).
+      Rails.logger.warn("You passed :importer_field_mapping as an option.  This may not fully work as desired.") if options.key?(:importer_field_mapping)
+      Bulkrax::Importer.new(
+        name: options.fetch(:importer_name, "Test importer for identifier"),
+        admin_set_id: options.fetch(:importer_admin_set_id, "admin_set/default"),
+        user: options.fetch(:importer_user, User.new(email: "hello@world.com")),
+        limit: options.fetch(:importer_limits, 1),
+        parser_klass: parser_class_name,
+        field_mapping: options.fetch(:importer_field_mappings) { Bulkrax.field_mappings.fetch(parser_class_name) },
+        parser_fields: parser_fields
+      ).tap do |importer|
+        # Why are we saving the importer and a run?  We might want to delve deeper into the call
+        # stack.  See https://github.com/scientist-softserv/adventist-dl/pull/266
+        importer.save!
+        # Later on, we might to want a current run
+        importer.importer_runs.create!
+      end
+    end
+    private_class_method :importer_for
+
+    ##
+    # @api private
+    #
+    # @param data [Hash<Symbol,String>] we're expecting a hash with keys that are symbols and then
+    #        values that are strings.
+    #
+    # @return [Bulkrax::CsvEntry]
+    #
+    # @note As a foible of this implementation, you'll need to include along a CSV to establish the
+    #       columns that you'll parse (e.g. the first row
+    def self.build_csv_entry_for(importer:, data:, identifier:, entry_class:, **_options)
+      entry_class.new(
+        importerexporter: importer,
+        identifier: identifier,
+        raw_metadata: data
+      )
+    end
+
+    ##
+    # @api private
+    #
+    # @param data [String] we're expecting a string that is well-formed XML for OAI parsing.
+    #
+    # @return [Bulkrax::OaiEntry]
+    def self.build_oai_entry_for(importer:, data:, identifier:, entry_class:, **options)
+      # The raw record assumes we take the XML data, parse it and then send that to the
+      # OAI::GetRecordResponse object.
+      doc = XML::Parser.string(data)
+      raw_record = OAI::GetRecordResponse.new(doc.parse)
+
+      raw_metadata = {
+        importer.parser.source_identifier.to_s => identifier,
+        "data" => data,
+        "collections" => options.fetch(:raw_metadata_collections, []),
+        "children" => options.fetch(:raw_metadata_children, [])
+      }
+
+      entry_class.new(
+        raw_record: raw_record,
+        importerexporter: importer,
+        identifier: identifier,
+        raw_metadata: raw_metadata
+      )
+    end
+
+    ##
+    # @api private
+    #
+    # @param data [String] we're expecting a string that is well-formed XML.
+    #
+    # @return [Bulkrax::XmlEntry]
+    def self.build_xml_entry_for(importer:, data:, identifier:, entry_class:, **options)
+      raw_metadata = {
+        importer.parser.source_identifier.to_s => identifier,
+        "data" => data,
+        "collections" => options.fetch(:raw_metadata_collections, []),
+        "children" => options.fetch(:raw_metadata_children, [])
+      }
+
+      entry_class.new(
+        importerexporter: importer,
+        identifier: identifier,
+        raw_metadata: raw_metadata
+      )
+    end
+  end
+end

data/lib/bulkrax/version.rb

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

data/lib/bulkrax.rb

@@ -185,6 +185,12 @@ module Bulkrax
     value.to_s.delete("\xEF\xBB\xBF")
   end
 
+  def self.fallback_user_for_importer_exporter_processing
+    return User.batch_user if defined?(Hyrax) && User.respond_to?(:batch_user)
+
+    raise "We have no fallback user available for Bulkrax.fallback_user_for_importer_exporter_processing"
+  end
+
   # This class confirms to the Active::Support.serialze interface.  It's job is to ensure that we
   # don't have keys with the tricksy Byte Order Mark character.
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Rob Kaufman
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -396,6 +396,7 @@ files:
 - db/migrate/20220609001128_rename_bulkrax_importer_run_to_importer_run.rb
 - lib/bulkrax.rb
 - lib/bulkrax/engine.rb
+- lib/bulkrax/entry_spec_helper.rb
 - lib/bulkrax/version.rb
 - lib/generators/bulkrax/install_generator.rb
 - lib/generators/bulkrax/templates/README
@@ -410,7 +411,7 @@ homepage: https://github.com/samvera-labs/bulkrax
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -425,8 +426,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Import and export tool for Hyrax and Hyku
 test_files: []