hydra-derivatives 3.1.3 → 3.1.4

data/spec/processors/image_spec.rb

@@ -1,46 +1,53 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives::Processors::Image do
-  let(:output_file) { double }
-  let(:file_name) { double }
-
+  let(:file_name) { "file_name" }
   subject { described_class.new(file_name, directives) }
 
-  before { allow(subject).to receive(:output_file).with(file_name).and_return(output_file) }
+  context "when arguments are passed as a hash" do
+    let(:directives)       { { label: :thumb, size: "200x300>", format: 'png', quality: 75 } }
+    let(:mock_transformer) { double("MockTransformer") }
 
-  describe "when arguments are passed as a hash" do
-    let(:directives) { { label: :thumb, size: "200x300>", format: 'png', quality: 75 } }
-    let(:file_name) { 'thumbnail' }
+    before do
+      allow(subject).to receive(:load_image_transformer).and_return(mock_transformer)
+      allow(subject).to receive(:write_image).with(mock_transformer)
+    end
 
     it "uses the specified size and name and quality" do
-      expect(subject).to receive(:create_resized_image).with(file_name, "200x300>", 'png', 75)
+      expect(mock_transformer).to receive(:flatten)
+      expect(mock_transformer).to receive(:resize).with("200x300>")
+      expect(mock_transformer).to receive(:format).with("png")
+      expect(mock_transformer).to receive(:quality).with("75")
       subject.process
     end
   end
 
-  describe 'timeout' do
-    let(:directives) { { thumb: "100x100>" } }
-    let(:file_name) { 'content_thumb' }
-
-    before do
-      allow(subject).to receive(:create_resized_image).with("100x100>", 'png')
-    end
+  describe "#process" do
+    let(:directives) { { size: "100x100>", format: "png" } }
 
-    context 'when set' do
+    context "when a timeout is set" do
       before do
         subject.timeout = 0.1
-        allow_any_instance_of(described_class).to receive(:process_without_timeout) { sleep 0.2 }
+        allow(subject).to receive(:create_resized_image) { sleep 0.2 }
       end
-      it 'raises a timeout exception' do
+      it "raises a timeout exception" do
         expect { subject.process }.to raise_error Hydra::Derivatives::TimeoutError
       end
     end
 
-    context 'when not set' do
+    context "when not set" do
       before { subject.timeout = nil }
-      it 'processes without a timeout' do
+      it "processes without a timeout" do
         expect(subject).to receive(:process_with_timeout).never
-        expect(subject).to receive(:process_without_timeout).once
+        expect(subject).to receive(:create_resized_image).once
+        subject.process
+      end
+    end
+
+    context "when running the complete command", unless: in_travis? do
+      let(:file_name) { File.join(fixture_path, "test.tif") }
+      it "converts the image" do
+        expect(Hydra::Derivatives::PersistBasicContainedOutputFileService).to receive(:call).with(kind_of(StringIO), directives)
         subject.process
       end
     end

data/spec/processors/jpeg2k_spec.rb

@@ -16,12 +16,11 @@ describe Hydra::Derivatives::Processors::Jpeg2kImage do
       calc = described_class.layer_rates(layers, compression_num)
       expect(calc).to eq("2.4,1.48331273,0.91675694,0.56659885,0.3501847,0.21643059,0.13376427,0.0826726")
     end
-
   end
 
   describe ".srgb_profile_path" do
     it "exists" do
-      expect(File.exists?(described_class.srgb_profile_path)).to eq true
+      expect(File.exist?(described_class.srgb_profile_path)).to eq true
     end
   end
 

data/spec/processors/processor_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives::Processors::Processor do
-
-  let(:object)        { "Fake Object"  }
+  let(:object)        { "Fake Object" }
   let(:source_name)   { 'content' }
   let(:directives)    { { thumb: "100x100>" } }
   let(:file_path)     { double }
 
-  subject { described_class.new(file_path, directives)}
+  subject { described_class.new(file_path, directives) }
 
   describe "output_file_service" do
     let(:custom_output_file_service) { "fake service" }

data/spec/processors/shell_based_processor_spec.rb

@@ -9,7 +9,7 @@ describe Hydra::Derivatives::Processors::ShellBasedProcessor do
 
   after { Object.send(:remove_const, :TestProcessor) }
 
-  let (:processor) { TestProcessor.new }
+  let(:processor) { TestProcessor.new }
 
   describe "options_for" do
     it "returns a hash" do

data/spec/processors/video_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Hydra::Derivatives::Processors::Video::Processor do
   let(:file_name) { 'foo/bar.mov' }
-  subject { described_class.new(file_name, directives)}
+  subject { described_class.new(file_name, directives) }
 
   describe ".config" do
     before do
@@ -13,8 +13,8 @@ describe Hydra::Derivatives::Processors::Video::Processor do
     after { described_class.config = @original_config }
     let(:directives) { { label: :thumb, format: "mp4", url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
 
-    it "should be configurable" do
-      expect(subject).to receive(:encode_file).with("mp4", { Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec mpeg4 -acodec aac -strict -2 -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "" })
+    it "is configurable" do
+      expect(subject).to receive(:encode_file).with("mp4", Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec mpeg4 -acodec aac -strict -2 -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "")
       subject.process
     end
   end
@@ -24,7 +24,7 @@ describe Hydra::Derivatives::Processors::Video::Processor do
       let(:directives) { { label: :thumb, format: 'webm', url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
 
       it "creates a fedora resource and infers the name" do
-        expect(subject).to receive(:encode_file).with("webm", { Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec libvpx -acodec libvorbis -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "" })
+        expect(subject).to receive(:encode_file).with("webm", Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec libvpx -acodec libvorbis -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "")
         subject.process
       end
     end

data/spec/services/audio_derivatives_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 describe Hydra::Derivatives::AudioDerivatives do
   describe ".create" do
     let(:filename) { 'spec/fixtures/piano_note.wav' }
-    context "with a filename", unless: $in_travis do
+    context "with a filename", unless: in_travis? do
       before do
         class LocalFileService
-          def self.call(file_name, options, &block)
+          def self.call(file_name, _options, &_block)
             yield File.open(file_name)
           end
         end
@@ -27,7 +27,7 @@ describe Hydra::Derivatives::AudioDerivatives do
     end
 
     context "with an object" do
-      let(:object)      { "Fake Object"  }
+      let(:object)      { "Fake Object" }
       let(:source_name) { :content }
       let(:file)        { double("the file") }
 
@@ -49,8 +49,8 @@ describe Hydra::Derivatives::AudioDerivatives do
     subject { described_class }
 
     it "relies on the source_file_service" do
-      expect(subject.source_file_service).to receive(:call).with('foo/bar.aiff', { baz: true })
-      subject.source_file('foo/bar.aiff', { baz: true })
+      expect(subject.source_file_service).to receive(:call).with('foo/bar.aiff', baz: true)
+      subject.source_file('foo/bar.aiff', baz: true)
     end
   end
 

data/spec/services/persist_basic_contained_output_file_service_spec.rb

@@ -1,29 +1,27 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives::PersistBasicContainedOutputFileService do
-
   before(:all) do
     class BasicContainerObject < ActiveFedora::Base
       has_subresource "the_derivative_name"
     end
   end
 
-  let(:object)            { BasicContainerObject.new  }
+  let(:object)            { BasicContainerObject.new }
   let(:file_path)         { File.join(fixture_path, 'test.tif') }
-  let(:file)              { File.new(file_path)}
+  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.create  }
+    let(:object) { BasicContainerObject.create }
     let(:stream) { StringIO.new("fake file content") }
     it "persists the file to the specified destination on the given object" do
-      described_class.call(stream, { format: 'jpg', url: "#{object.uri}/the_derivative_name" })
+      described_class.call(stream, format: 'jpg', url: "#{object.uri}/the_derivative_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

@@ -15,13 +15,13 @@ describe Hydra::Derivatives::RetrieveSourceFileService do
 
     class DirectContainerObject < ActiveFedora::Base
       directly_contains :files, has_member_relation: ::RDF::URI("http://pcdm.org/use#hasFile"),
-        class_name: "FileWithMetadata"
+                                class_name: "FileWithMetadata"
       directly_contains_one :directly_contained_file, through: :files, type: ::RDF::URI("http://pcdm.org/use#OriginalFile")
     end
   end
 
-  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  }
+  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' }
 
@@ -35,24 +35,24 @@ describe Hydra::Derivatives::RetrieveSourceFileService do
     end
 
     it "persists the file to the specified destination on the given object" do
-      described_class.call(object, { source: source_name }) do |f|
+      described_class.call(object, source: source_name) do |f|
         expect(f.read).to eq(object.contained_file.content)
       end
     end
   end
 
-  context "when file is directly contained" do  # direct containers are more efficient, but most legacy code will have indirect containers
+  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.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
-      described_class.call(object, { source: source_name }) do |f|
+      described_class.call(object, source: source_name) do |f|
         expect(f.read).to eq(object.directly_contained_file.content)
       end
     end

data/spec/services/tempfile_service_spec.rb

@@ -11,7 +11,9 @@ describe Hydra::Derivatives::TempfileService do
         @uri = 'http://example.com/pid/123'
       end
 
-      def has_content?; content.present?; end
+      def has_content?
+        content.present?
+      end
     end
   end
 
@@ -19,7 +21,7 @@ describe Hydra::Derivatives::TempfileService do
 
   let(:file) { class_with_metadata_extraction.new(initialization_options) }
 
-  subject { Hydra::Derivatives::TempfileService.new(file) }
+  subject { described_class.new(file) }
   context '#tempfile' do
     it 'has a method called to_tempfile' do
       expect { |b| subject.tempfile(&b) }.to yield_with_args(Tempfile)

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 ENV['environment'] ||= 'test'
 # - RSpec adds ./lib to the $LOAD_PATH
 require 'hydra/derivatives'
-#Resque.inline = Rails.env.test?
+# Resque.inline = Rails.env.test?
 require 'byebug' unless ENV['TRAVIS']
 
 require 'active_fedora/cleaner'
@@ -19,8 +19,10 @@ 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
+
+def in_travis?
+  !ENV['TRAVIS'].nil? && ENV['TRAVIS'] == 'true'
+end

data/spec/units/config_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "the configuration" do
   subject { Hydra::Derivatives }
 
-  it "should have some configuration defaults" do
+  it "has some configuration defaults" do
     expect(subject.ffmpeg_path).to eq('ffmpeg')
     expect(subject.enable_ffmpeg).to be true
     expect(subject.libreoffice_path).to eq('soffice')
@@ -14,28 +14,27 @@ describe "the configuration" do
     expect(subject.source_file_service).to eq(Hydra::Derivatives::RetrieveSourceFileService)
   end
 
-  it "should let you change the configuration" do
+  it "lets you change the configuration" do
     subject.ffmpeg_path = '/usr/local/ffmpeg-1.0/bin/ffmpeg'
     expect(subject.ffmpeg_path).to eq('/usr/local/ffmpeg-1.0/bin/ffmpeg')
 
     subject.kdu_compress_path = '/opt/local/bin/kdu_compress'
     expect(subject.kdu_compress_path).to eq('/opt/local/bin/kdu_compress')
-
   end
 
-  it "should let you set a custom output file service" do
+  it "lets 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
+  it "lets 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
+  it "lets you reset the configuration" do
     subject.ffmpeg_path = '/usr/local/ffmpeg-1.0/bin/ffmpeg'
     subject.reset_config!
     expect(subject.ffmpeg_path).to eq('ffmpeg')
@@ -44,5 +43,4 @@ describe "the configuration" do
     subject.reset_config!
     expect(subject.kdu_compress_path).to eq('kdu_compress')
   end
-
 end

data/spec/units/derivatives_spec.rb

@@ -5,41 +5,28 @@ describe Hydra::Derivatives do
     class CustomFile < ActiveFedora::Base
       include Hydra::Derivatives
     end
-    class CustomProcessor < Hydra::Derivatives::Processors::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
+  after(:all) { Object.send(:remove_const, :CustomFile) }
 
   describe "source_file_service" do
-    let(:custom_source_file_service) { "fake service" }
-    before do
-      allow(Hydra::Derivatives).to receive(:source_file_service).and_return(custom_source_file_service)
-    end
-    subject { Class.new { include Hydra::Derivatives } }
+    before  { subject.source_file_service = custom_source_file_service }
 
     context "as a global configuration setting" do
+      let(:custom_source_file_service) { "fake service" }
+      subject { CustomFile }
+
       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
-      let(:another_custom_source_file_service) { "another fake service" }
-      subject { Class.new { include Hydra::Derivatives }.new }
-      before { subject.source_file_service = another_custom_source_file_service }
+      let(:custom_source_file_service) { "another fake service" }
+      subject { CustomFile.new }
 
       it "accepts a custom source file service as an option" do
-        expect(subject.source_file_service).to eq(another_custom_source_file_service)
+        expect(subject.source_file_service).to eq(custom_source_file_service)
       end
     end
   end

data/spec/units/logger_spec.rb

@@ -1,25 +1,22 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives::Logger do
-
   context "with log levels" do
+    let(:levels) { %w(unknown fatal error warn info debug) }
 
-    let(:levels) { ["unknown", "fatal", "error", "warn", "info", "debug"] }
-
-    it "should respond successfully" do
+    it "responds successfully" do
       levels.each do |level|
-        expect(Hydra::Derivatives::Logger.respond_to?(level)).to be_truthy
+        expect(described_class.respond_to?(level)).to be_truthy
       end
     end
-    it "should accept messages" do
-      expect(Hydra::Derivatives::Logger.warn("message")).to be_truthy
+    it "accepts messages" do
+      expect(described_class.warn("message")).to be_truthy
     end
   end
 
   context "with garbage" do
-    it "should raise an error" do
-      expect{Hydra::Derivatives::Logger.garbage}.to raise_error(NoMethodError)
+    it "raises an error" do
+      expect { described_class.garbage }.to raise_error(NoMethodError)
     end
   end
-
 end

data/spec/units/transcoding_spec.rb

@@ -1,60 +1,79 @@
 require 'spec_helper'
 
-describe "Transcoder" do
+describe "Transcoding" do
   before(:all) do
     class GenericFile < ActiveFedora::Base
       include Hydra::Derivatives
       property :mime_type_from_fits, predicate: ::RDF::URI('http://example.com/mime'), multiple: false
       has_subresource 'original_file'
 
-      def create_derivatives(filename)
+      def create_derivatives(_filename)
         case mime_type_from_fits
         when 'application/pdf'
           PdfDerivatives.create(self, source: :original_file,
-                                outputs: [{ label: :thumb, size: "100x100>", url: "#{uri}/original_file_thumb" }])
+                                      outputs: [{ label: :thumb, size: "100x100>", url: "#{uri}/original_file_thumb" }])
           FullTextExtract.create(self, source: :original_file, outputs: [{ url: "#{uri}/fulltext" }])
         when 'audio/wav'
-          AudioDerivatives.create(self, source: :original_file, outputs: [{ label: :mp3, format: 'mp3', url: "#{uri}/mp3" }, { label: :ogg, format: 'ogg', url: "#{uri}/ogg" }])
+          AudioDerivatives.create(self, source: :original_file,
+                                        outputs: [
+                                          { label: :mp3, format: 'mp3', url: "#{uri}/mp3" },
+                                          { label: :ogg, format: 'ogg', url: "#{uri}/ogg" }])
         when 'video/avi'
           VideoDerivatives.create(self, source: :original_file,
-                                  outputs: [
-                                    { label: :mp4, format: 'mp4', url: "#{uri}/original_file_mp4" },
-                                    { label: :webm, format: 'webm', url: "#{uri}/original_file_webm" },
-                                    { label: :thumbnail, format: 'jpg', url: "#{uri}/thumbnail" }])
+                                        outputs: [
+                                          { label: :mp4,       format: 'mp4',  url: "#{uri}/original_file_mp4" },
+                                          { label: :webm,      format: 'webm', url: "#{uri}/original_file_webm" },
+                                          { label: :thumbnail, format: 'jpg',  url: "#{uri}/thumbnail" }])
         when 'image/png', 'image/jpg'
           ImageDerivatives.create(self, source: :original_file,
                                   outputs: [
                                     { label: :medium, size: "300x300>", url: "#{uri}/original_file_medium" },
-                                    { label: :thumb, size: "100x100>", url: "#{uri}/original_file_thumb" },
-                                    { label: :access, url: "#{uri}/access", format: 'jpg' },
+                                    { label: :thumb,  size: "100x100>", url: "#{uri}/original_file_thumb" },
+                                    { label: :access, format: 'jpg',    url: "#{uri}/access" },
           ])
         when 'application/vnd.ms-powerpoint'
-          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'pptx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
+          DocumentDerivatives.create(self, source: :original_file,
+                                           outputs: [
+                                             { label: :preservation, format: 'pptx', url: "#{uri}/original_file_preservation" },
+                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
+                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }])
         when 'text/rtf'
-          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'odf' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
+          DocumentDerivatives.create(self, source: :original_file,
+                                           outputs: [
+                                             { label: :preservation, format: 'odf', url: "#{uri}/original_file_preservation" },
+                                             { label: :access,       format: 'pdf', url: "#{uri}/original_file_access" },
+                                             { label: :thumnail,     format: 'jpg', url: "#{uri}/original_file_thumbnail" }])
         when 'application/msword'
-          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'docx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
+          DocumentDerivatives.create(self, source: :original_file,
+                                           outputs: [
+                                             { label: :preservation, format: 'docx', url: "#{uri}/original_file_preservation" },
+                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
+                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }])
         when 'application/vnd.ms-excel'
-          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'xslx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
+          DocumentDerivatives.create(self, source: :original_file,
+                                           outputs: [
+                                             { label: :preservation, format: 'xslx', url: "#{uri}/original_file_preservation" },
+                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
+                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }])
         when 'image/tiff'
-          Jpeg2kImageDerivatives.create(self, source: :original_file, outputs: [
-            { label: :resized, recipe: :default, resize: "600x600>", processor: 'jpeg2k_image', url: "#{uri}/resized" },
-            { label: :config_lookup, recipe: :default, processor: 'jpeg2k_image', url: "#{uri}/config_lookup" },
-            { label: :string_recipe, recipe: '-quiet', processor: 'jpeg2k_image', url: "#{uri}/string_recipe" },
-            { label: :diy, processor: 'jpeg2k_image', url: "#{uri}/original_file_diy" }
-          ])
+          Jpeg2kImageDerivatives.create(self, source: :original_file,
+                                              outputs: [
+                                                { label: :resized,       recipe: :default, processor: 'jpeg2k_image', resize: "600x600>", url: "#{uri}/resized" },
+                                                { label: :config_lookup, recipe: :default, processor: 'jpeg2k_image',                     url: "#{uri}/config_lookup" },
+                                                { label: :string_recipe, recipe: '-quiet', processor: 'jpeg2k_image',                     url: "#{uri}/string_recipe" },
+                                                { label: :diy,                             processor: 'jpeg2k_image',                     url: "#{uri}/original_file_diy" }])
         when 'image/x-adobe-dng'
-          ImageDerivatives.create(self, source: :original_file, outputs: [
-            { label: :access, size: "300x300>", format: 'jpg', processor: :raw_image },
-            { label: :thumb, size: "100x100>", format: 'jpg', processor: :raw_image }
-          ])
-         end
+          ImageDerivatives.create(self, source: :original_file,
+                                        outputs: [
+                                          { label: :access, size: "300x300>", format: 'jpg', processor: :raw_image },
+                                          { label: :thumb,  size: "100x100>", format: 'jpg', processor: :raw_image }])
+        end
       end
     end
   end
 
   after(:all) do
-    Object.send(:remove_const, :GenericFile);
+    Object.send(:remove_const, :GenericFile)
   end
 
   describe "with an attached image" do
@@ -67,7 +86,7 @@ describe "Transcoder" do
       end
     end
 
-    it "should transcode" do
+    it "transcodes" do
       expect(file.attached_files.key?('original_file_medium')).to be_falsey
       file.create_derivatives(filename)
       file.reload
@@ -81,7 +100,7 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached RAW image", unless: $in_travis do
+  describe "with an attached RAW image", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/test.dng', __FILE__) }
     let(:attachment) { File.open(filename) }
     let(:file) do
@@ -92,8 +111,8 @@ describe "Transcoder" do
       end
     end
 
-    it "should transcode" do
-     expect(file.attached_files.key?('access')).to be_falsey
+    it "transcodes" do
+      expect(file.attached_files.key?('access')).to be_falsey
       expect(file.attached_files.key?('thumb')).to be_falsey
 
       file.create_derivatives(filename)
@@ -104,7 +123,7 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached pdf", unless: $in_travis do
+  describe "with an attached pdf", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/test.pdf', __FILE__) }
     let(:attachment) { File.open(filename) }
     let(:file) do
@@ -115,23 +134,28 @@ describe "Transcoder" do
       end
     end
 
-    it "should transcode" do
+    it "transcodes" do
       expect(file.attached_files.key?('original_file_thumb')).to be_falsey
       file.create_derivatives(filename)
       file.reload
       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['fulltext'].content).to match /This PDF file was created using CutePDF/
+      expect(file.attached_files['fulltext'].content).to match(/This PDF file was created using CutePDF/)
       expect(file.attached_files['fulltext'].mime_type).to eq 'text/plain'
     end
   end
 
-  describe "with an attached audio", unless: $in_travis do
+  describe "with an attached audio", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/piano_note.wav', __FILE__) }
     let(:attachment) { File.open(filename) }
-    let(:file) { GenericFile.new(mime_type_from_fits: 'audio/wav').tap { |t| t.original_file.content = attachment; t.save } }
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'audio/wav').tap do |t|
+        t.original_file.content = attachment
+        t.save
+      end
+    end
 
-    it "should transcode" do
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_mp3']).to have_content
@@ -141,18 +165,18 @@ describe "Transcoder" do
     end
   end
 
-  describe "when the source datastrem has an unknown mime_type", unless: $in_travis do
+  describe "when the source datastrem has an unknown mime_type", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/piano_note.wav', __FILE__) }
     let(:attachment) { File.open(filename) }
     let(:file) do
       GenericFile.new(mime_type_from_fits: 'audio/wav').tap do |t|
-        t.original_file.content = attachment;
-        t.original_file.mime_type = 'audio/vnd.wav';
+        t.original_file.content = attachment
+        t.original_file.mime_type = 'audio/vnd.wav'
         t.save
       end
     end
 
-    it "should transcode" do
+    it "transcodes" do
       allow_any_instance_of(::Logger).to receive(:warn)
       file.create_derivatives(filename)
       file.reload
@@ -161,7 +185,7 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached video", unless: $in_travis do
+  describe "with an attached video", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/countdown.avi', __FILE__) }
     let(:attachment) { File.open(filename) }
     let(:file) do
@@ -171,7 +195,7 @@ describe "Transcoder" do
       end
     end
 
-    it "should transcode" do
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_mp4']).to have_content
@@ -190,13 +214,13 @@ describe "Transcoder" do
         Hydra::Derivatives::Processors::Video::Processor.timeout = nil # clear timeout
       end
 
-      it "should raise a timeout" do
+      it "raises a timeout" do
         expect { file.create_derivatives(filename) }.to raise_error Hydra::Derivatives::TimeoutError
       end
     end
   end
 
-  describe "with an attached Powerpoint", unless: $in_travis do
+  describe "with an attached Powerpoint", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/FlashPix.ppt', __FILE__) }
     let(:attachment) { File.open(filename) }
     let(:file) do
@@ -205,7 +229,7 @@ describe "Transcoder" do
       end
     end
 
-    it "should transcode" do
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_thumbnail']).to have_content
@@ -217,12 +241,17 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached rich text format", unless: $in_travis do
+  describe "with an attached rich text format", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/sample.rtf', __FILE__) }
     let(:attachment) { File.open(filename) }
-    let(:file) { GenericFile.new(mime_type_from_fits: 'text/rtf').tap { |t| t.original_file.content = attachment; t.save } }
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'text/rtf').tap do |t|
+        t.original_file.content = attachment
+        t.save
+      end
+    end
 
-    it "should transcode" do
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_thumbnail']).to have_content
@@ -234,12 +263,19 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached word doc format", unless: $in_travis do
-    let(:filename) { File.expand_path('../../fixtures/test.doc', __FILE__) }
+  describe "with an attached word doc format", unless: in_travis? do
+    let(:filename)   { File.expand_path('../../fixtures/test.doc', __FILE__) }
     let(:attachment) { File.open(filename) }
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/msword').tap { |t| t.original_file.content = attachment; t.save } }
 
-    it "should transcode" do
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'application/msword').tap do |t|
+        t.original_file.content = attachment
+        t.original_file.mime_type = 'application/msword'
+        t.save
+      end
+    end
+
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_thumbnail']).to have_content
@@ -251,12 +287,19 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached excel format", unless: $in_travis do
-    let(:filename) { File.expand_path('../../fixtures/test.xls', __FILE__) }
-    let(:attachment) { File.open(filename)}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap { |t| t.original_file.content = attachment; t.save } }
+  describe "with an attached excel format", unless: in_travis? do
+    let(:filename)   { File.expand_path('../../fixtures/test.xls', __FILE__) }
+    let(:attachment) { File.open(filename) }
+
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap do |t|
+        t.original_file.content = attachment
+        t.original_file.mime_type = 'application/vnd.ms-excel'
+        t.save
+      end
+    end
 
-    it "should transcode" do
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_thumbnail']).to have_content
@@ -268,11 +311,18 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached tiff", unless: $in_travis do
+  describe "with an attached tiff", unless: in_travis? do
     let(:filename) { File.expand_path('../../fixtures/test.tif', __FILE__) }
-    let(:attachment) { File.open(filename)}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'image/tiff').tap { |t| t.original_file.content = attachment; t.save } }
-    it "should transcode" do
+    let(:attachment) { File.open(filename) }
+
+    let(:file) do
+      GenericFile.new(mime_type_from_fits: 'image/tiff').tap do |t|
+        t.original_file.content = attachment
+        t.save
+      end
+    end
+
+    it "transcodes" do
       file.create_derivatives(filename)
       file.reload
       expect(file.attached_files['original_file_diy']).to have_content