newspaper_works 0.1.0

data/app/services/newspaper_works/jp2_derivative_service.rb

@@ -0,0 +1,120 @@
+require 'open3'
+
+module NewspaperWorks
+  class JP2DerivativeService < NewspaperPageDerivativeService
+    # OpenJPEG 2000 Command to make NDNP-compliant grayscale JP2:
+    CMD_GRAY = 'opj_compress -i %<source_file>s -o %<out_file>s ' \
+              '-d 0,0 -b 64,64 -n 6 -p RLCP -t 1024,1024 -I -M 1 ' \
+              '-r 64,53.821,45.249,40,32,26.911,22.630,20,16,14.286,' \
+              '11.364,10,8,6.667,5.556,4.762,4,3.333,2.857,2.500,2,' \
+              '1.667,1.429,1.190,1'.freeze
+
+    # OpenJPEG 2000 Command to make RGB JP2:
+    CMD_COLOR = 'opj_compress -i %<source_file>s -o %<out_file>s ' \
+                '-d 0,0 -b 64,64 -n 6 -p RPCL -t 1024,1024 -I -M 1 '\
+                '-r 2.4,1.48331273,.91673033,.56657224,.35016049,.21641118,' \
+                '.13374944,.0944,.08266171'.freeze
+
+    # OpenJPEG 1.x command replacement for 2.x opj_compress, takes same options;
+    #   this is necessary on Ubuntu Trusty (e.g. Travis CI)
+    CMD_1X = 'image_to_j2k'.freeze
+
+    # Target file extension of this service plugin:
+    TARGET_EXT = 'jp2'.freeze
+
+    attr_accessor :source_meta
+    attr_reader :file_set
+    delegate :uri, :mime_type, to: :file_set
+
+    def initialize(file_set)
+      # cached result string for imagemagick `identify` command
+      @source_meta = nil
+      @command = nil
+      @unlink_after_creation = []
+      super(file_set)
+    end
+
+    def create_derivatives(filename)
+      # Base class takes care of loading @source_path, @dest_path
+      super(filename)
+
+      # no creation if jp2 master => deemed unnecessary/duplicative
+      return if mime_type == 'image/jp2'
+
+      # if we have a non-TIFF source, or a 1-bit monochrome source, we need
+      #   to make a NetPBM-based intermediate (temporary) file for OpenJPEG
+      #   to consume.
+      needs_intermediate = !tiff_source? || one_bit?
+
+      # We use either intermediate temp file, or temp symlink (to work
+      #   around OpenJPEG 2000 file naming quirk).
+      needs_intermediate ? make_intermediate_source : make_symlink
+
+      # Get OpenJPEG command, rendered with source, destination, appropriate
+      #   to either color or grayscale source
+      render_cmd = opj_command
+
+      # Run the generated command to make derivative file at @dest_path
+      `#{render_cmd}`
+
+      # Clean up any intermediate files or symlinks used during creation
+      cleanup_intermediate
+    end
+
+    private
+
+      # source introspection:
+
+      def tiff_source?
+        identify.include?('TIFF')
+      end
+
+      def make_symlink
+        # OpenJPEG binaries have annoying quirk of only using TIFF input
+        #   files whose name ends in .TIF or .tif (three letter); for all
+        #   non-monochrome TIFF files, we just assume we need to symlink
+        #   to such a filename.
+        tmpname = File.join(Dir.tmpdir, "#{SecureRandom.uuid}.tif")
+        FileUtils.ln_s(@source_path, tmpname)
+        @unlink_after_creation.push(tmpname)
+        # finally, point @source_path for command at intermediate link:
+        @source_path = tmpname
+      end
+
+      def make_intermediate_source
+        # generate a random filename to be made, with appropriate extension,
+        #   inside /tmp dir:
+        tmpname = File.join(
+          Dir.tmpdir,
+          format(
+            "#{SecureRandom.uuid}.%<ext>s",
+            ext: use_color? ? 'ppm' : 'pgm'
+          )
+        )
+        # if pdf source, get only first page
+        source_path = @source_path
+        source_path += '[0]' if @source_path.ends_with?('pdf')
+        # Use ImageMagick `convert` to create intermediate bitmap:
+        `convert #{source_path} #{tmpname}`
+        @unlink_after_creation.push(tmpname)
+        # finally, point @source_path for command at intermediate file:
+        @source_path = tmpname
+      end
+
+      def opj_command
+        # Get a command template appropriate to OpenJPEG 1.x or 2.x
+        use_openjpeg_1x = `which opj_compress`.empty?
+        cmd = use_color? ? CMD_COLOR : CMD_GRAY
+        cmd = cmd.sub('opj_compress', 'image_to_j2k') if use_openjpeg_1x
+        # return command with source and destination file names injected
+        format(cmd, source_file: @source_path, out_file: @dest_path)
+      end
+
+      def cleanup_intermediate
+        # remove symlink or intermediate file once we no longer need
+        @unlink_after_creation.each do |path|
+          FileUtils.rm(path)
+        end
+      end
+  end
+end

data/app/services/newspaper_works/newspaper_page_derivative_service.rb

@@ -0,0 +1,91 @@
+module NewspaperWorks
+  # Base type for derivative services specific to NewspaperPage only
+  class NewspaperPageDerivativeService
+    attr_reader :file_set, :master_format
+    delegate :uri, :mime_type, to: :file_set
+
+    TARGET_EXT = nil
+
+    def self.target_ext
+      self::TARGET_EXT
+    end
+
+    def initialize(file_set)
+      @file_set = file_set
+      @dest_path = nil
+      @source_path = nil
+      @source_meta = nil
+    end
+
+    def valid?
+      parent = file_set.in_works[0]
+      # fallback to Fedora-stored relationships if work's aggregation of
+      #   file set is not indexed in Solr
+      parent = file_set.member_of.select(&:work?)[0] if parent.nil?
+      parent.class == NewspaperPage
+    end
+
+    def derivative_path_factory
+      Hyrax::DerivativePath
+    end
+
+    # prepare full path for passed extension/destination name, return path
+    def prepare_path(extension)
+      dest_path = derivative_path_factory.derivative_path_for_reference(
+        @file_set,
+        extension
+      )
+      dir = File.join(dest_path.split('/')[0..-2])
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      dest_path
+    end
+
+    # calculate and ensure directory components for singular @dest_path
+    #   should only be used by subclasses producing a single derivative
+    def load_destpath
+      @dest_path = prepare_path(self.class.target_ext)
+    end
+
+    def identify
+      if @source_meta.nil?
+        path = @source_path
+        cmd = "identify #{path}"
+        # fallback to graphicsmagick if source is jp2, as Ubuntu 16.10
+        #   ImageMagick has no jp2 support.
+        cmd = 'gm ' + cmd if path.ends_with?('jp2')
+        Open3.popen3(cmd) do |_stdin, stdout, _stderr, _wait_thr|
+          @source_meta = stdout.read
+        end
+      end
+      @source_meta
+    end
+
+    def use_color?
+      # imagemagick `identify` output describes color space:
+      !(identify.include?('Gray') || one_bit?)
+    end
+
+    # is source one-bit monochrome?
+    def one_bit?
+      identify.include?('1-bit')
+    end
+
+    def create_derivatives(filename)
+      # presuming that filename is full path to source file
+      @source_path = filename
+
+      # Get destination path from Hyrax for file extension defined in
+      #   TARGET_EXT constant on respective derivative service subclass.
+      load_destpath
+    end
+
+    def cleanup_derivatives(*args)
+      target_ext = args && args[0] ? args[0] : self.class.target_ext
+      derivative_path_factory.derivatives_for_reference(file_set).each do |path|
+        FileUtils.rm_f(path) if path.ends_with?(target_ext)
+      end
+    end
+
+    # def cleanup_derivatives; end
+  end
+end

data/app/services/newspaper_works/pdf_derivative_service.rb

@@ -0,0 +1,45 @@
+require 'open3'
+
+module NewspaperWorks
+  class PDFDerivativeService < NewspaperPageDerivativeService
+    TARGET_EXT = 'pdf'.freeze
+
+    # PDF (JPEG, 8 bit grayscale), 150ppi
+    GRAY_PDF_CMD = 'convert %<source_file>s ' \
+                   '-resize 1800 -density 150 ' \
+                   '-depth 8 -colorspace Gray ' \
+                   '-compress jpeg %<out_file>s'.freeze
+
+    # sRBG color PDF (JPEG, 8 bits per channel), 150ppi
+    COLOR_PDF_CMD = 'convert %<source_file>s ' \
+                    '-resize 1800 -density 150 ' \
+                    '-depth 8 ' \
+                    '-compress jpeg %<out_file>s'.freeze
+
+    # graphicsmagick prefix, may be needed for jp2 source on Ubuntu
+    GM_PREFX = 'gm '.freeze
+
+    def initialize(file_set)
+      super(file_set)
+    end
+
+    # Get conversion command; command varies on whether or not we have
+    #   JP2 source, and whether we have color or grayscale material.
+    def convert_cmd
+      template = use_color? ? COLOR_PDF_CMD : GRAY_PDF_CMD
+      cmd = format(template, source_file: @source_path, out_file: @dest_path)
+      @source_path.ends_with?('jp2') ? GM_PREFIX + cmd : cmd
+    end
+
+    def create_derivatives(filename)
+      # Base class takes care of loading @source_path, @dest_path
+      super(filename)
+
+      # no creation if pdf master
+      return if mime_type == 'application/pdf'
+
+      # Get and run imagemagick or graphicsmagick command
+      `#{convert_cmd}`
+    end
+  end
+end

data/app/services/newspaper_works/pluggable_derivative_service.rb

@@ -0,0 +1,114 @@
+# General derivative service for NewspaperWorks, which is meant to wrap
+#   and replace the stock Hyrax::FileSetDerivativeService with a proxy
+#   that runs one or more derivative service "plugin" components.
+#
+#   Note: Hyrax::DerivativeService consumes this, instead of (directly)
+#   consuming Hyrax::FileSetDerivativeService.
+#
+#   Unlike the "run the first valid plugin" arrangement that the
+#   Hyrax::DerivativeService uses to run an actual derivative creation
+#   service component, this component is:
+#
+#   (a) Consumed by Hyrax::DerivativeService as that first valid plugin;
+#
+#   (b) Wraps and runs 0..* plugins, not just the first.
+#
+# This should be registered to take precedence over default by:
+#   Hyrax::DerivativeService.services.unshift(
+#     NewspaperWorks::PluggableDerivativeService
+#   )
+#
+#   Modify NewspaperWorks::PluggableDerivativeService.plugins
+#   to add, remove, or reorder plugin (derivative service) classes.
+#
+class NewspaperWorks::PluggableDerivativeService
+  attr_reader :file_set
+  delegate :uri, :mime_type, to: :file_set
+
+  # default plugin Hyrax OOTB, makes thumbnails and sometimes extracts text:
+  default_plugin = Hyrax::FileSetDerivativesService
+
+  # make and expose an array of plugins
+  @plugins = [default_plugin]
+  @allowed_methods = [:cleanup_derivatives, :create_derivatives]
+  class << self
+    attr_accessor :plugins, :allowed_methods
+  end
+
+  def plugins
+    self.class.plugins
+  end
+
+  def initialize(file_set)
+    @file_set = file_set
+  end
+
+  def valid?
+    # this wrapper/proxy/composite is always valid, but it may compose
+    #   multiple plugins, some of which may or may not be valid, so
+    #   validity checks happen within as well.
+    true
+  end
+
+  def respond_to_missing?(method_name)
+    self.class.allowed_methods.include?(method_name) || super
+  end
+
+  # get derivative services relevant to method name and file_set context
+  #   -- omits plugins if particular destination exists or will soon.
+  def services(method_name)
+    result = plugins.map { |plugin| plugin.new(file_set) }.select(&:valid?)
+    result.select do |plugin|
+      dest = nil
+      dest = plugin.class.target_ext if plugin.class.respond_to?(:target_ext)
+      !skip_destination?(method_name, dest)
+    end
+  end
+
+  def method_missing(name, *args, **opts, &block)
+    if respond_to_missing?(name)
+      # we have an allowed method, construct services and include all valid
+      #   services for the file_set
+      # services = plugins.map { |plugin| plugin.new(file_set) }.select(&:valid?)
+      # run all valid services, in order:
+      services(name).each do |plugin|
+        plugin.send(name, *args)
+      end
+    else
+      super
+    end
+  end
+
+  private
+
+    def skip_destination?(method_name, destination_name)
+      return false if file_set.id.nil? || destination_name.nil?
+      return false unless method_name == :create_derivatives
+      # skip :create_derivatives if existing --> do not re-create
+      existing_derivative?(destination_name) ||
+        impending_derivative?(destination_name)
+    end
+
+    def existing_derivative?(name)
+      path = derivative_path_factory.derivative_path_for_reference(
+        file_set,
+        name
+      )
+      File.exist?(path)
+    end
+
+    # is there an impending attachment from ingest logged to db?
+    #   -- avoids stomping over pre-made derivative
+    #      for which an attachment is still in-progress.
+    def impending_derivative?(name)
+      result = NewspaperWorks::DerivativeAttachment.find_by(
+        fileset_id: file_set.id,
+        destination_name: name
+      )
+      !result.nil?
+    end
+
+    def derivative_path_factory
+      Hyrax::DerivativePath
+    end
+end

data/app/services/newspaper_works/text_extraction_derivative_service.rb

@@ -0,0 +1,56 @@
+module NewspaperWorks
+  class TextExtractionDerivativeService < NewspaperPageDerivativeService
+    def initialize(file_set)
+      super(file_set)
+      @alto_path = nil
+      @txt_path = nil
+    end
+
+    def create_derivatives(src)
+      from_alto = NewspaperWorks::TextFormatsFromALTOService.new(
+        file_set
+      )
+      return from_alto.create_derivatives(src) unless from_alto.alto_path.nil?
+      create_derivatives_from_ocr(src)
+    end
+
+    def create_derivatives_from_ocr(filename)
+      @source_path = filename
+      # prepare destination directory for ALTO (as .xml files):
+      @alto_path = prepare_path('xml')
+      # prepare destination directory for plain text (as .txt files):
+      @txt_path = prepare_path('txt')
+      # prepare destination directory for flat JSON (as .json files):
+      @json_path = prepare_path('json')
+      ocr = NewspaperWorks::TextExtraction::PageOCR.new(filename)
+      # OCR will run once, on first method call to either .alto or .plain:
+      write_plain_text(ocr.plain)
+      write_alto(ocr.alto)
+      write_json(ocr.word_json)
+    end
+
+    def write_alto(xml)
+      File.open(@alto_path, 'w') do |outfile|
+        outfile.write(xml)
+      end
+    end
+
+    def write_plain_text(text)
+      File.open(@txt_path, 'w') do |outfile|
+        outfile.write(text)
+      end
+    end
+
+    def write_json(text)
+      File.open(@json_path, 'w') do |outfile|
+        outfile.write(text)
+      end
+    end
+
+    def cleanup_derivatives
+      super('txt')
+      super('xml')
+      super('json')
+    end
+  end
+end

data/app/services/newspaper_works/text_formats_from_alto_service.rb

@@ -0,0 +1,77 @@
+module NewspaperWorks
+  # Plugin to make text format derviatives (JSON, plain-text) from ALTO,
+  #   either existing derivative, or an impending attachment.
+  #   NOTE: to keep this from conflicting with TextExtractionDerivativeService,
+  #         this class should be invoked by it, not PluggableDerivativeService.
+  class TextFormatsFromALTOService < NewspaperPageDerivativeService
+    TARGET_EXT = 'tiff'.freeze
+
+    def save_derivative(destination, data)
+      # Load/prepare base of "pairtree" dir structure for extension, fileset
+      prepare_path(destination)
+      #
+      save_path = derivative_path_factory.derivative_path_for_reference(
+        @file_set,
+        destination
+      )
+      # Write data as UTF-8 encoded text
+      File.open(save_path, "w:UTF-8") do |f|
+        f.write(data)
+      end
+    end
+
+    def nonempty_file?(path)
+      return false if path.nil?
+      return false unless File.exist?(path)
+      !File.size(path).zero?
+    end
+
+    # if there was no derivative yet, there might be one in-transit from
+    #   an ingest, so check for that, and use its source if applicable:
+    def incoming_alto_path
+      path = NewspaperWorks::DerivativeAttachment.where(
+        fileset_id: @file_set.id,
+        destination_name: 'xml'
+      ).pluck(:path).uniq.first
+      path if nonempty_file?(path)
+    end
+
+    def alto_path
+      # check first for existing, non-empty derivative data:
+      path = derivative_path_factory.derivative_path_for_reference(
+        @file_set,
+        'xml'
+      )
+      return path if nonempty_file?(path)
+      incoming_alto_path
+    end
+
+    def alto
+      path = alto_path
+      File.read(path, encoding: 'UTF-8') unless path.nil?
+    end
+
+    def create_derivatives(_filename)
+      # as this plugin makes derivatives of derivative, _filename is ignored
+      source_file = alto
+      return if source_file.nil?
+      # Image width from characterized primary file helps ensure proper scaling:
+      file = @file_set.original_file
+      width = file.nil? ? nil : file.width[0].to_i
+      height = file.nil? ? nil : file.height[0].to_i
+      # ALTOReader is responsible for transcoding, this class just saves result
+      reader = NewspaperWorks::TextExtraction::AltoReader.new(
+        source_file,
+        width,
+        height
+      )
+      save_derivative('json', reader.json)
+      save_derivative('txt', reader.text)
+    end
+
+    def cleanup_derivatives(*args)
+      # do nothing here; NewspaperWorks::TextExtractionDerivativeService
+      # has this job instead for cleaning ALTO, JSON, TXT.
+    end
+  end
+end

data/app/services/newspaper_works/tiff_derivative_service.rb

@@ -0,0 +1,54 @@
+require 'open3'
+
+module NewspaperWorks
+  class TIFFDerivativeService < NewspaperPageDerivativeService
+    TARGET_EXT = 'tiff'.freeze
+
+    # For imagemagick commands, the output type is determined by the
+    #   output file's extension.
+    # TIFF (LZW, 8 bit grayscale)
+    GRAY_CMD = 'convert %<source_file>s ' \
+               '-depth 8 -colorspace Gray ' \
+               '-compress lzw %<out_file>s'.freeze
+
+    # Monochrome one-bit black/white TIFF, Group 4 compressed:
+    MONO_CMD = 'convert %<source_file>s ' \
+               '-depth 1 -monochrome -compress Group4 -type bilevel ' \
+               '%<out_file>s'.freeze
+
+    # sRBG color TIFF (8 bits per channel, lzw)
+    COLOR_CMD = 'convert %<source_file>s ' \
+                '-depth 24 ' \
+                '-compress lzw %<out_file>s'.freeze
+
+    # graphicsmagick prefix, may be needed for jp2 source on Ubuntu
+    GM_PREFX = 'gm '.freeze
+
+    def initialize(file_set)
+      super(file_set)
+    end
+
+    # Get conversion command; command varies on whether or not we have
+    #   JP2 source, and whether we have color or grayscale material.
+    def convert_cmd
+      source_path = @source_path
+      source_path += '[0]' if @source_path.ends_with?('pdf')
+      template = use_color? ? COLOR_CMD : GRAY_CMD
+      template = MONO_CMD if one_bit?
+      cmd = format(template, source_file: source_path, out_file: @dest_path)
+      # normalization of command based on source
+      @source_path.ends_with?('jp2') ? GM_PREFIX + cmd : cmd
+    end
+
+    def create_derivatives(filename)
+      # Base class takes care of loading @source_path, @dest_path
+      super(filename)
+
+      # no creation if pdf master
+      return if mime_type == 'image/tiff'
+
+      # Get and run imagemagick or graphicsmagick command
+      `#{convert_cmd}`
+    end
+  end
+end

data/app/validators/newspaper_works/publication_date_start_end_validator.rb

@@ -0,0 +1,48 @@
+module NewspaperWorks
+  # validates start and end date are properly formatted and end date comes after
+  # or on the same date as the start date.
+  class PublicationDateStartEndValidator < ActiveModel::Validator
+    DATE_RANGE_REGEX = /\A\d{4}(-((0[1-9])|(1[0-2])))?(-(([0-2][1-9])|3[0-1]))?\z/
+
+    def validate(record)
+      start_date = record.publication_date_start
+      end_date = record.publication_date_end
+      valid_dates?(start_date, end_date, record) && start_before_end?(start_date, end_date, record)
+    end
+
+    private
+
+      def publication_date_valid?(pub_date)
+        return false unless DATE_RANGE_REGEX.match(pub_date)
+        date_split = pub_date.split("-").map(&:to_i)
+        return false if date_split.length == 3 &&
+                        !Date.valid_date?(date_split[0], date_split[1], date_split[2])
+        true
+      end
+
+      def start_before_end?(start_date, end_date, record)
+        return true unless start_date && end_date
+        date_error = "Publication start date must be earlier or the same as end date."
+        pub_start = start_date.split("-")
+        pub_end = end_date.split("-")
+        (0..2).each do |i|
+          if pub_start[i] && pub_end[i] && pub_end[i] < pub_start[i]
+            record.errors[:publication_date_start] << date_error
+            break
+          end
+        end
+        record.errors[:publication_date_start].blank?
+      end
+
+      def valid_dates?(start_date, end_date, record)
+        date_error = "Incorrect Date. Date input should be formatted yyyy[-mm][-dd] and be a valid date."
+        if start_date
+          record.errors[:publication_date_start] << date_error unless publication_date_valid?(start_date)
+        end
+        if end_date
+          record.errors[:publication_date_end] << date_error unless publication_date_valid?(end_date)
+        end
+        record.errors[:publication_date_start].blank? && record.errors[:publication_date_end].blank?
+      end
+  end
+end

data/app/validators/newspaper_works/publication_date_validator.rb

@@ -0,0 +1,16 @@
+module NewspaperWorks
+  # validates that a properly formatted date has been entered
+  class PublicationDateValidator < ActiveModel::Validator
+    DATE_REGEX = /\A\d{4}-((0[1-9])|(1[0-2]))-((0[1-9])|([1-2][0-9])|(3[0-1]))\z/
+    def validate(record)
+      error_msg = "Incorrect Date. Date input should be formatted yyyy-mm-dd and be a valid date."
+      return unless record.publication_date.present?
+      unless DATE_REGEX.match(record.publication_date)
+        record.errors[:publication_date] << error_msg
+        return
+      end
+      date_split = record.publication_date.split("-").map(&:to_i)
+      record.errors[:publication_date] << error_msg unless Date.valid_date?(date_split[0], date_split[1], date_split[2])
+    end
+  end
+end

data/app/views/catalog/_index_gallery_newspaper_article_wrapper.html.erb

@@ -0,0 +1,9 @@
+<div class="document col-xs-6 col-md-3">
+  <div class="thumbnail" data-fileset="<%= document.file_set_ids&.first %>" data-query="<%= highlight_matches(document, 'all_text_tsimv', 'em') || search_query(current_search_session.query_params) %>">
+    <%= render_newspaper_thumbnail_tag(document,
+                                       current_search_session.query_params) %>
+    <div class="caption">
+      <%= render_document_partials document, blacklight_config.view_config(:gallery).partials, :document_counter => document_counter %>
+    </div>
+  </div>
+</div>

data/app/views/catalog/_index_gallery_newspaper_page_wrapper.html.erb

@@ -0,0 +1,9 @@
+<div class="document col-xs-6 col-md-3">
+  <div class="thumbnail" data-fileset="<%= document.file_set_ids&.first %>" data-query="<%= highlight_matches(document, 'all_text_tsimv', 'em') || search_query(current_search_session.query_params) %>">
+    <%= render_newspaper_thumbnail_tag(document,
+                                       current_search_session.query_params) %>
+    <div class="caption">
+      <%= render_document_partials document, blacklight_config.view_config(:gallery).partials, :document_counter => document_counter %>
+    </div>
+  </div>
+</div>

data/app/views/catalog/_index_header_gallery_newspaper_article.html.erb

@@ -0,0 +1,23 @@
+<%# based on blacklight/app/views/catalog/_index_header_default.html.erb %>
+<%# header bar for doc items in index view -%>
+<div class="documentHeader row">
+  <%# main title container for doc partial view
+      How many bootstrap columns need to be reserved
+      for bookmarks control depends on size.
+  -%>
+  <% document_actions = capture do %>
+      <% # bookmark functions for items/docs -%>
+      <%= render_index_doc_actions document, wrapping_class: "index-document-functions col-sm-3 col-lg-2" %>
+  <% end %>
+  <h3 class="index_title document-title-heading <%= document_actions.present? ? "col-sm-9 col-lg-10" : "col-md-12" %>">
+    <% if counter = document_counter_with_offset(document_counter) %>
+      <span class="document-counter">
+        <%= t('blacklight.search.documents.counter', counter: counter) %>
+      </span>
+    <% end %>
+    <%= link_to document.title_or_label,
+                hyrax_newspaper_article_path(document.id,
+                                             anchor: iiif_search_anchor(current_search_session.query_params)) %>
+  </h3>
+  <%= document_actions %>
+</div>