popcap 0.7.2

data/spec/lib/pop_cap/commander_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'pop_cap/commander'
+
+module PopCap
+  describe Commander do
+    let(:commander) { Commander.new(%W{ls},%W{-l},%W{/tmp}) }
+
+    context "#new" do
+      it 'raises an error if no arguments' do
+        expect{Commander.new}.to raise_error(ArgumentError)
+      end
+
+      it 'sets @executed to empty' do
+        expect(commander.instance_variable_get('@executed')).to be_empty
+      end
+
+      it 'escapes @command' do
+        expect(commander.instance_variable_get('@command')).
+          to eq([['ls'],['-l'],['/tmp']])
+      end
+    end
+
+    context '#execute' do
+      it 'executes a shell command' do
+        Open3.should_receive(:capture3).with(['ls'],['-l'],['/tmp'])
+        commander.execute
+      end
+
+      it 'returns itself' do
+        Open3.should_receive(:capture3).with('blah')
+        command = Commander.new('blah')
+        expect(command.execute).to be_a(Commander)
+      end
+    end
+
+    it 'returns stdout' do
+      Open3.should_receive(:capture3).with('blah') { ['foo',nil,nil] }
+      command = Commander.new('blah').execute
+      expect(command.stdout).to eq('foo')
+    end
+
+    it 'returns stderr' do
+      Open3.should_receive(:capture3).with('blah') { [nil,'bar',nil] }
+      command = Commander.new('blah').execute
+      expect(command.stderr).to eq('bar')
+    end
+
+    context '#success' do
+      it 'is true if it succeeds' do
+        succeeded = double('status', success?: true)
+        Open3.should_receive(:capture3).with('blah') { [nil,nil,succeeded] }
+        command = Commander.new('blah').execute
+        expect(command.success?).to be_true
+      end
+
+      it 'is false if it fails' do
+        failed = double('status', success?: false)
+        Open3.should_receive(:capture3).with('blah') { [nil,nil,failed] }
+        command = Commander.new('blah').execute
+        expect(command.success?).to be_false
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/converter_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'pop_cap/converter'
+
+module PopCap
+  describe Converter do
+    class FakeClass
+      include Converter
+      def filepath
+        'path/to/file.flac'
+      end
+    end
+
+    let(:bitrate) { %W{-ab 192k}}
+    let(:filepath) { 'path/to/file.flac' }
+    let(:fk) { FakeClass.new }
+    let(:input) { %W{ffmpeg -i #{filepath}} }
+
+    context '#command' do
+      let(:output_path) { %W{path/to/file.ogg} }
+
+      it 'builds a command' do
+        expect(fk.convert('ogg')).to eq(input + bitrate + output_path)
+      end
+
+      context 'format' do
+        it 'handles symbol' do
+          expect(fk.convert(:ogg)).to eq(input + bitrate + output_path)
+        end
+
+        it 'is case insenstive' do
+          expect(fk.convert('OGG')).to eq(input + bitrate + output_path)
+        end
+      end
+
+      context 'bitrate' do
+        let(:output_path) { %W{path/to/file.mp3} }
+
+        it 'defaults to 192 kb/s' do
+          expect(fk.convert(:mp3)).to eq(input + %W{-ab 192k} + output_path)
+        end
+
+        it 'takes an optional bitrate' do
+          expect(fk.convert(:mp3, 64)).to eq(input + %W{-ab 64k} + output_path)
+        end
+
+        it 'handles bitrate as string' do
+          expect(fk.convert(:mp3, '128')).
+            to eq(input + %W{-ab 128k} + output_path)
+        end
+      end
+
+      context 'm4a' do
+        let(:output_path) { %W{path/to/file.m4a} }
+
+        it 'uses strict mode' do
+          expect(fk.convert(:m4a)).
+            to eq(input + %W{-strict -2} + bitrate + output_path)
+        end
+
+        it 'ignores strict mode if not m4a' do
+          expect(fk.convert(:ogg)).
+            to eq(input + bitrate + %W{path/to/file.ogg})
+        end
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/ffmpeg_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+require 'pop_cap/ffmpeg'
+
+module PopCap
+  describe FFmpeg do
+    before { PopCapSpecHelper.setup }
+    after { PopCapSpecHelper.teardown }
+
+    let(:commander) { double('Commander') }
+    let(:filepath) { File.realpath('spec/support/sample.flac') }
+    let(:ffmpeg) { FFmpeg.new(filepath) }
+
+    it 'returns its filepath' do
+      expect(ffmpeg.filepath).to eq filepath
+    end
+
+    it 'raises error if FFmpeg not installed' do
+      error_message = 'No such file or directory - FFmpeg is not installed.'
+      expect do
+        Open3.stub(:capture3).with('ffmpeg').and_raise(Errno::ENOENT)
+        FFmpeg.new('filepath')
+      end.to raise_error(MissingDependency, error_message)
+    end
+
+    it 'includes Fileable' do
+      expect(FFmpeg.included_modules).to include Fileable
+    end
+
+    context '#read_tags' do
+      let(:output) { double('output') }
+
+      it 'sends a read command to Commander' do
+        expect(ffmpeg.read_tags).to eq PopCapSpecHelper.raw_tags
+      end
+
+      it 'encodes invalid byte strings as UTF-8' do
+        Commander.stub_chain(:new, :execute) { output }
+        output.should_receive(:success?) { true }
+        output.should_receive(:stdout) { output }
+        output.stub(:valid_encoding?) { false }
+        output.stub_chain(:encoding, :name) { 'UTF-8' }
+        output.should_receive(:encode!).
+          with('UTF-16', 'UTF-8', undef: :replace, invalid: :replace)
+        output.should_receive(:encode!).with('UTF-8')
+        ffmpeg.read_tags
+      end
+
+      it 'raises error if could not read tags' do
+        expect do
+          failed = double('commander', :success? => false)
+          Commander.stub_chain(:new, :execute) { failed }
+          ffmpeg.read_tags
+        end.
+          to raise_error(FFmpegError, 'Error reading ' + filepath)
+      end
+    end
+
+    context '#update_tags' do
+      let(:new_tags) { {artist: 'UPDATEDARTIST'} }
+
+      it 'updates tags on a temp file & copies temp file to original' do
+        expect(ffmpeg.read_tags).to match /Sample Artist/
+        ffmpeg.update_tags(new_tags)
+        expect(ffmpeg.read_tags).to match /UPDATEDARTIST/
+        expect(ffmpeg.read_tags).not_to match /Sample Artist/
+      end
+
+      it 'reloads read_tags' do
+        ffmpeg.read_tags
+        Commander.stub_chain(:new, :execute).
+          and_return(double('output', success?: true))
+        ffmpeg.stub(:restore)
+        ffmpeg.update_tags({})
+        expect(ffmpeg.instance_variable_get('@stdout')).to be_nil
+      end
+
+      it 'raises error if could not update tags' do
+        expect do
+          failed = double('commander', :success? => false)
+          Commander.stub_chain(:new, :execute) { failed }
+          ffmpeg.update_tags({})
+        end.
+          to raise_error(FFmpegError, 'Error updating ' + filepath)
+      end
+    end
+
+    context '#convert' do
+      it 'converts from input format to specified output format & bitrate' do
+        ffmpeg.convert(:mp3, 64)
+        mp3 = FFmpeg.new(File.realpath('spec/support/sample.mp3'))
+        expect(mp3.read_tags).to match /format_name=mp3/
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/fileable_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'pop_cap/fileable'
+require 'support/popcap_spec_helper'
+
+module PopCap
+  describe Fileable do
+    class FileClass
+      attr_accessor :filepath
+
+      include Fileable
+      def initialize(filepath)
+        @filepath = filepath
+      end
+    end
+
+    let(:filepath) { 'spec/support/sample.flac' }
+    let(:fc) { FileClass.new(filepath) }
+
+    context '#filename' do
+      it 'returns the basename' do
+        expect(fc.filename).to eq 'sample.flac'
+      end
+    end
+
+    context '#backup' do
+      it 'backs up file to directory' do
+        FileUtils.should_receive(:cp).with(filepath, '/usr/sample.flac')
+        fc.backup('/usr')
+      end
+
+      it 'backup directory defaults to "/tmp"' do
+        FileUtils.should_receive(:cp).with(filepath, '/tmp/sample.flac')
+        fc.backup
+      end
+    end
+
+    context '#backup_path' do
+      it 'returns path from backup' do
+        FileUtils.should_receive(:cp).with(filepath, '/tmp/sample.flac')
+        fc.backup('/tmp')
+        expect(fc.backup_path).to eq '/tmp/sample.flac'
+      end
+
+      it 'raises an error if not backed up' do
+        expect{fc.backup_path}.to raise_error(PathError)
+      end
+    end
+
+    context '#restore' do
+      it 'takes an optional path' do
+        FileUtils.should_receive(:mv).with('/tmp/sample.flac', filepath)
+        fc.restore('/tmp')
+      end
+
+      it 'defaults to the backup path' do
+        FileUtils.should_receive(:cp).with(filepath, '/tmp/sample.flac')
+        fc.backup('/tmp')
+        FileUtils.should_receive(:mv).with('/tmp/sample.flac', filepath)
+        fc.restore
+      end
+    end
+
+    context '#tmppath' do
+      it 'returns a temporary path' do
+        expect(fc.tmppath).to eq '/tmp/sample.flac'
+      end
+    end
+
+    context '#destroy' do
+      it 'removes a file' do
+        FileUtils.should_receive(:rm_f).with(filepath)
+        fc.destroy
+      end
+
+      it 'blanks out filepath' do
+        FileUtils.should_receive(:rm_f).with(filepath)
+        fc.destroy
+        expect(fc.filepath).to be_nil
+      end
+    end
+
+    context '#rename' do
+      it 'removes a file with specified name' do
+        new_name = 'spec/support/example.file'
+        FileUtils.should_receive(:mv).with(filepath, new_name)
+        fc.rename('example.file')
+      end
+
+      it 'updates filepath' do
+        new_name = 'spec/support/example.file'
+        FileUtils.should_receive(:mv).with(filepath, new_name)
+        fc.rename('example.file')
+        expect(fc.filepath).to eq('spec/support/example.file')
+      end
+    end
+
+    context '#move' do
+      let(:destination) { '/tmp' }
+
+      it 'moves a file to directory' do
+        FileUtils.should_receive(:mv).with(filepath, destination)
+        fc.move('/tmp')
+      end
+
+      it 'updates filepath' do
+        FileUtils.should_receive(:mv).with(filepath, destination)
+        fc.move('/tmp')
+        expect(fc.filepath).to eq('/tmp/sample.flac')
+      end
+    end
+
+    context '#directory' do
+      it 'returns the directory path for the file' do
+        expect(fc.directory).to eq 'spec/support'
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/formatters/bit_rate_spec.rb

@@ -0,0 +1,53 @@
+require 'pop_cap/formatters/bit_rate'
+require 'spec_helper'
+
+module PopCap
+  module Formatters
+    describe BitRate do
+      it 'makes bitrate human readable' do
+        br = BitRate.new(128456)
+        expect(br.format).to eq('128 kb/s')
+      end
+
+      it 'handles strings' do
+        br = BitRate.new('128456')
+        expect(br.format).to eq('128 kb/s')
+      end
+
+      it 'handles long bitrates' do
+        br = BitRate.new('1284567')
+        expect(br.format).to eq('1284 kb/s')
+      end
+
+      it 'handles short bitrates' do
+        br = BitRate.new('64845')
+        expect(br.format).to eq('64 kb/s')
+      end
+
+      it 'formats as kilobytes' do
+        br = BitRate.new('64845')
+        expect(br.format).to match(/kb\/s/)
+      end
+
+      it 'is nil if empty string' do
+        br = BitRate.new('')
+        expect(br.format).to be_nil
+      end
+
+      it 'is nil if nil' do
+        br = BitRate.new(nil)
+        expect(br.format).to be_nil
+      end
+
+      it 'is nil if not a number' do
+        br = BitRate.new('foo')
+        expect(br.format).to be_nil
+      end
+
+      it 'is not greater than zero' do
+        br = BitRate.new(0)
+        expect(br.format).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/formatters/date_spec.rb

@@ -0,0 +1,74 @@
+require 'pop_cap/formatters/date'
+require 'spec_helper'
+
+module PopCap
+  module Formatters
+    describe Date do
+      it 'handles dates like "October 5, 1975"' do
+        dm = Date.new('October 5, 1975')
+        expect(dm.format).to eq 1975
+      end
+
+      it 'handles dates like "10-05-1984"' do
+        dm = Date.new('10-05-1984')
+        expect(dm.format).to eq 1984
+      end
+
+      it 'handles dates like "1993/10/05"' do
+        dm = Date.new('1993/10/05')
+        expect(dm.format).to eq 1993
+      end
+
+      it 'handles dates like 2012' do
+        dm = Date.new(2012)
+        expect(dm.format).to eq 2012
+      end
+
+      it 'returns an integer' do
+        dm = Date.new(1953)
+        expect(dm.format).to be_a Integer
+      end
+
+      context 'date range' do
+        it 'takes an optional start date range' do
+          dm = Date.new(1961, {start_date: 1900})
+          expect(dm.start_date).to eq(1900)
+        end
+
+        it 'takes an optional end date range' do
+          dm = Date.new(1961, {end_date: 3000})
+          expect(dm.end_date).to eq(3000)
+        end
+
+        it 'defaults to 1800 for start date' do
+          dm = Date.new(1961)
+          expect(dm.start_date).to eq(1800)
+        end
+
+        it 'defaults to 2100 for end date' do
+          dm = Date.new(1961)
+          expect(dm.end_date).to eq(2100)
+        end
+
+        it 'returns nil if beyond date range' do
+          dm = Date.new(1799)
+          expect(dm.format).to be_nil
+        end
+
+        it 'returns nil if under date range' do
+          dm = Date.new(2101)
+          expect(dm.format).to be_nil
+        end
+      end
+      it 'returns nil if no match' do
+        dm = Date.new(123)
+        expect(dm.format).to be_nil
+      end
+
+      it 'returns nil if ambiguous' do
+        dm = Date.new(19751005)
+        expect(dm.format).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/formatters/duration_spec.rb

@@ -0,0 +1,64 @@
+require 'pop_cap/formatters/duration'
+require 'spec_helper'
+
+module PopCap
+  module Formatters
+    describe Duration do
+      it 'formats duration as HH:MM:SS' do
+        dur = Duration.new('40003')
+        expect(dur.format).to eq('11:06:43')
+      end
+
+      it 'removes leading zeroes for hours' do
+        dur = Duration.new('750')
+        expect(dur.format).to eq('12:30')
+      end
+
+      it 'removes leading zeroes for minutes' do
+        dur = Duration.new('420')
+        expect(dur.format).to eq('7:00')
+      end
+
+      it 'removes leading zeroes for seconds' do
+        dur = Duration.new('8')
+        expect(dur.format).to eq('8')
+      end
+
+      it 'handles integers' do
+        dur = Duration.new(12345)
+        expect(dur.format).to eq('3:25:45')
+      end
+
+      it 'handles floats' do
+        dur = Duration.new(1234.5678)
+        expect(dur.format).to eq('20:34')
+      end
+
+      it 'returns warning if time greater than 24 hours' do
+        dur = Duration.new('86400')
+        expect(dur.format).
+          to eq('Warning: Time is greater than 24 hours.')
+      end
+
+      it 'is nil if invalid number' do
+        dur = Duration.new('string')
+        expect(dur.format).to be_nil
+      end
+
+      it 'is nil if nil' do
+        dur = Duration.new(nil)
+        expect(dur.format).to be_nil
+      end
+
+      it 'is nil if empty string' do
+        dur = Duration.new('')
+        expect(dur.format).to be_nil
+      end
+
+      it 'is nil if zero' do
+        dur = Duration.new(0)
+        expect(dur.format).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/formatters/filesize_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'pop_cap/formatters/filesize'
+
+module PopCap
+  module Formatters
+    describe Filesize do
+      it 'uses binary conversion' do
+        fs = Filesize.new('1024')
+        expect(fs.format).to eq '1K'
+      end
+
+      it 'uses "B" for bytes' do
+        fs = Filesize.new(204)
+        expect(fs.format).to eq '204B'
+      end
+
+      it 'uses "K" for kilobytes' do
+        fs = Filesize.new(2048)
+        expect(fs.format).to eq '2K'
+      end
+
+      it 'uses "M" for megabytes' do
+        fs = Filesize.new(2048000)
+        expect(fs.format).to eq '2M'
+      end
+
+      it 'uses "G" for gigabytes' do
+        fs = Filesize.new(2148000000)
+        expect(fs.format).to eq '2G'
+      end
+
+      it 'uses "T" for terabytes' do
+        fs = Filesize.new(2148000000000)
+        expect(fs.format).to eq '2T'
+      end
+
+      it 'returns a warning if larger than 999 terabytes' do
+        fs = Filesize.new(1099500000000000)
+        expect(fs.format).
+          to eq 'Warning: Number is larger than 999 terabytes.'
+      end
+
+      it 'rounds to nearest tenth' do
+        fs = Filesize.new(63587)
+        expect(fs.format).to eq '62.1K'
+      end
+
+      it 'drops tenth if it is zero' do
+        fs = Filesize.new(4096)
+        expect(fs.format).to eq '4K'
+      end
+
+      it 'handles strings' do
+        fs = Filesize.new('123456')
+        expect(fs.format).to eq '120.6K'
+      end
+
+      it 'handles integers' do
+        fs = Filesize.new(123456)
+        expect(fs.format).to eq '120.6K'
+      end
+
+      it 'handles floats' do
+        fs = Filesize.new(1234.56)
+        expect(fs.format).to eq '1.2K'
+      end
+
+      it 'returns nil for nil' do
+        fs = Filesize.new(nil)
+        expect(fs.format).to be_nil
+      end
+
+      it 'returns nil for empty string' do
+        fs = Filesize.new('')
+        expect(fs.format).to be_nil
+      end
+
+      it 'returns nil if not a number' do
+        fs = Filesize.new('hello')
+        expect(fs.format).to be_nil
+      end
+
+      it 'returns nil if zero' do
+        fs = Filesize.new(0)
+        expect(fs.format).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/formatters_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'pop_cap/formatters'
+
+module PopCap
+  describe Formatters do
+
+    let(:formatter_files) { Dir['lib/pop_cap/formatters/*.rb'] }
+
+    it 'requires all formatters in "formatter/"' do
+      loaded_files = $LOADED_FEATURES
+      formatter_files.each do |path|
+        expect(loaded_files).to include(File.realpath(path))
+      end
+    end
+
+    context "#included_formatters" do
+      it 'builds a hash of included formatters' do
+        expect(::INCLUDED_FORMATTERS).to be_a Hash
+      end
+
+      it 'has formatter names as keys' do
+        formatter_files.each do |file|
+          formatter_key = File.basename(file, '.rb').to_sym
+          expect(::INCLUDED_FORMATTERS.keys).to include(formatter_key)
+        end
+      end
+
+      it 'has the formatter path as the value' do
+        formatter_files.each do |file|
+          value = file.sub(%r(^lib\/),'').sub(%r(\.rb$),'')
+          expect(::INCLUDED_FORMATTERS.values).to include(value)
+        end
+      end
+    end
+  end
+end