hydra-derivatives 2.0.0 → 3.0.0

data/lib/hydra/derivatives/processor.rb

@@ -1,33 +0,0 @@
-module Hydra
-  module Derivatives
-    class Processor
-      attr_accessor :object, :source_name, :directives, :source_file_service, :output_file_service
-
-      def initialize(obj, source_name, directives, opts={})
-        self.object = obj
-        self.source_name = source_name
-        self.directives = directives
-        self.source_file_service = opts.fetch(:source_file_service, Hydra::Derivatives.source_file_service)
-        self.output_file_service = opts.fetch(:output_file_service, Hydra::Derivatives.output_file_service)
-      end
-
-      def process
-        raise "Processor is an abstract class. Implement `process' on #{self.class.name}"
-      end
-
-      def output_file_id(name)
-        [source_name, name].join('_')
-      end
-
-      # @deprecated Please use a PersistOutputFileService class to save an object
-      def output_file
-        raise NotImplementedError, "Processor is an abstract class. Utilize an implementation of a PersistOutputFileService class in #{self.class.name}"
-      end
-      
-      def source_file
-        @source_file ||= source_file_service.call(object, source_name)
-      end
-
-    end
-  end
-end

data/lib/hydra/derivatives/railtie.rb

@@ -1,9 +0,0 @@
-module Hydra
-  module Derivative
-    class Railtie < Rails::Railtie
-      initializer 'hydra-derivative' do
-        require 'hydra-file_characterization'
-      end
-    end
-  end
-end

data/lib/hydra/derivatives/raw_image.rb

@@ -1,45 +0,0 @@
-require 'mini_magick'
-
-module Hydra
-  module Derivatives
-    class RawImage < Image
-      class_attribute :timeout
-
-      protected
-
-      def create_image(destination_name, format, quality=nil)
-        xfrm = load_image_transformer
-        # Transpose format and scaling due to the fact that ImageMagick can
-        # read but not write RAW files and this will otherwise cause many
-        # cryptic segmentation faults
-        xfrm.format(format)
-        yield(xfrm) if block_given?
-        xfrm.quality(quality.to_s) if quality
-        write_image(destination_name, format, xfrm)
-        remove_temp_files(xfrm)
-      end
-
-      # Delete any temp files that might clutter up the disk if
-      # you are doing a batch or don't touch your temporary storage
-      # for a long time
-      def remove_temp_files(xfrm)
-        xfrm.destroy!
-      end
-
-      # Override this method if you want a different transformer, or # need to load the raw image from a different source (e.g.  
-      # external file).
-      #
-      # In this case always add an extension to help out MiniMagick
-      # with RAW files
-      def load_image_transformer
-        extension = MIME::Types[source_file.mime_type].first.extensions.first
-
-        if extension.present?
-          MiniMagick::Image.read(source_file.content, ".#{extension}")
-        else
-          MiniMagick::Image.read(source_file.content)
-        end
-      end
-    end
-  end
-end

data/lib/hydra/derivatives/shell_based_processor.rb

@@ -1,81 +0,0 @@
-# An abstract class for asyncronous jobs that transcode files using FFMpeg
-
-require 'tmpdir'
-require 'open3'
-
-module Hydra
-  module Derivatives
-    module ShellBasedProcessor
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :timeout
-        extend Open3
-      end
-
-      def process
-        directives.each do |name, args|
-          format = args[:format]
-          raise ArgumentError, "You must provide the :format you want to transcode into. You provided #{args}" unless format
-          # TODO if the source is in the correct format, we could just copy it and skip transcoding.
-          output_file_name = args[:datastream] || output_file_id(name)
-          encode_file(output_file_name, format, new_mime_type(format), options_for(format))
-        end
-      end
-
-      # override this method in subclass if you want to provide specific options.
-      # returns a hash of options that the specific processors use
-      def options_for(format)
-        {}
-      end
-
-      def encode_file(destination_name, file_suffix, mime_type, options)
-        out_file = nil
-        output_file = Dir::Tmpname.create(['sufia', ".#{file_suffix}"], Hydra::Derivatives.temp_file_base){}
-        Hydra::Derivatives::TempfileService.create(source_file) do |f|
-          self.class.encode(f.path, options, output_file)
-        end
-        out_file = Hydra::Derivatives::IoDecorator.new(File.open(output_file, "rb"))
-        out_file.mime_type = mime_type
-        output_file_service.call(object, out_file, destination_name)
-        File.unlink(output_file)
-      end
-
-      module ClassMethods
-
-        def execute(command)
-          context = {}
-          if timeout
-            execute_with_timeout(timeout, command, context)
-          else
-            execute_without_timeout(command, context)
-          end
-        end
-
-        def execute_with_timeout(timeout, command, context)
-          begin
-            status = Timeout::timeout(timeout) do
-              execute_without_timeout(command, context)
-            end
-          rescue Timeout::Error => ex
-            pid = context[:pid]
-            Process.kill("KILL", pid)
-            raise Hydra::Derivatives::TimeoutError, "Unable to execute command \"#{command}\"\nThe command took longer than #{timeout} seconds to execute"
-          end
-
-        end
-
-        def execute_without_timeout(command, context)
-          stdin, stdout, stderr, wait_thr = popen3(command)
-          context[:pid] = wait_thr[:pid]
-          stdin.close
-          out = stdout.read
-          stdout.close
-          err = stderr.read
-          stderr.close
-          raise "Unable to execute command \"#{command}\"\n#{err}" unless wait_thr.value.success?
-        end
-      end
-    end
-  end
-end

data/spec/lib/hydra/derivatives/extract_metadata_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module Hydra::Derivatives
-  describe ExtractMetadata do
-    let(:class_with_metadata_extraction) do
-      Class.new do
-        attr_reader :content, :mime_type, :uri
-
-        def initialize(options = {})
-          @content = options.fetch(:content, '')
-          @mime_uype = options.fetch(:mime_type, nil)
-          @uri = 'http://example.com/pid/123'
-        end
-
-        include Hydra::Derivatives::ExtractMetadata
-        def has_content?; content.present?; end
-      end
-    end
-
-    let(:initialization_options) { {content: 'abc', mime_type: 'text/plain'} }
-    subject { class_with_metadata_extraction.new(initialization_options) }
-
-    context '#extract_metadata' do
-      context 'without content' do
-        let(:initialization_options) { {content: '', mime_type: 'text/plain'} }
-        it 'should be nil' do
-          expect(subject.extract_metadata).to be_nil
-        end
-      end
-
-      context 'with content', unless: ENV['TRAVIS'] == 'true' do
-        let(:mime_type) { 'image/jpeg' }
-        it 'should get some XML' do
-          expect(subject.extract_metadata).to match "<identity format=\"Plain text\" mimetype=\"text/plain\""
-        end
-      end
-    end
-  end
-end

data/spec/units/extract_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-class ExtractThing < ActiveFedora::File
-  include Hydra::Derivatives::ExtractMetadata
-  attr_accessor :pid
-end
-
-describe Hydra::Derivatives::ExtractMetadata, :unless => $in_travis do
-  let(:subject) { ExtractThing.new('http://example.com/foo') }
-  let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
-
-  describe "Image Content" do
-    it "should get a mime type" do
-      subject.content = attachment
-      subject.pid = "abc"
-      xml = subject.extract_metadata
-      doc = Nokogiri::HTML(xml)
-      identity = doc.xpath('//identity').first
-      expect(identity.attr('mimetype')).to eq('image/png')
-    end
-  end
-end

data/spec/units/processor_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Processor do
-
-  let(:object)        { "Fake Object"  }
-  let(:source_name)   { 'content' }
-  let(:directives)    { { thumb: "100x100>" } }
-
-  subject { Hydra::Derivatives::Processor.new(object, source_name, directives)}
-
-  describe "source_file" do
-    it "relies on the source_file_service" do
-      expect(subject.source_file_service).to receive(:call).with(object, source_name)
-      subject.source_file
-    end
-  end
-
-  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 { Hydra::Derivatives::Processor.new(object, source_name, directives, output_file_service: another_custom_output_file_service)}
-      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
-
-  describe "source_file_service" do
-
-    let(:custom_source_file_service) { "fake service" }
-    let(:another_custom_source_file_service) { "another fake service" }
-
-    context "as a global configuration setting" do
-      before do
-        allow(Hydra::Derivatives).to receive(:source_file_service).and_return(custom_source_file_service)
-      end
-      it "utilizes the default source file service" do
-        expect(subject.source_file_service).to eq(custom_source_file_service)
-      end
-    end
-
-    context "as an instance level configuration setting" do
-      subject { Hydra::Derivatives::Processor.new(object, source_name, directives, source_file_service: another_custom_source_file_service)}
-      it "accepts a custom source file service as an option" do
-        expect(subject.source_file_service).to eq(another_custom_source_file_service)
-      end
-    end
-  end
-
-end

data/spec/units/shell_based_processor_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-
-describe Hydra::Derivatives::ShellBasedProcessor do
-  class TestProcessor  <
-    include Hydra::Derivatives::ShellBasedProcessor
-  end
-
-  let (:processor) {TestProcessor.new}
-
-  describe "has expected interface" do
-
-    describe "options_for" do
-      it "returns a hash" do
-        expect(processor.options_for("a")).to be_a Hash
-      end
-    end
-  end
-end
-
-
-

data/spec/units/video_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Video::Processor do
-  subject { described_class.new(double(:obj), 'content', directives)}
-
-  describe ".config" do
-    before do
-      @original_config = described_class.config.dup
-      described_class.config.mpeg4.codec = "-vcodec mpeg4 -acodec aac -strict -2"
-    end
-
-    after { described_class.config = @original_config }
-      let(:directives) {{ thumb: { format: "mp4", datastream: 'thumbnail' } }}
-
-    it "should be configurable" do
-      expect(subject).to receive(:encode_file).with("thumbnail", "mp4", 'video/mp4', {Hydra::Derivatives::Ffmpeg::OUTPUT_OPTIONS =>"-s 320x240 -vcodec mpeg4 -acodec aac -strict -2 -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Ffmpeg::INPUT_OPTIONS=>""})
-      subject.process
-    end
-  end
-
-  context "when arguments are passed as a hash" do
-    context "and datastream is provided as an argument" do
-      let(:directives) {{ thumb: { format: "webm", datastream: 'thumbnail' } }}
-      it "should create a datastream with the specified name" do
-        expect(subject).to receive(:encode_file).with("thumbnail", "webm", 'video/webm', {Hydra::Derivatives::Ffmpeg::OUTPUT_OPTIONS =>"-s 320x240 -vcodec libvpx -acodec libvorbis -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Ffmpeg::INPUT_OPTIONS=>""})
-        subject.process
-
-      end
-    end
-
-    context "and datastream is not provided as an argument" do
-      let(:directives) {{ thumb: { format: "webm" } }}
-      it "should create a datastream and infer the name" do
-        expect(subject).to receive(:encode_file).with("content_thumb", "webm", 'video/webm', {Hydra::Derivatives::Ffmpeg::OUTPUT_OPTIONS =>"-s 320x240 -vcodec libvpx -acodec libvorbis -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Ffmpeg::INPUT_OPTIONS=>""})
-        subject.process
-
-      end
-    end
-
-    context "and jpg is requested" do
-      let(:directives) {{ thumb: { format: 'jpg' , datastream: 'thumbnail'} }}
-      it "should create a datastream and infer the name" do
-        expect(subject).to receive(:encode_file).with("thumbnail", "jpg", "image/jpeg", {:output_options=>"-s 320x240 -vcodec mjpeg -vframes 1 -an -f rawvideo", :input_options=>" -itsoffset -2"})
-        subject.process
-
-      end
-    end
-  end
-end
-