iiif_print 1.0.0 → 2.0.0

data/lib/samvera/derivatives/hyrax.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Samvera
+  module Derivatives
+    # The default behavior of {Hyrax::FileSetDerivativesService} is to create a derivative and then
+    # apply it to the FileSet.  This module wraps that behavior such that we can leverage the
+    # {Samvera::Derivatives} module and interfaces to handle cases where some of the derivatives
+    # already exist.
+    module Hyrax
+      # @note This conforms to the {Hyrax::DerivativeService} interface.  The intention of this
+      #       class is to be the sole registered {Hyrax::DerivativeService.services}
+      class ServiceShim
+        # @param file_set [FileSet]
+        # @param candidate_derivative_types [Array<Symbol>] the possible types of derivatives that
+        #        we could create for this file_set.
+        # @param config [#registry_for]
+        #
+        # @todo We will want some kind of lambda to determine the candidate_derivative_types for this
+        #       file_set.
+        def initialize(file_set, candidate_derivative_types: [], config: Samvera::Derivatives.config)
+          @file_set = file_set
+          @config = config
+          @derivatives = candidate_derivative_types.map { |type| config.registry_for(type: type) }
+        end
+
+        attr_reader :file_set
+
+        # @return [Array<Samvera::Derivatives::Configuration::RegisteredType>]
+        attr_reader :derivatives
+        attr_reader :config
+
+        def valid?
+          # We have a file set, which also means a parent work.  I believe we always want this to be
+          # valid, because we want to leverage the locator/applicator behavior instead of the
+          # implicit work.
+          true
+        end
+
+        def cleanup_derivatives; end
+
+        # We have two vectors of consideration for derivative generation:
+        #
+        # - The desired derivatives for a file_set's parent work (e.g. the candidate derivatives)
+        # - The available derivatives for a file_set's mime type
+        def create_derivatives(file_path)
+          derivatives.each do |derivative|
+            Samvera::Derivatives.locate_and_apply_derivative_for(
+              file_set: file_set,
+              file_path: file_path,
+              derivative: derivative
+            )
+          end
+        end
+
+        def derivative_url(_destination_name)
+          ""
+        end
+      end
+
+      class FileApplicatorStrategy < Samvera::Derivatives::FileApplicator::Strategy
+        # With this set to true, we're telling the applicator to use the from_location
+        # (e.g. {Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper}) to apply the
+        # derivatives.
+        self.delegate_apply_to_given_from_location = true
+      end
+
+      class FileLocatorStrategy < Samvera::Derivatives::FileLocator::Strategy
+        # Implements {Samvera::Derivatives::FileLocator::Strategy} interface.
+        #
+        # @see Samvera::Derivatives::FileLocator::Strategy
+        #
+        # @return [Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper]
+        def self.locate(file_set:, file_path:, **)
+          file_set.samvera_derivatives_default_from_location_wrapper(file_path: file_path)
+        end
+      end
+
+      class FileSetDerivativesServiceWrapper
+        class_attribute :wrapped_derivative_service_class, default: ::Hyrax::FileSetDerivativesService
+
+        # @param file_set [FileSet]
+        # @param file_path [String]
+        def initialize(file_set:, file_path:)
+          @file_set = file_set
+          @file_path = file_path
+          @wrapped_derivative_service = wrapped_derivative_service_class.new(file_set)
+        end
+        attr_reader :file_set, :wrapped_derivative_service, :file_path
+
+        # @see Samvera::Derivatives::FileLocator.call
+        def present?
+          true
+        end
+
+        # @see Samvera::Derivatives::FileApplicator::Strategy
+        def apply!(*)
+          # Why the short-circuit? By the nature of the underlying
+          # ::Hyrax::FileSetDerivativesService, we generate multiple derivatives in one pass.  But
+          # with the implementation of Samvera::Derivatives, we declare the derivatives and then
+          # iterate on locating and applying them.  With this short-circuit, we will only apply the
+          # derivatives once.
+          return true if defined?(@already_applied)
+
+          return false unless wrapped_derivative_service.valid?
+
+          wrapped_derivative_service.create_derivatives(file_path)
+          @already_applied = true
+        end
+      end
+
+      ##
+      # The purpose of this module is to preserve the existing Hyrax derivative behavior while also
+      # allowing for the two-step tango of locator and applicator.
+      #
+      # @see Samvera::Derivatives.locate_and_apply_derivative_for
+      module FileSetDecorator
+        # @return [Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper]
+        def samvera_derivatives_default_from_location_wrapper(file_path:)
+          @samvera_derivatives_default_from_location_wrapper ||=
+            Samvera::Derivatives::Hyrax::FileSetDerivativesServiceWrapper.new(file_set: self, file_path: file_path)
+        end
+      end
+    end
+  end
+end
+
+# TODO: We are likely going to want that.
+# Hyrax::DerivativeService.services = [Samvera::Derivatives::Hyrax::ServiceShim]
+FileSet.prepend(Samvera::Derivatives::Hyrax::FileSetDecorator)

data/lib/samvera/derivatives.rb

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

data/tasks/copy_authorities_to_test_app.rake

@@ -0,0 +1,11 @@
+namespace :engine_cart do
+  desc "Copy custom rights_statement and license questioning authority YAML files into the test app"
+  task copy_authorities: :generate do
+    test_app_path = ENV['ENGINE_CART_DESTINATION'] || File.expand_path(".internal_test_app", File.dirname(__FILE__))
+    src_dir = File.expand_path("../spec/fixtures/authorities", __dir__)
+    dest_dir = File.join(test_app_path, "config/authorities")
+
+    FileUtils.mkdir_p(dest_dir)
+    FileUtils.cp_r("#{src_dir}/.", dest_dir)
+  end
+end

data/tasks/iiif_print_dev.rake

@@ -20,14 +20,14 @@ task :spec_with_app_load do
 end
 
 if ENV.fetch('IN_DOCKER', false)
-  desc 'Generate the engine_cart and spin up test servers and run specs'
-  task ci: %w[rubocop engine_cart:generate] do
+  desc 'Generate the engine_cart, copy authorities and spin up test servers and run specs'
+  task ci: %w[rubocop engine_cart:generate engine_cart:copy_authorities] do
     puts 'running continuous integration'
     Rake::Task['spec'].invoke
   end
 else
-  desc 'Generate the engine_cart and spin up test servers and run specs'
-  task ci: %w[rubocop engine_cart:generate] do
+  desc 'Generate the engine_cart, copy authorities and spin up test servers and run specs'
+  task ci: %w[rubocop engine_cart:generate engine_cart:copy_authorities] do
     puts 'running continuous integration'
     Rake::Task['spec_with_app_load'].invoke
   end