iiif_print 1.0.0

data/spec/iiif_print/data/work_files_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe IiifPrint::Data::WorkFiles do
+  include_context "shared setup"
+
+  let(:work) { work_with_file }
+  let(:tiff_path) { File.join(fixture_path, 'ocr_gray.tiff') }
+  let(:tiff_uri) { 'file://' + File.expand_path(tiff_path) }
+
+  describe "adapter composition" do
+    it "adapts work" do
+      adapter = described_class.new(work)
+      expect(adapter.work).to be work
+    end
+
+    it "adapts work with 'of' alt constructor" do
+      adapter = described_class.of(work)
+      expect(adapter.work).to be work
+    end
+  end
+
+  describe "path assignment queueing" do
+    it "queues assigned file path" do
+      adapter = described_class.of(work)
+      expect(adapter.assigned).to be_empty
+      # assign a valid source path
+      adapter.assign(tiff_path)
+      expect(adapter.assigned).to include tiff_path
+    end
+
+    it "will fail to assign file in non registered dir" do
+      adapter = described_class.new(work)
+      # need a non-registered file that exists:
+      bad_path = File.expand_path("../../spec_helper.rb", fixture_path)
+      expect { adapter.assign(bad_path) }.to raise_error(SecurityError)
+    end
+
+    it "queues a file:/// URI" do
+      adapter = described_class.of(work)
+      expect(adapter.assigned).to be_empty
+      adapter.assign(tiff_uri)
+      expect(adapter.assigned).to include tiff_uri
+    end
+
+    it "queues a Pathname, normalized to string" do
+      adapter = described_class.of(work)
+      expect(adapter.assigned).to be_empty
+      adapter.assign(Pathname.new(tiff_path))
+      expect(adapter.assigned).to include tiff_path
+    end
+
+    it "unqueues a queued path" do
+      adapter = described_class.of(work)
+      adapter.assign(tiff_path)
+      expect(adapter.assigned).to include tiff_path
+      adapter.unassign(tiff_path)
+      expect(adapter.assigned).to be_empty
+    end
+  end
+
+  describe "hash/mapping-like file enumeration" do
+    it "has expected WorkFile in values for work" do
+      adapter = described_class.of(work)
+      values = adapter.values
+      expect(values).to be_an Array
+      expect(values.size).to eq 1
+      expect(values[0]).to be_an IiifPrint::Data::WorkFile
+      expect(values[0].parent).to be adapter
+      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
+      expect(values[0].fileset).to eq first_fileset
+      expect(values[0].unwrapped).to be_a Hydra::PCDM::File
+    end
+
+    it "has expected fileset keys for work" do
+      adapter = described_class.of(work)
+      keys = adapter.keys
+      expect(keys).to be_an Array
+      expect(keys[0]).to be_a String
+      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
+      expect(keys[0]).to eq first_fileset.id
+    end
+
+    it "has expected entries for work" do
+      adapter = described_class.of(work)
+      entries = adapter.entries
+      expect(entries).to be_an Array
+      expect(entries[0]).to be_an Array
+      expect(entries[0].size).to eq 2
+      expect(entries[0][0]).to eq adapter.keys[0]
+      expect(entries[0][1]).to eq adapter.values[0]
+    end
+
+    it "gets work file by fileset id" do
+      adapter = described_class.of(work)
+      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
+      fsid = adapter.keys[0]
+      expect(fsid).to eq first_fileset.id
+      work_file = adapter.get(fsid)
+      expect(work_file.unwrapped).to eq first_fileset.original_file
+      work_file = adapter[fsid]
+      expect(work_file.unwrapped).to eq first_fileset.original_file
+    end
+
+    it "gets work file by work-local filename" do
+      adapter = described_class.of(work)
+      first_fileset = work.members.detect { |m| m.is_a?(FileSet) }
+      name = first_fileset.original_file.original_name
+      work_file = adapter.get(name)
+      expect(work_file).to eq adapter.get(first_fileset.id)
+    end
+
+    it "verifies inclusion of fileset id key" do
+      adapter = described_class.of(work)
+      fsid = adapter.keys[0]
+      expect(adapter.include?(fsid)).to be true
+    end
+  end
+
+  describe "assignment state" do
+    it "has empty state for work with no files" do
+      bare_work = MyWork.new
+      bare_work.title = ['No files to see here']
+      bare_work.save!
+      adapter = described_class.of(bare_work)
+      expect(adapter.keys.empty?).to be true
+      expect(adapter.state).to eq 'empty'
+    end
+
+    it "has 'dirty' state when files assigned" do
+      adapter = described_class.of(work)
+      expect(adapter.state).to eq 'saved'
+      adapter.assign(tiff_path)
+      # changes to dirty
+      expect(adapter.state).to eq 'dirty'
+      # unassign path again to empty assigned queue:
+      adapter.unassign(tiff_path)
+      # no we are back to 'saved' since no changes are queued now:
+      expect(adapter.state).to eq 'saved'
+    end
+  end
+
+  describe "commits changes" do
+    # We need to register these jobs to run now, at minimum:
+    do_now_jobs = [IngestLocalFileJob, IngestJob, InheritPermissionsJob]
+    # These we skip: [CharacterizeJob, CreateDerivativesJob]
+    #   -- skipping these saves 10-15 seconds on attachment example
+
+    permission_methods = [
+      :edit_users,
+      :read_users,
+      :discover_users,
+      :edit_groups,
+      :read_groups,
+      :discover_groups
+    ]
+
+    let(:bare_work) do
+      bare_work = MyWork.new
+      bare_work.title = ['No files to see here']
+      bare_work.save!
+      bare_work
+    end
+
+    it "commits unassign (file deletions)" do
+      adapter = described_class.of(work)
+      expect(adapter.keys.size).to eq 1
+      adapter.unassign(adapter.keys[0])
+      adapter.commit!
+      expect(adapter.keys.size).to eq 0
+      expect(work.members.to_a.count { |m| m.is_a? FileSet }).to eq 0
+    end
+
+    context "when it is a new work" do
+      it "commit for assignment invokes actor stack" do
+        work = MyWork.new(title: ['Just a new work'])
+        adapter = described_class.of(work)
+        adapter.assign(tiff_path)
+        allow(Hyrax::CurationConcern.actor).to receive(:create).and_return(true)
+        expect(Hyrax::CurationConcern.actor).to receive(:create)
+        expect(adapter.commit!).to be true
+      end
+    end
+
+    context "when the work already exists" do
+      it "commit for assignment invokes actor stack" do
+        work = bare_work
+        adapter = described_class.of(work)
+        adapter.assign(tiff_path)
+        allow(Hyrax::CurationConcern.actor).to receive(:update).and_return(true)
+        expect(Hyrax::CurationConcern.actor).to receive(:update)
+        expect(adapter.commit!).to be true
+      end
+    end
+
+    xit "commits successful file attachment", perform_enqueued: do_now_jobs do
+      work = bare_work
+      adapter = described_class.of(work)
+      adapter.assign(tiff_path)
+      adapter.commit!
+      # registered jobs (do_now_jobs) performed as effect of commit!
+      #   are configured to effectively run inline. Reloading work
+      #   should refresh the work.members, and by consequence adapter.keys
+      work.reload
+      expect(adapter.keys.size).to eq 1
+      expect(work.members.to_a.count { |m| m.is_a? FileSet }).to eq 1
+      expect(adapter.names).to include 'ocr_gray.tiff'
+    end
+
+    xit "copies work perimssions to fileset", perform_enqueued: do_now_jobs do
+      adapter = described_class.of(bare_work)
+      adapter.assign(tiff_path)
+      adapter.commit!
+      bare_work.reload
+      fileset = bare_work.members.detect { |m| m.is_a?(FileSet) }
+      permission_methods.each do |m|
+        expect(fileset.send(m)).to match_array bare_work.send(m)
+      end
+      expect(fileset.visibility).to eq bare_work.visibility
+    end
+  end
+
+  describe "derivative access" do
+    it "gets derivatives for first fileset" do
+      fileset = work.members.detect { |m| m.is_a?(FileSet) }
+      adapter = described_class.of(work)
+      # adapts same context(s):
+      expect(adapter.derivatives.fileset.id).to eq fileset.id
+      expect(adapter.derivatives.work).to be work
+      expect(adapter.derivatives.class).to eq \
+        IiifPrint::Data::WorkDerivatives
+      # transitive parent/child relationship, can traverse to adapter from
+      # derivatives:
+      expect(adapter.derivatives.parent.parent).to be adapter
+    end
+  end
+end

data/spec/iiif_print/image_tool_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe IiifPrint::ImageTool do
+  let(:fixtures) { File.join(IiifPrint::GEM_PATH, 'spec/fixtures/files') }
+
+  # Image fixtures to test identification, metadata extraction for:
+  let(:gray_jp2) { File.join(fixtures, 'ocr_gray.jp2') }
+  let(:color_jp2) { File.join(fixtures, '4.1.07.jp2') }
+  let(:gray_tiff) { File.join(fixtures, 'ocr_gray.tiff') }
+  let(:mono_tiff) { File.join(fixtures, 'ocr_mono.tiff') }
+  let(:color_tiff) { File.join(fixtures, '4.1.07.tiff') }
+  let(:pdf) { File.join(fixtures, 'minimal-1-page.pdf') }
+
+  describe "Extracts metadata with JP2 backend" do
+    it "constructs with a path" do
+      identify = described_class.new(gray_jp2)
+      expect(identify.path).to eq gray_jp2
+    end
+
+    it "gets metadata for grayscale JP2 image" do
+      result = described_class.new(gray_jp2).metadata
+      expect(result[:color]).to eq 'gray'
+      expect(result[:width]).to eq 418
+      expect(result[:height]).to eq 1046
+      expect(result[:bits_per_component]).to eq 8
+      expect(result[:num_components]).to eq 1
+    end
+
+    it "gets metadata for color JP2 image" do
+      result = described_class.new(color_jp2).metadata
+      expect(result[:color]).to eq 'color'
+      expect(result[:width]).to eq 256
+      expect(result[:height]).to eq 256
+      expect(result[:bits_per_component]).to eq 8
+      # e.g. is 3, but would be four if sample image had an alpha channel
+      expect(result[:num_components]).to eq 3
+    end
+  end
+
+  describe "Extracts metadata for non-JP2 images with imagemagick" do
+    it "gets metadata for gray TIFF image" do
+      result = described_class.new(gray_tiff).metadata
+      expect(result[:color]).to eq 'gray'
+      expect(result[:width]).to eq 418
+      expect(result[:height]).to eq 1046
+      expect(result[:bits_per_component]).to eq 8
+      expect(result[:num_components]).to eq 1
+    end
+
+    it "gets metadata for monochrome TIFF image" do
+      result = described_class.new(mono_tiff).metadata
+      expect(result[:color]).to eq 'monochrome'
+      expect(result[:width]).to eq 1261
+      expect(result[:height]).to eq 1744
+      expect(result[:bits_per_component]).to eq 1
+      expect(result[:num_components]).to eq 1
+    end
+
+    it "gets metadata for color TIFF image" do
+      result = described_class.new(color_tiff).metadata
+      expect(result[:color]).to eq 'color'
+      expect(result[:width]).to eq 256
+      expect(result[:height]).to eq 256
+      expect(result[:bits_per_component]).to eq 8
+      # e.g. is 3, but would be four if sample image had an alpha channel
+      expect(result[:num_components]).to eq 3
+    end
+
+    it "detects mime type of pdf" do
+      result = described_class.new(pdf).metadata
+      expect(result[:content_type]).to eq 'application/pdf'
+    end
+  end
+
+  describe "converts images" do
+    it "makes a monochrome TIFF from JP2" do
+      tool = described_class.new(gray_jp2)
+      dest = File.join(Dir.mktmpdir, 'mono.tif')
+      tool.convert(dest, true)
+      expect(File.exist?(dest)).to be true
+      expect(described_class.new(dest).metadata[:color]).to eq 'monochrome'
+    end
+
+    it "makes a gray TIFF from JP2" do
+      tool = described_class.new(gray_jp2)
+      dest = File.join(Dir.mktmpdir, 'gray.tif')
+      tool.convert(dest, false)
+      expect(File.exist?(dest)).to be true
+      expect(described_class.new(dest).metadata[:color]).to eq 'gray'
+    end
+
+    it "makes a monochrome TIFF from grayscale TIFF" do
+      tool = described_class.new(gray_tiff)
+      dest = File.join(Dir.mktmpdir, 'mono.tif')
+      tool.convert(dest, true)
+      expect(File.exist?(dest)).to be true
+      expect(described_class.new(dest).metadata[:color]).to eq 'monochrome'
+    end
+
+    # Not yet supported to use this tool to make JP2, for now the only
+    #   component in IiifPrint doing that is
+    #   IiifPrint::JP2DerivativeService
+    it "raises error on JP2 destination" do
+      expect { described_class.new(gray_tiff).convert('out.jp2') }.to \
+        raise_error(RuntimeError)
+    end
+  end
+end

data/spec/iiif_print/jobs/child_works_from_pdf_job_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe IiifPrint::Jobs::ChildWorksFromPdfJob do
+  # TODO: add specs
+  let(:work) { WorkWithIiifPrintConfig.new(title: ['required title']) }
+  let(:my_user) { build(:user) }
+  let(:uploaded_pdf_file) { create(:uploaded_pdf_file) }
+  let(:uploaded_file_ids) { [uploaded_pdf_file.id] }
+  let(:pdf_paths) do
+    uploads = Hyrax::UploadedFile.find(uploaded_file_ids)
+    upload_paths = uploads.map { |upload| upload.file.file.file }
+    upload_paths.select { |path| path.end_with?('.pdf', '.PDF') }
+  end
+  let(:admin_set_id) { "admin_set/default" }
+  let(:prior_pdfs) { 0 }
+
+  let(:subject) { described_class.perform(work, paths, user, admin_set_id, prior_pdfs) }
+
+  describe '#perform' do
+    xit 'calls pdf splitter service with path' do
+    end
+
+    xit 'submits one BatchCreateJob per PDF' do
+    end
+
+    xit 'submits IiifPrint::Jobs::CreateRelationshipsJob' do
+    end
+  end
+end

data/spec/iiif_print/jobs/create_relationships_job_spec.rb

@@ -0,0 +1,17 @@
+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 }
+
+  let(:subject) { described_class.perform(user: my_user, parent_id: parent.id, parent_model: parent_model, child_model: child_model) }
+
+  describe '#perform' do
+    xit 'loads all child work ids into ordered_members' do
+    end
+  end
+end

data/spec/iiif_print/jp2_image_metadata_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe IiifPrint::JP2ImageMetadata do
+  let(:fixtures) { File.join(IiifPrint::GEM_PATH, 'spec/fixtures/files') }
+
+  let(:gray_jp2) { File.join(fixtures, 'ocr_gray.jp2') }
+
+  let(:color_jp2) { File.join(fixtures, '4.1.07.jp2') }
+
+  describe "Extracts technical metadata from a JP2 file" do
+    it "constructs with a path" do
+      meta = described_class.new(gray_jp2)
+      expect(meta.path).to eq gray_jp2
+    end
+
+    it "gets metadata for grayscale image" do
+      meta = described_class.new(gray_jp2)
+      result = meta.technical_metadata
+      expect(result[:color]).to eq 'gray'
+      expect(result[:width]).to eq 418
+      expect(result[:height]).to eq 1046
+      expect(result[:bits_per_component]).to eq 8
+      expect(result[:num_components]).to eq 1
+    end
+
+    it "gets metadata for color image" do
+      meta = described_class.new(color_jp2)
+      result = meta.technical_metadata
+      expect(result[:color]).to eq 'color'
+      expect(result[:width]).to eq 256
+      expect(result[:height]).to eq 256
+      expect(result[:bits_per_component]).to eq 8
+      # e.g. is 3, but would be four if sample image had an alpha channel
+      expect(result[:num_components]).to eq 3
+    end
+  end
+end

data/spec/iiif_print/lineage_service_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe IiifPrint::LineageService do
+  describe '.ancestor_ids_for' do
+    xit 'works'
+  end
+
+  describe '.descendent_file_set_ids_for' do
+    xit 'works'
+  end
+end

data/spec/iiif_print/metadata_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+RSpec.describe IiifPrint::Metadata do
+  let(:base_url) { "https://my.dev.test" }
+  let(:solr_document) { SolrDocument.new(attributes) }
+  let(:fields) do
+    metadata_fields.map do |field|
+      SampleField.new(
+        name: field.first,
+        label: Hyrax::Renderers::AttributeRenderer.new(field, nil).label,
+        options: field.last
+      )
+    end
+  end
+  let(:metadata_fields) do
+    {
+      title: {},
+      description: {},
+      date_modified: {}
+    }
+  end
+
+  SampleField = Struct.new(:name, :label, :options, keyword_init: true)
+
+  describe ".build_metadata_for" do
+    subject(:manifest_metadata) do
+      described_class.build_metadata_for(
+        work: solr_document,
+        version: version,
+        fields: fields,
+        current_ability: double(Ability),
+        base_url: base_url
+      )
+    end
+
+    context "for version 2 of the IIIF spec" do
+      let(:version) { 2 }
+
+      context "with a field that has some plain text" do
+        let(:attributes) { { "title_tesim" => ["My Awesome Title"] } }
+
+        it "maps the metadata accordingly" do
+          expect(manifest_metadata).to eq [
+            { "label" => "Title", "value" => ["My Awesome Title"] }
+          ]
+        end
+      end
+
+      context "with a field that contains a url string" do
+        let(:attributes) { { "description_tesim" => ["A url like https://www.example.com/, cool!"] } }
+
+        it "creates a link for the url string" do
+          expect(manifest_metadata).to eq [
+            { "label" => "Description",
+               "value" =>
+                [
+                  "A url like <a href='https://www.example.com/' target='_blank'>https://www.example.com/</a>, cool!"
+                ] }
+          ]
+        end
+      end
+
+      context "with a date" do
+        let(:attributes) { { "date_modified_dtsi" => "2011-11-11T11:11:11Z" } }
+
+        it "displays it just the date" do
+          expect(manifest_metadata).to eq [{ "label" => "Date modified", "value" => ["2011-11-11"] }]
+        end
+      end
+
+      context "with a faceted option" do
+        let(:metadata_fields) { { creator: { render_as: :faceted } } }
+        let(:attributes) { { "creator_tesim" => ["McAuthor, Arthur"] } }
+
+        it "adds a link to the faceted search" do
+          expect(manifest_metadata). to eq [
+            { "label" => "Creator",
+              "value" =>
+                ["<a href='#{base_url}/catalog?f%5Bcreator_sim%5D%5B%5D=McAuthor%2C+Arthur&locale=en'>McAuthor, Arthur</a>"] }
+          ]
+        end
+      end
+
+      context "when the work is apart of a collection" do
+        let(:metadata_fields) { { collection: {} } }
+        let(:collection_attributes) { { "id" => "321cba", "title_tesim" => ["My Cool Collection"] } }
+        let(:collection_solr_doc) { SolrDocument.new(collection_attributes) }
+        let(:attributes) { { "member_of_collection_ids_ssim" => "321cba" } }
+
+        it "renders a link to the collection" do
+          allow(Hyrax::CollectionMemberService).to receive(:run).and_return([collection_solr_doc])
+          expect(manifest_metadata).to eq [
+            { "label" => "Collection",
+              "value" => ["<a href='#{base_url}/collections/321cba'>My Cool Collection</a>"] }
+          ]
+        end
+      end
+    end
+
+    context "for version 3 of the IIIF spec", skip: "version 3 metadata not implemented yet" do
+      let(:version) { 3 }
+
+      it "maps the metadata accordingly" do
+        # NOTE: this assumes the I18n.locale is set as :en
+        expect(manifest_metadata).to eq [
+          { "label" => { "en" => ["Title"] }, "value" => { "none" => ["My Awesome Title"] } },
+          { "label" => { "en" => ["Description"] },
+            "value" => { "none" => ["This is and awesome description"] } },
+          { "label" => { "en" => ["Date modified"] }, "value" => { "none" => ["2011-11-11"] } },
+          { "label" => { "en" => ["Creator"] }, "value" => { "none" => ["McAuthor, Arthur"] } }
+        ]
+      end
+    end
+  end
+end

data/spec/iiif_print/split_pdfs/pages_into_images_service_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'misc_shared'
+
+RSpec.describe IiifPrint::SplitPdfs::PagesIntoImagesService do
+  # TODO: add specs
+end

data/spec/iiif_print/text_extraction/alto_reader_spec.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'spec_helper'
+
+RSpec.describe IiifPrint::TextExtraction::AltoReader do
+  let(:fixture_path) do
+    File.join(
+      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
+    )
+  end
+
+  let(:minimal_path) { File.join(fixture_path, 'minimal-alto.xml') }
+  let(:ndnp_alto_path) { File.join(fixture_path, 'ndnp-alto-sample.xml') }
+  let(:minimal) { File.read(minimal_path) }
+
+  let(:reader_minimal) { described_class.new(minimal) }
+  let(:reader_minimal_path) { described_class.new(minimal_path) }
+  let(:reader_ndnp) { described_class.new(ndnp_alto_path) }
+
+  describe "reads alto" do
+    it "loads ALTO source" do
+      expect(reader_minimal_path.source).to eq reader_minimal.source
+      expect(reader_minimal_path.source.size).to eq 1383
+      expect(reader_ndnp.source.size).to eq 1_050_876
+    end
+
+    it "loads document stream" do
+      expect(reader_minimal_path.doc_stream).to be_kind_of Nokogiri::XML::SAX::Document
+      expect(reader_minimal_path.doc_stream).to respond_to :text
+      expect(reader_minimal_path.doc_stream).to respond_to :words
+    end
+  end
+
+  describe "outputs text derivative formats" do
+    it "outputs plain text" do
+      # try simple flat text input
+      expect(reader_minimal.text).to eq "This is only a test."
+      expect(reader_minimal.text).to eq reader_minimal.doc_stream.text
+      # try more complex input
+      expect(reader_ndnp.text.size).to eq 30_519
+    end
+
+    it "passes args to WordCoordsBuilder and receives output" do
+      parsed = JSON.parse(reader_minimal.json)
+      expect(parsed['coords'].length).to be > 1
+      parsed = JSON.parse(reader_ndnp.json)
+      expect(parsed['coords'].size).to eq 2_125
+    end
+  end
+end

data/spec/iiif_print/text_extraction/hocr_reader_spec.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'nokogiri'
+require 'spec_helper'
+
+RSpec.describe IiifPrint::TextExtraction::HOCRReader do
+  let(:fixture_path) do
+    File.join(
+      IiifPrint::GEM_PATH, 'spec', 'fixtures', 'files'
+    )
+  end
+
+  let(:minimal_path) { File.join(fixture_path, 'ocr_mono_text_hocr.html') }
+  let(:minimal) { File.read(minimal_path) }
+
+  let(:reader_minimal) { described_class.new(minimal) }
+  let(:reader_minimal_path) { described_class.new(minimal_path) }
+
+  describe "reads hOCR" do
+    it "loads hOCR either from path or source text" do
+      expect(reader_minimal_path.source).to eq reader_minimal.source
+      # size here is in Unicode characters, not bytes:
+      expect(reader_minimal_path.source.size).to eq 16_590
+    end
+
+    it "loads document stream" do
+      expect(reader_minimal_path.doc_stream).to be_kind_of Nokogiri::XML::SAX::Document
+      expect(reader_minimal_path.doc_stream).to respond_to :text
+      expect(reader_minimal_path.doc_stream).to respond_to :words
+    end
+  end
+
+  describe "outputs text derivative formats" do
+    it "outputs plain text" do
+      plain_text = reader_minimal.text
+      expect(plain_text.slice(0, 40)).to eq "_A  FEARFUL  ADVENTURE.\n‘The  Missouri. "
+      expect(reader_minimal.text).to eq reader_minimal.doc_stream.text
+      expect(reader_minimal.text.size).to eq 831
+    end
+
+    it "passes args to WordCoordsBuilder and receives output" do
+      parsed = JSON.parse(reader_minimal.json)
+      expect(parsed['coords'].length).to be > 1
+    end
+  end
+end