iiif_print 1.0.0 → 1.1.0

data/lib/samvera/derivatives.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'samvera/derivatives/configuration'
+
+##
+# Why Samvera and not Hyrax?  Because there are folks creating non-Hyrax applications that will
+# almost certainly want to leverage this work.  And there might be switches for `defined?(Hyrax)`.
+#
+# Further the following four gems have interest in the interfaces of this module:
+#
+# - Hyrax
+# - Hydra::Derivatives
+# - Bulkrax
+# - IiifPrint
+#
+# As such, it makes some sense to isolate the module and begin defining interfaces.
+module Samvera
+  ##
+  # This module separates the finding/creation of a derivative binary (via {FileLocator}) and
+  # applying that derivative to the FileSet (via {FileApplicator}).
+  #
+  # In working on the interface and objects there is an effort to preserve backwards functionality
+  # while also allowing for a move away from that functionality.
+  #
+  # There are three primary concepts to consider:
+  #
+  # - Locator :: responsible for knowing where the derivative is
+  # - Location :: responsible for encapsulating the location
+  # - Applicator :: responsible for applying the located derivative to the FileSet
+  #
+  # The "trick" in this is in the polymorphism of the Location.  Let's say we have the following
+  # desired functionality for the thumbnail derivative:
+  #
+  #   ```gherkin
+  #   Given a FileSet
+  #   When I provide a thumbnail derivative
+  #   Then I want to add that as the thumbnail for the FileSet
+  #
+  #   Given a FileSet
+  #   When I do not provide a thumbnail derivative
+  #   Then I want to generate a thumbnail
+  #     And add the generated as the thumbnail for the FileSet
+  #   ```
+  #
+  # In the above case we would have two Locator strategies:
+  #
+  # - Find Existing One
+  # - Will Generate One (e.g. Hyrax::FileSetDerivativesService with Hydra::Derivative behavior)
+  #
+  # And we would have two Applicator strategies:
+  #
+  # - Apply an Existing One
+  # - Generate One and Apply (e.g. Hyrax::FileSetDerivativesService with Hydra::Derivative behavior)
+  #
+  # The Location from the first successful Locator will dictate how the ApplicatorStrategies do
+  # their work.
+  module Derivatives
+    ##
+    # @api public
+    #
+    # Responsible for configuration of derivatives.
+    #
+    # @example
+    #   Samvera::Derivative.config do |config|
+    #     config.register(type: :thumbnail, applicators: [CustomApplicator], locators: [CustomLocator]) do |file_set|
+    #       file_set.video? || file_set.audio? || file_set.image?
+    #     end
+    #   end
+    #
+    # @yield [Configuration]
+    #
+    # @return [Configuration]
+    def self.config
+      @config ||= Configuration.new
+      yield(@config) if block_given?
+      @config
+    end
+
+    ##
+    # @api public
+    #
+    # Locate the derivative for the given :file_set and apply it to that :file_set.
+    #
+    # @param file_set [FileSet]
+    # @param derivative [Samvera::Derivatives::Configuration::RegisteredType]
+    # @param file_path [String]
+    #
+    # @note As a concession to existing implementations of creating derivatives, file_path is
+    #       included as a parameter.
+    def self.locate_and_apply_derivative_for(file_set:, derivative:, file_path:)
+      return false unless derivative.applicable_for?(file_set: file_set)
+
+      from_location = FileLocator.call(
+        file_set: file_set,
+        file_path: file_path,
+        derivative: derivative
+      )
+
+      FileApplicator.call(
+        from_location: from_location,
+        file_set: file_set,
+        derivative: derivative
+      )
+    end
+
+    ##
+    # The purpose of this module is to find the derivative file path for a FileSet and a given
+    # derivative type (e.g. :thumbnail).
+    #
+    # @see https://github.com/samvera-labs/bulkrax/issues/760 Design Document
+    #
+    # @note Ideally, this module would be part of Hyrax or Hydra::Derivatives
+    # @see https://github.com/samvera/hyrax
+    # @see https://github.com/samvera/hydra-derivatives
+    module FileLocator
+      ##
+      # @api public
+      #
+      # This method is responsible for finding the correct file names for the given file set and
+      # derivative type.
+      #
+      # @param file_set [FileSet]
+      # @param file_path [String]
+      # @param derivative [Samvera::Derivatives::Configuration::RegisteredType]
+      #
+      # @return [Samvera::Derivatives::FromLocation]
+      #
+      # @note Why {.call}?  This allows for a simple lambda interface, which can greatly ease testing
+      #       and composition.
+      def self.call(file_set:, file_path:, derivative:)
+        from_location = nil
+
+        derivative.locators.each do |locator|
+          from_location = locator.locate(
+            file_set: file_set,
+            file_path: file_path,
+            derivative_type: derivative.type
+          )
+          break if from_location.present?
+        end
+
+        from_location
+      end
+
+      ##
+      # @abstract
+      #
+      # The purpose of this abstract class is to provide the public interface for strategies.
+      #
+      # @see {.find}
+      class Strategy
+        ##
+        # @api public
+        # @param file_set [FileSet]
+        # @param file_path [String]
+        # @param derivative_type [#to_sym]
+        #
+        # @return [Samvera::Derivatives::FromLocation] when this is a valid strategy
+        # @return [NilClass] when this is not a valid strategy
+        def self.locate(file_set:, file_path:, derivative_type:)
+          raise NotImplementedError
+        end
+      end
+    end
+
+    module FileApplicator
+      ##
+      # @api public
+      #
+      # @param file_set [FileSet]
+      # @param from_location [#present?]
+      # @param derivative [Array<#apply!>]
+      def self.call(file_set:, from_location:, derivative:)
+        # rubocop:disable Rails/Blank
+        return false unless from_location.present?
+        # rubocop:enable Rails/Blank
+
+        derivative.applicators.each do |applicator|
+          applicator.apply!(file_set: file_set, derivative_type: derivative.type, from_location: from_location)
+        end
+      end
+
+      ##
+      # @abstract
+      #
+      # The purpose of this abstract class is to provide the public interface for strategies.
+      #
+      # @see {.find}
+      class Strategy
+        # In some cases the FromLocation knows how to write itself; this is the case when we wrap
+        # the Hyrax::FileSetDerivativesService.
+        class_attribute :delegate_apply_to_given_from_location, default: false
+
+        ##
+        # @param file_set [FileSet]
+        # @param derivative_type [#to_sym]
+        # @param from_location [Object]
+        def self.apply!(file_set:, derivative_type:, from_location:)
+          new(file_set: file_set, derivative_type: derivative_type, from_location: from_location).apply!
+        end
+
+        def initialize(file_set:, derivative_type:, from_location:)
+          @file_set = file_set
+          @derivative_type = derivative_type
+          @from_location = from_location
+        end
+        attr_reader :file_set, :derivative_type, :from_location
+
+        # @note What's going on with this logic?  To continue to leverage
+        #       Hyrax::FileSetDerivativesService, we want to let that wrapped service (as a
+        #       FromLocation) to do it's original work.  However, we might have multiple strategies
+        #       in play for application.  That case is when we want to first check for an existing
+        #       thumbnail and failing that generate the thumbnail.  The from_location could either
+        #       be the found thumbnail...or it could be the wrapped Hyrax::FileSetDerivativesService
+        #       that will create the thumbnail and write it to the location.  The two applicator
+        #       strategies in that case would be the wrapper and logic that will write the found
+        #       file to the correct derivative path.
+        def apply!
+          if delegate_apply_to_given_from_location?
+            return false unless from_location.respond_to?(:apply!)
+
+            from_location.apply!(file_set: file_set, derivative_type: derivative_type)
+          else
+            return false if from_location.respond_to?(:apply!)
+
+            perform_apply!
+          end
+        end
+
+        private
+
+        def perform_apply!
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/spec/factories/newspaper_page_solr_document.rb

@@ -1,11 +1,19 @@
 FactoryBot.define do
+  factory :file_set_solr_document, class: SolrDocument do
+    initialize_with do
+      new(id: 'fs123456',
+          has_model_ssim: ['FileSet'])
+    end
+  end
+
   factory :newspaper_page_solr_document, class: SolrDocument do
     initialize_with do
+      file_set = build(:file_set_solr_document)
       new(id: '123456',
           title_tesim: ['Page 1'],
           has_model_ssim: ['NewspaperPage'],
           issue_id_ssi: 'abc123',
-          file_set_ids_ssim: ['7891011'],
+          file_set_ids_ssim: [file_set.id],
           thumbnail_path_ss: '/downloads/123456?file=thumbnail')
     end
   end

data/spec/fixtures/authorities/licenses.yml

@@ -0,0 +1,4 @@
+terms:
+- id: https://creativecommons.org/licenses/by-sa/4.0/
+  term: Creative Commons BY-SA Attribution-ShareAlike 4.0 International
+  active: true

data/spec/fixtures/authorities/rights_statements.yml

@@ -0,0 +1,4 @@
+terms:
+- id: http://rightsstatements.org/vocab/InC-OW-EU/1.0/
+  term: "In Copyright - EU Orphan Work"
+  active: true

data/spec/iiif_print/base_derivative_service_spec.rb

@@ -1,11 +1,28 @@
 require 'spec_helper'
 
 RSpec.describe IiifPrint::BaseDerivativeService do
+  let(:file_set) { double(FileSet) }
+  let(:service) { described_class.new(file_set) }
+
   describe '#valid?' do
-    let(:file_set) { double(FileSet) }
-    let(:service) { described_class.new(file_set) }
     subject { service.valid? }
 
-    it { is_expected.to be_truthy }
+    context 'when given an image file' do
+      let(:file_set) { double(FileSet, mime_type: 'image/tiff', class: FileSet) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when given a non-image file' do
+      let(:file_set) { double(FileSet, mime_type: 'audio/mpeg', class: FileSet) }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe "instance" do
+    subject { service }
+
+    it { is_expected.to respond_to :target_extension }
   end
 end

data/spec/iiif_print/blacklight_iiif_search/annotation_decorator_spec.rb

@@ -1,20 +1,27 @@
 require 'spec_helper'
 
 RSpec.describe IiifPrint::BlacklightIiifSearch::AnnotationDecorator do
-  let(:page_document) { build(:newspaper_page_solr_document) }
+  let(:parent_id) { 'abc123' }
+  let(:page_document) do
+    doc = build(:newspaper_page_solr_document)
+    doc['is_page_of_ssim'] = [parent_id]
+    doc
+  end
   let(:controller) { CatalogController.new }
   let(:coordinates) do
     JSON.parse("{\"coords\":{\"software\":[[2641,4102,512,44]]}}")
   end
   let(:parent_document) do
-    SolrDocument.new('id' => page_document[:issue_id_ssi],
+    SolrDocument.new('id' => parent_id,
                      'has_model_ssim' => ['NewspaperIssue'])
   end
+  let(:query) { "software AND (is_page_of_ssim:#{parent_id} OR id:#{parent_id})" }
   let(:iiif_search_annotation) do
-    BlacklightIiifSearch::IiifSearchAnnotation.new(page_document, 'software',
+    BlacklightIiifSearch::IiifSearchAnnotation.new(page_document, query,
                                                    0, nil, controller,
                                                    parent_document)
   end
+  let(:file_set) { build(:file_set_solr_document) }
   let(:test_request) { ActionDispatch::TestRequest.new({}) }
 
   before do
@@ -22,6 +29,7 @@ RSpec.describe IiifPrint::BlacklightIiifSearch::AnnotationDecorator do
     allow(controller).to receive(:polymorphic_url)
       .with(parent_document, host: test_request.base_url, locale: nil)
       .and_return("/#{page_document[:issue_id_ssi]}")
+    allow(SolrDocument).to receive(:find).with(file_set.id).and_return(file_set)
   end
 
   describe '#annotation_id' do

data/spec/iiif_print/catalog_search_builder_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe IiifPrint::CatalogSearchBuilder do
     before { subject.highlight_search_params(solr_parameters) }
     it 'adds the highlight fields to solr_parameters' do
       expect(solr_parameters[:hl]).to be_truthy
-      expect(solr_parameters[:'hl.fl']).to eq('all_text_tsimv')
+      expect(solr_parameters[:'hl.fl']).to eq('*')
     end
   end
 

data/spec/iiif_print/configuration_spec.rb

@@ -3,6 +3,48 @@ require 'spec_helper'
 RSpec.describe IiifPrint::Configuration do
   let(:config) { described_class.new }
 
+  describe '#ancestory_identifier_function' do
+    subject(:function) { config.ancestory_identifier_function }
+    it "is expected to be a lambda with an arity of one" do
+      expect(function.arity).to eq(1)
+    end
+
+    it "is configurable" do
+      expect do
+        config.ancestory_identifier_function = ->(w) { w.object_id }
+      end.to change { config.ancestory_identifier_function.object_id }
+    end
+  end
+
+  describe '#unique_child_title_generator_function' do
+    subject(:function) { config.unique_child_title_generator_function }
+
+    it "is expected to be a lambda with keyword args" do
+      expect(function.parameters).to eq([[:keyreq, :original_pdf_path],
+                                         [:keyreq, :image_path],
+                                         [:keyreq, :parent_work],
+                                         [:keyreq, :page_number],
+                                         [:keyreq, :page_padding]])
+    end
+
+    it 'works as originally designed' do
+      work = double(title: ["My Title"], id: '1234')
+      expect(function.call(
+               original_pdf_path: "/hello/world/nice.pdf",
+               image_path: __FILE__,
+               parent_work: work,
+               page_number: 23,
+               page_padding: 5
+             )).to eq("1234 - nice.pdf Page 00024")
+    end
+
+    it "is configurable" do
+      expect do
+        config.unique_child_title_generator_function = ->(**kwargs) { kwargs }
+      end.to change { config.unique_child_title_generator_function.object_id }
+    end
+  end
+
   describe "#metadata_fields" do
     subject { config.metadata_fields }
 
@@ -14,17 +56,6 @@ RSpec.describe IiifPrint::Configuration do
     end
   end
 
-  describe "#sort_iiif_manifest_canvases_by" do
-    subject { config.sort_iiif_manifest_canvases_by }
-
-    it { is_expected.to be_a Symbol }
-    it "allows for an override" do
-      original = config.sort_iiif_manifest_canvases_by
-      config.sort_iiif_manifest_canvases_by = :title
-      expect(config.metadata_fields).not_to eq original
-    end
-  end
-
   describe "#handle_after_create_fileset" do
     let(:file_set) { double(FileSet) }
     let(:user) { double(User) }
@@ -50,18 +81,113 @@ RSpec.describe IiifPrint::Configuration do
     end
   end
 
-  describe '#additional_tessearct_options' do
+  describe '#additional_tesseract_options' do
     context "by default" do
-      subject { config.additional_tessearct_options }
+      subject { config.additional_tesseract_options }
       it { is_expected.not_to be_present }
     end
 
     it "can be configured" do
       expect do
-        config.additional_tessearct_options = "-l esperanto"
-      end.to change(config, :additional_tessearct_options)
+        config.additional_tesseract_options = "-l esperanto"
+      end.to change(config, :additional_tesseract_options)
         .from("")
         .to("-l esperanto")
     end
   end
+
+  describe '#default_iiif_manifest_version' do
+    subject { config.default_iiif_manifest_version }
+
+    context 'default' do
+      it { is_expected.to eq 2 }
+    end
+
+    context 'when set to empty' do
+      before { config.default_iiif_manifest_version = '' }
+      it { is_expected.to eq 2 }
+    end
+
+    it 'can be set' do
+      expect { config.default_iiif_manifest_version = 3 }
+        .to change(config, :default_iiif_manifest_version)
+        .from(2)
+        .to(3)
+    end
+  end
+
+  describe '#child_work_attributes_function' do
+    subject(:function) { config.child_work_attributes_function }
+
+    it "is expected to be a lambda with keyword args" do
+      expect(function.parameters).to eq([[:keyreq, :parent_work],
+                                         [:keyreq, :admin_set_id]])
+    end
+  end
+
+  describe "#sort_iiif_manifest_canvases_by" do
+    subject { config.sort_iiif_manifest_canvases_by }
+
+    it { is_expected.to be_a NilClass }
+    it "allows for an override" do
+      original = config.sort_iiif_manifest_canvases_by
+      config.sort_iiif_manifest_canvases_by = :title
+      expect(config.metadata_fields).not_to eq original
+    end
+  end
+
+  describe "#ocr_coords_from_json_function" do
+    subject(:function) { config.ocr_coords_from_json_function }
+
+    it "is expected to be a lambda with one keyword arg and optional args" do
+      expect(function.parameters).to eq([[:keyreq, :file_set_id], [:keyrest]])
+    end
+  end
+
+  describe "#all_text_generator_function" do
+    subject(:function) { config.all_text_generator_function }
+
+    it "is expected to be a lambda with one keyword arg" do
+      expect(function.parameters).to eq([[:keyreq, :object]])
+    end
+  end
+
+  describe "#iiif_metadata_field_presentation_order" do
+    subject { config.iiif_metadata_field_presentation_order }
+
+    it { is_expected.to be_a NilClass }
+    it "allows for an override" do
+      original = config.iiif_metadata_field_presentation_order
+      config.iiif_metadata_field_presentation_order = :title
+      expect(config.iiif_metadata_field_presentation_order).not_to eq original
+    end
+  end
+
+  describe "#questioning_authority_fields" do
+    subject { config.questioning_authority_fields }
+
+    it { is_expected.to be_a Array }
+    context "by default" do
+      it { is_expected.to eq ['rights_statement', 'license'] }
+    end
+
+    it "allows for an override" do
+      expect do
+        config.questioning_authority_fields = ['rights_statement', 'license', 'subject']
+      end.to change(config, :questioning_authority_fields).from(['rights_statement', 'license']).to(['rights_statement', 'license', 'subject'])
+    end
+  end
+
+  describe '#skip_splitting_pdf_files_that_end_with_these_texts' do
+    subject { config.skip_splitting_pdf_files_that_end_with_these_texts }
+    context 'by default' do
+      it { is_expected.to be_empty }
+    end
+
+    context 'is configurable' do
+      before { config.skip_splitting_pdf_files_that_end_with_these_texts = ['.READER.pdf'] }
+
+      it { is_expected.not_to be_empty }
+    end
+  end
 end

data/spec/iiif_print/jobs/child_works_from_pdf_job_spec.rb

@@ -3,7 +3,7 @@ require 'misc_shared'
 
 RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
   # TODO: add specs
-  let(:work) { WorkWithIiifPrintConfig.new(title: ['required title']) }
+  let(:work) { WorkWithIiifPrintConfig.new(title: ['required title'], id: '123') }
   let(:my_user) { build(:user) }
   let(:uploaded_pdf_file) { create(:uploaded_pdf_file) }
   let(:uploaded_file_ids) { [uploaded_pdf_file.id] }
@@ -15,7 +15,7 @@ RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
   let(:admin_set_id) { "admin_set/default" }
   let(:prior_pdfs) { 0 }
 
-  let(:subject) { described_class.perform(work, paths, user, admin_set_id, prior_pdfs) }
+  let(:subject) { described_class.perform_now(work, pdf_paths, my_user, admin_set_id, prior_pdfs) }
 
   describe '#perform' do
     xit 'calls pdf splitter service with path' do
@@ -26,5 +26,10 @@ RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
 
     xit 'submits IiifPrint::Jobs::CreateRelationshipsJob' do
     end
+
+    context 'with more than 9 pages' do
+      xit 'pads the page number with a zero' do
+      end
+    end
   end
 end

data/spec/iiif_print/jobs/create_relationships_job_spec.rb

@@ -1,17 +1,118 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'misc_shared'
 
-RSpec.describe IiifPrint::Jobs::CreateRelationshipsJob do
-  # TODO: add specs
-  let(:parent) { WorkWithIiifPrintConfig.new(title: ['required title']) }
-  let(:my_user) { build(:user) }
-  let(:parent_model) { WorkWithIiifPrintConfig }
-  let(:child_model) { WorkWithIiifPrintConfig }
+module IiifPrint::Jobs
+  RSpec.describe CreateRelationshipsJob, type: :job do
+    let(:create_relationships_job) { described_class.new }
+
+    let(:parent_model) { WorkWithIiifPrintConfig.to_s }
+    let(:child_model) { WorkWithIiifPrintConfig.to_s }
+    let(:file) { FileSet.new.tap { |fs| fs.save!(validate: false) } }
+    let(:parent_record) { WorkWithIiifPrintConfig.new(title: ['required title']) }
+    let(:child_record1) { WorkWithIiifPrintConfig.new(title: ["Child of #{parent_record.id} page 01"]) }
+    let(:child_record2) { WorkWithIiifPrintConfig.new(title: ["Child of #{parent_record.id} page 02"]) }
+    let(:pending_rel1) do
+      IiifPrint::PendingRelationship.new(
+      parent_id: parent_record.id,
+      child_title: "Child of #{parent_record.id} page 01",
+      child_order: "Child of #{parent_record.id} page 01",
+      parent_model: parent_model,
+      child_model: child_model,
+      file_id: file.id
+    )
+    end
+    let(:pending_rel2) do
+      IiifPrint::PendingRelationship.new(
+      parent_id: parent_record.id,
+      child_title: "Child of #{parent_record.id} page 02",
+      child_order: "Child of #{parent_record.id} page 02",
+      parent_model: parent_model,
+      child_model: child_model,
+      file_id: file.id
+    )
+    end
+
+    describe '#perform' do
+      before do
+        allow(create_relationships_job).to receive(:acquire_lock_for).and_yield
+        allow(create_relationships_job).to receive(:reschedule_job)
+        allow(parent_record).to receive(:save!)
+
+        parent_record.save
+        pending_rel1.save
+        pending_rel2.save
+      end
+
+      subject(:perform) do
+        create_relationships_job.perform(
+          parent_id: parent_record.id,
+          parent_model: parent_model,
+          child_model: child_model,
+          retries: 0
+        )
+      end
+
+      context 'when adding a child work to a parent work' do
+        before do
+          child_record1.save
+          child_record2.save
+        end
+
+        it 'assigns the child to the parent\'s #ordered_members' do
+          perform
+          expect(parent_record.reload.ordered_member_ids).to eq([child_record1.id, child_record2.id])
+        end
+
+        it 'deletes the pending relationships' do
+          expect { perform }.to change(IiifPrint::PendingRelationship, :count).by(-2)
+        end
+
+        it 'does not reschedule the job' do
+          perform
+          expect(create_relationships_job).not_to have_received(:reschedule_job)
+        end
+      end
+
+      context 'when a relationship fails' do
+        before do
+          child_record1.save
+          child_record2.save
+        end
+
+        before do
+          expect_any_instance_of(CreateRelationshipsJob).to receive(:add_to_work).and_raise('error')
+        end
+
+        it 'does not save the parent' do
+          expect { perform }.to raise_error(RuntimeError)
+          expect(parent_record).not_to have_received(:save!)
+        end
+
+        it 'does not delete the pending relationships' do
+          expect { perform }.to raise_error(RuntimeError)
+          expect(IiifPrint::PendingRelationship.where(parent_id: parent_record.id).count).to eq(2)
+        end
+      end
+
+      context 'when any child record is not found' do
+        let(:child_record2) { nil }
+
+        before do
+          child_record1.save
+        end
 
-  let(:subject) { described_class.perform(user: my_user, parent_id: parent.id, parent_model: parent_model, child_model: child_model) }
+        it 'does not save the parent' do
+          perform
+          expect(parent_record).not_to have_received(:save!)
+        end
 
-  describe '#perform' do
-    xit 'loads all child work ids into ordered_members' do
+        it 'reschedules the job' do
+          perform
+          expect(create_relationships_job).to have_received(:reschedule_job)
+        end
+      end
     end
   end
 end