carrierwave-video 0.5.6 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 95679b1b2e16fb661650f03586f126d8477be156
-  data.tar.gz: 81715a2918564e59d20910e33ddaa27f2d135def
+SHA256:
+  metadata.gz: 9d5424a24ecf4eaf711a8ca2b1a779fcb6222fc2ade93a3106a1fcbdc04ad569
+  data.tar.gz: 2edb861101e2f2ee30215e9ef0e1368f61c0dc0f6a470186cf873783a2eb4a61
 SHA512:
-  metadata.gz: 9d470bc9348adbaeaff769cdee8f00af8d2df9f006eefb514b96c09667664f789f2c5883f89f25e415979859328cea7a73937aa829234dcc8053d8c39b3b74bb
-  data.tar.gz: d00292a59ad84837b73847619b685c67b9312857a3ba081dcc7fdafd087285930b32b6bd515ca98332b1a5326a60a0150a61ee3b1965325c424ba37b691dc5d1
+  metadata.gz: 1f11f72d4eb912467bff4d7ce002b33aa7471acf063e18a3db3b18fbad324a127d257000eea4a7dfbe19b35e57e4d09a85444c9af8eec431e8ea1bfcdcd78edd
+  data.tar.gz: b942ea38e90e46b240d73141fc9424dbf25f26f3c4e8a519cfeffa628fc7550f4fd1cde55621d91de7da05a865c57f9a3da1d7076be5f9dc8775a5b1f630a674

data/.rbenv-gemsets

@@ -0,0 +1 @@
+carrierwave-video

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -1,3 +1,3 @@
 language: ruby
 rvm:
-  - 1.9.3
+  - 2.3.1

data/README.rdoc

@@ -37,6 +37,14 @@ Pass in options to process:
 Resolution passed to ffmpeg:
     resolution: "640x360"
 
+Also, you can preserve initial video's aspect ratio by changing one of result's resolutions:
+    preserve_aspect_ratio: :width
+to change height of the video, depending on it's width (default value),
+    preserve_aspect_ratio: :height
+to change width of the video, depending on it's height, or
+    preserve_aspect_ratio: false
+to leave resolution unchanged
+
 If you want to keep the same resolution:
 
 Note: This only works with the edge version of streamio-ffmpeg (as of Feb 28, 2014) https://github.com/streamio/streamio-ffmpeg/issues/72
@@ -76,7 +84,7 @@ e.g. `def progress(format, format_options, progress)` would receive something li
 
 Custom:
 streamio-ffmpeg accepts custom params. You may pass these in but keep in mind the watermarking params will be appended if there were any.
-  custom: '-b 1500k'
+  custom: %w(-b 1500k)
 
 = Dynamic Configuration
 
@@ -150,5 +158,5 @@ Depending on how you installed ffmpeg, you need to put them in the correct direc
 *NOTE:*
 For older versions of ffmpeg, the +-preset+ flag was called +-vpre+.  If you are using a version prior to 0.11, you must call carrierwave-video using the +custom+ option to change those flags.  Something along the lines of:
 
-    encode_video(:mp4, :custom => '-qscale 0 -vpre slow -vpre baseline -g 30')
+    encode_video(:mp4, :custom => %w(-qscale 0 -vpre slow -vpre baseline -g 30))
 

data/carrierwave-video.gemspec

@@ -20,11 +20,11 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_development_dependency "rspec", ">= 2.10.0"
+  s.add_development_dependency "rspec", ">= 3.3.0"
   s.add_development_dependency "rake"
 
   s.add_runtime_dependency 'streamio-ffmpeg'
   s.add_runtime_dependency 'carrierwave'
   s.requirements << 'ruby, version 1.9 or greater'
-  s.requirements << 'ffmpeg, version 0.11.1 or greater with libx256, libfaac, libtheora, libvorbid, libvpx enabled'
+  s.requirements << 'ffmpeg, version 0.11.1 or greater with libx256, libfdk-aac, libtheora, libvorbid, libvpx enabled'
 end

data/lib/carrierwave-video/version.rb

@@ -1,5 +1,5 @@
 module Carrierwave
   module Video
-    VERSION = "0.5.6"
+    VERSION = "0.6.0"
   end
 end

data/lib/carrierwave/video.rb

@@ -90,7 +90,8 @@ module CarrierWave
             end
           end
 
-          raise CarrierWave::ProcessingError.new("Failed to transcode with FFmpeg. Check ffmpeg install and verify video is not corrupt or cut short. Original error: #{e}")
+          raise e
+
         ensure
           reset_logger
           send_callback(callbacks[:ensure])

data/lib/carrierwave/video/ffmpeg_options.rb

@@ -11,6 +11,7 @@ module CarrierWave
         @logger = options[:logger]
         @unparsed = options
         @progress = options[:progress]
+        @preserve_aspect_ratio = options[:preserve_aspect_ratio] || :width
 
         @format_options = defaults.merge(options)
       end
@@ -31,7 +32,7 @@ module CarrierWave
       end
 
       def encoder_options
-        { preserve_aspect_ratio: :width }
+        { preserve_aspect_ratio: @preserve_aspect_ratio }
       end
 
       # input
@@ -43,7 +44,7 @@ module CarrierWave
       def format_params
         params = @format_options.dup
         params.delete(:watermark)
-        params[:custom] = [params[:custom], watermark_params].compact.join(' ')
+        params[:custom] = params[:custom] + watermark_params
         params
       end
 
@@ -52,7 +53,7 @@ module CarrierWave
       end
 
       def watermark_params
-        return nil unless watermark?
+        return [] unless watermark?
 
         @watermark_params ||= begin
           path = @format_options[:watermark][:path]
@@ -69,27 +70,27 @@ module CarrierWave
                             "main_w-overlay_w-#{margin}:#{margin}"
                         end
 
-          "-vf \"movie=#{path} [logo]; [in][logo] overlay=#{positioning} [out]\""
+          ["-vf", "\"movie=#{path} [logo]; [in][logo] overlay=#{positioning} [out]\""]
         end
       end
 
       private
 
         def defaults
-          @defaults ||= { resolution: '640x360', watermark: {} }.tap do |h|
+          @defaults ||= { resolution: @resolution, watermark: {} }.tap do |h|
             case format
             when 'mp4'
               h[:video_codec] = 'libx264'
-              h[:audio_codec] = 'libfaac'
-              h[:custom] = '-qscale 0 -preset slow -g 30'
+              h[:audio_codec] = 'aac'
+              h[:custom] = %w(-r 30 -strict -2 -map_metadata -1)
             when 'ogv'
               h[:video_codec] = 'libtheora'
               h[:audio_codec] = 'libvorbis'
-              h[:custom] = '-b 1500k -ab 160000 -g 30'
+              h[:custom] = %w(-b 1500k -ab 160000 -g 30)
             when 'webm'
               h[:video_codec] = 'libvpx'
               h[:audio_codec] = 'libvorbis'
-              h[:custom] = '-b 1500k -ab 160000 -f webm -g 30'
+              h[:custom] = %w(-b 1500k -ab 160000 -f webm)
             end
           end
         end

data/spec/lib/carrierwave_video_spec.rb

@@ -16,58 +16,58 @@ describe CarrierWave::Video do
 
   describe ".encode_video" do
     it "processes the model" do
-      TestVideoUploader.should_receive(:process).with(encode_video: ["format", :opts])
+      expect(TestVideoUploader).to receive(:process).with(encode_video: ["format", :opts])
       TestVideoUploader.encode_video("format", :opts)
     end
 
     it "does not require options" do
-      TestVideoUploader.should_receive(:process).with(encode_video: ["format", {}])
+      expect(TestVideoUploader).to receive(:process).with(encode_video: ["format", {}])
       TestVideoUploader.encode_video("format")
     end
   end
 
   describe ".encode_ogv" do
     it "processes the model" do
-      TestVideoUploader.should_receive(:process).with(encode_ogv: [:opts])
+      expect(TestVideoUploader).to receive(:process).with(encode_ogv: [:opts])
       TestVideoUploader.encode_ogv(:opts)
     end
 
     it "does not require options" do
-      TestVideoUploader.should_receive(:process).with(encode_ogv: [{}])
+      expect(TestVideoUploader).to receive(:process).with(encode_ogv: [{}])
       TestVideoUploader.encode_ogv
     end
   end
 
   describe "#encode_video" do
     let(:format) { 'webm' }
-    let(:movie) { mock }
+    let(:movie) { double }
 
     before do
-      converter.stub(:current_path).and_return('video/path/file.mov')
+      allow(converter).to receive(:current_path).and_return('video/path/file.mov')
 
-      FFMPEG::Movie.should_receive(:new).and_return(movie)
+      expect(FFMPEG::Movie).to receive(:new).and_return(movie)
     end
 
     context "with no options set" do
-      before {  File.should_receive(:rename) }
+      before {  expect(File).to receive(:rename) }
 
       it "calls transcode with correct format options" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          codec_opts.should == {preserve_aspect_ratio: :width}
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(codec_opts).to eq({preserve_aspect_ratio: :width})
 
-          opts[:video_codec].should == 'libvpx'
-          opts[:audio_codec].should == 'libvorbis'
-          opts[:custom].should == '-b 1500k -ab 160000 -f webm -g 30'
+          expect(opts[:video_codec]).to eq('libvpx')
+          expect(opts[:audio_codec]).to eq('libvorbis')
+          expect(opts[:custom]).to eq(%w(-b 1500k -ab 160000 -f webm))
 
-          path.should == "video/path/tmpfile.#{format}"
+          expect(path).to eq("video/path/tmpfile.#{format}")
         end
 
         converter.encode_video(format)
       end
 
       it "provides a default for the resolution" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          opts[:resolution].should == '640x360'
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(opts[:resolution]).to eq('640x360')
         end
 
         converter.encode_video(format)
@@ -75,7 +75,7 @@ describe CarrierWave::Video do
     end
 
     context "with callbacks set" do
-      before { movie.should_receive(:transcode) }
+      before { expect(movie).to receive(:transcode) }
       let(:opts) do
         { callbacks: {
              before_transcode: :method1,
@@ -87,13 +87,13 @@ describe CarrierWave::Video do
       end
 
       context "no exceptions raised" do
-        before {  File.should_receive(:rename) }
+        before {  expect(File).to receive(:rename) }
 
         it "calls before_transcode, after_transcode, and ensure" do
-          converter.model.should_receive(:method1).with(format, opts).ordered
-          converter.model.should_receive(:method2).with(format, opts).ordered
-          converter.model.should_not_receive(:method3)
-          converter.model.should_receive(:method4).with(format, opts).ordered
+          expect(converter.model).to receive(:method1).with(format, opts).ordered
+          expect(converter.model).to receive(:method2).with(format, opts).ordered
+          expect(converter.model).not_to receive(:method3)
+          expect(converter.model).to receive(:method4).with(format, opts).ordered
 
           converter.encode_video(format, opts)
         end
@@ -101,88 +101,87 @@ describe CarrierWave::Video do
 
       context "exception raised" do
         let(:e) { StandardError.new("test error") }
-        before { File.should_receive(:rename).and_raise(e) }
-
+        before { expect(File).to receive(:rename).and_raise(e) }
 
         it "calls before_transcode and ensure" do
-          converter.model.should_receive(:method1).with(format, opts).ordered
-          converter.model.should_not_receive(:method2)
-          converter.model.should_receive(:method3).with(format, opts).ordered
-          converter.model.should_receive(:method4).with(format, opts).ordered
+          expect(converter.model).to receive(:method1).with(format, opts).ordered
+          expect(converter.model).not_to receive(:method2)
+          expect(converter.model).to receive(:method3).with(format, opts).ordered
+          expect(converter.model).to receive(:method4).with(format, opts).ordered
 
-          lambda do
+          expect do
             converter.encode_video(format, opts)
-          end.should raise_exception(CarrierWave::ProcessingError)
+          end.to raise_exception(e.class)
         end
       end
     end
 
     context "with logger set" do
-      let(:logger) { mock }
+      let(:logger) { double }
       before do
-        converter.model.stub(:logger).and_return(logger)
-        movie.should_receive(:transcode)
+        allow(converter.model).to receive(:logger).and_return(logger)
+        expect(movie).to receive(:transcode)
       end
 
       context "with no exceptions" do
-        before { File.should_receive(:rename) }
+        before { expect(File).to receive(:rename) }
 
         it "sets FFMPEG logger to logger and resets" do
           old_logger = ::FFMPEG.logger
-          ::FFMPEG.should_receive(:logger=).with(logger).ordered
-          ::FFMPEG.should_receive(:logger=).with(old_logger).ordered
+          expect(::FFMPEG).to receive(:logger=).with(logger).ordered
+          expect(::FFMPEG).to receive(:logger=).with(old_logger).ordered
           converter.encode_video(format, logger: :logger)
         end
       end
 
       context "with exceptions" do
         let(:e) { StandardError.new("test error") }
-        before { File.should_receive(:rename).and_raise(e) }
+        before { expect(File).to receive(:rename).and_raise(e) }
 
         it "logs exception" do
-          logger.should_receive(:error).with("#{e.class}: #{e.message}")
-          logger.should_receive(:error).any_number_of_times #backtrace
+          expect(logger).to receive(:error).with("#{e.class}: #{e.message}")
+          allow(logger).to receive(:error) #backtrace
 
-          lambda do
+          expect do
             converter.encode_video(format, logger: :logger)
-          end.should raise_exception(CarrierWave::ProcessingError)
+          end.to raise_exception(e.class)
         end
       end
     end
 
     context "with progress set" do
       before do
-        File.should_receive(:rename)
-        movie.stub(:transcode).and_yield(0.0).and_yield(1.0)
+        expect(File).to receive(:rename)
+        allow(movie).to receive(:transcode).and_yield(0.0).and_yield(1.0)
       end
       let(:opts) { {progress: :progress} }
 
       it "logs progress" do
-        converter.model.should_receive(:progress).with(0.0)
-        converter.model.should_receive(:progress).with(1.0)
+        expect(converter.model).to receive(:progress).with(0.0)
+        expect(converter.model).to receive(:progress).with(1.0)
         converter.encode_video(format, progress: :progress)
       end
 
       it "logs progress with format and options" do
-        converter.model.stub_chain(:method, :arity).and_return(3)
-        converter.model.should_receive(:progress).with(format, hash_including(opts), 0.0)
-        converter.model.should_receive(:progress).with(format, hash_including(opts), 1.0)
+        allow(converter.model).to receive_message_chain(:method, :arity).and_return(3)
+        expect(converter.model).to receive(:progress).with(format, hash_including(opts), 0.0)
+        expect(converter.model).to receive(:progress).with(format, hash_including(opts), 1.0)
         converter.encode_video(format, opts)
       end
     end
 
     context "with watermark set" do
-      before { File.should_receive(:rename) }
+      before { expect(File).to receive(:rename) }
 
       it "appends watermark params to custom params for ffmpeg" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          codec_opts.should == {preserve_aspect_ratio: :width}
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(codec_opts).to eq({preserve_aspect_ratio: :width})
 
-          opts[:video_codec].should == 'libvpx'
-          opts[:audio_codec].should == 'libvorbis'
-          opts[:custom].should == "-b 1500k -ab 160000 -f webm -g 30 -vf \"movie=path/to/file.png [logo]; [in][logo] overlay=5:main_h-overlay_h-5 [out]\""
+          expect(opts[:video_codec]).to eq('libvpx')
+          expect(opts[:audio_codec]).to eq('libvorbis')
+          expect(opts[:custom]).to eq(["-b","1500k","-ab","160000","-f","webm","-vf","\"movie=path/to/file.png [logo]; [in][logo] overlay=5:main_h-overlay_h-5 [out]\""])
 
-          path.should == "video/path/tmpfile.#{format}"
+          expect(path).to eq("video/path/tmpfile.#{format}")
         end
 
         converter.encode_video(format, watermark: {
@@ -193,14 +192,14 @@ describe CarrierWave::Video do
       end
 
       it "only requires path watermark parameter" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          codec_opts.should == {preserve_aspect_ratio: :width}
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(codec_opts).to eq({preserve_aspect_ratio: :width})
 
-          opts[:video_codec].should == 'libvpx'
-          opts[:audio_codec].should == 'libvorbis'
-          opts[:custom].should == "-b 1500k -ab 160000 -f webm -g 30 -vf \"movie=path/to/file.png [logo]; [in][logo] overlay= [out]\""
+          expect(opts[:video_codec]).to eq('libvpx')
+          expect(opts[:audio_codec]).to eq('libvorbis')
+          expect(opts[:custom]).to eq(["-b","1500k","-ab","160000","-f","webm","-vf","\"movie=path/to/file.png [logo]; [in][logo] overlay= [out]\""])
 
-          path.should == "video/path/tmpfile.#{format}"
+          expect(path).to eq("video/path/tmpfile.#{format}")
         end
 
         converter.encode_video(format, watermark: {
@@ -209,8 +208,8 @@ describe CarrierWave::Video do
       end
 
       it "removes watermark options from common options" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          opts.should_not have_key(:watermark)
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(opts).not_to have_key(:watermark)
         end
 
         converter.encode_video(format, watermark: {
@@ -223,13 +222,13 @@ describe CarrierWave::Video do
 
     context "with resolution set to :same" do
       before do
-        File.should_receive(:rename)
-        movie.stub(:resolution).and_return('1280x720')
+        expect(File).to receive(:rename)
+        allow(movie).to receive(:resolution).and_return('1280x720')
       end
 
       it "sets the output resolution to match that of the input" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          opts[:resolution].should == '1280x720'
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(opts[:resolution]).to eq('1280x720')
         end
 
         converter.encode_video(format, resolution: :same)
@@ -238,42 +237,42 @@ describe CarrierWave::Video do
 
     context "with custom passed in" do
       before do
-        File.should_receive(:rename)
+        expect(File).to receive(:rename)
       end
 
       it "takes the provided custom param" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          opts[:custom].should == '-preset slow' # a la changes in ffmpeg 0.11.1
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(opts[:custom]).to eq(%w(-preset slow)) # a la changes in ffmpeg 0.11.1
         end
 
-        converter.encode_video(format, custom: '-preset slow')
+        converter.encode_video(format, custom: %w(-preset slow))
       end
 
       it "maintains the watermark params" do
-        movie.should_receive(:transcode) do |path, opts, codec_opts|
-          opts[:custom].should == "-preset slow -vf \"movie=path/to/file.png [logo]; [in][logo] overlay= [out]\""
+        expect(movie).to receive(:transcode) do |path, opts, codec_opts|
+          expect(opts[:custom]).to eq(["-preset","slow","-vf","\"movie=path/to/file.png [logo]; [in][logo] overlay= [out]\""])
         end
 
-        converter.encode_video(format, custom: '-preset slow', watermark: {
+        converter.encode_video(format, custom: %w(-preset slow), watermark: {
           path: 'path/to/file.png'
         })
       end
     end
 
     context "given a block" do
-      let(:movie) { mock }
+      let(:movie) { double }
       let(:opts) { {} }
-      let(:params) { { resolution: "640x360", watermark: {}, video_codec: "libvpx", audio_codec: "libvorbis", custom: "-b 1500k -ab 160000 -f webm -g 30" } }
+      let(:params) { { resolution: "640x360", watermark: {}, video_codec: "libvpx", audio_codec: "libvorbis", custom: %w(-b 1500k -ab 160000 -f webm) } }
 
       before do
-        File.should_receive(:rename)
-        movie.stub(:resolution).and_return('1280x720')
+        expect(File).to receive(:rename)
+        allow(movie).to receive(:resolution).and_return('1280x720')
       end
 
       it "calls the block, with the movie file and params" do
-        movie.should_receive(:transcode) do |path, format_opts, codec_opts|
-          format_opts[:video_codec].should == 'libvpx'
-          format_opts[:audio_codec].should == 'libvorbis'
+        expect(movie).to receive(:transcode) do |path, format_opts, codec_opts|
+          expect(format_opts[:video_codec]).to eq('libvpx')
+          expect(format_opts[:audio_codec]).to eq('libvorbis')
         end
 
         expect {
@@ -282,10 +281,10 @@ describe CarrierWave::Video do
       end
 
       it "allows the block to modify the params" do
-        block = Proc.new { |input, params| params[:custom] = '-preset slow' }
+        block = Proc.new { |input, params| params[:custom] = %w(-preset slow) }
 
-        movie.should_receive(:transcode) do |path, format_opts, codec_opts|
-          format_opts[:custom].should == '-preset slow'
+        expect(movie).to receive(:transcode) do |path, format_opts, codec_opts|
+          expect(format_opts[:custom]).to eq(%w(-preset slow))
         end
 
         converter.encode_video(format, opts, &block)
@@ -293,12 +292,12 @@ describe CarrierWave::Video do
 
       it "evaluates the final params after any modifications" do
         block = Proc.new do |input, params|
-          params[:custom] = '-preset slow'
+          params[:custom] = %w(-preset slow)
           params[:watermark][:path] = 'customized/path'
         end
 
-        movie.should_receive(:transcode) do |path, format_opts, codec_opts|
-          format_opts[:custom].should == '-preset slow -vf "movie=customized/path [logo]; [in][logo] overlay= [out]"'
+        expect(movie).to receive(:transcode) do |path, format_opts, codec_opts|
+          expect(format_opts[:custom]).to eq(["-preset","slow","-vf","\"movie=customized/path [logo]; [in][logo] overlay= [out]\""])
         end
 
         converter.encode_video(format, opts, &block)
@@ -311,8 +310,8 @@ describe CarrierWave::Video do
           params[:resolution] = '1x1'
         end
 
-        movie.should_receive(:transcode) do |path, format_opts, codec_opts|
-          format_opts[:resolution].should == '1x1'
+        expect(movie).to receive(:transcode) do |path, format_opts, codec_opts|
+          expect(format_opts[:resolution]).to eq('1x1')
         end
 
         converter.encode_video(format, opts, &block)
@@ -321,23 +320,23 @@ describe CarrierWave::Video do
   end
 
   describe "#encode_ogv" do
-    let(:movie) { mock }
+    let(:movie) { double }
     let(:output_path) { 'video/path/tmpfile.ogv' }
     let(:movie_path) { 'video/path/input.mov' }
-    let(:logger) { mock(:logger) }
+    let(:logger) { double(:logger) }
 
 
     before do
-      converter.model.stub(:logger).and_return(logger)
-      File.should_receive(:rename)
-      converter.stub(:current_path).and_return('video/path/input.mov')
+      allow(converter.model).to receive(:logger).and_return(logger)
+      expect(File).to receive(:rename)
+      allow(converter).to receive(:current_path).and_return('video/path/input.mov')
     end
 
     context "no options set" do
       it "calls transcode with correct format options" do
-        transcoder = mock(:transcoder)
-        CarrierWave::Video::FfmpegTheora.should_receive(:new).with(movie_path, output_path).and_return(transcoder)
-        transcoder.should_receive(:run)
+        transcoder = double(:transcoder)
+        expect(CarrierWave::Video::FfmpegTheora).to receive(:new).with(movie_path, output_path).and_return(transcoder)
+        expect(transcoder).to receive(:run)
 
         converter.encode_ogv({})
       end
@@ -345,13 +344,13 @@ describe CarrierWave::Video do
 
     context "with logger set" do
       before do
-        converter.model.stub(:logger).and_return(logger)
+        allow(converter.model).to receive(:logger).and_return(logger)
       end
 
       it "calls transcode with correct format options and passes logger to transcoder" do
-        transcoder = mock(:transcoder)
-        CarrierWave::Video::FfmpegTheora.should_receive(:new).with(movie_path, output_path).and_return(transcoder)
-        transcoder.should_receive(:run).with(logger)
+        transcoder = double(:transcoder)
+        expect(CarrierWave::Video::FfmpegTheora).to receive(:new).with(movie_path, output_path).and_return(transcoder)
+        expect(transcoder).to receive(:run).with(logger)
 
         converter.encode_ogv({logger: :logger})
       end

data/spec/lib/ffmpeg_theora_spec.rb

@@ -14,19 +14,19 @@ describe CarrierWave::Video::FfmpegTheora do
 
     it "should run the ffmpeg2theora binary" do
       command = "#{binary} #{input_file_path} -o #{output_file_path}"
-      Open3.should_receive(:popen3).with(command)
+      expect(Open3).to receive(:popen3).with(command)
 
       transcoder.run
     end
 
     context "given a logger" do
-      let(:logger) { mock(:logger) }
+      let(:logger) { double(:logger) }
 
       it "should run and log results" do
         command = "#{binary} #{input_file_path} -o #{output_file_path}"
-        Open3.should_receive(:popen3).with(command)
-        logger.should_receive(:info).with("Running....#{command}")
-        logger.should_receive(:error).with("Failure!")
+        expect(Open3).to receive(:popen3).with(command)
+        expect(logger).to receive(:info).with("Running....#{command}")
+        expect(logger).to receive(:error).with("Failure!")
 
         transcoder.run(logger)
       end

data/spec/spec_helper.rb

@@ -2,5 +2,6 @@ require 'streamio-ffmpeg'
 require 'carrierwave/video'
 
 RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
   config.mock_with :rspec
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave-video
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.0
 platform: ruby
 authors:
 - rheaton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-16 00:00:00.000000000 Z
+date: 2018-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 3.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: 3.3.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -74,6 +74,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rbenv-gemsets"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - LICENSE
@@ -107,10 +109,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - ruby, version 1.9 or greater
-- ffmpeg, version 0.11.1 or greater with libx256, libfaac, libtheora, libvorbid, libvpx
-  enabled
+- ffmpeg, version 0.11.1 or greater with libx256, libfdk-aac, libtheora, libvorbid,
+  libvpx enabled
 rubyforge_project: carrierwave-video
-rubygems_version: 2.2.2
+rubygems_version: 2.7.4
 signing_key: 
 specification_version: 4
 summary: Carrierwave extension that uses ffmpeg to transcode videos.
@@ -118,4 +120,3 @@ test_files:
 - spec/lib/carrierwave_video_spec.rb
 - spec/lib/ffmpeg_theora_spec.rb
 - spec/spec_helper.rb
-has_rdoc: