hydra-derivatives 2.0.0 → 3.0.0

data/lib/hydra/derivatives/{video → processors/video}/processor.rb

@@ -1,6 +1,6 @@
-module Hydra::Derivatives
+module Hydra::Derivatives::Processors
   module Video
-    class Processor < Hydra::Derivatives::Processor
+    class Processor < Hydra::Derivatives::Processors::Processor
       include Ffmpeg
 
       class_attribute :config
@@ -36,12 +36,6 @@ module Hydra::Derivatives
           raise ArgumentError, "Unknown format `#{format}'"
         end
       end
-
-      def new_mime_type(format)
-        format == "jpg" ? "image/jpeg" : "video/#{format}"
-      end
     end
   end
 end
-
-

data/lib/hydra/derivatives/runners/audio_derivatives.rb

@@ -0,0 +1,7 @@
+module Hydra::Derivatives
+  class AudioDerivatives < Runner
+    def self.processor_class
+      Processors::Audio
+    end
+  end
+end

data/lib/hydra/derivatives/runners/document_derivatives.rb

@@ -0,0 +1,7 @@
+module Hydra::Derivatives
+  class DocumentDerivatives < Runner
+    def self.processor_class
+      Processors::Document
+    end
+  end
+end

data/lib/hydra/derivatives/runners/full_text_extract.rb

@@ -0,0 +1,16 @@
+module Hydra::Derivatives
+  class FullTextExtract < ImageDerivatives
+    # Adds format: 'txt' as the default to each of the directives
+    def self.transform_directives(options)
+      options.each do |directive|
+        directive.reverse_merge!(format: 'txt')
+      end
+      options
+    end
+
+    def self.processor_class
+      Processors::FullText
+    end
+  end
+end
+

data/lib/hydra/derivatives/runners/image_derivatives.rb

@@ -0,0 +1,16 @@
+module Hydra::Derivatives
+  class ImageDerivatives < Runner
+
+    # Adds format: 'png' as the default to each of the directives
+    def self.transform_directives(options)
+      options.each do |directive|
+        directive.reverse_merge!(format: 'png')
+      end
+      options
+    end
+
+    def self.processor_class
+      Processors::Image
+    end
+  end
+end

data/lib/hydra/derivatives/runners/jpeg2k_image_derivatives.rb

@@ -0,0 +1,15 @@
+module Hydra::Derivatives
+  class Jpeg2kImageDerivatives < Runner
+    # # Adds format: 'png' as the default to each of the directives
+    # def self.transform_directives(options)
+    #   options.each do |directive|
+    #     directive.reverse_merge!(format: 'png')
+    #   end
+    #   options
+    # end
+
+    def self.processor_class
+      Processors::Jpeg2kImage
+    end
+  end
+end

data/lib/hydra/derivatives/runners/pdf_derivatives.rb

@@ -0,0 +1,6 @@
+module Hydra
+  module Derivatives
+    class PdfDerivatives < ImageDerivatives
+    end
+  end
+end

data/lib/hydra/derivatives/runners/runner.rb

@@ -0,0 +1,52 @@
+module Hydra
+  module Derivatives
+    class Runner
+
+      def self.output_file_service= val
+        @output_file_service = val
+      end
+
+      # Use the output service configured for this class or default to the global setting
+      def self.output_file_service
+        @output_file_service || Hydra::Derivatives.output_file_service
+      end
+
+      def self.source_file_service= val
+        @source_file_service = val
+      end
+
+      # Use the source service configured for this class or default to the global setting
+      def self.source_file_service
+        @source_file_service || Hydra::Derivatives.source_file_service
+      end
+
+
+      # @param [String, ActiveFedora::Base] object_or_filename path to the source file, or an object
+      # @param [Hash] options options to pass to the encoder
+      # @options options [Array] :outputs a list of desired outputs, each entry is a hash that has :label (optional), :format and :url
+      def self.create(object_or_filename, options)
+        source_file(object_or_filename, options) do |f|
+          transform_directives(options.delete(:outputs)).each do |instructions|
+            processor_class.new(f.path,
+                                instructions.merge(source_file_service: source_file_service),
+                                output_file_service: output_file_service).process
+          end
+        end
+      end
+
+      # Override this method if you need to add any defaults
+      def self.transform_directives(options)
+        options
+      end
+
+      def self.source_file(object_or_filename, options, &block)
+        source_file_service.call(object_or_filename, options, &block)
+      end
+
+      def self.processor_class
+        raise "Overide the processor_class method in a sub class"
+      end
+    end
+  end
+end
+

data/lib/hydra/derivatives/runners/video_derivatives.rb

@@ -0,0 +1,7 @@
+module Hydra::Derivatives
+  class VideoDerivatives < Runner
+    def self.processor_class
+      Processors::Video::Processor
+    end
+  end
+end

data/lib/hydra/derivatives/services/mime_type_service.rb

@@ -0,0 +1,10 @@
+require 'mime/types'
+
+module Hydra::Derivatives
+  module MimeTypeService
+    # @param [String] file_path path to a file
+    def self.mime_type(file_path)
+      MIME::Types.type_for(file_path).first.to_s
+    end
+  end
+end

data/lib/hydra/derivatives/services/persist_basic_contained_output_file_service.rb

@@ -2,7 +2,7 @@ module Hydra::Derivatives
   # This Service is an implementation of the Hydra::Derivatives::PeristOutputFileService
   # It supports basic contained files, which is the behavior associated with Fedora 3 file datastreams that were migrated to Fedora 4
   # and, at the time that this class was authored, corresponds to the behavior of ActiveFedora::Base.attach_file and ActiveFedora::Base.attached_files
-  ### Rename this 
+  ### Rename this
   class PersistBasicContainedOutputFileService < PersistOutputFileService
 
     # This method conforms to the signature of the .call method on Hydra::Derivatives::PeristOutputFileService
@@ -10,16 +10,31 @@ module Hydra::Derivatives
     #
     # NOTE: Uses basic containment. If you want to use direct containment (ie. with PCDM) you must use a different service (ie. Hydra::Works::AddFileToGenericFile Service)
     #
-    # @param [ActiveFedora::Base] object file is be persisted to
-    # @param [File] filestream to be added, should respond to :mime_type and :original_name
-    #   original_name will get used as the path for a chile resource in fedora, it is not a path to a file on disk.
-
-    def self.call(object, file, destination_path)
+    # @param [#read] stream the data to be persisted
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @option directives [String] url This can determine the path of the object.
+    def self.call(stream, directives)
+      file = Hydra::Derivatives::IoDecorator.new(stream, new_mime_type(directives.fetch(:format)))
       o_name = determine_original_name(file)
       m_type = determine_mime_type(file)
-      object.add_file(file, path: destination_path, mime_type: m_type, original_name: o_name)
-      object.save
+      uri = URI(directives.fetch(:url))
+      raise ArgumentError, "#{uri} is not an http uri" unless uri.scheme == 'http'
+      remote_file = ActiveFedora::File.new(uri.to_s)
+      remote_file.content = file
+      remote_file.mime_type = m_type
+      remote_file.original_name = o_name
+      remote_file.save
     end
 
+    def self.new_mime_type(format)
+      case format
+      when 'mp4'
+        'video/mp4' # default is application/mp4
+      when 'webm'
+        'video/webm' # default is audio/webm
+      else
+        MIME::Types.type_for(format).first.to_s
+      end
+    end
   end
 end

data/lib/hydra/derivatives/services/persist_output_file_service.rb

@@ -3,11 +3,10 @@ module Hydra::Derivatives
 
     # Persists the file within the object at destination_name.  Uses basic containment.
     # If you want to use direct containment (ie. with PCDM) you must use a different service (ie. Hydra::Works::AddFileToGenericFile Service)
-    # @param [Object] object the source file is attached to
-    # @param [File] filestream to be added, should respond to :mime_type, :original_name
-    # @param [String] destination_name is the fedora path at which the child resource will be found or created beneath the object.
-
-    def self.call(object, file, destination_path)
+    # @param [String] file_path the path to the file to be added
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @option directives [String] url This can determine the path of the object.
+    def self.call(file_path, directives)
       raise NotImplementedError, "PersistOutputFileService is an abstract class. Implement `call' on #{self.class.name}"
     end
 

data/lib/hydra/derivatives/services/retrieve_source_file_service.rb

@@ -2,11 +2,13 @@ module Hydra::Derivatives
   class RetrieveSourceFileService
 
     # Retrieves the source
-    # @param [Object] object the source file is attached to
-    # @param [String] method name that can be called on object to retrieve the source file
-
-    def self.call(object, source_name)
-      object.send(source_name)
+    # @param [ActiveFedora::Base] object the source file is attached to
+    # @param [Hash] options
+    # @option options [Symbol] :source a method that can be called on the object to retrieve the source file
+    # @yield [Tempfile] a temporary source file that has a lifetime of the block
+    def self.call(object, options, &block)
+      source_name = options.fetch(:source)
+      Hydra::Derivatives::TempfileService.create(object.send(source_name), &block)
     end
   end
-end
+end

data/spec/processors/full_text.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::Processors::FullText do
+  let(:file_path) { File.join(fixture_path, 'test.docx') }
+  let(:directives) { { format: 'txt', url: 'http://localhost:8983/fedora/rest/dev/1234/ogg' } }
+  let(:processor) { described_class.new(file_path, directives) }
+
+  describe "process" do
+    subject { processor.process }
+
+    context "when it is successful" do
+      before do
+        allow_any_instance_of(described_class).to receive(:fetch).and_return('{"":"one two three"}')
+      end
+      it { is_expected.to be true }
+    end
+
+    it 'extracts fulltext and stores the results' do
+      expect(processor.output_file_service).to receive(:call).with(/Project Charter for E-Content Delivery Platform Review/, directives)
+      processor.process
+    end
+  end
+
+  describe "fetch" do
+    subject { processor.send(:fetch) }
+    let(:request) { double }
+    let(:response_body) { 'returned by Solr' }
+    let(:resp) { double(code: '200', body: response_body) }
+    let(:uri) { URI('http://example.com:99/solr/update') }
+
+    before do
+      allow(processor).to receive(:uri).and_return(URI('http://example.com:99/solr/update'))
+      allow(Net::HTTP).to receive(:new).with('example.com', 99).and_return(request)
+    end
+
+    context "that is successful" do
+      let(:resp) { double(code: '200', body: response_body) }
+      it "calls the extraction service" do
+        expect(request).to receive(:post).with('http://example.com:99/solr/update', String, "Content-Type" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "Content-Length" => "24244").and_return(resp)
+        expect(subject).to eq response_body
+      end
+    end
+
+    context "that fails" do
+      let(:resp) { double(code: '500', body: response_body) }
+      it "raises an error" do
+        expect(request).to receive(:post).with('http://example.com:99/solr/update', String, "Content-Type" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "Content-Length" => "24244").and_return(resp)
+        expect { subject }.to raise_error RuntimeError, /Solr Extract service was unsuccessful. 'http:\/\/example\.com:99\/solr\/update' returned code 500 for .*spec\/fixtures\/test.docx\nreturned by Solr/
+      end
+    end
+  end
+
+  describe "uri" do
+    subject { processor.send(:uri) }
+
+    it "points at the extraction service" do
+      expect(subject).to be_kind_of URI
+      expect(subject.to_s).to end_with '/update/extract?extractOnly=true&wt=json&extractFormat=text'
+    end
+  end
+end

data/spec/{units → processors}/image_spec.rb

@@ -1,29 +1,19 @@
 require 'spec_helper'
 
-describe Hydra::Derivatives::Image do
-  let(:object) { ActiveFedora::Base.new }
+describe Hydra::Derivatives::Processors::Image do
   let(:output_file) { double }
+  let(:file_name) { double }
 
-  subject { Hydra::Derivatives::Image.new(object, 'content', directives)}
+  subject { described_class.new(file_name, directives) }
 
   before { allow(subject).to receive(:output_file).with(file_name).and_return(output_file) }
 
-  describe "when arguments are passed as a string" do
-    let(:directives) { { thumb: "100x100>" } }
-    let(:file_name) { 'content_thumb' }
-
-    it "should use the string as the size and the name is autogenerated" do
-      expect(subject).to receive(:create_resized_image).with(file_name, "100x100>", 'png')
-      subject.process
-    end
-  end
-
   describe "when arguments are passed as a hash" do
-    let(:directives) { { thumb: { size: "200x300>", datastream: file_name } } }
+    let(:directives) { { label: :thumb, size: "200x300>", format: 'png', quality: 75 } }
     let(:file_name) { 'thumbnail' }
 
-    it "should use the specified size and name" do
-      expect(subject).to receive(:create_resized_image).with(file_name, "200x300>", 'png')
+    it "uses the specified size and name and quality" do
+      expect(subject).to receive(:create_resized_image).with(file_name, "200x300>", 'png', 75)
       subject.process
     end
   end
@@ -39,7 +29,7 @@ describe Hydra::Derivatives::Image do
     context 'when set' do
       before do
         subject.timeout = 0.1
-        allow_any_instance_of(Hydra::Derivatives::Image).to receive(:process_without_timeout) { sleep 0.2 }
+        allow_any_instance_of(described_class).to receive(:process_without_timeout) { sleep 0.2 }
       end
       it 'raises a timeout exception' do
         expect { subject.process }.to raise_error Hydra::Derivatives::TimeoutError

data/spec/{units → processors}/jpeg2k_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 require 'yaml'
 
-describe Hydra::Derivatives::Jpeg2kImage do
+describe Hydra::Derivatives::Processors::Jpeg2kImage do
   let(:object) { ActiveFedora::Base.new }
 
   describe "#calculate_recipe" do
     it "calculates the number of levels from a size" do
       dim = 7200
-      expect(Hydra::Derivatives::Jpeg2kImage.level_count_for_size(dim)).to eq(6)
+      expect(described_class.level_count_for_size(dim)).to eq(6)
     end
 
     it "calculates the compression rates for each quality layer" do
       compression_num = 10
       layers = 8
-      calc = Hydra::Derivatives::Jpeg2kImage.layer_rates(layers, compression_num)
+      calc = described_class.layer_rates(layers, compression_num)
       expect(calc).to eq("2.4,1.48331273,0.91675694,0.56659885,0.3501847,0.21643059,0.13376427,0.0826726")
     end
 
@@ -27,28 +27,26 @@ describe Hydra::Derivatives::Jpeg2kImage do
 
     it "can get the recipe from a config file" do
       args = { recipe: :myrecipe }
-      r = Hydra::Derivatives::Jpeg2kImage.kdu_compress_recipe(args, 'grey', 7200)
+      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
       expect(r).to eq(@sample_cfg['jp2_recipes'][:myrecipe_grey])
     end
 
     it "can take a recipe as a string" do
       args = { recipe: '-my -excellent -recipe' }
-      r = Hydra::Derivatives::Jpeg2kImage.kdu_compress_recipe(args, 'grey', 7200)
+      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
       expect(r).to eq(args[:recipe])
     end
 
     it "will fall back to a #calculate_recipe if a symbol is passed but no recipe is found" do
       args = { recipe: :x }
-      r = Hydra::Derivatives::Jpeg2kImage.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(Hydra::Derivatives::Jpeg2kImage.calculate_recipe(args, 'grey', 7200))
+      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
+      expect(r).to eq(described_class.calculate_recipe(args, 'grey', 7200))
     end
 
     it "will fall back to a #calculate_recipe if there is no attempt to provide one" do
       args = {}
-      r = Hydra::Derivatives::Jpeg2kImage.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(Hydra::Derivatives::Jpeg2kImage.calculate_recipe(args, 'grey', 7200))
+      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
+      expect(r).to eq(described_class.calculate_recipe(args, 'grey', 7200))
     end
-
   end
-
 end

data/spec/processors/processor_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::Processors::Processor do
+
+  let(:object)        { "Fake Object"  }
+  let(:source_name)   { 'content' }
+  let(:directives)    { { thumb: "100x100>" } }
+  let(:file_path)     { double }
+
+  subject { described_class.new(file_path, directives)}
+
+  describe "output_file_service" do
+    let(:custom_output_file_service) { "fake service" }
+    let(:another_custom_output_file_service) { "another fake service" }
+
+    context "as a global configuration setting" do
+      before do
+        allow(Hydra::Derivatives).to receive(:output_file_service).and_return(custom_output_file_service)
+      end
+      it "utilizes the default output file service" do
+        expect(subject.output_file_service).to eq(custom_output_file_service)
+      end
+    end
+
+    context "as an instance level configuration setting" do
+      subject do
+        described_class.new('/opt/derivatives/foo.mp4', directives,
+                            output_file_service: another_custom_output_file_service)
+      end
+
+      it "accepts a custom output file service as an option" do
+        expect(subject.output_file_service).to eq(another_custom_output_file_service)
+      end
+    end
+  end
+end