hydra-derivatives 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e418eb7b224258c51b95ad6746452c9ffbf31676
-  data.tar.gz: ebef5a24146e2eff209b238dadb307a0b7e98c8d
+  metadata.gz: 9c023bf84dd9a0305bbecdeda90d7d8986153adc
+  data.tar.gz: 24543bbc4676d4a992249de13bae1750b188622c
 SHA512:
-  metadata.gz: a7e457990c5b95c834944b319f9355c6abc12870e733b652d4b05f898be684071f4e5595a56feaaf6c7348b90a6810e780f00096b206c30a02e7202d1133d1d3
-  data.tar.gz: 4c5a120d2287b7f315bf78a01c644a08efc70ba0733fa295c62cce4d15ba64ef4aa15f3991afd3ce7a0c9fbd312e952b11bd4b7feaa7f9ae7792bd45a7e078a3
+  metadata.gz: 7634f4729547506988e49107de96224037b3b036e9d8f7feada641e4f338bcf7e9c3f03eaa77ea5c2ea6301d3bd0a83ac6090f1b464fadc3f651c9e25d12c8c1
+  data.tar.gz: f0e16f0e1652fe06eb9728f76e51aef55b1ac23b7023b99de0587456ae4186ea68df7163bac7b75c2900023beef7dd0d311d24763504a31d8da3feec575e7e46

data/.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 rvm:
-  - 2.1
-  - 2.0
+  - 2.
 env:
   global:
     - NOKOGIRI_USE_SYSTEM_LIBRARIES=true

data/README.md

@@ -14,15 +14,15 @@ If you have an ActiveFedora class like this:
         makes_derivatives do |obj|
           case obj.mime_type
           when 'application/pdf'
-            obj.transform_file :content, { :thumb => "100x100>" }
+            obj.transform_file :original_file, { :thumb => "100x100>" }
           when 'audio/wav'
-            obj.transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+            obj.transform_file :original_file, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
           when 'video/avi'
-            obj.transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
+            obj.transform_file :original_file, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
           when 'image/png', 'image/jpg'
-            obj.transform_file :content, { :medium => "300x300>", :thumb => "100x100>" }
+            obj.transform_file :original_file, { :medium => "300x300>", :thumb => "100x100>" }
           when 'image/tiff'
-            obj.transform_file :content, { :service => { resize: "3600x3600>" } }, processor: 'jpeg2k_image'
+            obj.transform_file :original_file, { :service => { resize: "3600x3600>" } }, processor: 'jpeg2k_image'
           end
         end
     end
@@ -34,7 +34,7 @@ Or a class like this:
     class GenericFile < ActiveFedora::Base
         include Hydra::Derivatives
 
-        contains 'content'
+        contains 'original_file'
         attr_accessor :mime_type
 
         # Use a callback method to declare which derivatives you want
@@ -43,15 +43,15 @@ Or a class like this:
         def generate_derivatives
           case mime_type
           when 'application/pdf'
-            transform_file :content, { :thumb => "100x100>" }
+            transform_file :original_file, { :thumb => "100x100>" }
           when 'audio/wav'
-            transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+            transform_file :original_file, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
           when 'video/avi'
-            transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
+            transform_file :original_file, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
           when 'image/png', 'image/jpg'
-            transform_file :content, { :medium => "300x300>", :thumb => {size: "100x100>", datastream: 'thumbnail'} }
+            transform_file :original_file, { :medium => "300x300>", :thumb => {size: "100x100>", datastream: 'thumbnail'} }
           when 'image/tiff'
-            transform_file :content, { :service => { recipe: :default } }, processor: 'jpeg2k_image'
+            transform_file :original_file, { :service => { recipe: :default } }, processor: 'jpeg2k_image'
           end
         end
     end
@@ -61,7 +61,7 @@ And you add some content to it:
 
 ```ruby
    obj = GenericFile.new
-   obj.content.content = File.open(...)
+   obj.original_file.content = File.open(...)
    obj.mime_type = 'image/jpg'
    obj.save
 ```

data/VERSION

@@ -1 +1 @@
-1.2.1
+2.0.0

data/hydra-derivatives.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'hydra-file_characterization', '~> 0.3'
   spec.add_dependency 'mini_magick', '>= 3.2', '< 5'
   spec.add_dependency 'activesupport', '~> 4.0'
-  spec.add_dependency 'mime-types', '>= 1'
-  spec.add_dependency 'deprecation', '~> 0.1'
+  spec.add_dependency 'mime-types', '< 3'
+  spec.add_dependency 'deprecation'
 end
 

data/lib/hydra/derivatives.rb

@@ -1,6 +1,7 @@
 require 'active_fedora'
 require 'hydra/derivatives/railtie' if defined?(Rails)
 require 'deprecation'
+
 module Hydra
   module Derivatives
     extend ActiveSupport::Concern
@@ -18,8 +19,16 @@ module Hydra
     autoload :ExtractMetadata
     autoload :ShellBasedProcessor
     autoload :Jpeg2kImage
+    autoload :RawImage
     autoload :Logger
     autoload :TempfileService
+    autoload :IoDecorator
+
+    # services
+    autoload :RetrieveSourceFileService,         'hydra/derivatives/services/retrieve_source_file_service'
+    autoload :PersistOutputFileService,          'hydra/derivatives/services/persist_output_file_service'
+    autoload :PersistBasicContainedOutputFileService, 'hydra/derivatives/services/persist_basic_contained_output_file_service'
+    autoload :TempfileService,                   'hydra/derivatives/services/tempfile_service'
 
     # Raised if the timout elapses
     class TimeoutError < ::Timeout::Error; end
@@ -33,7 +42,7 @@ module Hydra
     end
 
     [:ffmpeg_path, :libreoffice_path, :temp_file_base, :fits_path, :kdu_compress_path,
-      :kdu_compress_recipes, :enable_ffmpeg].each do |method|
+      :kdu_compress_recipes, :enable_ffmpeg, :source_file_service, :output_file_service].each do |method|
       module_eval <<-RUBY
         def self.#{method.to_s}
           config.#{method.to_s}
@@ -68,6 +77,9 @@ module Hydra
     # @param file_name
     # @param [Hash] transform_directives - each key corresponds to a desired derivative.  Associated values vary according to processor being used.
     # @param [Hash] opts for specifying things like choice of :processor (processor defaults to :image)
+    # @option opts [Symbol] :processor (:image) Processor to use
+    # @option opts [Class] :source_file_service (Hydra::Derivatives::RetrieveSourceFileService) service to use when persisting generated derivatives.  The default for this can be set in your config file.
+    # @option opts [Class] :output_file_service (Hydra::Derivatives::PersistIndirectlyContainedOutputFile) service to use when retrieving the source.  The default for this can be set in your config file.
     #
     # @example This will create content_thumb
     #   transform_file :content, { :thumb => "100x100>" }
@@ -82,9 +94,14 @@ module Hydra
     #   transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
     #   transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
     #
+    # @example Specify an output file service to use when persisting generated derivatives
+    #   obj.transform_file :content, { mp4: { format: 'mp4' } }, processor: :video, output_file_service: My::System::PersistOutputFileToTapeStorage
+    #
+    # @example Specify a source file service to use when retrieving the source
+    #   obj.transform_file :content, { mp4: { format: 'mp4' } }, processor: :video, source_file_service: My::System::PersistOutputFileToTapeStorage
+
     def transform_file(file_name, transform_directives, opts={})
-      processor = processor_class(opts[:processor] || :image)
-      processor.new(self, file_name, transform_directives).process
+      initialize_processor(file_name, transform_directives, opts).process
     end
 
     def processor_class(processor)
@@ -139,5 +156,11 @@ module Hydra
         end
       end
     end
+
+    private
+    def initialize_processor(file_name, transform_directives, opts={})
+      processor_class(opts[:processor] || :image).new(self, file_name, transform_directives, opts)
+    end
+
   end
 end

data/lib/hydra/derivatives/config.rb

@@ -1,8 +1,10 @@
 module Hydra
   module Derivatives
     class Config
-      attr_writer :ffmpeg_path, :libreoffice_path, :temp_file_base, :fits_path,
+      attr_writer :ffmpeg_path, :libreoffice_path, :temp_file_base, 
+        :source_file_service, :output_file_service, :fits_path,
         :enable_ffmpeg, :kdu_compress_path, :kdu_compress_recipes
+
       def ffmpeg_path
         @ffmpeg_path ||= 'ffmpeg'
       end
@@ -15,6 +17,14 @@ module Hydra
         @temp_file_base ||= '/tmp'
       end
 
+      def source_file_service
+        @source_file_service ||= Hydra::Derivatives::RetrieveSourceFileService
+      end
+
+      def output_file_service
+        @output_file_service ||= Hydra::Derivatives::PersistBasicContainedOutputFileService
+      end
+
       def fits_path
         @fits_path ||= 'fits.sh'
       end

data/lib/hydra/derivatives/document.rb

@@ -9,7 +9,7 @@ module Hydra
         execute "#{Hydra::Derivatives.libreoffice_path} --invisible --headless --convert-to #{format} --outdir #{outdir} #{path}"
       end
 
-      def encode_file(dest_path, file_suffix, mime_type, options = { })
+      def encode_file(destination_name, file_suffix, mime_type, options = { })
         new_output = ''
         Hydra::Derivatives::TempfileService.create(source_file) do |f|
           if mime_type == 'image/jpeg'
@@ -23,8 +23,9 @@ module Hydra
             new_output = File.join(Hydra::Derivatives.temp_file_base, [File.basename(f.path).sub(File.extname(f.path), ''), file_suffix].join('.'))
           end
         end
-        out_file = File.open(new_output, "rb")
-        object.add_file(out_file.read, path: dest_path, mime_type: mime_type)
+        out_file = Hydra::Derivatives::IoDecorator.new(File.open(new_output, "rb"))
+        out_file.mime_type = mime_type
+        output_file_service.call(object, out_file, destination_name)
         File.unlink(out_file)
       end
 

data/lib/hydra/derivatives/extract_metadata.rb

@@ -22,7 +22,6 @@ module Hydra
         m = /\/([^\/]*)$/.match(uri)
         ["#{m[1]}-#{version_id}", "#{extension}"]
       end
-
     end
   end
 end

data/lib/hydra/derivatives/image.rb

@@ -1,4 +1,5 @@
 require 'mini_magick'
+
 module Hydra
   module Derivatives
     class Image < Processor
@@ -20,9 +21,16 @@ module Hydra
         directives.each do |name, args|
           opts = args.kind_of?(Hash) ? args : {size: args}
           format = opts.fetch(:format, 'png')
-          output_file_name = opts.fetch(:datastream, output_file_id(name))
-          create_resized_image(output_file(output_file_name), opts[:size], format)
+          destination_name = output_filename_for(name, opts)
+          create_resized_image(destination_name, opts[:size], format)
+        end
+      end
+
+      def output_filename_for(name, opts = {})
+        if opts.has_key? :datastream
+          Deprecation.warn Hydra::Derivatives::Image, 'The :datastream option is deprecated and will be removed in a future release.' 
         end
+        opts.fetch(:datastream, output_file_id(name))
       end
 
       protected
@@ -31,26 +39,28 @@ module Hydra
         MIME::Types.type_for(format).first.to_s
       end
 
-      def create_resized_image(output_file, size, format, quality=nil)
-        create_image(output_file, format, quality) do |xfrm|
+      def create_resized_image(destination_name, size, format, quality=nil)
+        create_image(destination_name, format, quality) do |xfrm|
           xfrm.resize(size) if size.present?
         end
-        output_file.mime_type = new_mime_type(format)
       end
 
-      def create_image(output_file, format, quality=nil)
+      def create_image(destination_name, format, quality=nil)
         xfrm = load_image_transformer
         yield(xfrm) if block_given?
         xfrm.format(format)
         xfrm.quality(quality.to_s) if quality
-        write_image(output_file, xfrm)
+        write_image(destination_name, format, xfrm)
       end
 
-      def write_image(output_file, xfrm)
-        stream = StringIO.new
-        xfrm.write(stream)
-        stream.rewind
-        output_file.content = stream
+      def write_image(destination_name, format, xfrm)
+        output_io = Hydra::Derivatives::IoDecorator.new(StringIO.new) 
+        output_io.mime_type = new_mime_type(format)
+
+        xfrm.write(output_io)
+        output_io.rewind
+
+        output_file_service.call(object, output_io, destination_name)
       end
 
       # Override this method if you want a different transformer, or need to load the

data/lib/hydra/derivatives/io_decorator.rb

@@ -0,0 +1,15 @@
+# Nieve implementation of IO wrapper class that adds mime_type and original_name attributes.
+# This is done so the attributes do not have to be passed as additional arguments, 
+#  and are attached properly to the object they describe.
+#
+#
+#  Use SimpleDelegator to wrap the given class or instance
+require 'delegate'
+
+module Hydra
+  module Derivatives
+    class IoDecorator < SimpleDelegator
+      attr_accessor :mime_type, :original_name
+    end
+  end
+end

data/lib/hydra/derivatives/jpeg2k_image.rb

@@ -25,7 +25,7 @@ module Hydra
         end
       end
 
-      def encode_file(dest_path, recipe, opts={})
+      def encode_file(destination_name, recipe, opts={})
         output_file = self.class.tmp_file('.jp2')
         if opts[:file_path]
           self.class.encode(opts[:file_path], recipe, output_file)
@@ -34,8 +34,10 @@ module Hydra
             self.class.encode(f.path, recipe, output_file)
           end
         end
-        out_file = File.open(output_file, "rb")
-        object.add_file(out_file.read, path: dest_path, mime_type: 'image/jp2')
+        out_file = Hydra::Derivatives::IoDecorator.new(File.open(output_file, "rb"))
+        out_file.mime_type = "image/jp2"
+        output_file_service.call(object, out_file, destination_name)
+
         File.unlink(output_file)
       end
 

data/lib/hydra/derivatives/processor.rb

@@ -1,12 +1,14 @@
 module Hydra
   module Derivatives
     class Processor
-      attr_accessor :object, :source_name, :directives
+      attr_accessor :object, :source_name, :directives, :source_file_service, :output_file_service
 
-      def initialize(obj, source_name, directives)
+      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
@@ -17,19 +19,13 @@ module Hydra
         [source_name, name].join('_')
       end
 
-      def output_file(path)
-        # first, check for a defined file
-        output_file = if object.attached_files[path]
-          object.attached_files[path]
-        else
-          ActiveFedora::File.new("#{object.uri}/#{path}").tap do |file|
-            object.attach_file(file, path)
-          end
-        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
-        object.attached_files[source_name.to_s]
+        @source_file ||= source_file_service.call(object, source_name)
       end
 
     end

data/lib/hydra/derivatives/raw_image.rb

@@ -0,0 +1,45 @@
+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/services/persist_basic_contained_output_file_service.rb

@@ -0,0 +1,25 @@
+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 
+  class PersistBasicContainedOutputFileService < PersistOutputFileService
+
+    # This method conforms to the signature of the .call method on Hydra::Derivatives::PeristOutputFileService
+    # * Persists the file within the object at destination_name
+    #
+    # 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)
+      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
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+module Hydra::Derivatives
+  class PersistOutputFileService
+
+    # 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)
+      raise NotImplementedError, "PersistOutputFileService is an abstract class. Implement `call' on #{self.class.name}"
+    end
+
+    def self.determine_original_name( file )
+      if file.respond_to? :original_name
+         file.original_name
+       else
+         "derivative"
+       end
+    end
+
+    def self.determine_mime_type( file )
+      if file.respond_to? :mime_type
+         file.mime_type
+       else
+         "appliction/octet-stream"
+       end
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+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)
+    end
+  end
+end

data/lib/hydra/derivatives/shell_based_processor.rb

@@ -29,14 +29,15 @@ module Hydra
         {}
       end
 
-      def encode_file(dest_path, file_suffix, mime_type, options)
+      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 = File.open(output_file, "rb")
-        object.add_file(out_file.read, path: dest_path, mime_type: mime_type)
+        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
 

data/spec/services/persist_basic_contained_output_file_service_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::PersistBasicContainedOutputFileService do
+
+  before(:all) do
+    class BasicContainerObject < ActiveFedora::Base
+      contains "the_derivative_name"
+    end
+  end
+
+  let(:object)            { BasicContainerObject.new  }
+  let(:file_path)         { File.join(fixture_path, 'test.tif') }
+  let(:file)              { File.new(file_path)}
+  let(:destination_name)  { 'the_derivative_name' }
+
+  # alas, we have to support this as the default because all legacy code (and fedora 3 systems) created basic contained files
+  # The new signature does not have a destination_name option.  There is a default string that will get applied, but his might
+  # not be sufficient.
+  context "when file is basic contained (default assumption)" do  
+    let(:object)          { BasicContainerObject.new  }
+    it "persists the file to the specified destination on the given object" do
+      described_class.call(object, "fake file content", destination_name)
+      expect(object.send(destination_name.to_sym).content).to eq("fake file content")
+      expect(object.send(destination_name.to_sym).content_changed?).to eq false
+    end
+  end
+
+end

data/spec/services/retrieve_source_file_service_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::RetrieveSourceFileService do
+
+  before(:all) do
+    
+    # Need a class that: 
+    #  1) Allows you to set .uri= (to work with directly_contains)
+    #  2) has a metadata_node (to work with directly_contains_one)
+    class FileWithMetadata < ActiveFedora::File
+      include ActiveFedora::WithMetadata
+    end
+    
+    class ObjectWithBasicContainer < ActiveFedora::Base
+      contains "contained_file"
+    end
+
+    class DirectContainerObject < ActiveFedora::Base
+      directly_contains :files, has_member_relation: ::RDF::URI("http://pcdm.org/use#hasFile"),
+        class_name: "FileWithMetadata"
+      directly_contains_one :directly_contained_file, through: :files, type: ::RDF::URI("http://pcdm.org/use#OriginalFile")
+    end
+  end
+
+  subject { described_class.call(object, source_name) }
+  
+  context "when file is in basic container (default assumption)" do  # alas, we have to support this as the default because all legacy code (and fedora 3 systems) created indirectly contained files
+    let(:object)            { ObjectWithBasicContainer.new  }
+    let(:content)           { "fake file content (basic container)" }
+    let(:source_name)       { 'contained_file' }
+    
+    before do
+      # attaches the file as an indirectly contained object
+      object.contained_file.content = content
+    end
+    it "persists the file to the specified destination on the given object" do
+      expect(subject).to eq(object.contained_file)
+    end
+  end
+
+  context "when file is directly contained" do  # direct containers are more efficient, but most legacy code will have indirect containers
+    let(:object)            { DirectContainerObject.new }
+    let(:content)           { "fake file content (direct container)" }
+    let(:source_name)       { 'directly_contained_file' }
+    
+    before do
+      object.save  # can't build directly contained objects without saving the parent first
+      object.build_directly_contained_file
+      object.directly_contained_file.content = content
+    end
+    it "retrieves the file from the specified location on the given object" do
+      expect(subject).to eq(object.directly_contained_file)
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -12,4 +12,15 @@ RSpec.configure do |config|
   end
 end
 
+# Workaround for RAW image support until these are pushed upstream to
+# the MIME Types gem
+require 'mime-types'
+dng_format = MIME::Type.new('image/x-adobe-dng')
+dng_format.extensions = 'dng'
+MIME::Types.add(dng_format)
+
 $in_travis = !ENV['TRAVIS'].nil? && ENV['TRAVIS'] == 'true'
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end

data/spec/units/config_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "the configuration" do
-  subject {Hydra::Derivatives }
+  subject { Hydra::Derivatives }
 
   it "should have some configuration defaults" do
     expect(subject.ffmpeg_path).to eq('ffmpeg')
@@ -10,6 +10,8 @@ describe "the configuration" do
     expect(subject.temp_file_base).to eq('/tmp')
     expect(subject.fits_path).to eq('fits.sh')
     expect(subject.kdu_compress_path).to eq('kdu_compress')
+    expect(subject.output_file_service).to eq(Hydra::Derivatives::PersistBasicContainedOutputFileService)
+    expect(subject.source_file_service).to eq(Hydra::Derivatives::RetrieveSourceFileService)
   end
 
   it "should let you change the configuration" do
@@ -21,6 +23,18 @@ describe "the configuration" do
 
   end
 
+  it "should let you set a custom output file service" do
+    output_file_service = double("MyOutputFileService")
+    subject.output_file_service = output_file_service
+    expect(subject.output_file_service).to eq(output_file_service)
+  end
+
+  it "should let you set a custom source file service" do
+    source_file_service = double("MyRetriveSourceFileService")
+    subject.source_file_service = source_file_service
+    expect(subject.source_file_service).to eq(source_file_service)
+  end
+
   it "should let you reset the configuration" do
     subject.ffmpeg_path = '/usr/local/ffmpeg-1.0/bin/ffmpeg'
     subject.reset_config!

data/spec/units/derivatives_spec.rb

@@ -8,11 +8,26 @@ describe Hydra::Derivatives do
     end
     class CustomProcessor < Hydra::Derivatives::Processor
     end
+    class CustomSourceFileService
+    end
+    class CustomOutputFileService
+    end
   end
 
   after(:all)  do
     Object.send(:remove_const, :CustomFile)
     Object.send(:remove_const, :CustomProcessor)
+    Object.send(:remove_const, :CustomSourceFileService)
+    Object.send(:remove_const, :CustomOutputFileService)
+  end
+
+  describe "initialize_processor" do
+    subject{ CustomFile.new.send(:initialize_processor, :content, { thumb: '100x100>' }, processor: Hydra::Derivatives::Video::Processor, source_file_service: CustomSourceFileService, output_file_service: CustomOutputFileService) }
+    it "passes source_file_service and output_file_service options to the processor" do
+      expect(subject.class).to eq(Hydra::Derivatives::Video::Processor)
+      expect(subject.source_file_service).to eq(CustomSourceFileService)
+      expect(subject.output_file_service).to eq(CustomOutputFileService)
+    end
   end
 
   context "when using an included processor" do

data/spec/units/image_spec.rb

@@ -13,7 +13,7 @@ describe Hydra::Derivatives::Image do
     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(output_file, "100x100>", 'png')
+      expect(subject).to receive(:create_resized_image).with(file_name, "100x100>", 'png')
       subject.process
     end
   end
@@ -23,7 +23,7 @@ describe Hydra::Derivatives::Image do
     let(:file_name) { 'thumbnail' }
 
     it "should use the specified size and name" do
-      expect(subject).to receive(:create_resized_image).with(output_file, "200x300>", 'png')
+      expect(subject).to receive(:create_resized_image).with(file_name, "200x300>", 'png')
       subject.process
     end
   end
@@ -33,7 +33,7 @@ describe Hydra::Derivatives::Image do
     let(:file_name) { 'content_thumb' }
 
     before do
-      allow(subject).to receive(:create_resized_image).with(output_file, "100x100>", 'png')
+      allow(subject).to receive(:create_resized_image).with("100x100>", 'png')
     end
 
     context 'when set' do

data/spec/units/processor_spec.rb

@@ -0,0 +1,61 @@
+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/transcoding_spec.rb

@@ -14,42 +14,47 @@ describe "Transcoder" do
       end
 
       has_attributes :mime_type_from_fits, :flag_as, datastream: :characterization, multiple: false
-      contains 'content', class_name: 'ContentDatastream'
+      contains 'original_file', class_name: 'ContentDatastream'
 
       makes_derivatives do |obj|
         case obj.mime_type_from_fits
         when 'application/pdf'
-          obj.transform_file :content, { thumb: '100x100>' }
+          obj.transform_file :original_file, { thumb: '100x100>' }
         when 'audio/wav'
-          obj.transform_file :content, { mp3: { format: 'mp3' }, ogg: { format: 'ogg'} }, processor: :audio
+          obj.transform_file :original_file, { mp3: { format: 'mp3' }, ogg: { format: 'ogg'} }, processor: :audio
         when 'video/avi'
-          obj.transform_file :content, { mp4: { format: 'mp4' }, webm: { format: 'webm'}, thumbnail: { format: 'jpg', datastream: 'thumbnail' } }, processor: :video
+          obj.transform_file :original_file, { mp4: { format: 'mp4' }, webm: { format: 'webm'}, thumbnail: { format: 'jpg', datastream: 'thumbnail' } }, processor: :video
         when 'image/png', 'image/jpg'
-          obj.transform_file :content, { medium: "300x300>", thumb: "100x100>", access: { format: 'jpg', datastream: 'access'} }
+          obj.transform_file :original_file, { medium: "300x300>", thumb: "100x100>", access: { format: 'jpg', datastream: 'access'} }
         when 'application/vnd.ms-powerpoint'
-          obj.transform_file :content, { preservation: { format: 'pptx'}, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :original_file, { preservation: { format: 'pptx'}, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'text/rtf'
-          obj.transform_file :content, { preservation: { format: 'odf' }, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :original_file, { preservation: { format: 'odf' }, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'application/msword'
-          obj.transform_file :content, { access: { format: 'pdf' }, preservation: { format: 'docx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :original_file, { access: { format: 'pdf' }, preservation: { format: 'docx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'application/vnd.ms-excel'
-          obj.transform_file :content, { access: { format: 'pdf' }, preservation: { format: 'xslx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :original_file, { access: { format: 'pdf' }, preservation: { format: 'xslx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'image/tiff'
-          obj.transform_file :content, {
+          obj.transform_file :original_file, {
             resized: { recipe: :default, resize: "600x600>", datastream: 'resized' },
             config_lookup: { recipe: :default, datastream: 'config_lookup' },
             string_recipe: { recipe: '-quiet', datastream: 'string_recipe' },
             diy: { }
           }, processor: 'jpeg2k_image'
-        end
-
+        when 'image/x-adobe-dng'
+          obj.transform_file :original_file, 
+		 	{
+				access: { size: "300x300>", format: "jpg", datastream: "access" },
+				thumb: { size: "100x100>", format: "jpg", datastream: "thumb" }
+		  	}, processor: :raw_image
+         end
       end
 
       makes_derivatives :generate_special_derivatives
 
       def generate_special_derivatives
         if flag_as == "special" && mime_type_from_fits == 'image/png'
-          transform_file :content, { medium: { size: "200x300>", datastream: 'special_ds' } }
+          transform_file :original_file, { medium: { size: "200x300>", datastream: 'special_ds' } }
         end
       end
     end
@@ -64,46 +69,68 @@ describe "Transcoder" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
     let(:file) do
       GenericFile.new(mime_type_from_fits: 'image/png').tap do |f|
-        f.content.content = attachment
+        f.original_file.content = attachment
         f.save!
       end
     end
 
     it "should transcode" do
-      expect(file.attached_files.key?('content_medium')).to be_falsey
+      expect(file.attached_files.key?('original_file_medium')).to be_falsey
+      file.create_derivatives
+      expect(file.attached_files['original_file_medium']).to have_content
+      expect(file.attached_files['original_file_medium'].mime_type).to eq('image/png')
+      expect(file.attached_files['original_file_thumb']).to have_content
+      expect(file.attached_files['original_file_thumb'].mime_type).to eq('image/png')
+      expect(file.attached_files['access']).to have_content
+      expect(file.attached_files['access'].mime_type).to eq('image/jpeg')
+      expect(file.attached_files.key?('original_file_text')).to be_falsey
+    end
+  end
+
+  describe "with an attached RAW image", unless: $in_travis do
+    let(:attachment) { File.open(File.expand_path('../../fixtures/test.dng', __FILE__))}
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'image/x-adobe-dng') do |f|
+        f.original_file.content = attachment
+        f.original_file.mime_type = 'image/x-adobe-dng'
+        f.save!
+      end
+    end
+
+    it "should transcode" do
+     expect(file.attached_files.key?('access')).to be_falsey
+      expect(file.attached_files.key?('thumb')).to be_falsey
+
       file.create_derivatives
-      expect(file.attached_files['content_medium']).to have_content
-      expect(file.attached_files['content_medium'].mime_type).to eq('image/png')
-      expect(file.attached_files['content_thumb']).to have_content
-      expect(file.attached_files['content_thumb'].mime_type).to eq('image/png')
       expect(file.attached_files['access']).to have_content
       expect(file.attached_files['access'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files.key?('content_text')).to be_falsey
+      expect(file.attached_files['thumb']).to have_content
+      expect(file.attached_files['thumb'].mime_type).to eq('image/jpeg')
     end
   end
 
   describe "with an attached pdf" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/test.pdf', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/pdf').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/pdf').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      expect(file.attached_files.key?('content_thumb')).to be_falsey
+      expect(file.attached_files.key?('original_file_thumb')).to be_falsey
       file.create_derivatives
-      expect(file.attached_files['content_thumb']).to have_content
-      expect(file.attached_files['content_thumb'].mime_type).to eq('image/png')
+      expect(file.attached_files['original_file_thumb']).to have_content
+      expect(file.attached_files['original_file_thumb'].mime_type).to eq('image/png')
     end
   end
 
   describe "with an attached audio", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/piano_note.wav', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'audio/wav').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'audio/wav').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_mp3']).to have_content
-      expect(file.attached_files['content_mp3'].mime_type).to eq('audio/mpeg')
-      expect(file.attached_files['content_ogg']).to have_content
-      expect(file.attached_files['content_ogg'].mime_type).to eq('audio/ogg')
+      expect(file.attached_files['original_file_mp3']).to have_content
+      expect(file.attached_files['original_file_mp3'].mime_type).to eq('audio/mpeg')
+      expect(file.attached_files['original_file_ogg']).to have_content
+      expect(file.attached_files['original_file_ogg'].mime_type).to eq('audio/ogg')
     end
   end
 
@@ -111,8 +138,8 @@ describe "Transcoder" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/piano_note.wav', __FILE__))}
     let(:file) do
       GenericFile.new(mime_type_from_fits: 'audio/wav').tap do |t|
-        t.content.content = attachment;
-        t.content.mime_type = 'audio/vnd.wav';
+        t.original_file.content = attachment;
+        t.original_file.mime_type = 'audio/vnd.wav';
         t.save
       end
     end
@@ -120,21 +147,21 @@ describe "Transcoder" do
     it "should transcode" do
       allow_any_instance_of(::Logger).to receive(:warn)
       file.create_derivatives
-      expect(file.attached_files['content_mp3']).to have_content
-      expect(file.attached_files['content_mp3'].mime_type).to eq('audio/mpeg')
+      expect(file.attached_files['original_file_mp3']).to have_content
+      expect(file.attached_files['original_file_mp3'].mime_type).to eq('audio/mpeg')
     end
   end
 
   describe "with an attached video", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/countdown.avi', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'video/avi').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'video/avi').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_mp4']).to have_content
-      expect(file.attached_files['content_mp4'].mime_type).to eq('video/mp4')
-      expect(file.attached_files['content_webm']).to have_content
-      expect(file.attached_files['content_webm'].mime_type).to eq('video/webm')
+      expect(file.attached_files['original_file_mp4']).to have_content
+      expect(file.attached_files['original_file_mp4'].mime_type).to eq('video/mp4')
+      expect(file.attached_files['original_file_webm']).to have_content
+      expect(file.attached_files['original_file_webm'].mime_type).to eq('video/webm')
       expect(file.attached_files['thumbnail']).to have_content
       expect(file.attached_files['thumbnail'].mime_type).to eq('image/jpeg')
     end
@@ -155,7 +182,7 @@ describe "Transcoder" do
 
   describe "using callback methods" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'image/png', flag_as: "special").tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'image/png', flag_as: "special").tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       expect(file.attached_files.key?('special_ds')).to be_falsey
@@ -168,71 +195,71 @@ describe "Transcoder" do
 
   describe "with an attached Powerpoint", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/FlashPix.ppt', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-powerpoint').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-powerpoint').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_thumbnail']).to have_content
-      expect(file.attached_files['content_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['content_access']).to have_content
-      expect(file.attached_files['content_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['content_preservation']).to have_content
-      expect(file.attached_files['content_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.presentationml.presentation')
+      expect(file.attached_files['original_file_thumbnail']).to have_content
+      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
+      expect(file.attached_files['original_file_access']).to have_content
+      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
+      expect(file.attached_files['original_file_preservation']).to have_content
+      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.presentationml.presentation')
     end
   end
 
   describe "with an attached rich text format", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/sample.rtf', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'text/rtf').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'text/rtf').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_thumbnail']).to have_content
-      expect(file.attached_files['content_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['content_access']).to have_content
-      expect(file.attached_files['content_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['content_preservation']).to have_content
-      expect(file.attached_files['content_preservation'].mime_type).to eq('application/vnd.oasis.opendocument.text')
+      expect(file.attached_files['original_file_thumbnail']).to have_content
+      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
+      expect(file.attached_files['original_file_access']).to have_content
+      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
+      expect(file.attached_files['original_file_preservation']).to have_content
+      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.oasis.opendocument.text')
     end
   end
 
   describe "with an attached word doc format", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/test.doc', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/msword').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/msword').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_thumbnail']).to have_content
-      expect(file.attached_files['content_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['content_access']).to have_content
-      expect(file.attached_files['content_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['content_preservation']).to have_content
-      expect(file.attached_files['content_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
+      expect(file.attached_files['original_file_thumbnail']).to have_content
+      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
+      expect(file.attached_files['original_file_access']).to have_content
+      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
+      expect(file.attached_files['original_file_preservation']).to have_content
+      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
     end
   end
 
   describe "with an attached excel format", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/test.xls', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_thumbnail']).to have_content
-      expect(file.attached_files['content_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['content_access']).to have_content
-      expect(file.attached_files['content_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['content_preservation']).to have_content
-      expect(file.attached_files['content_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+      expect(file.attached_files['original_file_thumbnail']).to have_content
+      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
+      expect(file.attached_files['original_file_access']).to have_content
+      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
+      expect(file.attached_files['original_file_preservation']).to have_content
+      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
     end
   end
 
   describe "with an attached tiff", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/test.tif', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'image/tiff').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'image/tiff').tap { |t| t.original_file.content = attachment; t.save } }
     it "should transcode" do
       file.create_derivatives
-      expect(file.attached_files['content_diy']).to have_content
-      expect(file.attached_files['content_diy'].mime_type).to eq('image/jp2')
+      expect(file.attached_files['original_file_diy']).to have_content
+      expect(file.attached_files['original_file_diy'].mime_type).to eq('image/jp2')
       expect(file.attached_files['config_lookup']).to have_content
       expect(file.attached_files['config_lookup'].mime_type).to eq('image/jp2')
       expect(file.attached_files['resized']).to have_content

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-derivatives
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-18 00:00:00.000000000 Z
+date: 2015-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -132,30 +132,30 @@ dependencies:
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: deprecation
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0'
 description: Derivative generation plugin for hydra
 email:
 - justin@curationexperts.com
@@ -185,12 +185,17 @@ files:
 - lib/hydra/derivatives/extract_metadata.rb
 - lib/hydra/derivatives/ffmpeg.rb
 - lib/hydra/derivatives/image.rb
+- lib/hydra/derivatives/io_decorator.rb
 - lib/hydra/derivatives/jpeg2k_image.rb
 - lib/hydra/derivatives/logger.rb
 - lib/hydra/derivatives/processor.rb
 - lib/hydra/derivatives/railtie.rb
+- lib/hydra/derivatives/raw_image.rb
+- lib/hydra/derivatives/services/persist_basic_contained_output_file_service.rb
+- lib/hydra/derivatives/services/persist_output_file_service.rb
+- lib/hydra/derivatives/services/retrieve_source_file_service.rb
+- lib/hydra/derivatives/services/tempfile_service.rb
 - lib/hydra/derivatives/shell_based_processor.rb
-- lib/hydra/derivatives/tempfile_service.rb
 - lib/hydra/derivatives/video.rb
 - lib/hydra/derivatives/video/config.rb
 - lib/hydra/derivatives/video/processor.rb
@@ -200,6 +205,7 @@ files:
 - spec/fixtures/jpeg2k_config.yml
 - spec/fixtures/piano_note.wav
 - spec/fixtures/sample.rtf
+- spec/fixtures/test.dng
 - spec/fixtures/test.doc
 - spec/fixtures/test.docx
 - spec/fixtures/test.pdf
@@ -209,6 +215,8 @@ files:
 - spec/fixtures/test.xlsx
 - spec/fixtures/world.png
 - spec/lib/hydra/derivatives/extract_metadata_spec.rb
+- spec/services/persist_basic_contained_output_file_service_spec.rb
+- spec/services/retrieve_source_file_service_spec.rb
 - spec/services/tempfile_service_spec.rb
 - spec/spec_helper.rb
 - spec/units/config_spec.rb
@@ -217,6 +225,7 @@ files:
 - spec/units/image_spec.rb
 - spec/units/jpeg2k_spec.rb
 - spec/units/logger_spec.rb
+- spec/units/processor_spec.rb
 - spec/units/shell_based_processor_spec.rb
 - spec/units/transcoding_spec.rb
 - spec/units/video_spec.rb
@@ -240,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Derivative generation plugin for hydra
@@ -251,6 +260,7 @@ test_files:
 - spec/fixtures/jpeg2k_config.yml
 - spec/fixtures/piano_note.wav
 - spec/fixtures/sample.rtf
+- spec/fixtures/test.dng
 - spec/fixtures/test.doc
 - spec/fixtures/test.docx
 - spec/fixtures/test.pdf
@@ -260,6 +270,8 @@ test_files:
 - spec/fixtures/test.xlsx
 - spec/fixtures/world.png
 - spec/lib/hydra/derivatives/extract_metadata_spec.rb
+- spec/services/persist_basic_contained_output_file_service_spec.rb
+- spec/services/retrieve_source_file_service_spec.rb
 - spec/services/tempfile_service_spec.rb
 - spec/spec_helper.rb
 - spec/units/config_spec.rb
@@ -268,7 +280,7 @@ test_files:
 - spec/units/image_spec.rb
 - spec/units/jpeg2k_spec.rb
 - spec/units/logger_spec.rb
+- spec/units/processor_spec.rb
 - spec/units/shell_based_processor_spec.rb
 - spec/units/transcoding_spec.rb
 - spec/units/video_spec.rb
-has_rdoc: