iiif_print 1.0.0 → 2.0.0

data/lib/iiif_print/split_pdfs/pdf_image_extraction_service.rb

@@ -8,78 +8,83 @@ module IiifPrint
     # For dpi extraction, falls back to calculating using MiniMagick,
     #   if neccessary.
     class PdfImageExtractionService
-      # class constant column numbers
-      COL_WIDTH = 3
-      COL_HEIGHT = 4
-      COL_COLOR = 5
-      COL_CHANNELS = 6
-      COL_BITS = 7
-      # only poppler 0.25+ has this column in output:
-      COL_XPPI = 12
-
       def initialize(path)
         @path = path
-        @cmd = format('pdfimages -list %<path>s', path: path)
-        @output = nil
-        @entries = nil
+        process(command: format('pdfimages -list %<path>s 2>/dev/null', path: path))
       end
 
-      def process
-        # call just once
-        if @output.nil?
-          Open3.popen3(@cmd) do |_stdin, stdout, _stderr, _wait_thr|
-            @output = stdout.read.split("\n")
-          end
-        end
-        @output.slice(2, @output.size - 1)
-      end
+      attr_reader :path, :page_count, :width, :height, :pixels_per_inch
+      alias ppi pixels_per_inch
 
-      def entries
-        if @entries.nil?
-          @entries = []
-          output = process
-          (0..output.size - 1).each do |i|
-            @entries.push(output[i].gsub(/\s+/m, ' ').strip.split(" "))
-          end
-        end
-        @entries
+      # @return [Array<String, Integer, Integer>]
+      def color
+        [@color_description, @channels, @bits]
       end
 
-      def selectcolumn(i, &block)
-        result = entries.map { |e| e[i] }
-        return result.map!(&block) if block_given?
-        result
-      end
+      private
 
-      def width
-        selectcolumn(COL_WIDTH, &:to_i).max
-      end
+      # class constant column numbers
+      COL_WIDTH = 3
+      COL_HEIGHT = 4
+      COL_COLOR_DESC = 5
+      COL_CHANNELS = 6
+      COL_BITS = 7
+      # only poppler 0.25+ has this column in output:
+      COL_XPPI = 12
 
-      def height
-        selectcolumn(COL_HEIGHT, &:to_i).max
-      end
+      # rubocop:disable Metrics/AbcSize - Because this helps us process the results in one loop.
+      # rubocop:disable Metrics/MethodLength - Again, to help speed up the processing loop.
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      #
+      # The first two lines are tabular header information:
+      #
+      # Example:
+      #
+      #   bash-5.1$ pdfimages -list fmc_color.pdf  | head -5
+      #   page   num  type   width height color comp bpc  enc interp  object ID x-ppi y-ppi size ratio
+      #   --------------------------------------------------------------------------------------------
+      #   1     0 image    2475   413  rgb     3   8  jpeg   no        10  0   300   300 21.8K 0.7%
+      def process(command:)
+        @page_count = 0
+        @color_description = 'gray'
+        @width = 0
+        @height = 0
+        @channels = 0
+        @bits = 0
+        @pixels_per_inch = 0
+        Open3.popen3(command) do |_stdin, stdout, _stderr, _wait_thr|
+          stdout.read.split("\n").each_with_index do |line, index|
+            # Skip the two header lines
+            next if index <= 1
+            @page_count += 1
+            cells = line.gsub(/\s+/m, ' ').strip.split(" ")
 
-      def color
-        # desc is either 'gray', 'cmyk', 'rgb', but 1-bit gray is black/white
-        #   so caller may want all of this information, and in case of
-        #   mixed color spaces across images, this returns maximum
-        desc = entries.any? { |e| e[COL_COLOR] != 'gray' } ? 'rgb' : 'gray'
-        channels = entries.map { |e| e[COL_CHANNELS].to_i }.max
-        bits = entries.map { |e| e[COL_BITS].to_i }.max
-        [desc, channels, bits]
-      end
+            @color_description = 'rgb' if cells[COL_COLOR_DESC] != 'gray'
+            @width = cells[COL_WIDTH].to_i if cells[COL_WIDTH].to_i > @width
+            @height = cells[COL_HEIGHT].to_i if cells[COL_HEIGHT].to_i > @height
+            @channels = cells[COL_CHANNELS].to_i if cells[COL_CHANNELS].to_i > @channels
+            @bits = cells[COL_BITS].to_i if cells[COL_BITS].to_i > @bits
 
-      def ppi
-        if entries[0].size <= 12
-          # poppler < 0.25
-          pdf = MiniMagick::Image.open(@path)
-          width_points = pdf.width
-          width_px = width
-          return (72 * width_px / width_points).to_i
+            # In the case of poppler version < 0.25, we will have no more than 12 columns.  As such,
+            # we need to do some alternative magic to calculate this.
+            if @page_count == 1 && cells.size <= 12
+              pdf = MiniMagick::Image.open(@path)
+              width_points = pdf.width
+              width_px = width
+              @pixels_per_inch = (72 * width_px / width_points).to_i
+            elsif cells[COL_XPPI].to_i > @pixels_per_inch
+              # By the magic of nil#to_i if we don't have more than 12 columns, we've already set
+              # the @pixels_per_inch and this line won't due much of anything.
+              @pixels_per_inch = cells[COL_XPPI].to_i
+            end
+          end
         end
-        # with poppler 0.25+, pdfimages just gives us this:
-        selectcolumn(COL_XPPI, &:to_i).max
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/iiif_print/text_extraction/hocr_reader.rb

@@ -84,6 +84,7 @@ module IiifPrint
           # add trailing space to plaintext buffer for between words:
           @text += ' '
           @words.push(@current) if word_complete?
+          @current = nil # clear the current word
         end
 
         def end_line
@@ -120,9 +121,12 @@ module IiifPrint
         #   for current word, and append line endings to plain text:
         #
         # @param name [String] element name.
-        def end_element(_name)
-          end_line if @element_class_name == 'ocr_line'
-          end_word if @element_class_name == 'ocrx_word'
+        def end_element(name)
+          if name == 'span'
+            end_word if @element_class_name == 'ocrx_word'
+            @text += "\n" if @element_class_name.nil?
+          end
+          @element_class_name = nil
         end
 
         # Callback for completion of parsing hOCR, used to normalize generated

data/lib/iiif_print/text_extraction/page_ocr.rb

@@ -9,7 +9,7 @@ module IiifPrint
     class PageOCR
       attr_accessor :html, :path
 
-      def initialize(path, additional_tessearct_options: IiifPrint.config.additional_tessearct_options)
+      def initialize(path, additional_tesseract_options: IiifPrint.config.additional_tesseract_options)
         @path = path
         # hOCR html:
         @html = nil
@@ -17,13 +17,14 @@ module IiifPrint
         @source_meta = nil
         @box = nil
         @plain = nil
-        @additional_tessearct_options = additional_tessearct_options
+        @additional_tesseract_options = additional_tesseract_options
       end
 
       def run_ocr
         outfile = File.join(Dir.mktmpdir, 'output_html')
-        cmd = "tesseract #{path} #{outfile} hocr"
-        cmd += " #{@additional_tessearct_options}" if @additional_tessearct_options.present?
+        cmd = "OMP_THREAD_LIMIT=1 tesseract #{path} #{outfile}"
+        cmd += " #{@additional_tesseract_options}" if @additional_tesseract_options.present?
+        cmd += " hocr"
         `#{cmd}`
         outfile + '.hocr'
       end

data/lib/iiif_print/text_extraction_derivative_service.rb

@@ -28,13 +28,15 @@ module IiifPrint
 
       ocr_derivatives.each do |extension, method_name|
         path = prepare_path(extension.to_s)
-        write(content: ocr.public_send(method_name), path: path)
+        write(content: ocr.public_send(method_name), path: path, extension: extension)
       end
     end
 
-    def write(content:, path:)
+    def write(content:, path:, extension:)
+      mime_type = mime_type_for(extension)
       File.open(path, 'w') do |outfile|
         outfile.write(content)
+        IiifPrint.copy_derivatives_from_data_store(stream: content, directives: { url: path, container: 'extracted_text', mime_type: mime_type })
       end
     end
 

data/lib/iiif_print/text_formats_from_alto_service.rb

@@ -4,9 +4,10 @@ module IiifPrint
   #   NOTE: to keep this from conflicting with TextExtractionDerivativeService,
   #         this class should be invoked by it, not PluggableDerivativeService.
   class TextFormatsFromALTOService < BaseDerivativeService
-    self.target_extension = 'tiff'.freeze
+    self.target_extension = 'txt'.freeze
 
     def save_derivative(destination, data)
+      mime_type = mime_type_for(destination)
       # Load/prepare base of "pairtree" dir structure for extension, fileset
       prepare_path(destination)
       #
@@ -17,6 +18,7 @@ module IiifPrint
       # Write data as UTF-8 encoded text
       File.open(save_path, "w:UTF-8") do |f|
         f.write(data)
+        IiifPrint.copy_derivatives_from_data_store(stream: data, directives: { url: file_set.id.to_s, container: 'extracted_text', mime_type: mime_type })
       end
     end
 

data/lib/iiif_print/tiff_derivative_service.rb

@@ -32,7 +32,9 @@ module IiifPrint
       source_path += '[0]' if @source_path.ends_with?('pdf')
       template = use_color? ? COLOR_CMD : GRAY_CMD
       template = MONO_CMD if one_bit?
-      format(template, source_file: source_path, out_file: @dest_path)
+      data = format(template, source_file: source_path, out_file: @dest_path)
+      IiifPrint.copy_derivatives_from_data_store(stream: data, directives: { url: file_set.id.to_s, container: 'service_file', mime_type: mime_type_for(target_extension) })
+      data
     end
 
     def create_derivatives(filename)

data/lib/iiif_print/version.rb

@@ -1,3 +1,3 @@
 module IiifPrint
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/iiif_print.rb

@@ -14,13 +14,16 @@ require "iiif_print/tiff_derivative_service"
 require "iiif_print/lineage_service"
 require "iiif_print/metadata"
 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/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"
+require "iiif_print/persistence_layer"
+require "iiif_print/persistence_layer/active_fedora_adapter"
+require "iiif_print/persistence_layer/valkyrie_adapter"
 
+# 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,64 @@ module IiifPrint
     @config
   end
 
+  class << self
+    delegate(
+      :persistence_adapter,
+      :skip_splitting_pdf_files_that_end_with_these_texts,
+      to: :config
+    )
+
+    delegate(
+      :clean_for_tests!,
+      :copy_derivatives_from_data_store,
+      :create_relationship_between,
+      :destroy_children_split_from,
+      :extract_text_for,
+      :find_by,
+      :find_by_title_for,
+      :grandparent_for,
+      :index_works,
+      :object_in_works,
+      :object_ordered_works,
+      :parent_for,
+      :pdf?,
+      :save,
+      :solr_construct_query,
+      :solr_name,
+      :solr_query,
+      to: :persistence_adapter
+    )
+  end
+
+  # NOTE: We use lambdas so we can have default values but also provide a lazy configuration.
+  # There are certainly better ways but this is the least intrusive refactor from prior state.
   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,
-    derivative_service_plugins: [
-      IiifPrint::JP2DerivativeService,
-      IiifPrint::PDFDerivativeService,
-      IiifPrint::TextExtractionDerivativeService,
-      IiifPrint::TIFFDerivativeService
-    ]
+    pdf_splitter_job: -> { IiifPrint::Jobs::ChildWorksFromPdfJob },
+    pdf_splitter_service: -> { IiifPrint::SplitPdfs::PagesToJpgsSplitter },
+    derivative_service_plugins: lambda {
+                                  [
+                                    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,29 +108,73 @@ 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]
   #
   # @see IiifPrint::DEFAULT_MODEL_CONFIGURATION
   # @todo Because not every job will split PDFs and write to a child model. May want to introduce
   #       an alternative splitting method to create new filesets on the existing work instead of new child works.
+  # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   def self.model_configuration(**kwargs)
     Module.new do
-      def iiif_print_config?
-        true
+      extend ActiveSupport::Concern
+
+      included do
+        work_type = self # In this case self is the class we're mixing the new module into.
+
+        # Ensure that the work_type and corresponding indexer are properly decorated for IiifPrint
+        indexer = if defined?(Valkyrie::Resource) && work_type < Valkyrie::Resource
+                    IiifPrint::PersistenceLayer::ValkyrieAdapter.decorate_with_adapter_logic(work_type: work_type)
+                  elsif work_type < ActiveFedora::Base
+                    IiifPrint::PersistenceLayer::ActiveFedoraAdapter.decorate_with_adapter_logic(work_type: work_type)
+                  else
+                    raise "Unable to mix '.model_configuration' into #{work_type}"
+                  end
+
+        # Ensure that the work_type and corresponding indexer are properly decorated for IiifPrint
+        if defined?(Valkyrie::Resource) && work_type < Valkyrie::Resource
+          IiifPrint::PersistenceLayer::ValkyrieAdapter.decorate_form_with_adapter_logic(work_type: work_type)
+        elsif work_type < ActiveFedora::Base
+          IiifPrint::PersistenceLayer::ActiveFedoraAdapter.decorate_form_with_adapter_logic(work_type: work_type)
+        else
+          raise "Unable to mix '.model_configuration' into #{work_type}"
+        end
+
+        # Deriving lineage of objects is a potentially complicated thing.  We provide a default
+        # service but each work_type's indexer can be configured by amending it's
+        # {.iiif_print_lineage_service}.
+        indexer.class_attribute(:iiif_print_lineage_service, default: IiifPrint::LineageService) unless indexer.respond_to?(:iiif_print_lineage_service)
+        work_type::GeneratedResourceSchema.send(:include, IiifPrint::SetChildFlag) if work_type.const_defined?(:GeneratedResourceSchema)
       end
 
       # We don't know what you may want in your configuration, but from this gems implementation,
       # we're going to provide the defaults to ensure that it works.
       DEFAULT_MODEL_CONFIGURATION.each_pair do |key, default_value|
-        kwargs[key] ||= default_value
+        kwargs[key] ||= default_value.call
       end
 
       define_method(:iiif_print_config) do
         @iiif_print_config ||= ModelConfig.new(**kwargs)
       end
+
+      def iiif_print_config?
+        true
+      end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   # @api public
   #
@@ -107,7 +191,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 +201,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 +213,114 @@ 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?
+
+    # Hyrax::FileSet ids are Valkyrie::ID's which can't be passed, so we call id on that and get the string id
+    file_set_id = file_set.id.try(:id) || file_set.id
+    work_admin_set_id = work.admin_set_id.try(:id) || work.admin_set_id
+
+    work.try(:iiif_print_config)&.pdf_splitter_job&.perform_later(
+      file_set_id,
+      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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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