bulkrax 4.4.0 → 5.1.0

data/app/views/hyrax/dashboard/sidebar/_repository_content.html.erb

@@ -1,27 +1,30 @@
-  <li class="h5 nav-item"><%= t('hyrax.admin.sidebar.repository_objects') %></li>
+<li class="h5 nav-item"><%= t('hyrax.admin.sidebar.repository_objects') %></li>
 
-  <%= menu.nav_link(hyrax.my_collections_path,
-                    class: "nav-link",
-                    onclick: "dontChangeAccordion(event);",
-                    also_active_for: hyrax.dashboard_collections_path) do %>
-    <span class="fa fa-folder-open" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('hyrax.admin.sidebar.collections') %></span>
-  <% end %>
+<%= menu.nav_link(hyrax.my_collections_path,
+                  class: "nav-link",
+                  onclick: "dontChangeAccordion(event);",
+                  also_active_for: hyrax.dashboard_collections_path) do %>
+  <span class="fa fa-folder-open" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('hyrax.admin.sidebar.collections') %></span>
+<% end %>
 
-  <%= menu.nav_link(hyrax.my_works_path,
-                    class: "nav-link",
-                    onclick: "dontChangeAccordion(event);",
-                    also_active_for: hyrax.dashboard_works_path) do %>
-    <span class="fa fa-file" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('hyrax.admin.sidebar.works') %></span>
-  <% end %>
+<%= menu.nav_link(hyrax.my_works_path,
+                  class: "nav-link",
+                  onclick: "dontChangeAccordion(event);",
+                  also_active_for: hyrax.dashboard_works_path) do %>
+  <span class="fa fa-file" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('hyrax.admin.sidebar.works') %></span>
+<% end %>
 
-  <% if ::Hyrax::DashboardController&.respond_to?(:sidebar_partials) %>
+<% if ::Hyrax::DashboardController&.respond_to?(:sidebar_partials) %>
   <%= render 'hyrax/dashboard/sidebar/menu_partials', menu: menu, section: :repository_content %>
-  <% else %>
-  <%= menu.nav_link(bulkrax.importers_path) do %>
-    <span class="fa fa-cloud-upload" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('bulkrax.admin.sidebar.importers') %></span>
-  <% end %>
-
-  <%= menu.nav_link(bulkrax.exporters_path) do %>
-    <span class="fa fa-cloud-download" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('bulkrax.admin.sidebar.exporters') %></span>
+<% else %>
+  <% if current_ability.can_import_works? %>
+    <%= menu.nav_link(bulkrax.importers_path) do %>
+      <span class="fa fa-cloud-upload" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('bulkrax.admin.sidebar.importers') %></span>
+    <% end %>
   <% end %>
+  <% if current_ability.can_export_works? %>
+    <%= menu.nav_link(bulkrax.exporters_path) do %>
+      <span class="fa fa-cloud-download" aria-hidden="true"></span> <span class="sidebar-action-text"><%= t('bulkrax.admin.sidebar.exporters') %></span>
+    <% end %>
   <% end %>
+<% end %>

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 = '4.4.0'
+  VERSION = '5.1.0'
 end

data/lib/bulkrax.rb

@@ -4,8 +4,13 @@ require "bulkrax/version"
 require "bulkrax/engine"
 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,
@@ -168,4 +173,52 @@ module Bulkrax
   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)
+    # Removing [Byte Order Mark (BOM)](https://en.wikipedia.org/wiki/Byte_order_mark)
+    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.
+  #
+  # @see https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize
+  class NormalizedJson
+    def self.normalize_keys(hash)
+      return hash unless hash.respond_to?(:each_pair)
+      returning_value = {}
+      hash.each_pair do |key, value|
+        returning_value[Bulkrax.normalize_string(key)] = value
+      end
+      returning_value
+    end
+
+    # When we write the serialized data to the database, we "dump" the value into that database
+    # column.
+    def self.dump(value)
+      JSON.dump(normalize_keys(value))
+    end
+
+    # When we load the serialized data from the database, we pass the database's value into "load"
+    # function.
+    #
+    # rubocop:disable Security/JSONLoad
+    def self.load(string)
+      normalize_keys(JSON.load(string))
+    end
+    # rubocop:enable Security/JSONLoad
+  end
 end
+# rubocop:disable Metrics/ModuleLength

data/lib/generators/bulkrax/install_generator.rb

@@ -55,6 +55,26 @@ class Bulkrax::InstallGenerator < Rails::Generators::Base
     end
   end
 
+  def add_ability
+    file = 'app/models/ability.rb'
+    file_text = File.read(file)
+    import_line = 'def can_import_works?'
+    export_line = 'def can_export_works?'
+    unless file_text.include?(import_line)
+      insert_into_file file, before: /^end/ do
+        "  def can_import_works?\n    can_create_any_work?\n  end"
+      end
+    end
+
+    # rubocop:disable Style/GuardClause
+    unless file_text.include?(export_line)
+      insert_into_file file, before: /^end/ do
+        "  def can_export_works?\n    can_create_any_work?\n  end"
+      end
+    end
+    # rubocop:enable Style/GuardClause
+  end
+
   def add_css
     ['css', 'scss', 'sass'].map do |ext|
       file = "app/assets/stylesheets/application.#{ext}"

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

@@ -80,4 +80,6 @@ Bulkrax.setup do |config|
 end
 
 # Sidebar for hyrax 3+ support
-Hyrax::DashboardController.sidebar_partials[:repository_content] << "hyrax/dashboard/sidebar/bulkrax_sidebar_additions" if Object.const_defined?(:Hyrax) && ::Hyrax::DashboardController&.respond_to?(:sidebar_partials)
+if Object.const_defined?(:Hyrax) && ::Hyrax::DashboardController&.respond_to?(:sidebar_partials)
+  Hyrax::DashboardController.sidebar_partials[:repository_content] << "hyrax/dashboard/sidebar/bulkrax_sidebar_additions"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bulkrax
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Rob Kaufman
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-01 00:00:00.000000000 Z
+date: 2023-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.2.4
 - !ruby/object:Gem::Dependency
   name: loofah
   requirement: !ruby/object:Gem::Requirement
@@ -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: []