iiif_print 1.0.0

data/spec/helpers/hyrax/iiif_helper_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+# @note This spec was brought over from Hyrax 3.4.2
+# @see https://github.com/samvera/hyrax/blob/afdda8240494ed382301f7d0ab0fd7bafe79185e/spec/helpers/hyrax/iiif_helper_spec.rb
+RSpec.describe Hyrax::IiifHelper, type: :helper do
+  let(:solr_document) { SolrDocument.new }
+  let(:request) { double }
+  let(:ability) { nil }
+  let(:presenter) { Hyrax::WorkShowPresenter.new(solr_document, ability, request) }
+  let(:uv_partial_path) { 'hyrax/base/iiif_viewers/universal_viewer' }
+
+  describe '#iiif_viewer_display' do
+    before do
+      allow(helper).to receive(:iiif_viewer_display_partial).with(presenter)
+                                                            .and_return(uv_partial_path)
+    end
+
+    it "renders a partial" do
+      expect(helper).to receive(:render)
+        .with(uv_partial_path, presenter: presenter)
+      helper.iiif_viewer_display(presenter)
+    end
+
+    it "takes options" do
+      expect(helper).to receive(:render)
+        .with(uv_partial_path, presenter: presenter, transcript_id: '123')
+      helper.iiif_viewer_display(presenter, transcript_id: '123')
+    end
+  end
+
+  describe '#iiif_viewer_display_partial' do
+    subject { helper.iiif_viewer_display_partial(presenter) }
+
+    it 'defaults to universal viewer' do
+      expect(subject).to eq uv_partial_path
+    end
+
+    context "with #iiif_viewer override" do
+      let(:iiif_viewer) { :mirador }
+
+      before do
+        allow(presenter).to receive(:iiif_viewer).and_return(iiif_viewer)
+      end
+
+      it { is_expected.to eq 'hyrax/base/iiif_viewers/mirador' }
+    end
+  end
+
+  describe '#universal_viewer_base_url' do
+    subject { helper.universal_viewer_base_url }
+
+    it 'defaults to universal viewer base path' do
+      expect(subject).to eq "http://test.host/uv/uv.html"
+    end
+  end
+
+  describe '#universal_viewer_config_url' do
+    subject { helper.universal_viewer_config_url }
+
+    it 'defaults to universal viewer base path' do
+      expect(subject).to eq "http://test.host/uv/uv-config.json"
+    end
+  end
+end

data/spec/helpers/iiif_print_helper_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrintHelper do
+  let(:query_term) { 'suffrage' }
+  let(:query_params_hash) { { q: query_term } }
+  let(:document) { build(:newspaper_page_solr_document) }
+
+  describe '#iiif_search_anchor' do
+    it 'returns the correct string' do
+      expect(helper.iiif_search_anchor({})).to eq nil
+      expect(helper.iiif_search_anchor(query_params_hash)).to eq("?h=#{query_term}")
+    end
+  end
+
+  describe '#search_query' do
+    it 'returns the correct string' do
+      expect(helper.search_query({})).to eq nil
+      expect(helper.search_query(query_params_hash)).to eq(query_term)
+    end
+  end
+
+  describe '#highlight_matches' do
+    let(:hl_fl) { 'all_text_tsimv' }
+
+    describe 'when highlighting is present in Solr response' do
+      before do
+        allow(document).to receive(:highlight_field).with(hl_fl).and_return(['foo <em>bar</em> baz'.html_safe])
+      end
+      it 'returns the matching terms when highlighting present' do
+        expect(helper.highlight_matches(document, hl_fl, 'em')).to eq 'bar'
+      end
+    end
+
+    describe 'when highlighting is not present' do
+      before do
+        allow(document).to receive(:highlight_field).with(hl_fl).and_return([])
+      end
+      it 'returns the matching terms when highlighting present' do
+        expect(helper.highlight_matches(document, hl_fl, 'em')).to eq nil
+      end
+    end
+  end
+end

data/spec/iiif_print/base_derivative_service_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrint::BaseDerivativeService do
+  describe '#valid?' do
+    let(:file_set) { double(FileSet) }
+    let(:service) { described_class.new(file_set) }
+    subject { service.valid? }
+
+    it { is_expected.to be_truthy }
+  end
+end

data/spec/iiif_print/blacklight_iiif_search/annotation_decorator_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrint::BlacklightIiifSearch::AnnotationDecorator do
+  let(:page_document) { build(:newspaper_page_solr_document) }
+  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],
+                     'has_model_ssim' => ['NewspaperIssue'])
+  end
+  let(:iiif_search_annotation) do
+    BlacklightIiifSearch::IiifSearchAnnotation.new(page_document, 'software',
+                                                   0, nil, controller,
+                                                   parent_document)
+  end
+  let(:test_request) { ActionDispatch::TestRequest.new({}) }
+
+  before do
+    allow(controller).to receive(:request).and_return(test_request)
+    allow(controller).to receive(:polymorphic_url)
+      .with(parent_document, host: test_request.base_url, locale: nil)
+      .and_return("/#{page_document[:issue_id_ssi]}")
+  end
+
+  describe '#annotation_id' do
+    subject { iiif_search_annotation.annotation_id }
+    it 'returns a properly formatted URL' do
+      expect(subject).to include("#{page_document[:issue_id_ssi]}/manifest/canvas/#{page_document[:file_set_ids_ssim].first}/annotation/0")
+    end
+  end
+
+  describe '#canvas_uri_for_annotation' do
+    before { allow(iiif_search_annotation).to receive(:fetch_and_parse_coords).and_return(coordinates) }
+
+    subject { iiif_search_annotation.canvas_uri_for_annotation }
+    it 'returns a properly formatted URL' do
+      expect(subject).to include("#{page_document[:issue_id_ssi]}/manifest/canvas/#{page_document[:file_set_ids_ssim].first}")
+    end
+
+    describe 'private methods' do
+      # test #coordinates based on output of #canvas_uri_for_annotation, which calls it
+      describe '#coordinates' do
+        it 'gets the expected value from #coordinates' do
+          expect(subject).to include("#xywh=2641,4102,512,44")
+        end
+      end
+    end
+  end
+end

data/spec/iiif_print/catalog_search_builder_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrint::CatalogSearchBuilder do
+  # specs for IiifPrint::HighlightSearchParams
+  describe 'highlight_search_params' do
+    let(:solr_parameters) { { q: 'abolition' } }
+    subject { described_class.new(solr_parameters) }
+
+    it 'is included in the default_processor_chain' do
+      expect(described_class.default_processor_chain).to include(:highlight_search_params)
+    end
+
+    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')
+    end
+  end
+
+  # specs for IiifPrint::ExcludeModels
+  describe 'exclude_models' do
+    let(:solr_parameters) { { all_fields: 'prohibition' } }
+    subject { described_class.new(solr_parameters) }
+
+    it 'is included in the default_processor_chain' do
+      expect(described_class.default_processor_chain).to include(:exclude_models)
+    end
+
+    context 'with configured model name solr field values' do
+      before do
+        config = IiifPrint::Configuration.new.tap { |c| c.excluded_model_name_solr_field_values = ['Excluded Model', 'Another Excluded Model'] }
+        subject.exclude_models(solr_parameters, config: config)
+      end
+
+      it 'adds the facet fields to solr_parameters with default key' do
+        expect(solr_parameters[:fq]).to be_truthy
+        expect(solr_parameters[:fq]).to(
+          include("-human_readable_type_sim:\"Excluded Model\"", "-human_readable_type_sim:\"Another Excluded Model\"")
+        )
+      end
+
+      context 'with configured model name solr field key' do
+        before do
+          config = IiifPrint::Configuration.new.tap do |c|
+            c.excluded_model_name_solr_field_values = ['ExcludedModel', 'AnotherExcludedModel']
+            c.excluded_model_name_solr_field_key = 'has_model_ssim'
+          end
+          subject.exclude_models(solr_parameters, config: config)
+        end
+
+        it 'adds the facet fields to solr_parameters with configured key' do
+          expect(solr_parameters[:fq]).to be_truthy
+          expect(solr_parameters[:fq]).to(
+            include("-has_model_ssim:\"ExcludedModel\"", "-has_model_ssim:\"AnotherExcludedModel\"")
+          )
+        end
+      end
+    end
+  end
+end

data/spec/iiif_print/configuration_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrint::Configuration do
+  let(:config) { described_class.new }
+
+  describe "#metadata_fields" do
+    subject { config.metadata_fields }
+
+    it { is_expected.to be_a Hash }
+    it "allows for an override" do
+      original = config.metadata_fields
+      config.metadata_fields = { title: {} }
+      expect(config.metadata_fields).not_to eq original
+    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) }
+    subject(:called_function) { config.handle_after_create_fileset(file_set, user) }
+
+    context "without configuration" do
+      it "calls IiifPrint::Data.handle_after_create_fileset" do
+        expect(IiifPrint::Data).to receive(:handle_after_create_fileset).with(file_set, user)
+
+        called_function
+      end
+    end
+
+    context "with configuration" do
+      let(:config_func) { ->(_file_set, _user) { :yup } }
+
+      it "calls the given configured lambda" do
+        config.after_create_fileset_handler = config_func
+        expect(IiifPrint::Data).not_to receive(:handle_after_create_fileset)
+        expect(config_func).to receive(:call).with(file_set, user)
+        called_function
+      end
+    end
+  end
+
+  describe '#additional_tessearct_options' do
+    context "by default" do
+      subject { config.additional_tessearct_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)
+        .from("")
+        .to("-l esperanto")
+    end
+  end
+end

data/spec/iiif_print/data/work_derivatives_spec.rb

@@ -0,0 +1,245 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe IiifPrint::Data::WorkDerivatives do
+  include_context "shared setup"
+
+  let(:bare_work) do
+    work = NewspaperPage.new
+    work.title = ['Another one']
+    work.save!
+    work
+  end
+
+  let(:work) do
+    # sample work comes from shared setup, but we need derivative, save...
+    mk_txt_derivative(sample_work)
+    sample_work.save!(validate: false)
+    sample_work
+  end
+
+  let(:adapter) { described_class.new(work) }
+
+  let(:txt1) do
+    registered_dirs = IiifPrint.config.registered_ingest_dirs
+    registered_dirs.push('/tmp') unless registered_dirs.include?('/tmp')
+    file = Tempfile.new(['txt1', '.txt'])
+    file.write('hello')
+    file.flush
+    file
+  end
+
+  let(:txt2) do
+    file = Tempfile.new('txt2.txt')
+    file.write('bye')
+    file.flush
+    file
+  end
+
+  let(:encoded_text) do
+    file = Tempfile.new('txt_encoded.txt', encoding: 'UTF-8')
+    file.write('Gorgonzola Dolce® — on sale for £12.50/kg')
+    file.flush
+    file
+  end
+
+  describe "enumerates available derivatives like hash" do
+    xit "includes expected derivative path for work" do
+      expect(adapter.keys).to include 'txt'
+    end
+
+    xit "can be introspected for quantity of derivatives" do
+      # `size` method without argument is count of derivatives,
+      #   functions equivalently to adapter.keys.size
+      expect(adapter.size).to eq adapter.keys.size
+    end
+
+    xit "enumerates expected derivative extension for work" do
+      ext_found = adapter.keys
+      expect(ext_found).to include 'txt'
+    end
+
+    xit "enumerates expected derivative extension for file set" do
+      file_set = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.new(file_set)
+      ext_found = adapter.keys
+      expect(ext_found).to include 'txt'
+    end
+
+    xit "enumerates expected derivative extension for file set id" do
+      file_set = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.new(file_set.id)
+      ext_found = adapter.keys
+      expect(ext_found).to include 'txt'
+    end
+  end
+
+  describe "loads derivatives for a work" do
+    xit "Loads text derivative path" do
+      expect(File.exist?(adapter.path('txt'))).to be true
+      expect(adapter.exist?('txt')).to be true
+    end
+
+    xit "Loads text derivative data" do
+      expect(adapter.data('txt')).to include 'mythical'
+    end
+
+    xit "Handles character encoding on read" do
+      # replace fixture text derivative for work with encoded text
+      adapter.attach(encoded_text.path, 'txt')
+      data = adapter.data('txt')
+      expect(data).to include '—' # em-dash
+      expect(data).to include '£' # gb-pound sign
+      expect(data.encoding.to_s).to eq 'UTF-8'
+    end
+
+    xit "Loads thumbnail derivative data" do
+      mk_thumbnail_derivative(work)
+      # get size by loading data
+      expect(adapter.data('thumbnail').bytes.size).to eq 16_743
+      # get size by File.size via .size method
+      expect(adapter.size('thumbnail')).to eq 16_743
+    end
+
+    xit "Can access jp2 derivative" do
+      mk_jp2_derivative(work)
+      expect(File.exist?(adapter.path('jp2'))).to be true
+      expect(adapter.exist?('jp2')).to be true
+    end
+  end
+
+  describe "create, update, delete derivatives" do
+    xit "will queue derivative file assignment" do
+      adapter = described_class.new(bare_work)
+      adapter.assign(example_gray_jp2)
+      expect(adapter.assigned).to include example_gray_jp2
+    end
+
+    xit "will fail to assign file in non-registered dirs" do
+      adapter = described_class.new(bare_work)
+      # need a non-whitlisted file that exists:
+      bad_path = File.expand_path("../../spec_helper.rb", fixture_path)
+      expect { adapter.assign(bad_path) }.to raise_error(SecurityError)
+    end
+
+    xit "will remove file assignment from queue" do
+      adapter = described_class.new(bare_work)
+      expect(adapter.state).to eq 'empty'
+      adapter.assign(example_gray_jp2)
+      expect(adapter.assigned).to include example_gray_jp2
+      expect(adapter.state).to eq 'dirty'
+      adapter.unassign(example_gray_jp2)
+      expect(adapter.assigned).not_to include example_gray_jp2
+      expect(adapter.state).to eq 'empty'
+    end
+
+    xit "will queue a deletion" do
+      # Given a work with a derivative (txt) already assigned
+      expect(adapter.state).to eq 'saved'
+      # unassigning path...
+      adapter.unassign('txt')
+      # will lead to queued unassignment (intent to delete)...
+      expect(adapter.unassigned).to include 'txt'
+      # and a 'dirty' adapter state (unflushed changes):
+      expect(adapter.state).to eq 'dirty'
+    end
+
+    xit "will flush a removal and addition on commit!" do
+      # Given a work with a derivative (txt) already assigned
+      expect(adapter.keys).to include 'txt'
+      expect(adapter.keys).not_to include 'jp2'
+      # unassigning path...
+      adapter.unassign('txt')
+      # and assigning another attachment:
+      adapter.assign(example_gray_jp2)
+      # ...committing these will flush the changes (synchronously):
+      adapter.commit!
+      expect(adapter.keys).not_to include 'txt'
+      expect(adapter.keys).to include 'jp2'
+      expect(adapter.size('jp2')).to eq 27_703
+    end
+
+    xit "can attach derivative from file" do
+      expect(adapter.keys).not_to include 'jp2'
+      adapter.attach(example_gray_jp2, 'jp2')
+      expect(adapter.exist?('jp2')).to be true
+      expect(adapter.path('jp2')).not_to be nil
+      expect(File.size(adapter.path('jp2'))).to eq File.size(example_gray_jp2)
+      expect(adapter.keys).to include 'jp2'
+      d_path = path_factory.derivative_path_for_reference(adapter.fileset_id, 'jp2')
+      expect(adapter.values).to include d_path
+    end
+
+    xit "can replace aderivative with new attachment" do
+      adapter.attach(txt1.path, 'txt')
+      expect(adapter.data('txt')).to eq 'hello'
+      adapter.attach(txt2.path, 'txt')
+      expect(adapter.data('txt')).to eq 'bye'
+    end
+
+    xit "can delete an attached derivative" do
+      adapter.attach(txt1.path, 'txt')
+      expect(adapter.keys).to include 'txt'
+      expect(adapter.data('txt')).to eq 'hello'
+      adapter.delete('txt')
+      expect(adapter.path('txt')).to be nil
+      expect(adapter.keys).not_to include 'txt'
+    end
+
+    xit "persists log of attachment to RDBMS" do
+      adapter.assign(txt1.path)
+      result = IiifPrint::DerivativeAttachment.find_by(
+        fileset_id: adapter.fileset.id,
+        path: txt1.path,
+        destination_name: 'txt'
+      )
+      expect(result).not_to be_nil
+    end
+
+    xit "persists a log of path relation to primary file" do
+      # this is an integration test by practical necessity, with
+      #   WorkFiles adapting a bare work with no fileset.
+      work_files = IiifPrint::Data::WorkFiles.of(bare_work)
+      work_files.assign(example_gray_jp2)
+      adapter = work_files.derivatives
+      adapter.assign(txt1.path)
+      result = IiifPrint::IngestFileRelation.find_by(
+        derivative_path: txt1.path,
+        file_path: example_gray_jp2
+      )
+      expect(result).not_to be_nil
+    end
+
+    xit "commits queued derivatives" do
+      IiifPrint::IngestFileRelation.where(file_path: example_gray_jp2).delete_all
+      work_files = IiifPrint::Data::WorkFiles.of(bare_work)
+      work_files.assign(example_gray_jp2)
+      adapter = work_files.derivatives
+      adapter.assign(txt1.path)
+      expect(File.exist?(txt1.path)).to be true
+      expect(adapter.keys.size).to eq 0
+      # we need a fileset, saved with import_url, attached to work:
+      fileset = valid_file_set
+      fileset.import_url = 'file://' + example_gray_jp2
+      fileset.save!
+      bare_work.members.push(fileset)
+      bare_work.save!
+      fileset.reload
+      expect(fileset.member_of[0].id).to eq bare_work.id
+      # with a new adapter instance...
+      adapter2 = described_class.of(bare_work)
+      # call .commit_queued! with our fileset...
+      expect(File.exist?(txt1.path)).to be true
+      adapter2.commit_queued!(fileset)
+      # ...which should result in saved, reloaded derivative...
+      expect(adapter2.keys.size).to eq 1
+      expect(File.size(adapter2.values[0])).to eq File.size(txt1.path)
+      # ...also found via Hyrax::DerviativePath:
+      found = Hyrax::DerivativePath.derivatives_for_reference(fileset.id)
+      expect(found.size).to eq 1
+      expect(File.size(found[0])).to eq File.size(txt1.path)
+    end
+  end
+end

data/spec/iiif_print/data/work_file_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe IiifPrint::Data::WorkFile do
+  include_context "shared setup"
+
+  # sample objects:
+  let(:work) { work_with_file }
+
+  describe "adapter composition" do
+    it "adapts work with nil fileset" do
+      adapter = described_class.new(work)
+      expect(adapter.work).to be work
+      expect(adapter.fileset).to be_nil
+    end
+
+    it "adapts work with 'of' alt constructor" do
+      adapter = described_class.of(work)
+      expect(adapter.work).to be work
+    end
+
+    it "adapts work and explicitly provided fileset" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      expect(adapter.work).to be work
+      expect(adapter.fileset).to be fileset
+    end
+
+    it "constructs with a parent object, if provided" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      parent = double('parent')
+      adapter = described_class.of(work, fileset, parent)
+      expect(adapter.parent).to be parent
+    end
+  end
+
+  describe "read file metadata" do
+    it "gets original filename" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      expect(adapter.name).to eq fileset.original_file.original_name
+      expect(adapter.name).to eq 'credits.md'
+    end
+
+    it "gets miscellaneous metadata field values" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      # expectations for accessors of size, date_*, mime_type
+      expect(adapter.size).to eq File.size(txt_path)
+      expect(adapter.name).to eq 'credits.md'
+      expect(adapter.mime_type).to eq 'text/plain'
+      # getting actual value for date fields requires digging through
+      #   multiple layers of ActiveTuples indirection...
+      expect(adapter.date_created.to_a[0].to_s).to eq static_date.to_s
+      expect(adapter.date_modified.to_a[0].to_s).to eq static_date.to_s
+    end
+  end
+
+  describe "read binary via transparent repository checkout" do
+    it "gets path (from checkout)" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      # Get a path to a working copy
+      path = adapter.path
+      expect(path).to be_a String
+      expect(File.exist?(path)).to be true
+      # size of working copy binary checkout matches size in computed metadata
+      expect(File.size(path)).to eq fileset.original_file.size
+    end
+
+    it "gets data as bytes" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      # Get a data from the working copy
+      data = adapter.data
+      expect(data).to be_a String
+      # size of working copy binary checkout matches size in computed metadata
+      expect(data.size).to eq fileset.original_file.size
+    end
+
+    it "runs block on data as IO" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      adapter.with_io { |io| expect(io.read.size).to eq File.size(txt_path) }
+    end
+  end
+
+  describe "derivative access" do
+    it "gets derivatives for file" do
+      fileset = work.members.detect { |m| m.is_a? FileSet }
+      adapter = described_class.of(work, fileset)
+      expect(adapter.derivatives.class).to eq \
+        IiifPrint::Data::WorkDerivatives
+      expect(adapter.derivatives.fileset).to be fileset
+      expect(adapter.derivatives.work).to be work
+      expect(adapter.derivatives.parent).to be adapter
+    end
+  end
+end