iiif_print 1.0.0 → 1.1.0

data/lib/iiif_print.rb

@@ -17,10 +17,13 @@ require "iiif_print/works_controller_behavior"
 require "iiif_print/jobs/application_job"
 require "iiif_print/blacklight_iiif_search/annotation_decorator"
 require "iiif_print/jobs/child_works_from_pdf_job"
-require "iiif_print/jobs/create_relationships_job"
-require "iiif_print/split_pdfs/pages_into_images_service"
+require "iiif_print/jobs/request_split_pdf_job"
+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"
+require "iiif_print/split_pdfs/destroy_pdf_child_works_service"
 
+# rubocop:disable Metrics/ModuleLength
 module IiifPrint
   extend ActiveSupport::Autoload
   autoload :Configuration
@@ -28,9 +31,10 @@ module IiifPrint
 
   ##
   # @api public
+  #
   # Exposes the IiifPrint configuration.
   #
-  # @yield [IiifPrint::Configuration] if a block is passed
+  # @yieldparam [IiifPrint::Configuration] config if a block is passed
   # @return [IiifPrint::Configuration]
   # @see IiifPrint::Configuration for configuration options
   def self.config(&block)
@@ -39,28 +43,65 @@ module IiifPrint
     @config
   end
 
+  class << self
+    delegate :skip_splitting_pdf_files_that_end_with_these_texts, to: :config
+  end
+
+  ##
+  # Return the immediate parent of the given :file_set.
+  #
+  # @param file_set [FileSet]
+  # @return [#work?, Hydra::PCDM::Work]
+  # @return [NilClass] when no parent is found.
+  def self.parent_for(file_set)
+    # fallback to Fedora-stored relationships if work's aggregation of
+    #   file set is not indexed in Solr
+    file_set.parent || file_set.member_of.find(&:work?)
+  end
+
+  ##
+  # Return the parent's parent of the given :file_set.
+  #
+  # @param file_set [FileSet]
+  # @return [#work?, Hydra::PCDM::Work]
+  # @return [NilClass] when no grand parent is found.
+  def self.grandparent_for(file_set)
+    parent_of_file_set = parent_for(file_set)
+    # HACK: This is an assumption about the file_set structure, namely that an image page split from
+    # a PDF is part of a file set that is a child of a work that is a child of a single work.  That
+    # is, it only has one grand parent.  Which is a reasonable assumption for IIIF Print but is not
+    # valid when extended beyond IIIF Print.  That is GenericWork does not have a parent method but
+    # does have a parents method.
+    parent_of_file_set.try(:parent_works).try(:first) ||
+      parent_of_file_set.try(:parents).try(:first) ||
+      parent_of_file_set&.member_of&.find(&:work?)
+  end
+
   DEFAULT_MODEL_CONFIGURATION = {
     # Split a PDF into individual page images and create a new child work for each image.
     pdf_splitter_job: IiifPrint::Jobs::ChildWorksFromPdfJob,
-    pdf_splitter_service: IiifPrint::SplitPdfs::PagesIntoImagesService,
+    pdf_splitter_service: IiifPrint::SplitPdfs::PagesToJpgsSplitter,
     derivative_service_plugins: [
-      IiifPrint::JP2DerivativeService,
-      IiifPrint::PDFDerivativeService,
-      IiifPrint::TextExtractionDerivativeService,
-      IiifPrint::TIFFDerivativeService
+      IiifPrint::TextExtractionDerivativeService
     ]
   }.freeze
 
   # This is the record level configuration for PDF split handling.
   ModelConfig = Struct.new(:pdf_split_child_model, *DEFAULT_MODEL_CONFIGURATION.keys, keyword_init: true)
+  private_constant :ModelConfig
 
-  # This method is responsible for assisting in the configuration of a "model".
+  ##
+  # @api public
+  # This method is responsible for configuring a model for additional derivative generation.
   #
   # @example
   #   class Book < ActiveFedora::Base
   #     include IiifPrint.model_configuration(
   #       pdf_split_child_model: Page,
   #       derivative_service_plugins: [
+  #         IiifPrint::JP2DerivativeService,
+  #         IiifPrint::PDFDerivativeService,
+  #         IiifPrint::TextExtractionDerivativeService,
   #         IiifPrint::TIFFDerivativeService
   #       ]
   #     )
@@ -68,6 +109,18 @@ module IiifPrint
   #
   # @param kwargs [Hash<Symbol,Object>] the configuration values that overrides the
   #        DEFAULT_MODEL_CONFIGURATION.
+  # @option kwargs [Array<Class>] derivative_service_plugins the various derivatives to run on the
+  #        "original" files associated with this work.  Options include:
+  #        {IiifPrint::JP2DerivativeService}, {IiifPrint::PDFDerivativeService},
+  #        {IiifPrint::TextExtractionDerivativeService}, {IiifPrint::TIFFDerivativeService}
+  # @option kwargs [Class] pdf_splitter_job responsible for handling the splitting of the original file
+  # @option kwargs [Class] pdf_split_child_model when we split the file into pages, what's the child model
+  #         we want for those pages?  Often times this is likely the same model as the parent.
+  # @option kwargs [Class] pdf_splitter_service the specific service that splits the PDF.  Options are:
+  #         {IiifPrint::SplitPdfs::PagesToJpgsSplitter},
+  #         {IiifPrint::SplitPdfs::PagesToTiffsSplitter},
+  #         {IiifPrint::SplitPdfs::PagesToPngsSplitter},
+  #         {IiifPrint::SplitPdfs::DerivativeRodeoSplitter}
   #
   # @return [Module]
   #
@@ -107,7 +160,7 @@ module IiifPrint
   # @see Hyrax::IiifManifestPresenter#manifest_metadata
   def self.manifest_metadata_for(work:,
                                  version: config.default_iiif_manifest_version,
-                                 fields: default_fields_for(work),
+                                 fields: defined?(AllinsonFlex) ? fields_for_allinson_flex : default_fields,
                                  current_ability:,
                                  base_url:)
     Metadata.build_metadata_for(work: work,
@@ -117,6 +170,11 @@ module IiifPrint
                                 base_url: base_url)
   end
 
+  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
+    IiifPrint.manifest_metadata_for(work: work, current_ability: current_ability, base_url: base_url)
+  end
   # 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.
@@ -124,13 +182,110 @@ module IiifPrint
 
   # @api private
   # @todo Figure out a way to use a custom label, right now it takes it get rendered from the title.
-  def self.default_fields_for(_work, fields: config.metadata_fields)
+  def self.default_fields(fields: config.metadata_fields)
     fields.map do |field|
       Field.new(
         name: field.first,
-        label: Hyrax::Renderers::AttributeRenderer.new(field, nil).label,
+        label: Hyrax::Renderers::AttributeRenderer.new(field.first, nil).label,
         options: field.last
       )
     end
   end
+
+  ##
+  # @param fields [Array<IiifPrint::Field>]
+  def self.fields_for_allinson_flex(fields: allinson_flex_fields, sort_order: IiifPrint.config.iiif_metadata_field_presentation_order)
+    fields = sort_af_fields!(fields, sort_order: sort_order)
+    fields.each_with_object({}) do |field, hash|
+      # filters out admin_only fields
+      next if field.indexing&.include?('admin_only')
+
+      # WARNING: This is assuming A LOT
+      # This is taking the Allinson Flex fields that have the same name and only
+      # using the first one while discarding the rest.  There currently no way to
+      # controller which one(s) are discarded but this fits for the moment.
+      next if hash.key?(field.name)
+
+      # currently only supports the faceted option
+      # Why the `render_as:`? This was originally derived from Hyku default attributes
+      # @see https://github.com/samvera/hyku/blob/c702844de4c003eaa88eb5a7514c7a1eae1b289e/app/views/hyrax/base/_attribute_rows.html.erb#L3
+      hash[field.name] = Field.new(
+        name: field.name,
+        label: field.value,
+        options: field.indexing&.include?('facetable') ? { render_as: :faceted } : nil
+      )
+    end.values
+  end
+
+  CollectionFieldShim = Struct.new(:name, :value, :indexing, keyword_init: true)
+
+  ##
+  # @return [Array<IiifPrint::Field>]
+  def self.allinson_flex_fields
+    return @allinson_flex_fields if defined?(@allinson_flex_fields)
+
+    allinson_flex_relation = AllinsonFlex::ProfileProperty
+                             .joins(:texts)
+                             .where(allinson_flex_profile_texts: { name: 'display_label' })
+                             .distinct
+                             .select(:name, :value, :indexing)
+    flex_fields = allinson_flex_relation.to_a
+    unless allinson_flex_relation.exists?(name: 'collection')
+      collection_field = CollectionFieldShim.new(name: :collection, value: 'Collection', indexing: [])
+      flex_fields << collection_field
+    end
+    @allinson_flex_fields = flex_fields
+  end
+
+  ##
+  # @param fields [Array<IiifPrint::Field>]
+  # @param sort_order [Array<Symbol>]
+  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
+  end
+
+  ##
+  # @api public
+  #
+  # @param work [ActiveFedora::Base]
+  # @param file_set [FileSet]
+  # @param locations [Array<String>]
+  # @param user [User]
+  #
+  # @return [Symbol] when none of the locations are to be split.
+  def self.conditionally_submit_split_for(work:, file_set:, locations:, user:, skip_these_endings: skip_splitting_pdf_files_that_end_with_these_texts)
+    locations = locations.select { |location| split_for_path_suffix?(location, skip_these_endings: skip_these_endings) }
+    return :no_pdfs_for_splitting if locations.empty?
+
+    work.try(:iiif_print_config)&.pdf_splitter_job&.perform_later(
+      file_set,
+      locations,
+      user,
+      work.admin_set_id,
+      0 # A no longer used parameter; but we need to preserve the method signature (for now)
+    )
+  end
+
+  ##
+  # @api public
+  #
+  # @param path [String] the path, hopefully with an extension, to the file we're considering
+  #        splitting.
+  # @param skip_these_endings [Array<#downcase>] the endings that we should skip for splitting
+  #        purposes.
+  # @return [TrueClass] when the path is one we should split
+  # @return [FalseClass] when the path is one we should not split
+  #
+  # @see .skip_splitting_pdf_files_that_end_with_these_texts
+  def self.split_for_path_suffix?(path, skip_these_endings: skip_splitting_pdf_files_that_end_with_these_texts)
+    return false unless path.downcase.end_with?('.pdf')
+    return true if skip_these_endings.empty?
+    !path.downcase.end_with?(*skip_these_endings.map(&:downcase))
+  end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/samvera/derivatives/configuration.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Samvera
+  module Derivatives
+    ##
+    # The purpose of this class is to contain the explicit derivative generation directives for the
+    # upstream application.
+    #
+    # @note The implicit deriviate types for Hyrax are as follows:
+    #       - type :extracted_text with sources [:pdf, :office_document]
+    #       - type :thumbnail with sources [:pdf, :office_document, :thumbnail, :image]
+    #       - type :mp3 with sources [:audio]
+    #       - type :ogg with sources [:audio]
+    #       - type :webm with sources [:video]
+    #       - type :mp4 with sources [:video]
+    #
+    # @note A long-standing practice of Samvera's Hyrax has been to have assumptive and implicit
+    #       derivative generation (see Hyrax::FileSetDerivativesService).  In being implicit, a
+    #       challenge arises, namely overriding and configuring.  There exists a crease in the code
+    #       to allow for a different derivative approach (see Hyrax::DerivativeService).  Yet that
+    #       approach continues the tradition of implicit work.
+    class Configuration
+      def initialize
+        # Favoring a Hash for ease of lookup as well as the concept that there can be only one entry
+        # per type.
+        @registered_types = {}
+      end
+
+      # TODO: Consider the appropriate extension
+      RegisteredType = Struct.new(:type, :locators, :applicators, :applicability, keyword_init: true) do
+        def applicable_for?(file_set:)
+          applicability.call(file_set)
+        end
+      end
+
+      ##
+      # @api pulic
+      #
+      # @param type [Symbol] The named type of derivative
+      # @param locators [Array<Samvera::Derivatives::FileLocator::Strategy>] The strategies that
+      #        we'll attempt in finding the derivative that we will later apply.
+      # @param applicators [Array<Samvera::Derivatives::FileApplicator::Strategy>] The strategies
+      #        that we'll use to apply the found derivative to the {FileSet}
+      #
+      # @yieldparam applicability [#call]
+      #
+      # @return [RegisteredType]
+      #
+      # @note What is the best mechanism for naming the sources?  At present we're doing a lot of
+      #       assumption on the types.
+      def register(type:, locators:, applicators:, &applicability)
+        # Should the validator be required?
+        @registered_types[type.to_sym] = RegisteredType.new(
+          type: type.to_sym,
+          locators: Array(locators),
+          applicators: Array(applicators),
+          applicability: applicability || default_applicability
+        )
+      end
+
+      ##
+      # @api public
+      #
+      # @param type [Symbol]
+      #
+      # @return [RegisteredType]
+      def registry_for(type:)
+        @registered_types.fetch(type.to_sym) { empty_registry_for(type: type.to_sym) }
+      end
+
+      private
+
+      def empty_registry_for(type:)
+        RegisteredType.new(type: type, locators: [], applicators: [], applicability: ->(_file_set) { false })
+      end
+
+      # We're going to assume this is true unless configured otherwise.
+      def default_applicability
+        ->(_file_set) { true }
+      end
+    end
+  end
+end

data/lib/samvera/derivatives/hyrax.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Samvera
+  module Derivatives
+    # The default behavior of {Hyrax::FileSetDerivativesService} is to create a derivative and then
+    # apply it to the FileSet.  This module wraps that behavior such that we can leverage the
+    # {Samvera::Derivatives} module and interfaces to handle cases where some of the derivatives
+    # already exist.
+    module Hyrax
+      # @note This conforms to the {Hyrax::DerivativeService} interface.  The intention of this
+      #       class is to be the sole registered {Hyrax::DerivativeService.services}
+      class ServiceShim
+        # @param file_set [FileSet]
+        # @param candidate_derivative_types [Array<Symbol>] the possible types of derivatives that
+        #        we could create for this file_set.
+        # @param config [#registry_for]
+        #
+        # @todo We will want some kind of lambda to determine the candidate_derivative_types for this
+        #       file_set.
+        def initialize(file_set, candidate_derivative_types: [], config: Samvera::Derivatives.config)
+          @file_set = file_set
+          @config = config
+          @derivatives = candidate_derivative_types.map { |type| config.registry_for(type: type) }
+        end
+
+        attr_reader :file_set
+
+        # @return [Array<Samvera::Derivatives::Configuration::RegisteredType>]
+        attr_reader :derivatives
+        attr_reader :config
+
+        def valid?
+          # We have a file set, which also means a parent work.  I believe we always want this to be
+          # valid, because we want to leverage the locator/applicator behavior instead of the
+          # implicit work.
+          true
+        end
+
+        def cleanup_derivatives; end
+
+        # We have two vectors of consideration for derivative generation:
+        #
+        # - The desired derivatives for a file_set's parent work (e.g. the candidate derivatives)
+        # - The available derivatives for a file_set's mime type
+        def create_derivatives(file_path)
+          derivatives.each do |derivative|
+            Samvera::Derivatives.locate_and_apply_derivative_for(
+              file_set: file_set,
+              file_path: file_path,
+              derivative: derivative
+            )
+          end
+        end
+
+        def derivative_url(_destination_name)
+          ""
+        end
+      end
+
+      class FileApplicatorStrategy < Samvera::Derivatives::FileApplicator::Strategy
+        # With this set to true, we're telling the applicator to use the from_location
+        # (e.g. {Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper}) to apply the
+        # derivatives.
+        self.delegate_apply_to_given_from_location = true
+      end
+
+      class FileLocatorStrategy < Samvera::Derivatives::FileLocator::Strategy
+        # Implements {Samvera::Derivatives::FileLocator::Strategy} interface.
+        #
+        # @see Samvera::Derivatives::FileLocator::Strategy
+        #
+        # @return [Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper]
+        def self.locate(file_set:, file_path:, **)
+          file_set.samvera_derivatives_default_from_location_wrapper(file_path: file_path)
+        end
+      end
+
+      class FileSetDerivativesServiceWrapper
+        class_attribute :wrapped_derivative_service_class, default: ::Hyrax::FileSetDerivativesService
+
+        # @param file_set [FileSet]
+        # @param file_path [String]
+        def initialize(file_set:, file_path:)
+          @file_set = file_set
+          @file_path = file_path
+          @wrapped_derivative_service = wrapped_derivative_service_class.new(file_set)
+        end
+        attr_reader :file_set, :wrapped_derivative_service, :file_path
+
+        # @see Samvera::Derivatives::FileLocator.call
+        def present?
+          true
+        end
+
+        # @see Samvera::Derivatives::FileApplicator::Strategy
+        def apply!(*)
+          # Why the short-circuit? By the nature of the underlying
+          # ::Hyrax::FileSetDerivativesService, we generate multiple derivatives in one pass.  But
+          # with the implementation of Samvera::Derivatives, we declare the derivatives and then
+          # iterate on locating and applying them.  With this short-circuit, we will only apply the
+          # derivatives once.
+          return true if defined?(@already_applied)
+
+          return false unless wrapped_derivative_service.valid?
+
+          wrapped_derivative_service.create_derivatives(file_path)
+          @already_applied = true
+        end
+      end
+
+      ##
+      # The purpose of this module is to preserve the existing Hyrax derivative behavior while also
+      # allowing for the two-step tango of locator and applicator.
+      #
+      # @see Samvera::Derivatives.locate_and_apply_derivative_for
+      module FileSetDecorator
+        # @return [Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper]
+        def samvera_derivatives_default_from_location_wrapper(file_path:)
+          @samvera_derivatives_default_from_location_wrapper ||=
+            Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper.new(file_set: self, file_path: file_path)
+        end
+      end
+    end
+  end
+end
+
+# TODO: We are likely going to want that.
+# Hyrax::DerivativeService.services = [Samvera::Derivatives::Hyrax::ServiceShim]
+FileSet.prepend(Samvera::Derivatives::Hyrax::FileSetDecorator)