iiif_print 3.1.2 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 512bd4a70c6b11e94a4d82fb786264bb124c4ca38ca33549d34e3bcb6d0e37bc
-  data.tar.gz: 0b363334d97c0a97bc5b4ed8685c9be41f9ab7124e027af6a1334f2f53f6e86c
+  metadata.gz: 01fd18bb505838305103b589e56d196fbc346eb00390de671c53bb15083a39d6
+  data.tar.gz: c7bf87ae11b5ae00b597076254d897c9519fc2bf9facd777763861dcca511adf
 SHA512:
-  metadata.gz: 4e31e9b19c7ca850977bc1a04c912a98d49116d1b780e7ecdde7be43abbe447e44eceb20bc18be0d038887257b0432fc15ae79d20609ec9dfdea75e8946a82cc
-  data.tar.gz: b9639133a35990cabfe146fb13866e9a948e418a48a36962de3d10a70b52794f2466de9e789d851b778d91fa165659f4b90560759aee0b421313d9326ef2329d
+  metadata.gz: 3eee1a13ecdf5693e0dd987a9331d527fcf884d0c8dc10ea12b14f7b99165a3f13b712ac5cfddb6d1579fbd33ce6fc0945c1bc2c3195ff1aff7c56637e3aee46
+  data.tar.gz: 1a85675fa01612c0fc9115e2f1cf524fae745d6a2c4b8b897b283c4272bd1583ef3c40e5e9b605591cc36a641a4f8aedb8c5b022a90534bbb31f725aa670e8be

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: /app/samvera/hyrax-webapp
   specs:
-    iiif_print (3.1.2)
+    iiif_print (3.2.0)
       blacklight_iiif_search (>= 1.0, < 3.0)
       derivative-rodeo (~> 0.5)
       hyrax (>= 2.5, < 6)
       nokogiri (>= 1.13.2)
       rdf-vocab (~> 3.0)
+      request_store (>= 1.0)
 
 GEM
   remote: https://rubygems.org/

data/iiif_print.gemspec

@@ -25,6 +25,7 @@ SUMMARY
   spec.add_dependency 'hyrax', '>= 2.5', '< 6'
   spec.add_dependency 'nokogiri', '>=1.13.2'
   spec.add_dependency 'rdf-vocab', '~> 3.0'
+  spec.add_dependency 'request_store', '>= 1.0'
 
   spec.add_development_dependency 'bixby'
   spec.add_development_dependency 'database_cleaner', '~> 1.3'

data/lib/iiif_print/configuration.rb

@@ -289,9 +289,11 @@ module IiifPrint
     ##
     # This is the default sorter for the metadata.  It will sort by the order of the keys specificied.
     # By default, this is turned off as it returns nil. If you want to turn it on, you can set this
-    # this to an array of symbols the properties on the work.
+    # to an array of symbols for the properties on the work.  Properties not listed follow the listed
+    # ones, or take the place of `:remaining` when it is listed.
     #
     # @example [:title, :description, :date_created]
+    # @example [:title, :collection, :remaining, :rights_statement]
     # @return [Array<Symbol>]
     def iiif_metadata_field_presentation_order
       @iiif_metadata_field_presentation_order || nil

data/lib/iiif_print/engine.rb

@@ -2,6 +2,7 @@ require 'active_fedora'
 require 'hyrax'
 require 'blacklight_iiif_search'
 require 'derivative_rodeo'
+require 'request_store'
 
 module IiifPrint
   # module constants:

data/lib/iiif_print/flexibility/fields.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module IiifPrint
+  module Flexibility
+    ##
+    # The fields a flexible record's show page lists, from its M3 profile: those an anonymous visitor may see and
+    # its show presenter can render, labeled and ordered as the profile says, plus its collections.  Each carries
+    # its view options, which {IiifPrint::Flexibility::Values} renders it by.
+    class Fields
+      # The show page leads with the title and description, then the work's collections.
+      DEFAULT_ORDER = %i[title description abstract collection remaining].freeze
+
+      # @param document [SolrDocument]
+      # @param ability [Ability]
+      # @param sort_order [Array<Symbol>] see {IiifPrint::Configuration#iiif_metadata_field_presentation_order};
+      #   {DEFAULT_ORDER} when unset
+      def initialize(document, ability, sort_order: IiifPrint.config.iiif_metadata_field_presentation_order)
+        @document = document
+        @ability = ability
+        @sort_order = sort_order || DEFAULT_ORDER
+      end
+
+      # @return [Array<IiifPrint::Field>]
+      def to_a
+        presenter = Flexibility.presenter_for(@document, @ability)
+        definitions = Flexibility.view_definitions_for(@document)
+        fields = definitions.filter_map do |name, options|
+          options = options.to_h.symbolize_keys
+          term = (options[:render_term] || name).to_sym
+          next unless public?(name, options) && (term == :collection || presenter.respond_to?(term))
+
+          Field.new(name: term, label: label(term, options), options: options)
+        end
+        fields << collection_field unless collection_defined?(definitions)
+        IiifPrint.sort_af_fields!(fields, sort_order: @sort_order)
+      end
+
+      private
+
+      def collection_field
+        Field.new(name: :collection, label: Hyrax::Renderers::AttributeRenderer.new(:collection, nil).label)
+      end
+
+      def collection_defined?(definitions)
+        definitions.any? { |name, options| [name.to_s, options.to_h.symbolize_keys[:render_term].to_s].include?('collection') }
+      end
+
+      # The show page lists an admin note for editors only, whatever the profile says.
+      def public?(name, options)
+        return false if name.to_s == 'admin_note'
+
+        !(options[:admin_only] || options[:editor_only] || options[:show_page] == false)
+      end
+
+      def label(name, options)
+        labels = options[:display_label] || {}
+        label = (labels[I18n.locale.to_s] || labels['default'] || name).to_s
+        translated = I18n.t(label, default: label) if label.include?('.')
+        return translated if translated && translated != label
+
+        I18n.t(:"blacklight.search.fields.index.#{label}",
+               default: [:"blacklight.search.fields.show.#{label}", :"blacklight.search.fields.#{label}", label.humanize])
+      end
+    end
+  end
+end

data/lib/iiif_print/flexibility/values.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module IiifPrint
+  module Flexibility
+    ##
+    # A flexible field's values, read from the show presenter and rendered the way its profile's `render_as` renders
+    # them on the show page.
+    class Values
+      # What IIIF Presentation 3.0 allows in a metadata value (section 4.5).
+      IIIF_TAGS = %w[a b br i img p small span sub sup].freeze
+      IIIF_ATTRIBUTES = %w[href src alt].freeze
+      RIGHTS_SERVICES = %w[rights_statement license].freeze
+
+      # @param work [SolrDocument, SolrHit]
+      # @param presenter [#display_values_for] the record's show presenter
+      # @param base_url [String]
+      # @param autolink [#call] turns URLs in plain text into links
+      def initialize(work:, presenter:, base_url:, autolink:)
+        @work = work
+        @presenter = presenter
+        @base_url = base_url
+        @autolink = autolink
+      end
+
+      # @return [Array] the field's values as stored, blanks dropped
+      def raw(field_name)
+        Array(@presenter.try(field_name)).reject(&:blank?)
+      end
+
+      # @return [Array<String>] the field's values as html
+      def rendered(field_name, options)
+        options ||= {}
+        values = Array(@presenter.try(field_name)).reject(&:blank?)
+        return [values.map { |entry| "<p>#{compound_value(field_name, entry)}</p>" }.join] if options[:render_as].to_s == 'compound'
+
+        labels = labels_for(field_name, values)
+        values.map { |value| value(field_name, value.to_s, labels[value.to_s], options) }
+      end
+
+      private
+
+      # Keyed by value, as the show page's renderers get them in `options[:labels]`, and like them treating a blank
+      # label, or one equal to its value, as none.
+      def labels_for(field_name, values)
+        labels = @presenter.try(:controlled_labels_for, field_name, values) || display_labels(field_name, values)
+        labels.to_h.transform_keys(&:to_s).reject { |value, label| label.blank? || label.to_s == value }
+      end
+
+      # TODO: drop once Hyrax's PresentsAttributes#controlled_labels_for is public
+      def display_labels(field_name, values)
+        display = Array(@presenter.try(:display_values_for, field_name)).reject(&:blank?)
+        return {} unless display.size == values.size
+
+        values.map(&:to_s).zip(display.map(&:to_s)).to_h
+      end
+
+      def value(field_name, value, label, options)
+        return search_value(options[:search_field] || field_name, value, label, options[:render_as].to_s) if %w[faceted linked].include?(options[:render_as].to_s)
+
+        label = rights_label(field_name, options[:render_as].to_s, value, label)
+        case options[:render_as].to_s
+        when 'redirects_label' then link(File.join(@base_url, value), File.join(@base_url, value))
+        when 'html' then sanitize_html(value)
+        when 'date' then ERB::Util.h(formatted_date(value))
+        else labeled_value(value, label)
+        end
+      end
+
+      # Like Hyrax's faceted and linked renderers: a controlled term links by its label, through the label facet
+      # when the catalog registers one.
+      def search_value(field, value, label, render_as)
+        return search_link({ search_field: field, q: label || value }, label || value) if render_as == 'linked'
+
+        by_label = label.present? && label_facet?(field)
+        search_link({ "f[#{field}#{'_label' if by_label}_sim][]": by_label ? label : value }, label || value)
+      end
+
+      def label_facet?(field)
+        config = 'CatalogController'.safe_constantize.try(:blacklight_config)
+        config.respond_to?(:facet_fields) && config.facet_fields.key?("#{field}_label_sim")
+      end
+
+      def search_link(params, text)
+        params = params.merge(include_child_works: true) if @work["is_child_bsi"] == true
+        link(File.join(@base_url, Rails.application.routes.url_helpers.search_catalog_path(**params, locale: I18n.locale)), text)
+      end
+
+      def labeled_value(value, label)
+        return @autolink.call([ERB::Util.h(value)]).first if label.blank?
+        return ERB::Util.h(label) unless value.match?(%r{\Ahttps?://\S+\z})
+
+        link(value, label)
+      end
+
+      def formatted_date(value)
+        Date.parse(value).to_formatted_s(:standard)
+      rescue ArgumentError
+        value
+      end
+
+      # A rights statement or license rendered as such takes its label from its Hyrax service, as the show page's
+      # renderers do; one rendered otherwise falls back to the service only when no label was indexed.
+      def rights_label(field_name, render_as, value, label)
+        return service_label(render_as, value) || label if RIGHTS_SERVICES.include?(render_as)
+        return label || service_label(field_name.to_s, value) if RIGHTS_SERVICES.include?(field_name.to_s)
+
+        label
+      end
+
+      def service_label(service, value)
+        Hyrax.config.try("#{service}_service_class")&.new&.label(value) { nil }
+      end
+
+      def sanitize_html(value)
+        fragment = Nokogiri::HTML.fragment(value.to_s)
+        { 'a' => 'href', 'img' => 'src' }.each do |tag, attribute|
+          fragment.css("#{tag}[#{attribute}]").each { |node| node[attribute] = absolute_url(node[attribute]) }
+        end
+        Rails::Html::SafeListSanitizer.new.sanitize(fragment.to_html, tags: IIIF_TAGS, attributes: IIIF_ATTRIBUTES).strip
+      end
+
+      def absolute_url(url)
+        return url if url.blank? || url.match?(/\A[a-z][a-z0-9+.-]*:/i)
+
+        URI.join("#{@base_url.to_s.chomp('/')}/", url).to_s
+      rescue URI::Error
+        url
+      end
+
+      # One entry as Hyrax's compound renderer, and any decorator the app gives it, renders it on the show page, with
+      # a line break where each innermost block ended, since IIIF allows no blocks.
+      def compound_value(field_name, entry)
+        renderer = Hyrax::Renderers::CompoundAttributeRenderer.new(field_name, [entry], subproperties: compound_subproperties(field_name))
+        fragment = Nokogiri::HTML.fragment(renderer.render_value)
+        fragment.css('div').each { |div| div.add_next_sibling('<br>') unless div.at_css('div') }
+        sanitize_html(fragment.to_html).gsub(/\s*<br>\s*/, '<br>').sub(/(<br>)+\z/, '')
+      end
+
+      def compound_subproperties(field_name)
+        @presenter.send(:compound_subproperties_for, field_name) if @presenter.respond_to?(:compound_subproperties_for, true)
+      end
+
+      def link(href, text)
+        %(<a href="#{ERB::Util.h(href)}">#{ERB::Util.h(text)}</a>)
+      end
+    end
+  end
+end

data/lib/iiif_print/flexibility.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "iiif_print/flexibility/fields"
+require "iiif_print/flexibility/values"
+
+module IiifPrint
+  ##
+  # IIIF manifest metadata for records indexed under an M3 profile, built the way their show page is: which fields
+  # from {IiifPrint::Flexibility::Fields}, and how each value renders from {IiifPrint::Flexibility::Values}.
+  module Flexibility
+    class << self
+      ##
+      # @return [Boolean] whether the record's metadata comes from its M3 profile
+      def applies_to?(document)
+        Hyrax.config.try(:flexible?) && document.try(:flexible?)
+      end
+
+      def presenter_for(document, ability)
+        return Hyrax::FileSetPresenter.new(document, ability) if document.file_set?
+
+        controller = "Hyrax::#{document.hydra_model.model_name.collection.camelize}Controller".safe_constantize
+        (controller&.show_presenter || Hyrax::WorkShowPresenter).new(document, ability)
+      end
+
+      ##
+      # The profile's view definitions for the record, plus its title, description and abstract when the profile
+      # gives them no view block, since the show page shows those outside its field list.  Read once per request
+      # for each tenant, schema, version and context; each tenant numbers its own profile versions.
+      def view_definitions_for(document)
+        cache = RequestStore.store[:iiif_print_view_definitions] ||= {}
+        version = document.try(:schema_version)
+        contexts = document.try(:contexts)
+        tenant = Apartment::Tenant.current if defined?(Apartment::Tenant)
+        cache[[tenant, schema_name(document), version, contexts]] ||= begin
+          definitions = Hyrax::Schema.m3_schema_loader.view_definitions_for(schema: schema_name(document), version: version, contexts: contexts)
+          lead_definitions(document, definitions).merge(definitions.to_h.symbolize_keys)
+        end
+      end
+
+      private
+
+      LEAD_FIELDS = %i[title description abstract].freeze
+
+      def lead_definitions(document, definitions)
+        attributes = profile_attributes(document)
+        (LEAD_FIELDS - definitions.to_h.keys.map(&:to_sym)).each_with_object({}) do |name, lead|
+          config = attributes[name.to_s]
+          lead[name] = Hyrax::SchemaLoader::AttributeDefinition.new(name.to_s, config).view_options if config
+        end
+      end
+
+      def profile_attributes(document)
+        schema = Hyrax::FlexibleSchema.find_by(id: document.try(:schema_version)) || Hyrax::FlexibleSchema.order(:created_at).last
+        schema.try(:attributes_for, schema_name(document)) || {}
+      end
+
+      def schema_name(document)
+        Valkyrie.config.resource_class_resolver.call(document.hydra_model_name).to_s
+      rescue NameError
+        document.hydra_model.to_s
+      end
+    end
+  end
+end

data/lib/iiif_print/metadata.rb

@@ -38,13 +38,13 @@ module IiifPrint
       if version == 2
         case property
         when :label      then field.label
-        when :value      then cast_to_value(field_name: field.name, options: field.options)
+        when :value      then rendered_values_for(field)
         when :collection then make_collection_link(viewable_collections)
         end
       elsif version == 3
         case property
         when :label      then { I18n.locale.to_s => [field.label] }
-        when :value      then { 'none' => cast_to_value(field_name: field.name, options: field.options) }
+        when :value      then { 'none' => rendered_values_for(field) }
         when :collection then { 'none' => make_collection_link(viewable_collections) }
         end
       end
@@ -64,6 +64,12 @@ module IiifPrint
       Loofah.fragment(value).scrub!(:whitewash).to_s
     end
 
+    def rendered_values_for(field)
+      return flexible_values.rendered(field.name, field.options) if flexible?
+
+      cast_to_value(field_name: field.name, options: field.options)
+    end
+
     def cast_to_value(field_name:, options:)
       if options&.[](:render_as) == :faceted
         faceted_values_for(field_name: field_name)
@@ -98,14 +104,25 @@ module IiifPrint
     end
 
     def values_for(field_name:)
+      return flexible_values.raw(field_name.try(:name) || field_name) if flexible?
+
       field_name = field_name.try(:name) || field_name
       # TODO: we are assuming tesim or dtsi (for dates), might want to account for other suffixes in the future
       Array(work["#{field_name}_tesim"] || work["#{field_name}_dtsi"]&.to_date.try(:to_formatted_s, :standard))
     end
 
+    def flexible?
+      Flexibility.applies_to?(work)
+    end
+
+    def flexible_values
+      @flexible_values ||= Flexibility::Values.new(work: work, presenter: Flexibility.presenter_for(work, current_ability),
+                                                  base_url: @base_url, autolink: method(:make_link))
+    end
+
     def make_collection_link(collection_documents)
       collection_documents.map do |collection|
-        "<a href='#{File.join(@base_url, 'collections', collection.id)}'>#{collection.title.first}</a>"
+        "<a href='#{File.join(@base_url, 'collections', collection.id)}'>#{ERB::Util.h(collection.title.first)}</a>"
       end
     end
 

data/lib/iiif_print/version.rb

@@ -1,3 +1,3 @@
 module IiifPrint
-  VERSION = '3.1.2'.freeze
+  VERSION = '3.2.0'.freeze
 end

data/lib/iiif_print.rb

@@ -13,6 +13,7 @@ require "iiif_print/text_formats_from_alto_service"
 require "iiif_print/tiff_derivative_service"
 require "iiif_print/lineage_service"
 require "iiif_print/metadata"
+require "iiif_print/flexibility"
 require "iiif_print/split_pdfs/base_splitter"
 require "iiif_print/split_pdfs/child_work_creation_from_pdf_service"
 require "iiif_print/split_pdfs/derivative_rodeo_splitter"
@@ -203,8 +204,27 @@ module IiifPrint
   def self.manifest_metadata_from(work:, presenter:)
     current_ability = presenter.try(:ability) || presenter.try(:current_ability)
     base_url = presenter.try(:base_url) || presenter.try(:request)&.base_url
+    document = work.is_a?(::SolrDocument) ? work : ::SolrDocument.new(work)
+    return flexible_manifest_metadata_for(document, base_url: base_url) if Flexibility.applies_to?(document)
+
     IiifPrint.manifest_metadata_for(work: work, current_ability: current_ability, base_url: base_url)
   end
+
+  # @api private
+  #
+  # A flexible work's metadata lists the fields an anonymous visitor would see on its show page, whoever asked
+  # and whether or not the work itself is public.
+  def self.flexible_manifest_metadata_for(document, base_url:)
+    ability = anonymous_ability
+    manifest_metadata_for(work: document, fields: Flexibility::Fields.new(document, ability).to_a, current_ability: ability, base_url: base_url)
+  end
+
+  # One per request: an Ability is costly to build, and a manifest can ask once for every page.
+  def self.anonymous_ability
+    RequestStore.store[:iiif_print_anonymous_ability] ||= ::Ability.new(nil)
+  end
+  private_class_method :flexible_manifest_metadata_for, :anonymous_ability
+
   # Hash is an arbitrary attribute key/value pairs
   # Struct is a defined set of attribute "keys".  When we favor defined values,
   # then we are naming the concept and defining the range of potential values.
@@ -273,10 +293,10 @@ module IiifPrint
   def self.sort_af_fields!(fields, sort_order:)
     return fields if sort_order.blank?
 
-    fields.sort_by do |field|
-      sort_order_index = sort_order.index(field.name.to_sym)
-      sort_order_index.nil? ? sort_order.length : sort_order_index
-    end
+    remaining = sort_order.index(:remaining) || sort_order.length
+    fields.each_with_index.sort_by do |field, index|
+      [sort_order.index(field.name.to_sym) || remaining, index]
+    end.map(&:first)
   end
 
   ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iiif_print
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.2.0
 platform: ruby
 authors:
 - Sean Upton
@@ -97,6 +97,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bixby
   requirement: !ruby/object:Gem::Requirement
@@ -456,6 +470,9 @@ files:
 - lib/iiif_print/data/work_files.rb
 - lib/iiif_print/engine.rb
 - lib/iiif_print/errors.rb
+- lib/iiif_print/flexibility.rb
+- lib/iiif_print/flexibility/fields.rb
+- lib/iiif_print/flexibility/values.rb
 - lib/iiif_print/homepage_search_builder.rb
 - lib/iiif_print/image_tool.rb
 - lib/iiif_print/jp2_derivative_service.rb