iiif_print 1.0.0 → 2.0.0

data/lib/iiif_print/metadata.rb

@@ -17,48 +17,43 @@ module IiifPrint
       @base_url = base_url
     end
 
-    attr_reader :work, :version, :fields
+    attr_reader :work, :version, :fields, :current_ability
 
     def build_metadata
-      send("build_metadata_for_v#{version}")
-    end
-
-    private
-
-    def build_metadata_for_v2
       fields.map do |field|
-        label = Hyrax::Renderers::AttributeRenderer.new(field.name, nil).label
-        if field.name == :collection && member_of_collection?
-          viewable_collections = Hyrax::CollectionMemberService.run(work, @current_ability)
-          next if viewable_collections.empty?
-          { 'label' => label,
-            'value' => make_collection_link(viewable_collections) }
-        else
-          next if field_is_empty?(field)
-          { 'label' => label,
-            'value' => cast_to_value(field_name: field.name, options: field.options) }
+        values = values_for(field_name: field)
+        if field.name == :collection && member_of_collection? && viewable_collections.present?
+          { 'label' => metadata_map(field, :label),
+            'value' => metadata_map(field, :collection) }
+        elsif values.present? && !empty_string?(values)
+          { 'label' => metadata_map(field, :label),
+            'value' => metadata_map(field, :value) }
         end
       end.compact
     end
 
-    def build_metadata_for_v3
-      fields.map do |field|
-        values = Array(work.try(field.name)).map { |value| scrub(value.to_s) }
-        next if values.empty?
-        {
-          'label' => {
-            # Since we're using I18n to translate the field, we're setting the locale used in the translation.
-            I18n.locale.to_s => [Hyrax::Renderers::AttributeRenderer.new(field.name, nil).label]
-          },
-          'value' => {
-            'none' => values
-          }
-        }
-      end.compact
+    private
+
+    def metadata_map(field, property)
+      if version == 2
+        case property
+        when :label      then field.label
+        when :value      then cast_to_value(field_name: field.name, options: field.options)
+        when :collection then make_collection_link(viewable_collections)
+        end
+      elsif version == 3
+        case property
+        when :label      then { I18n.locale.to_s => [field.label] }
+        when :value      then { 'none' => cast_to_value(field_name: field.name, options: field.options) }
+        when :collection then { 'none' => make_collection_link(viewable_collections) }
+        end
+      end
     end
 
-    def field_is_empty?(field)
-      Array(work.try(field.name)).empty?
+    # Bulkrax imports values as [""] if there isn't a value but still a header,
+    # these fields should not show in the metadata pane
+    def empty_string?(values)
+      values.uniq.size == 1 ? values.first == "" : false
     end
 
     def member_of_collection?
@@ -71,21 +66,41 @@ module IiifPrint
 
     def cast_to_value(field_name:, options:)
       if options&.[](:render_as) == :faceted
-        values_for(field_name: field_name).map do |value|
-          search_field = field_name.to_s + "_sim"
-          path = Rails.application.routes.url_helpers.search_catalog_path(
-            "f[#{search_field}][]": value, locale: I18n.locale
-          )
-          path += '&include_child_works=true' if work["is_child_bsi"] == true
-          "<a href='#{File.join(@base_url, path)}'>#{value}</a>"
-        end
+        faceted_values_for(field_name: field_name)
+      elsif qa_field?(field_name: options&.dig(:render_as) || field_name)
+        authority_values_for(field_name: field_name)
       else
         make_link(values_for(field_name: field_name))
       end
     end
 
+    def faceted_values_for(field_name:)
+      values_for(field_name: field_name).map do |value|
+        search_field = field_name.to_s + "_sim"
+        path = Rails.application.routes.url_helpers.search_catalog_path(
+          "f[#{search_field}][]": value, locale: I18n.locale
+        )
+        path += '&include_child_works=true' if work["is_child_bsi"] == true
+        "<a href='#{File.join(@base_url, path)}'>#{value}</a>"
+      end
+    end
+
+    def qa_field?(field_name:, questioning_authority_fields: IiifPrint.config.questioning_authority_fields)
+      questioning_authority_fields.include?(field_name.to_s)
+    end
+
+    def authority_values_for(field_name:)
+      authority = Qa::Authorities::Local.subauthority_for(field_name.to_s.pluralize)
+      values_for(field_name: field_name).map do |value|
+        id, term = authority.find(value).values_at('id', 'term')
+        "<a href='#{id}'>#{term}</a>"
+      end
+    end
+
     def values_for(field_name:)
-      Array(work.send(field_name))
+      field_name = field_name.try(:name) || field_name
+      # TODO: we are assuming tesim or dtsi (for dates), might want to account for other suffixes in the future
+      Array(work["#{field_name}_tesim"] || work["#{field_name}_dtsi"]&.to_date.try(:to_formatted_s, :standard))
     end
 
     def make_collection_link(collection_documents)
@@ -94,11 +109,16 @@ module IiifPrint
       end
     end
 
-    # @note This method turns link looking strings into links
+    def viewable_collections
+      Hyrax::CollectionMemberService.run(SolrDocument.find(work.id), current_ability)
+    end
+
+    # @note This method turns link looking strings into links and assumes https if not protocol was given
     def make_link(texts)
       texts.map do |t|
         t.to_s.gsub(MAKE_LINK_REGEX) do |url|
-          "<a href='#{url}' target='_blank'>#{url}</a>"
+          protocol = url.start_with?('www.') ? 'https://' : ''
+          "<a href='#{protocol}#{url}' target='_blank'>#{url}</a>"
         end
       end
     end
@@ -106,10 +126,9 @@ module IiifPrint
     MAKE_LINK_REGEX = %r{
       \b
       (
-        (?: [a-z][\w-]+:
-          (?: /{1,3} | [a-z0-9%] ) |
-            www\d{0,3}[.] |
-            [a-z0-9.\-]+[.][a-z]{2,4}/
+        (?:
+          (?:https?://) |
+          (?:www\.)
         )
         (?:
           [^\s()<>]+ | \(([^\s()<>]+|(\([^\s()<>]+\)))*\)

data/lib/iiif_print/pdf_derivative_service.rb

@@ -24,7 +24,9 @@ module IiifPrint
     #   JP2 source, and whether we have color or grayscale material.
     def convert_cmd
       template = use_color? ? COLOR_PDF_CMD : GRAY_PDF_CMD
-      format(template, source_file: @source_path, out_file: @dest_path)
+      data = format(template, source_file: @source_path, out_file: @dest_path)
+      IiifPrint.copy_derivatives_from_data_store(stream: data, directives: { url: file_set.id.to_s, container: 'service_file', mime_type: mime_type_for(target_extension) })
+      data
     end
 
     def create_derivatives(filename)

data/lib/iiif_print/persistence_layer/active_fedora_adapter.rb

@@ -0,0 +1,189 @@
+module IiifPrint
+  module PersistenceLayer
+    class ActiveFedoraAdapter < AbstractAdapter
+      ##
+      # @param object [ActiveFedora::Base]
+      # @return [Array<SolrDocument>]
+      def self.object_in_works(object)
+        object.in_works
+      end
+
+      ##
+      # @param object [ActiveFedora::Base]
+      # @return [Array<SolrDocument>]
+      def self.object_ordered_works(object)
+        object.ordered_works
+      end
+
+      ##
+      # @param work_type [Class<ActiveFedora::Base>]
+      # @return indexer for the given :work_type
+      def self.decorate_with_adapter_logic(work_type:)
+        work_type.send(:include, IiifPrint::SetChildFlag) unless work_type.included_modules.include?(IiifPrint::SetChildFlag)
+        work_type.indexer
+      end
+
+      ##
+      # @param work_type [Class<ActiveFedora::Base>]
+      # @return indexer for the given :work_type
+      def self.decorate_form_with_adapter_logic(work_type:)
+        work_type.indexer
+      end
+
+      ##
+      # Return the immediate parent of the given :file_set.
+      #
+      # @param file_set [FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no parent is found.
+      def self.parent_for(file_set)
+        # fallback to Fedora-stored relationships if work's aggregation of
+        #   file set is not indexed in Solr
+        file_set.parent || file_set.member_of.find(&:work?)
+      end
+
+      ##
+      # Return the parent's parent of the given :file_set.
+      #
+      # @param file_set [FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no grand parent is found.
+      def self.grandparent_for(file_set)
+        parent_of_file_set = parent_for(file_set)
+        # HACK: This is an assumption about the file_set structure, namely that an image page split from
+        # a PDF is part of a file set that is a child of a work that is a child of a single work.  That
+        # is, it only has one grand parent.  Which is a reasonable assumption for IIIF Print but is not
+        # valid when extended beyond IIIF Print.  That is GenericWork does not have a parent method but
+        # does have a parents method.
+        parent_of_file_set.try(:parent_works).try(:first) ||
+          parent_of_file_set.try(:parents).try(:first) ||
+          parent_of_file_set&.member_of&.find(&:work?)
+      end
+
+      def self.solr_construct_query(*args)
+        if defined?(Hyrax::SolrQueryBuilderService)
+          Hyrax::SolrQueryBuilderService.construct_query(*args)
+        else
+          ActiveFedora::SolrQueryBuilder.construct_query(*args)
+        end
+      end
+
+      def self.clean_for_tests!
+        super do
+          ActiveFedora::Cleaner.clean!
+        end
+      end
+
+      def self.solr_query(query, **args)
+        if defined?(ActiveFedora::SolrService)
+          ActiveFedora::SolrService.query(query, **args)
+        else
+          Hyrax::SolrService.query(query, **args)
+        end
+      end
+
+      def self.solr_name(field_name)
+        if defined?(Hyrax) && Hyrax.config.respond_to?(:index_field_mapper)
+          Hyrax.config.index_field_mapper.solr_name(field_name.to_s)
+        else
+          ::ActiveFedora.index_field_mapper.solr_name(field_name.to_s)
+        end
+      end
+
+      ##
+      # @param file_set [Object]
+      # @param work [Object]
+      # @param model [Class] The class name for which we'll split children.
+      def self.destroy_children_split_from(file_set:, work:, model:, **_args)
+        # look first for children by the file set id they were split from
+        children = model.where(split_from_pdf_id: file_set.id)
+        if children.blank?
+          # find works where file name and work `to_param` are both in the title
+          children = model.where(title: file_set.label).where(title: work.to_param)
+        end
+        return if children.blank?
+        children.each do |rcd|
+          rcd.destroy(eradicate: true)
+        end
+        true
+      end
+
+      def self.pdf?(file_set)
+        file_set.class.pdf_mime_types.include?(file_set.mime_type)
+      end
+
+      ##
+      # Add a child record as a member of a parent record
+      #
+      # @param model [child_record] an ActiveFedora::Base model
+      # @param model [parent_record] an ActiveFedora::Base model
+      # @return [TrueClass]
+      def self.create_relationship_between(child_record:, parent_record:)
+        return true if parent_record.ordered_members.to_a.include?(child_record)
+        parent_record.ordered_members << child_record
+        true
+      end
+
+      ##
+      # find a work by title
+      # We should only find one, but there is no guarantee of that and `:where` returns an array.
+      #
+      # @param title [String]
+      # @param model [String] an ActiveFedora::Base model
+      def self.find_by_title_for(title:, model:)
+        work_type = model.constantize
+
+        work_type.where(title: title)
+      end
+
+      ##
+      # find a work or file_set
+      #
+      # @param id [String]
+      # @return [Array<ActiveFedora::Base]
+      def self.find_by(id:)
+        ActiveFedora::Base.find(id)
+      end
+
+      ##
+      # save a work
+      #
+      # @param object [Array<ActiveFedora::Base]
+      def self.save(object:)
+        object.save!
+      end
+
+      ##
+      # reindex an array of works and their file_sets
+      #
+      # @param objects [Array<ActiveFedora::Base]
+      # @return [TrueClass]
+      def self.index_works(objects:)
+        objects.each do |work|
+          work.update_index
+          work.file_sets.each(&:update_index) if work.respond_to?(:file_sets)
+        end
+        true
+      end
+
+      ##
+      # does nothing for ActiveFedora;
+      # allows valkyrie works to have an extra step to create the Hyrax::Metadata objects.
+      #
+      # @param []
+      # @return [TrueClass]
+      def self.copy_derivatives_from_data_store(*)
+        true
+      end
+
+      ##
+      # Extract text from the derivatives
+      #
+      # @param [FileSet] an ActiveFedora fileset
+      # @return [String] Text from fileset's file
+      def self.extract_text_for(file_set:)
+        IiifPrint.config.all_text_generator_function.call(object: file_set) || ''
+      end
+    end
+  end
+end

data/lib/iiif_print/persistence_layer/valkyrie_adapter.rb

@@ -0,0 +1,183 @@
+module IiifPrint
+  module PersistenceLayer
+    class ValkyrieAdapter < AbstractAdapter
+      ##
+      # @param object [Valkyrie::Resource]
+      # @return [Array<Valkyrie::Resource>]
+      def self.object_in_works(object)
+        Array.wrap(Hyrax.custom_queries.find_parent_work(resource: object))
+      end
+
+      ##
+      # @param object [Valkyrie::Resource]
+      # @return [Array<Valkyrie::Resource>]
+      def self.object_ordered_works(object)
+        child_file_sets = Hyrax.custom_queries.find_child_file_sets(resource: object).to_a
+        child_works = Hyrax.custom_queries.find_child_works(resource: object).to_a
+        child_works + child_file_sets
+      end
+
+      ##
+      # @param work_type [Class<Valkyrie::Resource>]
+      # @return the indexer for the given :work_type
+      def self.decorate_with_adapter_logic(work_type:)
+        work_type.send(:include, Hyrax::Schema(:child_works_from_pdf_splitting)) unless work_type.included_modules.include?(Hyrax::Schema(:child_works_from_pdf_splitting))
+        # TODO: Use `Hyrax::ValkyrieIndexer.indexer_class_for` once changes are merged.
+        indexer = "#{work_type}Indexer".constantize
+        indexer.send(:include, Hyrax::Indexer(:child_works_from_pdf_splitting)) unless indexer.included_modules.include?(Hyrax::Indexer(:child_works_from_pdf_splitting))
+        indexer
+      end
+
+      ##
+      # @param work_type [Class<ActiveFedora::Base>]
+      # @return form for the given :work_type
+      def self.decorate_form_with_adapter_logic(work_type:)
+        form = "#{work_type}Form".constantize
+        form.send(:include, Hyrax::FormFields(:child_works_from_pdf_splitting)) unless form.included_modules.include?(Hyrax::FormFields(:child_works_from_pdf_splitting))
+        form
+      end
+
+      ##
+      # Return the immediate parent of the given :file_set.
+      #
+      # @param file_set [Hyrax::FileMetadata or FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no parent is found.
+      def self.parent_for(file_set)
+        file_set = Hyrax.query_service.find_by(id: file_set.file_set_id) if file_set.is_a?(Hyrax::FileMetadata)
+        Hyrax.query_service.find_parents(resource: file_set).first
+      end
+
+      ##
+      # Return the parent's parent of the given :file_set.
+      #
+      # @param file_set [Hyrax::FileMetadata or FileSet]
+      # @return [#work?, Hydra::PCDM::Work]
+      # @return [NilClass] when no grand parent is found.
+      def self.grandparent_for(file_set)
+        parent = parent_for(file_set)
+        return nil unless parent
+        Hyrax.query_service.find_parents(resource: parent).first
+      end
+
+      def self.solr_construct_query(*args)
+        Hyrax::SolrQueryBuilderService.construct_query(*args)
+      end
+
+      def self.clean_for_tests!
+        # For Fedora backed repositories, we'll want to consider some cleaning mechanism.  For
+        # database backed repositories, we can rely on the database_cleaner gem.
+        raise NotImplementedError
+      end
+
+      def self.solr_query(query, **args)
+        Hyrax::SolrService.query(query, **args)
+      end
+
+      def self.solr_name(field_name)
+        Hyrax.config.index_field_mapper.solr_name(field_name.to_s)
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def self.destroy_children_split_from(file_set:, work:, model:, user:)
+        # rubocop:enable Lint/UnusedMethodArgument
+        # look for child records by the file set id they were split from
+        Hyrax.query_service.find_inverse_references_by(resource: file_set, property: :split_from_pdf_id, model: model).each do |child|
+          Hyrax.persister.delete(resource: child)
+          Hyrax.indexing_service.delete(resource: child)
+          Hyrax.publisher.publish('object.deleted', object: child, user: user)
+        end
+        true
+      end
+
+      def self.pdf?(file_set)
+        file_set.original_file.pdf?
+      end
+
+      ##
+      # Add a child record as a member of a parent record
+      #
+      # @param model [child_record] a Valkyrie::Resource model
+      # @param model [parent_record] a Valkyrie::Resource model
+      # @return [TrueClass]
+      def self.create_relationship_between(child_record:, parent_record:)
+        return true if parent_record.member_ids.include?(child_record.id)
+        parent_record.member_ids << child_record.id
+        true
+      end
+
+      ##
+      # find a work by title
+      # We should only find one, but there is no guarantee of that
+      # @param title [String]
+      # @param model [String] a Valkyrie::Resource model
+      # @return [Array<Valkyrie::Resource]
+      def self.find_by_title_for(title:, model:)
+        work_type = model.constantize
+        # TODO: This creates a hard dependency on Bulkrax because that is where this custom query is defined
+        #       Is this adequate?
+        Array.wrap(Hyrax.query_service.custom_query.find_by_model_and_property_value(model: work_type,
+                                                                                     property: :title,
+                                                                                     value: title))
+      end
+
+      ##
+      # find a work or file_set
+      #
+      # @param id [String]
+      def self.find_by(id:)
+        Hyrax.query_service.find_by(id: id)
+      end
+
+      ##
+      # save a work
+      #
+      # @param object [Array<Valkyrie::Resource]
+      def self.save(object:)
+        Hyrax.persister.save(resource: object)
+        Hyrax.index_adapter.save(resource: object)
+
+        Hyrax.publisher.publish('object.membership.updated', object: object, user: object.depositor)
+      end
+
+      ##
+      # reindex an array of works and their file_sets
+      #
+      # @param objects [Array<Valkyrie::Resource]
+      # @return [TrueClass]
+      def self.index_works(objects:)
+        objects.each do |work|
+          Hyrax.index_adapter.save(resource: work)
+          Hyrax.custom_queries.find_child_file_sets(resource: work).each do |file_set|
+            Hyrax.index_adapter.save(resource: file_set)
+          end
+        end
+        true
+      end
+
+      ##
+      # Performs an extra step to create the Hyrax::Metadata objects
+      # for derivatives.
+      #
+      # @param []
+      # @return [TrueClass]
+      def self.copy_derivatives_from_data_store(stream:, directives:)
+        Hyrax::ValkyriePersistDerivatives.call(stream, directives)
+      end
+
+      ##
+      # Extract text from the derivatives
+      #
+      # @param [Hyrax::FileSet] a Valkyrie fileset
+      # @return [String] Text from fileset's file
+      def self.extract_text_for(file_set:)
+        fm = Hyrax.custom_queries.find_many_file_metadata_by_use(resource: file_set,
+        use: Hyrax::FileMetadata::Use.uri_for(use: :extracted_file))
+        return if fm.empty?
+        text_fm = fm.find { |t| t.mime_type == Marcel::MimeType.for(extension: 'txt') }
+        return if text_fm.nil?
+        text_fm.content
+      end
+    end
+  end
+end

data/lib/iiif_print/persistence_layer.rb

@@ -0,0 +1,118 @@
+module IiifPrint
+  ##
+  # The PersistenceLayer module provides the namespace for other adapters:
+  #
+  # - {IiifPrint::PersistenceLayer::ActiveFedoraAdapter}
+  # - {IiifPrint::PersistenceLayer::ValkyrieAdapter}
+  #
+  # And the defining interface in the {IiifPrint::PersistenceLayer::AbstractAdapter}
+  module PersistenceLayer
+    # @abstract
+    class AbstractAdapter
+      ##
+      # @param object [Object]
+      # @return [Array<Object>]
+      def self.object_in_works(object)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param object [Object]
+      # @return [Array<Object>]
+      def self.object_ordered_works(object)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param work_type [Class]
+      # @return the corresponding indexer for the work_type
+      def self.decorate_with_adapter_logic(work_type:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param work_type [Class]
+      # @return the corresponding indexer for the work_type
+      def self.decorate_form_with_adapter_logic(work_type:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @param file_set [Object]
+      # @param work [Object]
+      # @param model [Class] The class name for which we'll split children.
+      def self.destroy_children_split_from(file_set:, work:, model:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.parent_for(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.grandparent_for(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.solr_field_query(*)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.clean_for_tests!
+        return false unless Rails.env.test?
+        yield
+      end
+
+      ##
+      # @abstract
+      def self.solr_query(*args)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      ##
+      # @abstract
+      def self.solr_name(*args)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.pdf?(_file_set)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.create_relationship_between(child_record:, parent_record:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.find_by_title_for(title:, model:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.find_by(id:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.save(object:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.index_works(objects:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.copy_derivatives_from_data_store(stream:, directives:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+
+      def self.extract_text_for(file_set:)
+        raise NotImplementedError, "#{self}.{__method__}"
+      end
+    end
+  end
+end