bulkrax 5.0.0 → 5.2.0

data/lib/bulkrax/entry_spec_helper.rb

@@ -0,0 +1,190 @@
+# 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
+
+    # @api public
+    #
+    # @param parser_class_name [String]
+    # @param parser_fields [Hash<String,Hash>]
+    #
+    # @return [Bulkrax::Exporter]
+    def self.exporter_for(parser_class_name:, parser_fields: {}, **options)
+      Bulkrax::Exporter.new(
+        name: options.fetch(:exporter_name, "Test importer for identifier"),
+        user: options.fetch(:exporter_user, User.new(email: "hello@world.com")),
+        limit: options.fetch(:exporter_limit, 1),
+        parser_klass: parser_class_name,
+        field_mapping: options.fetch(:exporter_field_mappings) { Bulkrax.field_mappings.fetch(parser_class_name) },
+        parser_fields: parser_fields
+      )
+    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.2.0'
 end

data/lib/bulkrax.rb

@@ -6,31 +6,91 @@ require 'active_support/all'
 
 # rubocop:disable Metrics/ModuleLength
 module Bulkrax
-  class << self
-    # @todo Move from module attribute methods to a configuration class.  With module attributes,
-    #       when we make a change we are polluting the global space.  This means that our tests that
-    #       modify these config values are modifying global state.  Which is not desirous, as it can
-    #       introduce unexpected flakey tests.
-    mattr_accessor :api_definition,
-                   :default_field_mapping,
-                   :default_work_type,
-                   :export_path,
-                   :field_mappings,
-                   :fill_in_blank_source_identifiers,
-                   :generated_metadata_mapping,
-                   :import_path,
-                   :multi_value_element_join_on,
-                   :multi_value_element_split_on,
-                   :object_factory,
-                   :parsers,
-                   :qa_controlled_properties,
-                   :related_children_field_mapping,
-                   :related_parents_field_mapping,
-                   :removed_image_path,
-                   :reserved_properties,
-                   :server_name
-
-    self.parsers = [
+  extend self # rubocop:disable Style/ModuleFunction
+  extend Forwardable
+
+  ##
+  # @api public
+  class Configuration
+    attr_accessor :api_definition,
+                  :curation_concerns,
+                  :default_field_mapping,
+                  :default_work_type,
+                  :export_path,
+                  :field_mappings,
+                  :file_model_class,
+                  :fill_in_blank_source_identifiers,
+                  :generated_metadata_mapping,
+                  :import_path,
+                  :multi_value_element_join_on,
+                  :multi_value_element_split_on,
+                  :object_factory,
+                  :parsers,
+                  :qa_controlled_properties,
+                  :related_children_field_mapping,
+                  :related_parents_field_mapping,
+                  :relationship_job_class,
+                  :removed_image_path,
+                  :required_elements,
+                  :reserved_properties,
+                  :server_name
+  end
+
+  def config
+    @config ||= Configuration.new
+    yield @config if block_given?
+    @config
+  end
+  alias setup config
+
+  def_delegators :@config,
+                 :api_definition,
+                 :api_definition=,
+                 :curation_concerns,
+                 :curation_concerns=,
+                 :default_field_mapping,
+                 :default_field_mapping=,
+                 :default_work_type,
+                 :default_work_type=,
+                 :export_path,
+                 :export_path=,
+                 :field_mappings,
+                 :field_mappings=,
+                 :file_model_class,
+                 :file_model_class=,
+                 :fill_in_blank_source_identifiers,
+                 :fill_in_blank_source_identifiers=,
+                 :generated_metadata_mapping,
+                 :generated_metadata_mapping=,
+                 :import_path,
+                 :import_path=,
+                 :multi_value_element_join_on,
+                 :multi_value_element_join_on=,
+                 :multi_value_element_split_on,
+                 :multi_value_element_split_on=,
+                 :object_factory,
+                 :object_factory=,
+                 :parsers,
+                 :parsers=,
+                 :qa_controlled_properties,
+                 :qa_controlled_properties=,
+                 :related_children_field_mapping,
+                 :related_children_field_mapping=,
+                 :related_parents_field_mapping,
+                 :related_parents_field_mapping=,
+                 :relationship_job_class,
+                 :relationship_job_class=,
+                 :removed_image_path,
+                 :removed_image_path=,
+                 :required_elements,
+                 :required_elements=,
+                 :reserved_properties,
+                 :reserved_properties=,
+                 :server_name,
+                 :server_name=
+
+  config do |conf|
+    conf.parsers = [
       { name: "OAI - Dublin Core", class_name: "Bulkrax::OaiDcParser", partial: "oai_fields" },
       { name: "OAI - Qualified Dublin Core", class_name: "Bulkrax::OaiQualifiedDcParser", partial: "oai_fields" },
       { name: "CSV - Comma Separated Values", class_name: "Bulkrax::CsvParser", partial: "csv_fields" },
@@ -38,16 +98,34 @@ module Bulkrax
       { name: "XML", class_name: "Bulkrax::XmlParser", partial: "xml_fields" }
     ]
 
-    self.import_path = Bulkrax.import_path || 'tmp/imports'
-    self.export_path = Bulkrax.export_path || 'tmp/exports'
-    self.removed_image_path = Bulkrax::Engine.root.join('spec', 'fixtures', 'removed.png').to_s
-    self.server_name = 'bulkrax@example.com'
+    conf.import_path = Bulkrax.import_path || 'tmp/imports'
+    conf.export_path = Bulkrax.export_path || 'tmp/exports'
+    conf.removed_image_path = Bulkrax::Engine.root.join('spec', 'fixtures', 'removed.png').to_s
+    conf.server_name = 'bulkrax@example.com'
+    conf.relationship_job_class = "Bulkrax::CreateRelationshipsJob"
+    conf.required_elements = ['title']
+
+    def conf.curation_concerns
+      @curation_concerns ||= defined?(::Hyrax) ? ::Hyrax.config.curation_concerns : []
+    end
+
+    def conf.curation_concerns=(val)
+      @curation_concerns = val
+    end
+
+    def conf.file_model_class
+      @file_model_class ||= defined?(::Hyrax) ? ::FileSet : File
+    end
+
+    def conf.file_model_class=(val)
+      @file_model_class = val
+    end
 
     # Hash of Generic field_mappings for use in the view
-    # There must be one field_mappings hash per view parial
+    # There must be one field_mappings hash per view partial
     # Based on Hyrax CoreMetadata && BasicMetadata
     # Override at application level to change
-    self.field_mappings = {
+    conf.field_mappings = {
       "Bulkrax::OaiDcParser" => {
         "contributor" => { from: ["contributor"] },
         # no appropriate mapping for coverage (based_near needs id)
@@ -95,7 +173,7 @@ module Bulkrax
     }
 
     # Lambda to set the default field mapping
-    self.default_field_mapping = lambda do |field|
+    conf.default_field_mapping = lambda do |field|
       return if field.blank?
       {
         field.to_s =>
@@ -110,7 +188,7 @@ module Bulkrax
     end
 
     # Properties that should not be used in imports. They are reserved for use by Hyrax.
-    self.reserved_properties = %w[
+    conf.reserved_properties = %w[
       create_date
       modified_date
       date_modified
@@ -133,10 +211,10 @@ module Bulkrax
     # List of Questioning Authority properties that are controlled via YAML files in
     # the config/authorities/ directory. For example, the :rights_statement property
     # is controlled by the active terms in config/authorities/rights_statements.yml
-    self.qa_controlled_properties = %w[rights_statement license]
+    conf.qa_controlled_properties = %w[rights_statement license]
   end
 
-  def self.api_definition
+  def api_definition
     @api_definition ||= ActiveSupport::HashWithIndifferentAccess.new(
       YAML.safe_load(
         ERB.new(
@@ -149,9 +227,9 @@ module Bulkrax
   DEFAULT_MULTI_VALUE_ELEMENT_JOIN_ON = ' | '
   # Specify the delimiter for joining an attribute's multi-value array into a string.
   #
-  # @note the specific delimeter should likely be present in the multi_value_element_split_on
+  # @note the specific delimiter should likely be present in the multi_value_element_split_on
   #       expression.
-  def self.multi_value_element_join_on
+  def multi_value_element_join_on
     @multi_value_element_join_on ||= DEFAULT_MULTI_VALUE_ELEMENT_JOIN_ON
   end
 
@@ -161,7 +239,7 @@ module Bulkrax
   #
   # @note The "true" value is to preserve backwards compatibility.
   # @see DEFAULT_MULTI_VALUE_ELEMENT_JOIN_ON
-  def self.multi_value_element_split_on
+  def multi_value_element_split_on
     if @multi_value_element_join_on.is_a?(TrueClass)
       DEFAULT_MULTI_VALUE_ELEMENT_SPLIT_ON
     else
@@ -169,23 +247,24 @@ module Bulkrax
     end
   end
 
-  # this function maps the vars from your app into your engine
-  def self.setup
-    yield self
-  end
-
   # Responsible for stripping hidden characters from the given string.
   #
   # @param value [#to_s]
   # @return [String] with hidden characters removed
   #
   # @see https://github.com/samvera-labs/bulkrax/issues/688
-  def self.normalize_string(value)
+  def normalize_string(value)
     # Removing [Byte Order Mark (BOM)](https://en.wikipedia.org/wiki/Byte_order_mark)
     value.to_s.delete("\xEF\xBB\xBF")
   end
 
-  # This class confirms to the Active::Support.serialze interface.  It's job is to ensure that we
+  def 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.serialize interface.  It's job is to ensure that we
   # don't have keys with the tricksy Byte Order Mark character.
   #
   # @see https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize

data/lib/generators/bulkrax/templates/config/initializers/bulkrax.rb

@@ -72,7 +72,7 @@ Bulkrax.setup do |config|
   # config.qa_controlled_properties += ['my_field']
 
   # Specify the delimiter regular expression for splitting an attribute's values into a multi-value array.
-  # config.multi_value_element_split_on = //\s*[:;|]\s*/.freeze
+  # config.multi_value_element_split_on = /\s*[:;|]\s*/.freeze
 
   # Specify the delimiter for joining an attribute's multi-value array into a string.  Note: the
   # specific delimeter should likely be present in the multi_value_element_split_on expression.

data/lib/tasks/reset.rake

@@ -32,7 +32,7 @@ namespace :hyrax do
       Mailboxer::Notification.delete_all
       Mailboxer::Conversation::OptOut.delete_all
       Mailboxer::Conversation.delete_all
-      AccountElevator.switch!('single.tenant.default')
+      AccountElevator.switch!(Site.instance.account) if defined?(AccountElevator)
       # we need to wait till Fedora is done with its cleanup
       # otherwise creating the admin set will fail
       while AdminSet.exists?(AdminSet::DEFAULT_ID)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Rob Kaufman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -327,6 +327,7 @@ files:
 - app/parsers/bulkrax/csv_parser.rb
 - app/parsers/bulkrax/oai_dc_parser.rb
 - app/parsers/bulkrax/oai_qualified_dc_parser.rb
+- app/parsers/bulkrax/parser_export_record_set.rb
 - app/parsers/bulkrax/xml_parser.rb
 - app/services/bulkrax/remove_relationships_for_importer.rb
 - app/views/bulkrax/entries/_parsed_metadata.html.erb
@@ -396,6 +397,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
@@ -425,7 +427,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Import and export tool for Hyrax and Hyku