hyrax 5.1.0 → 5.3.0

data/app/presenters/hyrax/pcdm_member_presenter_factory.rb

@@ -108,12 +108,10 @@ module Hyrax
 
     def query_docs(generic_type: nil, ids: object.member_ids)
       query = "{!terms f=id}#{ids.join(',')}"
-      query += "{!term f=generic_type_si}#{generic_type}" if generic_type
-      # works created via ActiveFedora use the _sim field
-      query += "{!term f=generic_type_sim}#{generic_type}" if generic_type
+      query = "(generic_type_si:#{generic_type} OR generic_type_sim:#{generic_type}) AND #{query}" if generic_type
 
       Hyrax::SolrService
-        .post(q: query, rows: 10_000)
+        .post(query, rows: 10_000)
         .fetch('response')
         .fetch('docs')
     end

data/app/presenters/hyrax/work_show_presenter.rb

@@ -3,6 +3,7 @@ module Hyrax
   class WorkShowPresenter
     include ModelProxy
     include PresentsAttributes
+    include MissingMethodBehavior
 
     ##
     # @!attribute [w] member_presenter_factory
@@ -24,12 +25,45 @@ module Hyrax
       @solr_document = Hyrax::SolrDocument::OrderedMembers.decorate(solr_document)
       @current_ability = current_ability
       @request = request
+      define_dynamic_methods if @solr_document.flexible?
     end
 
+    def define_dynamic_methods # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      Hyrax::FlexibleSchema.default_properties.each do |prop|
+        method_name = prop.to_s
+        property_details = Hyrax::FlexibleSchema.current_version["properties"][method_name]
+        next unless property_details
+
+        index_keys = property_details["indexing"]
+        next unless index_keys
+
+        multi_value = property_details['multiple'] || (property_details['data_type'] == 'array')
+
+        next if self.class.method_defined?(method_name) && solr_document.respond_to?(method_name)
+        # Define the method on the SolrDocument class
+        Hyrax::SolrDocument::OrderedMembers.send(:define_method, method_name) do |*_args|
+          index_keys.each do |index_key|
+            value = self[index_key]
+            return (multi_value ? Array.wrap(value) : value) if value.present?
+          end
+          multi_value ? [] : ""
+        end
+
+        # Define the method on the Presenter class
+        self.class.send(:define_method, method_name) do |*args|
+          @solr_document.send(method_name, *args)
+        end
+      end
+    end # rubocop:enable Metrics/MethodLength
+
     # We cannot rely on the method missing to catch this delegation.  Because
     # most all objects implicitly implicitly implement #to_s
     delegate :to_s, to: :solr_document
 
+    def schema_version
+      solr_document[:schema_version_ssi]
+    end
+
     def page_title
       "#{human_readable_type} | #{title.first} | ID: #{id} | #{I18n.t('hyrax.product_name')}"
     end
@@ -50,11 +84,9 @@ module Hyrax
 
     # @return [Boolean] render a IIIF viewer
     def iiif_viewer?
-      Hyrax.config.iiif_image_server? &&
-        representative_id.present? &&
+      representative_id.present? &&
         representative_presenter.present? &&
-        representative_presenter.image? &&
-        members_include_viewable_image?
+        (av_viewable? || image_viewable? || pdf_viewable?)
     end
 
     alias universal_viewer? iiif_viewer?
@@ -74,7 +106,11 @@ module Hyrax
     #   <h3>My IIIF Viewer!</h3>
     #   <a href=<%= main_app.polymorphic_url([main_app, :manifest, presenter], { locale: nil }) %>>Manifest</a>
     def iiif_viewer
-      :universal_viewer
+      if representative_presenter.present? && av_viewable?
+        Hyrax.config.iiif_av_viewer
+      else
+        :universal_viewer
+      end
     end
 
     # @return FileSetPresenter presenter for the representative FileSets
@@ -246,15 +282,6 @@ module Hyrax
 
     private
 
-    def method_missing(method_name, *args, &block)
-      return solr_document.public_send(method_name, *args, &block) if solr_document.respond_to?(method_name)
-      super
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      solr_document.respond_to?(method_name, include_private) || super
-    end
-
     # list of item ids to display is based on ordered_ids
     def authorized_item_ids(filter_unreadable: Flipflop.hide_private_items?)
       @member_item_list_ids ||=
@@ -320,5 +347,20 @@ module Hyrax
     def members_include_viewable_image?
       file_set_presenters.any? { |presenter| presenter.image? && current_ability.can?(:read, presenter.id) }
     end
+
+    def av_viewable?
+      return false unless Flipflop.iiif_av?
+      representative_presenter.video? || representative_presenter.audio?
+    end
+
+    def image_viewable?
+      return false unless Hyrax.config.iiif_image_server?
+      representative_presenter.image? && members_include_viewable_image?
+    end
+
+    def pdf_viewable?
+      return false unless Flipflop.iiif_pdf?
+      representative_presenter.pdf?
+    end
   end
 end

data/app/renderers/hyrax/renderers/attribute_renderer.rb

@@ -27,7 +27,7 @@ module Hyrax
 
       # Draw the table row for the attribute
       def render
-        return '' if values.blank? && !options[:include_empty]
+        return '' if blank_values? && !options[:include_empty]
 
         markup = %(<tr><th>#{label}</th>\n<td><ul class='tabular'>)
 
@@ -47,7 +47,7 @@ module Hyrax
 
       # Draw the dl row for the attribute
       def render_dl_row
-        return '' if values.blank? && !options[:include_empty]
+        return '' if blank_values? && !options[:include_empty]
 
         markup = %(<dt>#{label}</dt>\n<dd><ul class='tabular'>)
 
@@ -107,6 +107,10 @@ module Hyrax
       def work_type_label_key
         options[:work_type] ? options[:work_type].underscore : nil
       end
+
+      def blank_values?
+        Array(values).all?(&:blank?)
+      end
     end
   end
 end

data/app/renderers/hyrax/renderers/license_attribute_renderer.rb

@@ -7,18 +7,18 @@ module Hyrax
       private
 
       ##
-      # Special treatment for license/rights.  A URL from the Hyrax gem's config/hyrax.rb is stored in the descMetadata of the
-      # curation_concern.  If that URL is valid in form, then it is used as a link.  If it is not valid, it is used as plain text.
+      # Special treatment for license/rights. A URL from the Hyrax gem's
+      # `config/hyrax.rb` is stored in the descMetadata of the
+      # curation_concern. If the stored value is an absolute http/https URI,
+      # render it as a link with the authority's label; otherwise render the
+      # value as plain text to avoid emitting unsafe href values (e.g.
+      # `javascript:`) or broken links for free-text values.
       def attribute_value_to_html(value)
-        begin
-          parsed_uri = URI.parse(value)
-        rescue URI::InvalidURIError
-          nil
-        end
-        if parsed_uri.nil?
-          ERB::Util.h(value)
+        if Hyrax::AuthorityRenderingHelper.linkable_uri?(value)
+          label = Hyrax.config.license_service_class.new.label(value) { value }
+          %(<a href="#{ERB::Util.h(value)}" target="_blank" rel="noopener noreferrer">#{ERB::Util.h(label)}</a>)
         else
-          %(<a href=#{ERB::Util.h(value)} target="_blank">#{Hyrax.config.license_service_class.new.label(value)}</a>)
+          ERB::Util.h(value)
         end
       end
     end

data/app/renderers/hyrax/renderers/redirects_label_attribute_renderer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module Renderers
+    # Renders each redirect path as a clickable link. The link text is the full
+    # absolute URL (host + path); the href is the path alone, which the browser
+    # resolves against the current document's host. Used on show pages via the
+    # `redirects` schema's `render_as: redirects_label` view option.
+    class RedirectsLabelAttributeRenderer < AttributeRenderer
+      private
+
+      def li_value(value)
+        path = value.to_s
+        return ERB::Util.h(path) if path.blank?
+
+        display = base_url.present? ? "#{base_url}#{path}" : path
+        link_to(ERB::Util.h(display), path)
+      end
+
+      def base_url
+        options[:base_url].to_s.sub(%r{/+\z}, '')
+      end
+    end
+  end
+end

data/app/renderers/hyrax/renderers/rights_statement_attribute_renderer.rb

@@ -7,19 +7,18 @@ module Hyrax
       private
 
       ##
-      # Special treatment for license/rights.  A URL from the Hyrax gem's config/hyrax.rb is stored in the descMetadata of the
-      # curation_concern.  If that URL is valid in form, then it is used as a link.  If it is not valid, it is used as plain text.
+      # Special treatment for license/rights. A URL from the Hyrax gem's
+      # `config/hyrax.rb` is stored in the descMetadata of the
+      # curation_concern. If the stored value is an absolute http/https URI,
+      # render it as a link with the authority's label; otherwise render the
+      # value as plain text to avoid emitting unsafe href values (e.g.
+      # `javascript:`) or broken links for free-text values.
       def attribute_value_to_html(value)
-        begin
-          parsed_uri = URI.parse(value)
-        rescue URI::InvalidURIError
-          nil
-        end
-        if parsed_uri.nil?
-          ERB::Util.h(value)
-        else
+        if Hyrax::AuthorityRenderingHelper.linkable_uri?(value)
           label = Hyrax.config.rights_statement_service_class.new.label(value) { value }
-          %(<a href=#{ERB::Util.h(value)} target="_blank">#{label}</a>)
+          %(<a href="#{ERB::Util.h(value)}" target="_blank" rel="noopener noreferrer">#{ERB::Util.h(label)}</a>)
+        else
+          ERB::Util.h(value)
         end
       end
     end

data/app/search_builders/hyrax/dashboard/nested_collections_search_builder.rb

@@ -16,11 +16,7 @@ module Hyrax
 
       # Override for Hydra::AccessControlsEnforcement
       attr_reader :discovery_permissions
-      self.default_processor_chain += [:with_pagination, :show_only_other_collections_of_the_same_collection_type]
-
-      def with_pagination(solr_parameters)
-        solr_parameters[:rows] = 1000
-      end
+      self.default_processor_chain += [:show_only_other_collections_of_the_same_collection_type]
 
       # Solr can do graph traversal without the need of special indexing with the Graph query parser so
       # use this to compute both the parents and children of the current collection then exclude them

data/app/search_builders/hyrax/filter_by_type.rb

@@ -41,7 +41,7 @@ module Hyrax
     # types from appearing in search results
     # @return [Array<Class>] the list of work types to include in searches
     def work_types
-      Hyrax::ModelRegistry.work_classes
+      Hyrax::ModelRegistry.work_classes - Hyrax::ModelRegistry.file_set_classes
     end
 
     def work_classes

data/app/services/hyrax/action/create_valkyrie_work.rb

@@ -35,6 +35,7 @@ module Hyrax
         @params = params
         @work_attributes_key = work_attributes_key
         @work_attributes = @params.fetch(work_attributes_key, {})
+        @file_set_params = work_attributes[:file_set]&.map { |fs| fs.permit! } || []
       end
 
       attr_reader :form, :transactions, :user, :parent_id, :work_attributes, :uploaded_files, :params, :work_attributes_key
@@ -42,7 +43,7 @@ module Hyrax
       ##
       # @api public
       # @return [TrueClass] when the object is valid.
-      # @return [FalseClass] when the object is valid.
+      # @return [FalseClass] when the object is not valid.
       def validate
         form.validate(work_attributes)
       end
@@ -63,7 +64,7 @@ module Hyrax
       def step_args
         {
           'work_resource.add_to_parent' => { parent_id: params[:parent_id], user: user },
-          'work_resource.add_file_sets' => { uploaded_files: uploaded_files, file_set_params: work_attributes[:file_set] },
+          'work_resource.add_file_sets' => { uploaded_files: uploaded_files, file_set_params: @file_set_params },
           'change_set.set_user_as_depositor' => { user: user },
           'work_resource.change_depositor' => { user: ::User.find_by_user_key(form.on_behalf_of) },
           'work_resource.save_acl' => { permissions_params: form.input_params["permissions"] }

data/app/services/hyrax/analytics/ga4/base.rb

@@ -88,7 +88,7 @@ module Hyrax
         end
 
         def unwrap_metric(metric)
-          metric.metric_values.first.value.to_i
+          metric&.metric_values&.first&.value.to_i
         end
       end
     end

data/app/services/hyrax/analytics/ga4.rb

@@ -76,7 +76,11 @@ module Hyrax
           end
 
           def account_info
-            @account_info ||= JSON.parse(account_json_string)
+            @account_info ||= if account_json_string.is_a? Hash
+                                account_json_string
+                              else
+                                JSON.parse(account_json_string)
+                              end
           end
 
           KEYS.each do |key|

data/app/services/hyrax/authority_rendering_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Hyrax
+  # Shared rendering helpers for authority-backed values that may have been
+  # stored as either a real URI or as free text (the M3 metadata profile, plus
+  # bulk importers such as Bulkrax and Willow Sword, can both produce
+  # free-text values that the UI's authority dropdown did not constrain).
+  module AuthorityRenderingHelper
+    # Schemes considered safe to emit in an `<a href>`. Anything else (notably
+    # `javascript:`, `data:`, custom schemes, or non-absolute strings like
+    # `"moomin"`) is rendered as plain text so it cannot be activated as a
+    # link.
+    LINKABLE_URI_SCHEMES = %w[http https].freeze
+
+    module_function
+
+    # @param value [String, nil]
+    # @return [Boolean] true when the value parses as an absolute URI with an
+    #   allowed scheme, suitable to use as an anchor's href.
+    def linkable_uri?(value)
+      return false if value.blank?
+
+      parsed = URI.parse(value)
+      parsed.absolute? && LINKABLE_URI_SCHEMES.include?(parsed.scheme&.downcase)
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/app/services/hyrax/authority_service.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+module Hyrax
+  # Shared behavior for authority-backed services. Module-level services
+  # (such as {Hyrax::ResourceTypesService}) `extend` this module to gain a
+  # tolerant `label` / `active?` / `include_current_value` API plus the
+  # declarative macros described below.
+  #
+  # The tolerant methods are intentionally forgiving of off-authority values:
+  # `label` falls back to the id itself, `active?` returns false for ids that
+  # aren't present in the authority at all, and `include_current_value`
+  # preserves such values in edit forms so they are not silently dropped on
+  # save.
+  #
+  # ## Declarative macros
+  #
+  # Hosts use the {#authority_name} and {#microdata_namespace} macros to
+  # declare the wrapped subauthority and the i18n namespace used for
+  # schema.org type lookup. These macros generate the rest of the host's
+  # API for free:
+  #
+  #     module Hyrax
+  #       module DisciplineService
+  #         extend Hyrax::AuthorityService
+  #
+  #         authority_name 'discipline'
+  #         microdata_namespace 'type.'
+  #       end
+  #     end
+  #
+  # `authority_name` provides `authority`, `authority=`, `select_options`,
+  # and `select_all_options` (the latter is an alias of the former — both
+  # names are in use in the wild). `microdata_namespace` provides
+  # `microdata_type`.
+  #
+  # @note This module is intended for use via `extend` on a host module. The
+  #   macros define singleton methods on the host and are not available via
+  #   `include`. Hosts that need instance-level tolerant lookup should
+  #   subclass {Hyrax::QaSelectService} instead.
+  module AuthorityService
+    # Declares which Qa::Authorities::Local subauthority this host wraps,
+    # generating `authority`, `authority=`, `select_options`, and
+    # `select_all_options` accessors on the host.
+    #
+    # @param subauthority_name [String] the YAML subauthority name (e.g.
+    #   `'discipline'`)
+    def authority_name(subauthority_name)
+      define_singleton_method(:authority) do
+        @authority ||= Qa::Authorities::Local.subauthority_for(subauthority_name)
+      end
+
+      define_singleton_method(:authority=) do |value|
+        @authority = value
+      end
+
+      define_singleton_method(:select_all_options) do
+        authority.all.map { |element| [element[:label], element[:id]] }
+      end
+      singleton_class.alias_method(:select_options, :select_all_options)
+    end
+
+    # Declares the Microdata i18n namespace this host uses for schema.org
+    # type lookup, generating a `microdata_type(id)` method on the host.
+    #
+    # @param namespace [String] the Microdata key prefix (e.g. `'type.'`,
+    #   `'resource_type.'`, `'accessibility_feature_type.'`)
+    def microdata_namespace(namespace)
+      define_singleton_method(:microdata_type) do |id|
+        return Hyrax.config.microdata_default_type if id.nil?
+        Microdata.fetch("#{namespace}#{id}", default: Hyrax.config.microdata_default_type)
+      end
+    end
+
+    # @param id [String]
+    # @return [String] the label for the authority entry, falling back to the
+    #   id itself when no matching term is found.
+    #
+    # @yield when no 'term' value is present for the id
+    # @yieldreturn [String] an alternate label to return
+    def label(id, &block)
+      block ||= ->(_key) { id }
+      authority.find(id).fetch('term', &block)
+    end
+
+    # @return [Boolean] whether the id is an active entry. Returns false for
+    #   ids that aren't present in the authority at all, so a caller can treat
+    #   unknown ids as inactive (and preserve them in edit forms via
+    #   {#include_current_value}).
+    def active?(id)
+      result = authority.find(id)
+      return false if result.blank?
+      result.fetch('active', true)
+    end
+
+    # Preserves an off-authority value as a forced-select option in a Simple
+    # Form input so it is not silently dropped on save. Intended for use as a
+    # Simple Form `item_helper:` callback or to augment a `collection:` array
+    # in a partial.
+    def include_current_value(value, _index, render_options, html_options)
+      force_select = html_options[:class].is_a?(Array) ? [' force-select'] : ' force-select'
+      unless value.blank? || active?(value)
+        html_options[:class] += force_select
+        render_options += [[label(value), value]]
+      end
+      [render_options, html_options]
+    end
+  end
+end

data/app/services/hyrax/callbacks.rb

@@ -48,7 +48,7 @@ module Hyrax
 
       # Defines a callback for a given hook.
       def set(hook, warn: true, &block)
-        Deprecation.warn(self, warning_for_set) if warn
+        Deprecation.warn(warning_for_set) if warn
         raise NoBlockGiven, "a block is required when setting a callback" unless block_given?
         @callbacks[hook] = proc(&block)
       end
@@ -60,7 +60,7 @@ module Hyrax
 
       # Runs the callback defined for a given hook, with the arguments provided
       def run(hook, *args, warn: true, **opts)
-        Deprecation.warn(self, warning_for_run) if warn
+        Deprecation.warn(warning_for_run) if warn
         raise NotEnabled unless enabled?(hook)
         return nil unless set?(hook)
         @callbacks[hook].call(*args, **opts)

data/app/services/hyrax/change_depositor_service.rb

@@ -63,7 +63,7 @@ module Hyrax
     def self.apply_depositor_metadata(resource, depositor)
       depositor_id = depositor.respond_to?(:user_key) ? depositor.user_key : depositor
       resource.depositor = depositor_id if resource.respond_to? :depositor=
-      Hyrax::AccessControlList.new(resource: resource).grant(:edit).to(::User.find_by_user_key(depositor_id)).save
+      resource.permission_manager.acl.grant(:edit).to(::User.find_by_user_key(depositor_id)).save
     end
     private_class_method :apply_depositor_metadata
   end

data/app/services/hyrax/characterization/valkyrie_characterization_service.rb

@@ -107,13 +107,19 @@ class Hyrax::Characterization::ValkyrieCharacterizationService
   end
 
   # Assign values of the instance properties from the metadata mapping :prop => val
+  # @todo push exceptional per-property behavior into the mapping somehow?
   # @return [Hash]
   def apply_metadata(terms)
-    terms.each_pair do |term, value|
-      property = property_for(term)
-      next if property.nil?
-
-      Array(value).each { |v| append_property_value(property, v) }
+    values_by_property(terms).each do |property, values|
+      value = if property == :mime_type
+                values.last
+              elsif [:height, :width].include?(property)
+                # keep only the max height or width
+                values.map(&:to_i).max.to_s
+              else
+                values
+              end
+      metadata.public_send("#{property}=", value)
     end
   end
 
@@ -127,13 +133,15 @@ class Hyrax::Characterization::ValkyrieCharacterizationService
     end
   end
 
-  ##
-  # @todo push exceptional per-property behavior into the mapping somehow?
-  def append_property_value(property, value)
-    # We don't want multiple mime_types; this overwrites each time to accept last value
-    value = Array(metadata.public_send(property)) + [value] unless property == :mime_type
-    # We don't want multiple heights / widths, pick the max
-    value = value.map(&:to_i).max.to_s if property == :height || property == :width
-    metadata.public_send("#{property}=", value)
+  # Map each term to the corresponding property
+  # (multiple terms can map to the same property),
+  # and gather all values for each property
+  # @return [Hash]
+  def values_by_property(terms)
+    terms.each_with_object({}) do |(term, value), property_values|
+      next unless (property = property_for(term))
+
+      (property_values[property] ||= []).concat(Array(value))
+    end
   end
 end

data/app/services/hyrax/collections/nested_collection_query_service.rb

@@ -16,7 +16,7 @@ module Hyrax
       def self.available_child_collections(parent:, scope:, limit_to_id: nil)
         return [] unless nestable?(collection: parent)
         return [] unless scope.can?(:deposit, parent)
-        query_solr(collection: parent, access: :read, scope: scope, limit_to_id: limit_to_id, nest_direction: :as_child).documents
+        query_solr(collection: parent, access: :read, scope: scope, limit_to_id: limit_to_id, nest_direction: :as_child)
       end
 
       ##
@@ -34,7 +34,7 @@ module Hyrax
       def self.available_parent_collections(child:, scope:, limit_to_id: nil)
         return [] unless nestable?(collection: child)
         return [] unless scope.can?(:read, child)
-        query_solr(collection: child, access: :deposit, scope: scope, limit_to_id: limit_to_id, nest_direction: :as_parent).documents
+        query_solr(collection: child, access: :deposit, scope: scope, limit_to_id: limit_to_id, nest_direction: :as_parent)
       end
 
       ##
@@ -65,6 +65,7 @@ module Hyrax
       #   id is in the response. Useful for validation.
       # @param nest_direction [Symbol] :as_child or :as_parent
       def self.query_solr(collection:, access:, scope:, limit_to_id:, nest_direction:)
+        scope.blacklight_config.http_method = :post
         query_builder = Hyrax::Dashboard::NestedCollectionsSearchBuilder.new(
           access: access,
           collection: collection,
@@ -73,7 +74,12 @@ module Hyrax
         )
 
         query_builder.where(id: limit_to_id.to_s) if limit_to_id
-        scope.blacklight_config.repository.search(query_builder.query)
+
+        Hyrax::SolrService.fetch_all do |rows, start|
+          scope.blacklight_config.repository.search(
+            query_builder.query.merge(rows: rows, start: start, fl: 'id,title_tesim,has_model_ssim')
+          )
+        end
       end
       private_class_method :query_solr
 

data/app/services/hyrax/collections_service.rb

@@ -25,5 +25,22 @@ module Hyrax
 
       response.documents
     end
+
+    # Like {#search_results}, but pages through every matching collection
+    # (up to Hyrax.config.solr_max_results). Use this only for surfaces that
+    # need the full set, e.g. the "Add to Collection" dropdown where a user
+    # must see every collection they can deposit into.
+    #
+    # @param [Symbol] access :read or :edit
+    # @return [Array<SolrDocument>]
+    def all_search_results(access = nil)
+      builder = search_builder.with(user_params)
+      builder.with_access(access) if access
+      yield builder if block_given?
+
+      Hyrax::SolrService.fetch_all do |rows, start|
+        blacklight_config.repository.search(builder.query.merge(rows: rows, start: start))
+      end
+    end
   end
 end