hydra-derivatives 0.1.1 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9915bdcf795eeb369e8d6d74c73ea28b6e123d7
-  data.tar.gz: 8324701965b3eeaafab56b3d7c4c1865c7a63523
+  metadata.gz: 80810fa0b2485899158d367b925840c7919c70ae
+  data.tar.gz: 0711a06da2a40f7fe71450ec7d7efc94c79a3019
 SHA512:
-  metadata.gz: 85e2b44fb759711a73de6a282732f919f5fc2cb6caf8bcb7f312d6e78238588b9321d174e45aca66cfd58cc01f43b4ba65207400f532be822333a5aa43031e9d
-  data.tar.gz: 7367297fea0431159120dca7805b16e54fd2c6e252368f6ef8b57e8bf7ce89f19931d8485fe50ce774a3500a73e3bb31b95fb591e8ed4dccfb05e0df3e6c83fc
+  metadata.gz: 4ded4fc1774ddd3d2088a179c8ca545783a338580533e5051b824497de769ea1ec102956b6232fa635478ca8112401fbe82620dad35ce1b75e8a3becf759fee4
+  data.tar.gz: 729a4e5397096b15f4b7f9c4ce28dc00780471ea2ad7b99010fa162d21fbfbec5aa28bacdb40d72ed1795c8453871eb134acb0958a9f71f56bcd63140a68b817

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.1
+  - 2.0
+env:
+  global:
+    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
 notifications:
   email:
     recipients:

data/README.md

@@ -7,22 +7,22 @@ If you have an ActiveFedora class like this:
     class GenericFile < ActiveFedora::Base
         include Hydra::Derivatives
 
-        has_file_datastream :content
+        contains 'content'
         attr_accessor :mime_type
 
         # Use a block to declare which derivatives you want to generate
         makes_derivatives do |obj|
           case obj.mime_type
           when 'application/pdf'
-            obj.transform_datastream :content, { :thumb => "100x100>" }
+            obj.transform_file :content, { :thumb => "100x100>" }
           when 'audio/wav'
-            obj.transform_datastream :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+            obj.transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
           when 'video/avi'
-            obj.transform_datastream :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
+            obj.transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
           when 'image/png', 'image/jpg'
-            obj.transform_datastream :content, { :medium => "300x300>", :thumb => "100x100>" }
+            obj.transform_file :content, { :medium => "300x300>", :thumb => "100x100>" }
           when 'image/tiff'
-            obj.transform_datastream :content, { :service => { resize: "3600x3600>" } }, processor: 'jpeg2k_image'
+            obj.transform_file :content, { :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
 
-        has_file_datastream :content
+        contains 'content'
         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_datastream :content, { :thumb => "100x100>" }
+            transform_file :content, { :thumb => "100x100>" }
           when 'audio/wav'
-            transform_datastream :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+            transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
           when 'video/avi'
-            transform_datastream :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
+            transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
           when 'image/png', 'image/jpg'
-            transform_datastream :content, { :medium => "300x300>", :thumb => {size: "100x100>", datastream: 'thumbnail'} }
+            transform_file :content, { :medium => "300x300>", :thumb => {size: "100x100>", datastream: 'thumbnail'} }
           when 'image/tiff'
-            transform_datastream :content, { :service => { recipe: :default } }, processor: 'jpeg2k_image'
+            transform_file :content, { :service => { recipe: :default } }, processor: 'jpeg2k_image'
           end
         end
     end
@@ -66,7 +66,7 @@ And you add some content to it:
    obj.save
 ```
 
-Then when you call `obj.create_derivatives` two new datastreams, 'thumbnail' and 'content_medium', will have been created with downsized images in them.
+Then when you call `obj.create_derivatives` two new files, 'thumbnail' and 'content_medium', will have been created with downsized images in them.
 
 We recommend you run `obj.create_derivatives` in a background worker, because some derivative creation (especially videos) can take a long time.
 

data/Rakefile

@@ -4,6 +4,9 @@ require "bundler/gem_tasks"
 
 APP_ROOT="." # for jettywrapper
 require 'jettywrapper'
+JETTY_ZIP_BASENAME = 'fedora-4/master'
+Jettywrapper.url = "https://github.com/projecthydra/hydra-jetty/archive/#{JETTY_ZIP_BASENAME}.zip"
+
 # Dir.glob('tasks/*.rake').each { |r| import r }
 
 require 'rspec/core/rake_task'

data/VERSION

@@ -1 +1 @@
-0.1.1
+1.0.0.beta1

data/hydra-derivatives.gemspec

@@ -22,9 +22,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "jettywrapper"
   spec.add_development_dependency "rspec"
 
-  spec.add_dependency 'active-fedora'
+  spec.add_dependency 'active-fedora', '~> 9.0.0.beta3'
   spec.add_dependency 'hydra-file_characterization'
   spec.add_dependency 'mini_magick'
   spec.add_dependency 'activesupport', '>= 3.2.13', '< 5.0'
+  spec.add_dependency 'mime-types'
+  spec.add_dependency 'deprecation'
 end
 

data/lib/hydra/derivatives/config.rb

@@ -1,7 +1,7 @@
 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, :fits_path,
         :enable_ffmpeg, :kdu_compress_path, :kdu_compress_recipes
       def ffmpeg_path
         @ffmpeg_path ||= 'ffmpeg'
@@ -29,34 +29,34 @@ module Hydra
 
       def kdu_compress_recipes
         @kdu_compress_recipes ||= {
-          default_color: %Q{-rate 2.4,1.48331273,.91673033,.56657224,.35016049,.21641118,.13374944,.08266171 
-            -jp2_space sRGB 
-            -double_buffering 10 
-            -num_threads 4 
-            -no_weights 
-            Clevels=6 
-            Clayers=8 
-            Cblk=\{64,64\} 
-            Cuse_sop=yes 
-            Cuse_eph=yes  
-            Corder=RPCL 
-            ORGgen_plt=yes 
-            ORGtparts=R 
-            Stiles=\{1024,1024\} }.gsub(/\s+/, " ").strip,
-          default_grey: %Q{-rate 2.4,1.48331273,.91673033,.56657224,.35016049,.21641118,.13374944,.08266171 
-            -jp2_space sLUM 
-            -double_buffering 10 
-            -num_threads 4 
-            -no_weights 
-            Clevels=6 
-            Clayers=8 
-            Cblk=\{64,64\} 
-            Cuse_sop=yes 
-            Cuse_eph=yes  
-            Corder=RPCL 
-            ORGgen_plt=yes 
-            ORGtparts=R 
-            Stiles=\{1024,1024\} }.gsub(/\s+/, " ").strip
+          default_color: %Q{-rate 2.4,1.48331273,.91673033,.56657224,.35016049,.21641118,.13374944,.08266171
+            -jp2_space sRGB
+            -double_buffering 10
+            -num_threads 4
+            -no_weights
+            Clevels=6
+            Clayers=8
+            "Cblk={64,64}"
+            Cuse_sop=yes
+            Cuse_eph=yes
+            Corder=RPCL
+            ORGgen_plt=yes
+            ORGtparts=R
+            "Stiles={1024,1024}" }.gsub(/\s+/, " ").strip,
+          default_grey: %Q{-rate 2.4,1.48331273,.91673033,.56657224,.35016049,.21641118,.13374944,.08266171
+            -jp2_space sLUM
+            -double_buffering 10
+            -num_threads 4
+            -no_weights
+            Clevels=6
+            Clayers=8
+            "Cblk={64,64}"
+            Cuse_sop=yes
+            Cuse_eph=yes
+            Corder=RPCL
+            ORGgen_plt=yes
+            ORGtparts=R
+            "Stiles={1024,1024}" }.gsub(/\s+/, " ").strip
         }
       end
 

data/lib/hydra/derivatives/document.rb

@@ -9,26 +9,29 @@ module Hydra
         execute "#{Hydra::Derivatives.libreoffice_path} --invisible --headless --convert-to #{format} --outdir #{outdir} #{path}"
       end
 
-      def encode_datastream(dest_dsid, file_suffix, mime_type, options = '')
-        output_file = Dir::Tmpname.create(["#{object.id}-content.", ".#{file_suffix}"], Hydra::Derivatives.temp_file_base){}
+      def encode_file(dest_dsid, file_suffix, mime_type, options = '')
         new_output = ''
-        source_datastream.to_tempfile do |f|
+        source_file.to_tempfile do |f|
           if mime_type == 'image/jpeg'
             temp_file = File.join(Hydra::Derivatives.temp_file_base, [File.basename(f.path).sub(File.extname(f.path), ''), 'pdf'].join('.'))
             new_output = File.join(Hydra::Derivatives.temp_file_base, [File.basename(temp_file).sub(File.extname(temp_file), ''), file_suffix].join('.'))
             self.class.encode(f.path, options, temp_file)
-            self.class.encode(temp_file, options, output_file)
+            self.class.encode(temp_file, options, output_file(file_suffix))
             File.unlink(temp_file)
           else
-            self.class.encode(f.path, options, output_file)
+            self.class.encode(f.path, options, output_file(file_suffix))
             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_datastream(out_file.read, dsid: dest_dsid, mimeType: mime_type)
+        object.add_file_datastream(out_file.read, dsid: dest_dsid, mime_type: mime_type)
         File.unlink(out_file)
       end
 
+      def output_file(file_suffix)
+        Dir::Tmpname.create(["#{object.id.gsub('/', '_')}-content.", ".#{file_suffix}"], Hydra::Derivatives.temp_file_base){}
+      end
+
       def new_mime_type(format)
         case format
         when 'pdf'

data/lib/hydra/derivatives/extract_metadata.rb

@@ -1,4 +1,6 @@
 require 'hydra-file_characterization'
+require 'mime/types'
+
 module Hydra
   module Derivatives
     module ExtractMetadata
@@ -29,10 +31,12 @@ module Hydra
       protected
 
       def filename_for_characterization
-        mime_type = MIME::Types[mimeType].first
-        Logger.warn "Unable to find a registered mime type for #{mimeType.inspect} on #{pid}" unless mime_type
-        extension = mime_type ? ".#{mime_type.extensions.first}" : ''
-        ["#{pid}-#{dsVersionID}", "#{extension}"]
+        registered_mime_type = MIME::Types[mime_type].first
+        Logger.warn "Unable to find a registered mime type for #{mime_type.inspect} on #{uri}" unless registered_mime_type
+        extension = registered_mime_type ? ".#{registered_mime_type.extensions.first}" : ''
+        version_id = 1 # TODO fixme
+        m = /\/([^\/]*)$/.match(uri)
+        ["#{m[1]}-#{version_id}", "#{extension}"]
       end
 
     end

data/lib/hydra/derivatives/image.rb

@@ -3,11 +3,11 @@ module Hydra
   module Derivatives
     class Image < Processor
       def process
-        directives.each do |name, args| 
+        directives.each do |name, args|
           opts = args.kind_of?(Hash) ? args : {size: args}
           format = opts.fetch(:format, 'png')
-          output_datastream_name = opts.fetch(:datastream, output_datastream_id(name))
-          create_resized_image(output_datastream(output_datastream_name), opts[:size], format)
+          output_file_name = opts.fetch(:datastream, output_file_id(name))
+          create_resized_image(output_file(output_file_name), opts[:size], format)
         end
       end
 
@@ -17,32 +17,32 @@ module Hydra
         MIME::Types.type_for(format).first.to_s
       end
 
-      def create_resized_image(output_datastream, size, format, quality=nil)
-        create_image(output_datastream, format, quality) do |xfrm|
+      def create_resized_image(output_file, size, format, quality=nil)
+        create_image(output_file, format, quality) do |xfrm|
           xfrm.resize(size) if size.present?
         end
-        output_datastream.mimeType = new_mime_type(format)
+        output_file.mime_type = new_mime_type(format)
       end
 
-      def create_image(output_datastream, format, quality=nil)
+      def create_image(output_file, 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_datastream, xfrm)
+        write_image(output_file, xfrm)
       end
 
-      def write_image(output_datastream, xfrm)
+      def write_image(output_file, xfrm)
         stream = StringIO.new
         xfrm.write(stream)
         stream.rewind
-        output_datastream.content = stream
+        output_file.content = stream
       end
 
-      # Override this method if you want a different transformer, or need to load the 
-      # raw image from a different source (e.g.  external datastream)
+      # Override this method if you want a different transformer, or need to load the
+      # raw image from a different source (e.g.  external file)
       def load_image_transformer
-        MiniMagick::Image.read(source_datastream.content)
+        MiniMagick::Image.read(source_file.content)
       end
     end
   end

data/lib/hydra/derivatives/jpeg2k_image.rb

@@ -4,11 +4,11 @@ require 'nokogiri'
 
 module Hydra
   module Derivatives
-    class Jpeg2kImage < Processor 
+    class Jpeg2kImage < Processor
       include ShellBasedProcessor
 
       def process
-        image = MiniMagick::Image.read(source_datastream.content)
+        image = MiniMagick::Image.read(source_file.content)
         quality = image['%[channels]'] == 'gray' ? 'gray' : 'color'
         directives.each do |name, args|
           long_dim = self.class.long_dim(image)
@@ -19,26 +19,26 @@ module Hydra
           end
           image.write file_path
           recipe = self.class.kdu_compress_recipe(args, quality, long_dim)
-          output_datastream_name = args[:datastream] || output_datastream_id(name)
-          encode_datastream(output_datastream_name, recipe, file_path: file_path)
+          output_file_name = args[:datastream] || output_file_id(name)
+          encode_file(output_file_name, recipe, file_path: file_path)
           File.unlink(file_path) unless file_path.nil?
         end
       end
 
-      def encode_datastream(dest_dsid, recipe, opts={})
+      def encode_file(dest_dsid, recipe, opts={})
         output_file = self.class.tmp_file('.jp2')
         if opts[:file_path]
           self.class.encode(opts[:file_path], recipe, output_file)
         else
-          source_datastream.to_tempfile do |f|
+          source_file.to_tempfile do |f|
             self.class.encode(f.path, recipe, output_file)
           end
         end
         out_file = File.open(output_file, "rb")
-        object.add_file_datastream(out_file.read, dsid: dest_dsid, mimeType: 'image/jp2')
+        object.add_file_datastream(out_file.read, dsid: dest_dsid, mime_type: 'image/jp2')
         File.unlink(output_file)
       end
-      
+
       protected
       def preprocess(image, opts={})
         # resize: <geometry>, to_srgb: <bool>, src_quality: 'color'|'gray'
@@ -57,7 +57,7 @@ module Hydra
       def self.srgb_profile_path
         File.join [
           File.expand_path('../../../', __FILE__),
-          'color_profiles', 
+          'color_profiles',
           'sRGB_IEC61966-2-1_no_black_scaling.icc'
         ]
       end
@@ -90,21 +90,21 @@ module Hydra
         levels_arg = args.fetch(:levels, Hydra::Derivatives::Jpeg2kImage.level_count_for_size(long_dim))
         rates_arg = Hydra::Derivatives::Jpeg2kImage.layer_rates(args.fetch(:layers, 8), args.fetch(:compression, 10))
         tile_size = args.fetch(:tile_size, 1024)
-        tiles_arg = "\{#{tile_size},#{tile_size}\}"
+        tiles_arg = "#{tile_size},#{tile_size}"
         jp2_space_arg = quality == 'gray' ? 'sLUM' : 'sRGB'
 
-        %Q{-rate #{rates_arg} 
+        %Q{-rate #{rates_arg}
             -jp2_space #{jp2_space_arg}
-            -double_buffering 10 
-            -num_threads 4 
-            -no_weights 
-            Clevels=#{levels_arg} 
-            Stiles=#{tiles_arg}
-            Cblk=\{64,64\} 
-            Cuse_sop=yes 
-            Cuse_eph=yes  
-            Corder=RPCL 
-            ORGgen_plt=yes 
+            -double_buffering 10
+            -num_threads 4
+            -no_weights
+            Clevels=#{levels_arg}
+            "Stiles={#{tiles_arg}}"
+            "Cblk={64,64}"
+            Cuse_sop=yes
+            Cuse_eph=yes
+            Corder=RPCL
+            ORGgen_plt=yes
             ORGtparts=R  }.gsub(/\s+/, " ").strip
       end
 

data/lib/hydra/derivatives/logger.rb

@@ -5,7 +5,7 @@ module Hydra::Derivatives
 
       def method_missing method_name, *arguments, &block
         logger.send(method_name, *arguments, &block)
-      rescue  
+      rescue
         super
       end
 

data/lib/hydra/derivatives/processor.rb

@@ -13,23 +13,23 @@ module Hydra
         raise "Processor is an abstract class. Implement `process' on #{self.class.name}"
       end
 
-      def output_datastream_id(name)
+      def output_file_id(name)
         [source_name, name].join('_')
       end
 
-      def output_datastream(dsid)
-        # first, check for a defined datastream
-        output_datastream = if object.datastreams[dsid]
-          object.datastreams[dsid]
+      def output_file(path)
+        # first, check for a defined file
+        output_file = if object.attached_files[path]
+          object.attached_files[path]
         else
-          ds = ActiveFedora::Datastream.new(object.inner_object, dsid)
-          object.add_datastream(ds)
-          ds
+          ActiveFedora::File.new("#{object.uri}/#{path}").tap do |file|
+            object.attach_file(file, path)
+          end
         end
       end
 
-      def source_datastream
-        object.datastreams[source_name.to_s]
+      def source_file
+        object.attached_files[source_name.to_s]
       end
 
     end

data/lib/hydra/derivatives/shell_based_processor.rb

@@ -17,8 +17,8 @@ module Hydra
           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_datastream_name = args[:datastream] || output_datastream_id(name)
-          encode_datastream(output_datastream_name, format, new_mime_type(format), options_for(format))
+          output_file_name = args[:datastream] || output_file_id(name)
+          encode_file(output_file_name, format, new_mime_type(format), options_for(format))
         end
       end
 
@@ -26,14 +26,14 @@ module Hydra
       def options_for(format)
       end
 
-      def encode_datastream(dest_dsid, file_suffix, mime_type, options = '')
+      def encode_file(dest_dsid, file_suffix, mime_type, options = '')
         out_file = nil
         output_file = Dir::Tmpname.create(['sufia', ".#{file_suffix}"], Hydra::Derivatives.temp_file_base){}
-        source_datastream.to_tempfile do |f|
+        source_file.to_tempfile do |f|
           self.class.encode(f.path, options, output_file)
         end
         out_file = File.open(output_file, "rb")
-        object.add_file_datastream(out_file.read, :dsid=>dest_dsid, :mimeType=>mime_type)
+        object.add_file_datastream(out_file.read, dsid: dest_dsid, mime_type: mime_type)
         File.unlink(output_file)
       end
 

data/lib/hydra/derivatives.rb

@@ -1,10 +1,12 @@
 require 'active_fedora'
 require 'hydra/derivatives/railtie' if defined?(Rails)
-
+require 'deprecation'
 module Hydra
   module Derivatives
     extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
+    extend Deprecation
+    self.deprecation_horizon = "hydra-derivatives 1.0"
 
     autoload :Processor
     autoload :Image
@@ -58,28 +60,34 @@ module Hydra
       end
     end
 
-    # Create derivatives from a datastream according to transformation directives
-    # @param datastream_name
+    # Create derivatives from a file according to transformation directives
+    # @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)
     #
     # @example This will create content_thumb
-    #   transform_datastream :content, { :thumb => "100x100>" }
+    #   transform_file :content, { :thumb => "100x100>" }
     #
-    # @example Specify the dsid for the output datastream
-    #   transform_datastream :content, { :thumb => {size: "200x300>", datastream: 'thumbnail'} }
+    # @example Specify the dsid for the output file
+    #   transform_file :content, { :thumb => {size: "200x300>", datastream: 'thumbnail'} }
     #
     # @example Create multiple derivatives with one set of directives.  This will create content_thumb and content_medium
-    #   transform_datastream :content, { :medium => "300x300>", :thumb => "100x100>" }
+    #   transform_file :content, { :medium => "300x300>", :thumb => "100x100>" }
     #
     # @example Specify which processor you want to use (defaults to :image)
-    #   transform_datastream :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
-    #   transform_datastream :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
+    #   transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+    #   transform_file :content, { :mp4 => {format: 'mp4'}, :webm => {format: 'webm'} }, processor: :video
     #
-    def transform_datastream(datastream_name, transform_directives, opts={})
+    def transform_file(file_name, transform_directives, opts={})
       processor = opts[:processor] ? opts[:processor] : :image
-      "Hydra::Derivatives::#{processor.to_s.classify}".constantize.new(self, datastream_name, transform_directives).process
+      "Hydra::Derivatives::#{processor.to_s.classify}".constantize.new(self, file_name, transform_directives).process
+    end
+
+    def transform_datastream(file_name, transform_directives, opts={})
+      transform_file(file_name, transform_directives, opts={})
     end
+    deprecation_deprecate :transform_datastream
+
 
     module ClassMethods
       # Register transformation schemes for generating derivatives.
@@ -89,9 +97,9 @@ module Hydra
       #    makes_derivatives do |obj|
       #      case obj.mime_type
       #      when 'application/pdf'
-      #        obj.transform_datastream :content, { :thumb => "100x100>" }
+      #        obj.transform_file :content, { :thumb => "100x100>" }
       #      when 'audio/wav'
-      #        obj.transform_datastream :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
+      #        obj.transform_file :content, { :mp3 => {format: 'mp3'}, :ogg => {format: 'ogg'} }, processor: :audio
       #
       # @example Define transformation scheme using a callback method
       #      makes_derivatives :generate_image_derivatives
@@ -99,7 +107,7 @@ module Hydra
       #      def generate_image_derivatives
       #        case mime_type
       #        when 'image/png', 'image/jpg'
-      #          transform_datastream :content, { :medium => "300x300>", :thumb => "100x100>" }
+      #          transform_file :content, { :medium => "300x300>", :thumb => "100x100>" }
       #        end
       #      end
       def makes_derivatives(*callback_method_names, &block)

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

@@ -2,19 +2,21 @@ require 'spec_helper'
 
 module Hydra::Derivatives
   describe ExtractMetadata do
-    let(:class_with_metadata_extraction) {
+    let(:class_with_metadata_extraction) do
       Class.new do
-        attr_reader :content, :mimeType, :pid, :dsVersionID
+        attr_reader :content, :mime_type, :uri
+
         def initialize(options = {})
           @content = options.fetch(:content, '')
-          @mimeType = options.fetch(:mime_type, nil)
-          @pid = options.fetch(:pid, 'pid-123')
-          @dsVersionID = options.fetch(:dsVersionID, 'version-id-1')
+          @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) }
 

data/spec/spec_helper.rb

@@ -4,7 +4,12 @@ require 'hydra/derivatives'
 #Resque.inline = Rails.env.test?
 require 'byebug' unless ENV['TRAVIS']
 
+require 'active_fedora/cleaner'
+ActiveFedora::Base.logger = Logger.new(STDOUT)
 RSpec.configure do |config|
+  config.before(:each) do
+    ActiveFedora::Cleaner.clean!
+  end
 end
 
 $in_travis = !ENV['TRAVIS'].nil? && ENV['TRAVIS'] == 'true'

data/spec/units/extract_spec.rb

@@ -1,12 +1,12 @@
 require "spec_helper"
 
-class ExtractThing < ActiveFedora::Datastream
+class ExtractThing < ActiveFedora::File
   include Hydra::Derivatives::ExtractMetadata
   attr_accessor :pid
 end
 
 describe Hydra::Derivatives::ExtractMetadata, :unless => $in_travis do
-  let(:subject) { ExtractThing.new }
+  let(:subject) { ExtractThing.new('http://example.com/foo') }
   let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
 
   describe "Image Content" do

data/spec/units/image_spec.rb

@@ -2,26 +2,29 @@ require 'spec_helper'
 
 describe Hydra::Derivatives::Image do
   let(:object) { ActiveFedora::Base.new }
+  let(:output_file) { double }
+
+  subject { Hydra::Derivatives::Image.new(object, 'content', directives)}
+
+  before { expect(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>" } }
-    subject { Hydra::Derivatives::Image.new(object, 'content', directives)}
+    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(an_instance_of(ActiveFedora::Datastream), "100x100>", 'png') do |ds|
-        expect(ds.dsid).to eq('content_thumb')
-      end
+      expect(subject).to receive(:create_resized_image).with(output_file, "100x100>", 'png')
       subject.process
     end
   end
+
   describe "when arguments are passed as a hash" do
-    let(:directives) {{ :thumb => {size: "200x300>", datastream: 'thumbnail'} }}
-    subject { Hydra::Derivatives::Image.new(object, 'content', directives)}
+    let(:directives) { { thumb: { size: "200x300>", datastream: file_name } } }
+    let(:file_name) { 'thumbnail' }
+
     it "should use the specified size and name" do
-      expect(subject).to receive(:create_resized_image).with(an_instance_of(ActiveFedora::Datastream), "200x300>", 'png') do |ds|
-        expect(ds.dsid).to eq('thumbnail')
-      end
+      expect(subject).to receive(:create_resized_image).with(output_file, "200x300>", 'png')
       subject.process
-
     end
   end
 end

data/spec/units/transcoding_spec.rb

@@ -2,39 +2,40 @@ require 'spec_helper'
 
 describe "Transcoder" do
   before(:all) do
-    class ContentDatastream < ActiveFedora::Datastream
+    class ContentDatastream < ActiveFedora::File
       include Hydra::Derivatives::ExtractMetadata
     end
 
     class GenericFile < ActiveFedora::Base
       include Hydra::Derivatives
-      has_metadata 'characterization', type: ActiveFedora::SimpleDatastream do |m|
-        m.field "mime_type", :string
+      contains 'characterization', class_name: 'ActiveFedora::SimpleDatastream' do |m|
+        m.field "mime_type_from_fits", :string
+        m.field "flag_as", :string
       end
 
-      has_attributes :mime_type, datastream: :characterization, multiple: false
-      has_file_datastream 'content', type: ContentDatastream
+      has_attributes :mime_type_from_fits, :flag_as, datastream: :characterization, multiple: false
+      contains 'content', class_name: 'ContentDatastream'
 
       makes_derivatives do |obj|
-        case obj.mime_type
+        case obj.mime_type_from_fits
         when 'application/pdf'
-          obj.transform_datastream :content, { thumb: '100x100>' }
+          obj.transform_file :content, { thumb: '100x100>' }
         when 'audio/wav'
-          obj.transform_datastream :content, { mp3: { format: 'mp3' }, ogg: { format: 'ogg'} }, processor: :audio
+          obj.transform_file :content, { mp3: { format: 'mp3' }, ogg: { format: 'ogg'} }, processor: :audio
         when 'video/avi'
-          obj.transform_datastream :content, { mp4: { format: 'mp4' }, webm: { format: 'webm'}, thumbnail: { format: 'jpg', datastream: 'thumbnail' } }, processor: :video
+          obj.transform_file :content, { mp4: { format: 'mp4' }, webm: { format: 'webm'}, thumbnail: { format: 'jpg', datastream: 'thumbnail' } }, processor: :video
         when 'image/png', 'image/jpg'
-          obj.transform_datastream :content, { medium: "300x300>", thumb: "100x100>", access: { format: 'jpg', datastream: 'access'} }
+          obj.transform_file :content, { medium: "300x300>", thumb: "100x100>", access: { format: 'jpg', datastream: 'access'} }
         when 'application/vnd.ms-powerpoint'
-          obj.transform_datastream :content, { preservation: { format: 'pptx'}, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :content, { preservation: { format: 'pptx'}, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'text/rtf'
-          obj.transform_datastream :content, { preservation: { format: 'odf' }, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :content, { preservation: { format: 'odf' }, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'application/msword'
-          obj.transform_datastream :content, { access: { format: 'pdf' }, preservation: { format: 'docx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :content, { access: { format: 'pdf' }, preservation: { format: 'docx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'application/vnd.ms-excel'
-          obj.transform_datastream :content, { access: { format: 'pdf' }, preservation: { format: 'xslx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          obj.transform_file :content, { access: { format: 'pdf' }, preservation: { format: 'xslx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
         when 'image/tiff'
-          obj.transform_datastream :content, {
+          obj.transform_file :content, {
             resized: { recipe: :default, resize: "600x600>", datastream: 'resized' },
             config_lookup: { recipe: :default, datastream: 'config_lookup' },
             string_recipe: { recipe: '-quiet', datastream: 'string_recipe' },
@@ -47,15 +48,14 @@ describe "Transcoder" do
       makes_derivatives :generate_special_derivatives
 
       def generate_special_derivatives
-        if label == "special" && mime_type == 'image/png'
-          transform_datastream :content, { medium: { size: "200x300>", datastream: 'special_ds' } }
+        if flag_as == "special" && mime_type_from_fits == 'image/png'
+          transform_file :content, { medium: { size: "200x300>", datastream: 'special_ds' } }
         end
       end
     end
   end
 
   after(:all) do
-    GenericFile.destroy_all
     Object.send(:remove_const, :GenericFile);
     Object.send(:remove_const, :ContentDatastream);
   end
@@ -63,162 +63,169 @@ describe "Transcoder" do
   describe "with an attached image" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
     let(:file) do
-      GenericFile.new(mime_type: 'image/png').tap do |f|
+      GenericFile.new(mime_type_from_fits: 'image/png').tap do |f|
         f.content.content = attachment
-        f.save
+        f.save!
       end
     end
 
     it "should transcode" do
-      expect(file.datastreams.key?('content_medium')).to be_falsey
+      expect(file.attached_files.key?('content_medium')).to be_falsey
       file.create_derivatives
-      expect(file.datastreams['content_medium']).to have_content
-      expect(file.datastreams['content_medium'].mimeType).to eq('image/png')
-      expect(file.datastreams['content_thumb']).to have_content
-      expect(file.datastreams['content_thumb'].mimeType).to eq('image/png')
-      expect(file.datastreams['access']).to have_content
-      expect(file.datastreams['access'].mimeType).to eq('image/jpeg')
-      expect(file.datastreams.key?('content_text')).to be_falsey
+      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
     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: 'application/pdf').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/pdf').tap { |t| t.content.content = attachment; t.save } }
 
     it "should transcode" do
-      expect(file.datastreams.key?('content_thumb')).to be_falsey
+      expect(file.attached_files.key?('content_thumb')).to be_falsey
       file.create_derivatives
-      expect(file.datastreams['content_thumb']).to have_content
-      expect(file.datastreams['content_thumb'].mimeType).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')
     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: 'audio/wav').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'audio/wav').tap { |t| t.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_mp3']).to have_content
-      expect(file.datastreams['content_mp3'].mimeType).to eq('audio/mpeg')
-      expect(file.datastreams['content_ogg']).to have_content
-      expect(file.datastreams['content_ogg'].mimeType).to eq('audio/ogg')
+      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')
     end
   end
 
   describe "when the source datastrem has an unknown mime_type", unless: ENV['TRAVIS'] == 'true' do
     let(:attachment) { File.open(File.expand_path('../../fixtures/piano_note.wav', __FILE__))}
-    let(:file) { GenericFile.new(mime_type: 'audio/wav').tap { |t| t.content.content = attachment; t.content.mimeType = 'audio/vnd.wav'; t.save } }
+    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.save
+      end
+    end
 
     it "should transcode" do
+      allow_any_instance_of(::Logger).to receive(:warn)
       file.create_derivatives
-      expect(file.datastreams['content_mp3']).to have_content
-      expect(file.datastreams['content_mp3'].mimeType).to eq('audio/mpeg')
+      expect(file.attached_files['content_mp3']).to have_content
+      expect(file.attached_files['content_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: 'video/avi').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'video/avi').tap { |t| t.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_mp4']).to have_content
-      expect(file.datastreams['content_mp4'].mimeType).to eq('video/mp4')
-      expect(file.datastreams['content_webm']).to have_content
-      expect(file.datastreams['content_webm'].mimeType).to eq('video/webm')
-      expect(file.datastreams['thumbnail']).to have_content
-      expect(file.datastreams['thumbnail'].mimeType).to eq('image/jpeg')
+      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['thumbnail']).to have_content
+      expect(file.attached_files['thumbnail'].mime_type).to eq('image/jpeg')
     end
   end
 
   describe "using callback methods" do
     let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
-    let(:file) { GenericFile.new(mime_type: 'image/png', label: "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.content.content = attachment; t.save } }
 
     it "should transcode" do
-      expect(file.datastreams.key?('special_ds')).to be_falsey
+      expect(file.attached_files.key?('special_ds')).to be_falsey
       file.create_derivatives
-      expect(file.datastreams['special_ds']).to have_content
-      expect(file.datastreams['special_ds'].mimeType).to eq('image/png')
-      expect(file.datastreams['special_ds']).to have_content
+      expect(file.attached_files['special_ds']).to have_content
+      expect(file.attached_files['special_ds'].mime_type).to eq('image/png')
+      expect(file.attached_files['special_ds']).to have_content
     end
   end
 
   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: '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.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_thumbnail']).to have_content
-      expect(file.datastreams['content_thumbnail'].mimeType).to eq('image/jpeg')
-      expect(file.datastreams['content_access']).to have_content
-      expect(file.datastreams['content_access'].mimeType).to eq('application/pdf')
-      expect(file.datastreams['content_preservation']).to have_content
-      expect(file.datastreams['content_preservation'].mimeType).to eq('application/vnd.openxmlformats-officedocument.presentationml.presentation')
+      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')
     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: 'text/rtf').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'text/rtf').tap { |t| t.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_thumbnail']).to have_content
-      expect(file.datastreams['content_thumbnail'].mimeType).to eq('image/jpeg')
-      expect(file.datastreams['content_access']).to have_content
-      expect(file.datastreams['content_access'].mimeType).to eq('application/pdf')
-      expect(file.datastreams['content_preservation']).to have_content
-      expect(file.datastreams['content_preservation'].mimeType).to eq('application/vnd.oasis.opendocument.text')
+      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')
     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: 'application/msword').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'application/msword').tap { |t| t.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_thumbnail']).to have_content
-      expect(file.datastreams['content_thumbnail'].mimeType).to eq('image/jpeg')
-      expect(file.datastreams['content_access']).to have_content
-      expect(file.datastreams['content_access'].mimeType).to eq('application/pdf')
-      expect(file.datastreams['content_preservation']).to have_content
-      expect(file.datastreams['content_preservation'].mimeType).to eq('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
+      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')
     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: '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.content.content = attachment; t.save } }
 
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_thumbnail']).to have_content
-      expect(file.datastreams['content_thumbnail'].mimeType).to eq('image/jpeg')
-      expect(file.datastreams['content_access']).to have_content
-      expect(file.datastreams['content_access'].mimeType).to eq('application/pdf')
-      expect(file.datastreams['content_preservation']).to have_content
-      expect(file.datastreams['content_preservation'].mimeType).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+      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')
     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: 'image/tiff').tap { |t| t.content.content = attachment; t.save } }
+    let(:file) { GenericFile.new(mime_type_from_fits: 'image/tiff').tap { |t| t.content.content = attachment; t.save } }
     it "should transcode" do
       file.create_derivatives
-      expect(file.datastreams['content_diy']).to have_content
-      expect(file.datastreams['content_diy'].mimeType).to eq('image/jp2')
-      expect(file.datastreams['config_lookup']).to have_content
-      expect(file.datastreams['config_lookup'].mimeType).to eq('image/jp2')
-      expect(file.datastreams['resized']).to have_content
-      expect(file.datastreams['resized'].mimeType).to eq('image/jp2')
-      expect(file.datastreams['string_recipe']).to have_content
-      expect(file.datastreams['string_recipe'].mimeType).to eq('image/jp2')
+      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['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
+      expect(file.attached_files['resized'].mime_type).to eq('image/jp2')
+      expect(file.attached_files['string_recipe']).to have_content
+      expect(file.attached_files['string_recipe'].mime_type).to eq('image/jp2')
     end
   end
 end

data/spec/units/video_spec.rb

@@ -6,7 +6,7 @@ describe Hydra::Derivatives::Video do
       let(:directives) {{ :thumb => {format: "webm", datastream: 'thumbnail'} }}
       subject { Hydra::Derivatives::Video.new(double(:obj), 'content', directives)}
       it "should create a datastream with the specified name" do
-        expect(subject).to receive(:encode_datastream).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=>""})
+        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
@@ -16,7 +16,7 @@ describe Hydra::Derivatives::Video do
       let(:directives) {{ :thumb => {format: "webm"} }}
       subject { Hydra::Derivatives::Video.new(double(:obj), 'content', directives)}
       it "should create a datastream and infer the name" do
-        expect(subject).to receive(:encode_datastream).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=>""})
+        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
@@ -26,7 +26,7 @@ describe Hydra::Derivatives::Video do
       let(:directives) {{ :thumb => {:format => 'jpg' , datastream: 'thumbnail'} }}
       subject { Hydra::Derivatives::Video.new(double(:obj), 'content', directives)}
       it "should create a datastream and infer the name" do
-        expect(subject).to receive(:encode_datastream).with("thumbnail", "jpg", "image/jpeg", {:output_options=>"-s 320x240 -vcodec mjpeg -vframes 1 -an -f rawvideo", :input_options=>" -itsoffset -2"})
+        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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-derivatives
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-21 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,16 +70,16 @@ dependencies:
   name: active-fedora
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 9.0.0.beta3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 9.0.0.beta3
 - !ruby/object:Gem::Dependency
   name: hydra-file_characterization
   requirement: !ruby/object:Gem::Requirement
@@ -128,6 +128,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: deprecation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Derivative generation plugin for hydra
 email:
 - justin@curationexperts.com
@@ -201,9 +229,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
@@ -234,3 +262,4 @@ test_files:
 - spec/units/logger_spec.rb
 - spec/units/transcoding_spec.rb
 - spec/units/video_spec.rb
+has_rdoc: