bulkrax 7.0.0 → 8.0.0

data/app/parsers/bulkrax/bagit_parser.rb

@@ -1,223 +1,224 @@
 # frozen_string_literal: true
-require 'bagit'
 
-module Bulkrax
-  class BagitParser < CsvParser # rubocop:disable Metrics/ClassLength
-    include ExportBehavior
+unless ENV.fetch('BULKRAX_NO_BAGIT', 'false').to_s == 'true'
+  module Bulkrax
+    class BagitParser < CsvParser # rubocop:disable Metrics/ClassLength
+      include ExportBehavior
 
-    def self.export_supported?
-      true
-    end
-
-    def valid_import?
-      return true if import_fields.present?
-    rescue => e
-      set_status_info(e)
-      false
-    end
+      def self.export_supported?
+        true
+      end
 
-    def entry_class
-      rdf_format = parser_fields&.[]('metadata_format') == "Bulkrax::RdfEntry"
-      rdf_format ? RdfEntry : CsvEntry
-    end
+      def valid_import?
+        return true if import_fields.present?
+      rescue => e
+        set_status_info(e)
+        false
+      end
 
-    def path_to_files(filename:)
-      @path_to_files ||= Dir.glob(File.join(import_file_path, '**/data', filename)).first
-    end
+      def entry_class
+        rdf_format = parser_fields&.[]('metadata_format') == "Bulkrax::RdfEntry"
+        rdf_format ? RdfEntry : CsvEntry
+      end
 
-    # Take a random sample of 10 metadata_paths and work out the import fields from that
-    def import_fields
-      raise StandardError, 'No metadata files were found' if metadata_paths.blank?
-      @import_fields ||= metadata_paths.sample(10).map do |path|
-        entry_class.fields_from_data(entry_class.read_data(path))
-      end.flatten.compact.uniq
-    end
+      def path_to_files(filename:)
+        @path_to_files ||= Dir.glob(File.join(import_file_path, '**/data', filename)).first
+      end
 
-    # Create an Array of all metadata records
-    def records(_opts = {})
-      raise StandardError, 'No BagIt records were found' if bags.blank?
-      @records ||= bags.map do |bag|
-        path = metadata_path(bag)
-        raise StandardError, 'No metadata files were found' if path.blank?
-        data = entry_class.read_data(path)
-        get_data(bag, data)
+      # Take a random sample of 10 metadata_paths and work out the import fields from that
+      def import_fields
+        raise StandardError, 'No metadata files were found' if metadata_paths.blank?
+        @import_fields ||= metadata_paths.sample(10).map do |path|
+          entry_class.fields_from_data(entry_class.read_data(path))
+        end.flatten.compact.uniq
       end
 
-      @records = @records.flatten
-    end
+      # Create an Array of all metadata records
+      def records(_opts = {})
+        raise StandardError, 'No BagIt records were found' if bags.blank?
+        @records ||= bags.map do |bag|
+          path = metadata_path(bag)
+          raise StandardError, 'No metadata files were found' if path.blank?
+          data = entry_class.read_data(path)
+          get_data(bag, data)
+        end
+
+        @records = @records.flatten
+      end
 
-    def get_data(bag, data)
-      if entry_class == CsvEntry
-        data = data.map do |data_row|
-          record_data = entry_class.data_for_entry(data_row, source_identifier, self)
-          next record_data if importerexporter.metadata_only?
+      def get_data(bag, data)
+        if entry_class == CsvEntry
+          data = data.map do |data_row|
+            record_data = entry_class.data_for_entry(data_row, source_identifier, self)
+            next record_data if importerexporter.metadata_only?
 
-          record_data[:file] = bag.bag_files.join('|') if Bulkrax.curation_concerns.include? record_data[:model]&.constantize
-          record_data
+            record_data[:file] = bag.bag_files.join('|') if Bulkrax.curation_concerns.include? record_data[:model]&.constantize
+            record_data
+          end
+        else
+          data = entry_class.data_for_entry(data, source_identifier, self)
+          data[:file] = bag.bag_files.join('|') unless importerexporter.metadata_only?
         end
-      else
-        data = entry_class.data_for_entry(data, source_identifier, self)
-        data[:file] = bag.bag_files.join('|') unless importerexporter.metadata_only?
+
+        data
       end
 
-      data
-    end
+      # export methods
 
-    # export methods
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def write_files
+        require 'open-uri'
+        require 'socket'
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    def write_files
-      require 'open-uri'
-      require 'socket'
+        folder_count = 1
+        records_in_folder = 0
+        work_entries = importerexporter.entries.where(type: work_entry_class.to_s)
+        collection_entries = importerexporter.entries.where(type: collection_entry_class.to_s)
+        file_set_entries = importerexporter.entries.where(type: file_set_entry_class.to_s)
 
-      folder_count = 1
-      records_in_folder = 0
-      work_entries = importerexporter.entries.where(type: work_entry_class.to_s)
-      collection_entries = importerexporter.entries.where(type: collection_entry_class.to_s)
-      file_set_entries = importerexporter.entries.where(type: file_set_entry_class.to_s)
+        work_entries[0..limit || total].each do |entry|
+          record = Bulkrax.object_factory.find(entry.identifier)
+          next unless record
 
-      work_entries[0..limit || total].each do |entry|
-        record = ActiveFedora::Base.find(entry.identifier)
-        next unless record
+          bag_entries = [entry]
 
-        bag_entries = [entry]
+          if record.member_of_collection_ids.present?
+            collection_entries.each { |ce| bag_entries << ce if ce.parsed_metadata.value?(record.id) }
+          end
 
-        if record.member_of_collection_ids.present?
-          collection_entries.each { |ce| bag_entries << ce if ce.parsed_metadata.value?(record.id) }
-        end
+          if record.file_sets.present?
+            file_set_entries.each { |fse| bag_entries << fse if fse.parsed_metadata.value?(record.id) }
+          end
 
-        if record.file_sets.present?
-          file_set_entries.each { |fse| bag_entries << fse if fse.parsed_metadata.value?(record.id) }
-        end
+          records_in_folder += bag_entries.count
+          if records_in_folder > records_split_count
+            folder_count += 1
+            records_in_folder = bag_entries.count
+          end
 
-        records_in_folder += bag_entries.count
-        if records_in_folder > records_split_count
-          folder_count += 1
-          records_in_folder = bag_entries.count
-        end
+          bag ||= BagIt::Bag.new setup_bagit_folder(folder_count, entry.identifier)
+
+          record.file_sets.each do |fs|
+            file_name = filename(fs)
+            next if file_name.blank? || fs.original_file.blank?
+
+            io = open(fs.original_file.uri)
+            file = Tempfile.new([file_name, File.extname(file_name)], binmode: true)
+            file.write(io.read)
+            file.close
+            begin
+              bag.add_file(file_name, file.path) if bag.bag_files.select { |b| b.include?(file_name) }.blank?
+            rescue => e
+              entry.set_status_info(e)
+              set_status_info(e)
+            end
+          end
 
-        bag ||= BagIt::Bag.new setup_bagit_folder(folder_count, entry.identifier)
-
-        record.file_sets.each do |fs|
-          file_name = filename(fs)
-          next if file_name.blank? || fs.original_file.blank?
-
-          io = open(fs.original_file.uri)
-          file = Tempfile.new([file_name, File.extname(file_name)], binmode: true)
-          file.write(io.read)
-          file.close
-          begin
-            bag.add_file(file_name, file.path) if bag.bag_files.select { |b| b.include?(file_name) }.blank?
-          rescue => e
-            entry.set_status_info(e)
-            set_status_info(e)
+          CSV.open(setup_csv_metadata_export_file(folder_count, entry.identifier), "w", headers: export_headers, write_headers: true) do |csv|
+            bag_entries.each { |csv_entry| csv << csv_entry.parsed_metadata }
           end
-        end
 
-        CSV.open(setup_csv_metadata_export_file(folder_count, entry.identifier), "w", headers: export_headers, write_headers: true) do |csv|
-          bag_entries.each { |csv_entry| csv << csv_entry.parsed_metadata }
+          write_triples(folder_count, entry)
+          bag.manifest!(algo: 'sha256')
         end
-
-        write_triples(folder_count, entry)
-        bag.manifest!(algo: 'sha256')
       end
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-    def setup_csv_metadata_export_file(folder_count, id)
-      path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
-      FileUtils.mkdir_p(path) unless File.exist?(path)
+      def setup_csv_metadata_export_file(folder_count, id)
+        path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
+        FileUtils.mkdir_p(path) unless File.exist?(path)
 
-      File.join(path, id, 'metadata.csv')
-    end
+        File.join(path, id, 'metadata.csv')
+      end
 
-    def key_allowed(key)
-      !Bulkrax.reserved_properties.include?(key) &&
-        new_entry(entry_class, 'Bulkrax::Exporter').field_supported?(key) &&
-        key != source_identifier.to_s
-    end
+      def key_allowed(key)
+        !Bulkrax.reserved_properties.include?(key) &&
+          new_entry(entry_class, 'Bulkrax::Exporter').field_supported?(key) &&
+          key != source_identifier.to_s
+      end
 
-    def setup_triple_metadata_export_file(folder_count, id)
-      path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
-      FileUtils.mkdir_p(path) unless File.exist?(path)
+      def setup_triple_metadata_export_file(folder_count, id)
+        path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
+        FileUtils.mkdir_p(path) unless File.exist?(path)
 
-      File.join(path, id, 'metadata.nt')
-    end
+        File.join(path, id, 'metadata.nt')
+      end
 
-    def setup_bagit_folder(folder_count, id)
-      path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
-      FileUtils.mkdir_p(path) unless File.exist?(path)
+      def setup_bagit_folder(folder_count, id)
+        path = File.join(importerexporter.exporter_export_path, folder_count.to_s)
+        FileUtils.mkdir_p(path) unless File.exist?(path)
 
-      File.join(path, id)
-    end
+        File.join(path, id)
+      end
 
-    # @todo(bjustice) - remove hyrax reference
-    def write_triples(folder_count, e)
-      sd = SolrDocument.find(e.identifier)
-      return if sd.nil?
+      # @todo(bjustice) - remove hyrax reference
+      def write_triples(folder_count, e)
+        sd = SolrDocument.find(e.identifier)
+        return if sd.nil?
 
-      req = ActionDispatch::Request.new({ 'HTTP_HOST' => Socket.gethostname })
-      rdf = Hyrax::GraphExporter.new(sd, req).fetch.dump(:ntriples)
-      File.open(setup_triple_metadata_export_file(folder_count, e.identifier), "w") do |triples|
-        triples.write(rdf)
+        req = ActionDispatch::Request.new({ 'HTTP_HOST' => Socket.gethostname })
+        rdf = Hyrax::GraphExporter.new(sd, req).fetch.dump(:ntriples)
+        File.open(setup_triple_metadata_export_file(folder_count, e.identifier), "w") do |triples|
+          triples.write(rdf)
+        end
       end
-    end
 
-    # @todo - investigate getting directory structure
-    # @todo - investigate using perform_later, and having the importer check for
-    #   DownloadCloudFileJob before it starts
-    def retrieve_cloud_files(files)
-      # There should only be one zip file for Bagit, take the first
-      return if files['0'].blank?
-      target_file = File.join(path_for_import, files['0']['file_name'].tr(' ', '_'))
-      # Now because we want the files in place before the importer runs
-      Bulkrax::DownloadCloudFileJob.perform_now(files['0'], target_file)
-      return target_file
-    end
+      # @todo - investigate getting directory structure
+      # @todo - investigate using perform_later, and having the importer check for
+      #   DownloadCloudFileJob before it starts
+      def retrieve_cloud_files(files, _importer)
+        # There should only be one zip file for Bagit, take the first
+        return if files['0'].blank?
+        target_file = File.join(path_for_import, files['0']['file_name'].tr(' ', '_'))
+        # Now because we want the files in place before the importer runs
+        Bulkrax::DownloadCloudFileJob.perform_now(files['0'], target_file)
+        return target_file
+      end
 
-    private
+      private
 
-    def bags
-      return @bags if @bags.present?
-      new_bag = bag(import_file_path)
-      @bags = new_bag ? [new_bag] : Dir.glob("#{import_file_path}/**/*").map { |d| bag(d) }
-      @bags.delete(nil)
-      raise StandardError, 'No valid bags found' if @bags.blank?
-      return @bags
-    end
+      def bags
+        return @bags if @bags.present?
+        new_bag = bag(import_file_path)
+        @bags = new_bag ? [new_bag] : Dir.glob("#{import_file_path}/**/*").map { |d| bag(d) }
+        @bags.delete(nil)
+        raise StandardError, 'No valid bags found' if @bags.blank?
+        return @bags
+      end
 
-    # Gather the paths to all bags; skip any stray files
-    def bag_paths
-      bags.map(&:bag_dir)
-    end
+      # Gather the paths to all bags; skip any stray files
+      def bag_paths
+        bags.map(&:bag_dir)
+      end
 
-    def metadata_file_name
-      raise StandardError, 'The metadata file name must be specified' if parser_fields['metadata_file_name'].blank?
-      parser_fields['metadata_file_name']
-    end
+      def metadata_file_name
+        raise StandardError, 'The metadata file name must be specified' if parser_fields['metadata_file_name'].blank?
+        parser_fields['metadata_file_name']
+      end
 
-    # Gather the paths to all metadata files matching the metadata_file_name
-    def metadata_paths
-      @metadata_paths ||= bag_paths.map do |b|
-        Dir.glob("#{b}/**/*").select { |f| File.file?(f) && f.ends_with?(metadata_file_name) }
-      end.flatten.compact
-    end
+      # Gather the paths to all metadata files matching the metadata_file_name
+      def metadata_paths
+        @metadata_paths ||= bag_paths.map do |b|
+          Dir.glob("#{b}/**/*").select { |f| File.file?(f) && f.ends_with?(metadata_file_name) }
+        end.flatten.compact
+      end
 
-    def metadata_path(bag)
-      Dir.glob("#{bag.bag_dir}/**/*").detect { |f| File.file?(f) && f.ends_with?(metadata_file_name) }
-    end
+      def metadata_path(bag)
+        Dir.glob("#{bag.bag_dir}/**/*").detect { |f| File.file?(f) && f.ends_with?(metadata_file_name) }
+      end
 
-    def bag(path)
-      return nil unless path && File.exist?(File.join(path, 'bagit.txt'))
-      bag = BagIt::Bag.new(path)
-      return nil unless bag.valid?
-      bag
-    end
+      def bag(path)
+        return nil unless path && File.exist?(File.join(path, 'bagit.txt'))
+        bag = BagIt::Bag.new(path)
+        return nil unless bag.valid?
+        bag
+      end
 
-    # use the version of this method from the application parser instead
-    def real_import_file_path
-      return importer_unzip_path if file? && zip?
-      parser_fields['import_file_path']
+      # use the version of this method from the application parser instead
+      def real_import_file_path
+        return importer_unzip_path if file? && zip?
+        parser_fields['import_file_path']
+      end
     end
   end
 end

data/app/parsers/bulkrax/csv_parser.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'csv'
 module Bulkrax
   class CsvParser < ApplicationParser # rubocop:disable Metrics/ClassLength
     include ErroredEntries
@@ -23,6 +22,7 @@ module Bulkrax
       @records = csv_data.map { |record_data| entry_class.data_for_entry(record_data, nil, self) }
     end
 
+    # rubocop:disable Metrics/AbcSize
     def build_records
       @collections = []
       @works = []
@@ -34,7 +34,9 @@ module Bulkrax
             next unless r.key?(model_mapping)
 
             model = r[model_mapping].nil? ? "" : r[model_mapping].strip
-            if model.casecmp('collection').zero?
+            # TODO: Eventually this should be refactored to us Hyrax.config.collection_model
+            #       We aren't right now because so many Bulkrax users are in between Fedora and Valkyrie
+            if model.casecmp('collection').zero? || model.casecmp('collectionresource').zero?
               @collections << r
             elsif model.casecmp('fileset').zero?
               @file_sets << r
@@ -52,6 +54,7 @@ module Bulkrax
 
       true
     end
+    # rubocop:enabled Metrics/AbcSize
 
     def collections
       build_records if @collections.nil?
@@ -190,9 +193,10 @@ module Bulkrax
     # @todo - investigate getting directory structure
     # @todo - investigate using perform_later, and having the importer check for
     #   DownloadCloudFileJob before it starts
-    def retrieve_cloud_files(files)
+    def retrieve_cloud_files(files, importer)
       files_path = File.join(path_for_import, 'files')
       FileUtils.mkdir_p(files_path) unless File.exist?(files_path)
+      target_files = []
       files.each_pair do |_key, file|
         # fixes bug where auth headers do not get attached properly
         if file['auth_header'].present?
@@ -201,10 +205,12 @@ module Bulkrax
         end
         # this only works for uniquely named files
         target_file = File.join(files_path, file['file_name'].tr(' ', '_'))
+        target_files << target_file
         # Now because we want the files in place before the importer runs
         # Problematic for a large upload
-        Bulkrax::DownloadCloudFileJob.perform_now(file, target_file)
+        Bulkrax::DownloadCloudFileJob.perform_later(file, target_file)
       end
+      importer[:parser_fields]['original_file_paths'] = target_files
       return nil
     end
 
@@ -225,6 +231,7 @@ module Bulkrax
         CSV.open(setup_export_file(folder_count), "w", headers: export_headers, write_headers: true) do |csv|
           group.each do |entry|
             csv << entry.parsed_metadata
+            # TODO: This is precarious when we have descendents of Bulkrax::CsvCollectionEntry
             next if importerexporter.metadata_only? || entry.type == 'Bulkrax::CsvCollectionEntry'
 
             store_files(entry.identifier, folder_count.to_s)
@@ -234,7 +241,7 @@ module Bulkrax
     end
 
     def store_files(identifier, folder_count)
-      record = ActiveFedora::Base.find(identifier)
+      record = Bulkrax.object_factory.find(identifier)
       return unless record
 
       file_sets = record.file_set? ? Array.wrap(record) : record.file_sets
@@ -286,6 +293,9 @@ module Bulkrax
 
     def sort_entries(entries)
       # always export models in the same order: work, collection, file set
+      #
+      # TODO: This is a problem in that only these classes are compared.  Instead
+      #       We should add a comparison operator to the classes.
       entries.sort_by do |entry|
         case entry.type
         when 'Bulkrax::CsvCollectionEntry'

data/app/parsers/bulkrax/oai_dc_parser.rb

@@ -105,6 +105,24 @@ module Bulkrax
       set_status_info(e)
     end
 
+    def create_file_sets; end
+
+    def create_relationships
+      ScheduleRelationshipsJob.set(wait: 5.minutes).perform_later(importer_id: importerexporter.id)
+    end
+
+    def record_raw_metadata(_record)
+      nil
+    end
+
+    def record_deleted?(_record)
+      false
+    end
+
+    def record_remove_and_rerun?(_record)
+      false
+    end
+
     # oai records so not let us set the source identifier easily
     def record_has_source_identifier(record, index)
       identifier = record.send(source_identifier)

data/app/parsers/bulkrax/parser_export_record_set.rb

@@ -149,12 +149,12 @@ module Bulkrax
       end
 
       def works
-        @works ||= ActiveFedora::SolrService.query(works_query, **works_query_kwargs)
+        @works ||= Bulkrax.object_factory.query(works_query, **works_query_kwargs)
       end
 
       def collections
         @collections ||= if collections_query
-                           ActiveFedora::SolrService.query(collections_query, **collections_query_kwargs)
+                           Bulkrax.object_factory.query(collections_query, **collections_query_kwargs)
                          else
                            []
                          end
@@ -173,43 +173,39 @@ module Bulkrax
       # @see https://github.com/samvera/hyrax/blob/64c0bbf0dc0d3e1b49f040b50ea70d177cc9d8f6/app/indexers/hyrax/work_indexer.rb#L15-L18
       def file_sets
         @file_sets ||= ParserExportRecordSet.in_batches(candidate_file_set_ids) do |batch_of_ids|
-          fsq = "has_model_ssim:#{Bulkrax.file_model_class} AND id:(\"" + batch_of_ids.join('" OR "') + "\")"
+          fsq = "has_model_ssim:#{Bulkrax.file_model_internal_resource} AND id:(\"" + batch_of_ids.join('" OR "') + "\")"
           fsq += extra_filters if extra_filters.present?
-          ActiveFedora::SolrService.query(
+          Bulkrax.object_factory.query(
             fsq,
-            { fl: "id", method: :post, rows: batch_of_ids.size }
+            fl: "id", method: :post, rows: batch_of_ids.size
           )
         end
       end
 
       def solr_name(base_name)
-        if Module.const_defined?(:Solrizer)
-          ::Solrizer.solr_name(base_name)
-        else
-          ::ActiveFedora.index_field_mapper.solr_name(base_name)
-        end
+        Bulkrax.object_factory.solr_name(base_name)
       end
     end
 
     class All < Base
       def works_query
-        "has_model_ssim:(#{Bulkrax.curation_concerns.join(' OR ')}) #{extra_filters}"
+        "has_model_ssim:(#{Bulkrax.curation_concern_internal_resources.join(' OR ')}) #{extra_filters}"
       end
 
       def collections_query
-        "has_model_ssim:Collection #{extra_filters}"
+        "has_model_ssim:#{Bulkrax.collection_model_internal_resource} #{extra_filters}"
       end
     end
 
     class Collection < Base
       def works_query
         "member_of_collection_ids_ssim:#{importerexporter.export_source} #{extra_filters} AND " \
-        "has_model_ssim:(#{Bulkrax.curation_concerns.join(' OR ')})"
+        "has_model_ssim:(#{Bulkrax.curation_concern_internal_resources.join(' OR ')})"
       end
 
       def collections_query
         "(id:#{importerexporter.export_source} #{extra_filters}) OR " \
-        "(has_model_ssim:Collection AND member_of_collection_ids_ssim:#{importerexporter.export_source})"
+        "(has_model_ssim:#{Bulkrax.collection_model_internal_resource} AND member_of_collection_ids_ssim:#{importerexporter.export_source})"
       end
     end
 
@@ -247,12 +243,12 @@ module Bulkrax
 
       def works
         @works ||= ParserExportRecordSet.in_batches(complete_entry_identifiers) do |ids|
-          ActiveFedora::SolrService.query(
+          Bulkrax.object_factory.query(
             extra_filters.to_s,
             **query_kwargs.merge(
               fq: [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
-                "has_model_ssim:(#{Bulkrax.curation_concerns.join(' OR ')})"
+                "has_model_ssim:(#{Bulkrax.curation_concern_internal_resources.join(' OR ')})"
               ],
               fl: 'id'
             )
@@ -262,12 +258,12 @@ module Bulkrax
 
       def collections
         @collections ||= ParserExportRecordSet.in_batches(complete_entry_identifiers) do |ids|
-          ActiveFedora::SolrService.query(
-            "has_model_ssim:Collection #{extra_filters}",
+          Bulkrax.object_factory.query(
+            "has_model_ssim:#{Bulkrax.collection_model_internal_resource} #{extra_filters}",
             **query_kwargs.merge(
               fq: [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
-                "has_model_ssim:Collection"
+                "has_model_ssim:#{Bulkrax.collection_model_internal_resource}"
               ],
               fl: "id"
             )
@@ -281,12 +277,12 @@ module Bulkrax
       # @see Bulkrax::ParserExportRecordSet::Base#file_sets
       def file_sets
         @file_sets ||= ParserExportRecordSet.in_batches(complete_entry_identifiers) do |ids|
-          ActiveFedora::SolrService.query(
+          Bulkrax.object_factory.query(
             extra_filters,
-            query_kwargs.merge(
+            **query_kwargs.merge(
               fq: [
                 %(#{solr_name(work_identifier)}:("#{ids.join('" OR "')}")),
-                "has_model_ssim:#{Bulkrax.file_model_class}"
+                "has_model_ssim:#{Bulkrax.file_model_internal_resource}"
               ],
               fl: 'id'
             )

data/app/parsers/bulkrax/xml_parser.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-require 'marcel'
-
 module Bulkrax
   class XmlParser < ApplicationParser
     def entry_class

data/app/services/bulkrax/factory_class_finder.rb

@@ -29,6 +29,8 @@ module Bulkrax
       def self.call(name, suffix: SUFFIX)
         if name.end_with?(suffix)
           name.constantize
+        elsif name == "FileSet"
+          Bulkrax.file_model_class
         else
           begin
             "#{name}#{suffix}".constantize