popcap 0.7.2 → 0.8.0

data/spec/lib/pop_cap/ffmpeg/tag_writer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'pop_cap/ffmpeg/tag_writer'
+
+module PopCap
+  describe TagWriter do
+    let(:commander) { double('commander') }
+    let(:instance) { double('commander_instance') }
+    let(:file) { 'path/to/file.flac' }
+    let(:tags) { {artist: 'UPDATE'} }
+    let(:options) { {artist: 'UPDATE', commander: commander} }
+    let(:writer) { TagWriter.new(file, options) }
+
+    let(:command) do
+      %W{ffmpeg -i #{file} -metadata artist=UPDATE /tmp/file.flac}
+    end
+
+    describe '.write' do
+      it 'has a class method for #write' do
+        TagWriter.should_receive(:new).with(file, options) { instance }
+        instance.should_receive(:write)
+        TagWriter.write(file, options)
+      end
+    end
+
+    describe '#write' do
+      it 'updates tags to a temp file' do
+        commander.should_receive(:new).with(*command) { instance }
+        instance.stub_chain(:execute, :success?) { true }
+        FileUtils.stub(:move)
+        writer.write
+      end
+
+      it 'moves temp file to original' do
+        commander.should_receive(:new).with(*command) { instance }
+        instance.stub_chain(:execute, :success?) { true }
+        FileUtils.should_receive(:move).with('/tmp/file.flac', file)
+        writer.write
+      end
+
+      context 'errors' do
+        it 'raises FFmpegError if could not update tags' do
+          expect do
+            commander.should_receive(:new).with(*command) { instance }
+            instance.stub_chain(:execute, :success?) { false }
+            writer.write
+          end.to raise_error(FFmpegError, "Error writing #{file}.")
+        end
+
+        it 'does not move temp file' do
+          expect do
+            commander.should_receive(:new).with(*command) { instance }
+            instance.stub_chain(:execute, :success?) { false }
+            FileUtils.should_not_receive(:move).with('/tmp/file.flac', file)
+            writer.write
+          end.to raise_error(FFmpegError, "Error writing #{file}.")
+        end
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/fileable_spec.rb

@@ -13,7 +13,7 @@ module PopCap
       end
     end
 
-    let(:filepath) { 'spec/support/sample.flac' }
+    let(:filepath) { PopCapSpecHelper::SAMPLE_FILE }
     let(:fc) { FileClass.new(filepath) }
 
     context '#filename' do
@@ -81,16 +81,16 @@ module PopCap
 
     context '#rename' do
       it 'removes a file with specified name' do
-        new_name = 'spec/support/example.file'
+        new_name = 'spec/fixtures/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'
+        new_name = 'spec/fixtures/example.file'
         FileUtils.should_receive(:mv).with(filepath, new_name)
         fc.rename('example.file')
-        expect(fc.filepath).to eq('spec/support/example.file')
+        expect(fc.filepath).to eq('spec/fixtures/example.file')
       end
     end
 
@@ -111,7 +111,7 @@ module PopCap
 
     context '#directory' do
       it 'returns the directory path for the file' do
-        expect(fc.directory).to eq 'spec/support'
+        expect(fc.directory).to eq 'spec/fixtures'
       end
     end
   end

data/spec/lib/pop_cap/formatter_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'pop_cap/formatter'
+
+module PopCap
+  module Formatters
+    describe Formatter do
+      class TagClass < Formatter
+        def format; 'baz'; end
+      end
+
+      describe '.format' do
+        let(:taggy) { Formatters::TagClass.new('foo', {option: 'bar'}) }
+
+        it 'wraps #format in a class method' do
+          klass = Formatters::TagClass.format('foo', {option: 'bar'})
+          instance = taggy.format
+          expect(klass).to eq instance
+        end
+      end
+
+      describe '.subclasses' do
+        it 'returns a list of all subclasses in the ObjectSpace' do
+          expect(Formatter.subclasses).to include(PopCap::Formatters::TagClass)
+        end
+
+        it 'includes the subclass only once' do
+          unique = Formatter.subclasses.select do |cls|
+            cls == PopCap::Formatters::TagClass
+          end
+          expect(unique.size).to eq 1
+        end
+
+        it 'contains no nils' do
+          expect(Formatter.subclasses).not_to include(nil)
+        end
+
+        it 'requires all Formatters files' do
+          Formatter.subclasses
+          formatters_path = '../../../../lib/pop_cap/formatters/*.rb'
+          Dir[File.expand_path(formatters_path, __FILE__)].each do |file|
+            expect($LOADED_FEATURES).to include(file)
+          end
+        end
+      end
+
+      describe '.subclasses_demodulized' do
+        it 'returns of the subclasses with their names demodulized' do
+          expect(Formatter.subclasses_demodulized).to include('TagClass')
+        end
+      end
+    end
+
+    describe '#format' do
+      let(:taggy) { Formatters::TagClass.new('foo', {option: 'bar'}) }
+
+      it { expect(taggy).to respond_to(:format) }
+    end
+
+    describe '#new' do
+      let(:taggy) { Formatters::TagClass.new('foo', {option: 'bar'}) }
+
+      it 'has a getter for value' do
+        expect(taggy.value).to eq 'foo'
+      end
+
+      it 'has a getter for options' do
+        expect(taggy.options).to eq({option: 'bar'})
+      end
+    end
+  end
+end

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

@@ -4,6 +4,14 @@ require 'spec_helper'
 module PopCap
   module Formatters
     describe BitRate do
+      describe '.format' do
+        it 'wraps #format in a class method' do
+          klass = BitRate.format(128456)
+          instance = BitRate.new(128456).format
+          expect(klass).to eq(instance)
+        end
+      end
+
       it 'makes bitrate human readable' do
         br = BitRate.new(128456)
         expect(br.format).to eq('128 kb/s')

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

@@ -4,6 +4,14 @@ require 'spec_helper'
 module PopCap
   module Formatters
     describe Date do
+      describe '.format' do
+        it 'wraps #format in a class method' do
+          klass = Date.format('1975')
+          instance = Date.new('1975').format
+          expect(klass).to eq(instance)
+        end
+      end
+
       it 'handles dates like "October 5, 1975"' do
         dm = Date.new('October 5, 1975')
         expect(dm.format).to eq 1975

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

@@ -4,6 +4,14 @@ require 'spec_helper'
 module PopCap
   module Formatters
     describe Duration do
+      describe '.format' do
+        it 'wraps #format in a class method' do
+          klass = Duration.format('128456')
+          instance = Duration.new('128456').format
+          expect(klass).to eq(instance)
+        end
+      end
+
       it 'formats duration as HH:MM:SS' do
         dur = Duration.new('40003')
         expect(dur.format).to eq('11:06:43')

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

@@ -4,6 +4,14 @@ require 'pop_cap/formatters/filesize'
 module PopCap
   module Formatters
     describe Filesize do
+      describe '.format' do
+        it 'wraps #format in a class method' do
+          klass = Filesize.format('1975')
+          instance = Filesize.new('1975').format
+          expect(klass).to eq(instance)
+        end
+      end
+
       it 'uses binary conversion' do
         fs = Filesize.new('1024')
         expect(fs.format).to eq '1K'

data/spec/lib/pop_cap/tag/formatted_tag_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'pop_cap/tag/formatted_tag'
+
+module PopCap
+  describe FormattedTag do
+    class FakeFormatter
+      def self.format(value)
+        value.to_i
+      end
+    end
+
+    describe '#format' do
+      it 'formats a value with the formatter' do
+        tag = FormattedTag.new(FakeFormatter, '123')
+        expect(tag.format).to eq 123
+      end
+    end
+
+    describe '.format' do
+      it 'wraps #new & #format' do
+        instance = double('FormattedTagInstance')
+        FormattedTag.should_receive(:new).with(FakeFormatter, '123').
+          and_return(instance)
+        instance.should_receive(:format)
+        FormattedTag.format(FakeFormatter, '123')
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/tag/tag_hash_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+require 'pop_cap/tag/tag_hash'
+
+module PopCap
+  describe TagHash do
+    describe '#hash' do
+      let(:tag_hash) { TagHash.new(PopCapSpecHelper.raw_tags) }
+
+      it 'symbolizes all keys' do
+        tag_hash.hash.each_key do |key|
+          expect(key).to be_a Symbol
+        end
+      end
+
+      it 'renames filesize to size' do
+        expect(tag_hash.hash[:size]).to be_nil
+        expect(tag_hash.hash[:filesize]).not_to be_nil
+      end
+
+      it 'formats json output as a hash' do
+        expect(tag_hash.hash).to eq(PopCapSpecHelper.unformatted_hash)
+      end
+    end
+
+    describe '.hash' do
+      it 'wraps #new & #hash' do
+        instance = double('TagHash')
+        TagHash.should_receive(:new).with('foo') { instance }
+        instance.should_receive(:hash)
+        TagHash.hash('foo')
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/{tag_struct_spec.rb → tag/tag_struct_spec.rb}

@@ -1,11 +1,15 @@
 require 'spec_helper'
-require 'pop_cap/tag_struct'
+require 'pop_cap/tag/tag_struct'
 
 module PopCap
   describe TagStruct do
     let(:hash) { {artist: 'Artist', date: 1984} }
     let(:ts) { TagStruct.new(hash) }
 
+    it 'includes Enumerable' do
+      expect(TagStruct.included_modules).to include(Enumerable)
+    end
+
     describe '#new' do
       it 'raises error if not a hash' do
         expect do

data/spec/lib/pop_cap/taggable_spec.rb

@@ -17,20 +17,33 @@ module PopCap
       expect(sc).to respond_to(:raw_tags)
     end
 
-    context '#to_hash' do
-      it 'builds a sanitized hash from FFmpeg raw_tags' do
-        expect(sc.to_hash).to eq PopCapSpecHelper.to_hash
+    describe '#unformatted' do
+      it 'returns TagHash#hash' do
+        TagHash.should_receive(:hash).with(sc.raw_tags)
+        sc.unformatted
       end
 
       it 'is memoized' do
-        sc.to_hash
-        expect(sc.instance_variable_get('@hash')).
-          to eq PopCapSpecHelper.to_hash
+        sc.unformatted
+        TagHash.should_not_receive(:new)
+        sc.unformatted
       end
     end
 
-    context '#tags' do
-      it 'builds a tag structure of from a hash' do
+    describe '#formatted' do
+      it 'builds a formatted hash' do
+        expect(sc.formatted).to include(PopCapSpecHelper.formatted_hash)
+      end
+
+      it 'is memoized' do
+        sc.formatted
+        FormattedTag.should_not_receive(:new)
+        sc.formatted
+      end
+    end
+
+    describe '#tags' do
+      it 'builds a tag structure from #formatted_hash' do
         expect(sc.tags.album).to eq PopCapSpecHelper.tags.album
         expect(sc.tags.artist).to eq PopCapSpecHelper.tags.artist
         expect(sc.tags.bit_rate).to eq PopCapSpecHelper.tags.bit_rate
@@ -46,13 +59,14 @@ module PopCap
 
       it 'is memoized' do
         sc.tags
-        expect(sc.instance_variable_get('@tags')).to be_true
+        TagStruct.should_not_receive(:new)
+        sc.tags
       end
     end
 
     context '#reload!' do
       it 'sets instance variables to nil' do
-        %w(@lined @hash @tags).each do |instance|
+        %w(@formatted_hash @unformatted_hash @tag_struct).each do |instance|
           sc.reload!
           expect(sc.instance_variable_get(instance)).to be_nil
         end

data/spec/spec_helper.rb

@@ -1,7 +1,4 @@
 require 'reek/spec'
-require 'simplecov'
-
-SimpleCov.start
 
 RSpec.configure do
   include Reek::Spec

data/spec/support/popcap_spec_helper.rb

@@ -1,36 +1,43 @@
 require 'fileutils'
 require 'ostruct'
+require 'json'
 
 module PopCapSpecHelper
+  SAMPLE_FILE = 'spec/fixtures/sample.flac'
+
   class << self
     def raw_tags
-      <<-EOF.gsub(/^\s+/,'')
-        [FORMAT]
-        filename=#{File.realpath('spec/support/sample.flac')}
-        nb_streams=1
-        format_name=flac
-        format_long_name=raw FLAC
-        start_time=N/A
-        duration=1.000000
-        size=18291
-        bit_rate=146328
-        TAG:GENRE=Sample Genre
-        TAG:track=01
-        TAG:ALBUM=Sample Album
-        TAG:DATE=2012
-        TAG:TITLE=Sample Title
-        TAG:ARTIST=Sample Artist
-        [/FORMAT]
-      EOF
+      '{"format":{"filename":"/home/marsalis/.apps/popcap/spec/fixtures/'\
+        'sample.flac","nb_streams":1,"format_name":"flac","format_long_name"'\
+        ':"raw FLAC","duration":"1.000000","size":"18291","bit_rate":"146328"'\
+        ',"tags":{"GENRE":"Sample Genre","track":"01","ALBUM":"Sample Album",'\
+        '"DATE":"2012","TITLE":"Sample Title","ARTIST":"Sample Artist"}}}'
     end
 
-    def to_hash
+    def unformatted_hash
       {
-        filename: File.realpath('spec/support/sample.flac'),
-        nb_streams: '1',
+        filename: File.realpath(SAMPLE_FILE),
+        nb_streams: 1,
+        format_name: 'flac',
+        format_long_name: 'raw FLAC',
+        duration: '1.000000',
+        filesize: '18291',
+        bit_rate: '146328',
+        genre: 'Sample Genre',
+        track: '01',
+        album: 'Sample Album',
+        date: '2012',
+        title: 'Sample Title',
+        artist: 'Sample Artist'
+      }
+    end
+
+    def formatted_hash
+      {
+        filename: File.realpath(SAMPLE_FILE),
+        nb_streams: 1,
         format_name: 'flac',
         format_long_name: 'raw FLAC',
-        start_time: 'N/A',
         duration: '1',
         filesize: '17.9K',
         bit_rate: '146 kb/s',
@@ -46,7 +53,7 @@ module PopCapSpecHelper
     def tags
       OpenStruct.new(
         {
-        filename: File.realpath('spec/support/sample.flac'),
+        filename: File.realpath(SAMPLE_FILE),
         nb_streams: '1',
         format_name: 'flac',
         format_long_name: 'raw FLAC',
@@ -63,24 +70,34 @@ module PopCapSpecHelper
     end
 
     def remove_converted
-      FileUtils.rm_f('spec/support/sample.mp3')
+      FileUtils.rm_f('spec/fixtures/sample.mp3')
     end
 
     def setup
-      FileUtils.cp('spec/support/sample.flac', 'spec/support/backup.flac')
+      FileUtils.cp(SAMPLE_FILE, 'spec/fixtures/backup.flac')
     end
 
     def teardown
-      FileUtils.mv('spec/support/backup.flac', 'spec/support/sample.flac')
-      FileUtils.rm_f('spec/support/sample.mp3')
+      FileUtils.mv('spec/fixtures/backup.flac', SAMPLE_FILE)
+      FileUtils.rm_f('spec/fixtures/sample.mp3')
+    end
+
+    def object_names(const)
+      ObjectSpace.each_object(const).map { |cls| cls.name }
+    end
+
+    def all_names
+      ObjectSpace.each_object(Object).map do |obj|
+        obj.name if(obj.is_a?(Class) || obj.is_a?(Module))
+      end.compact
+    end
+
+    def classes
+      ObjectSpace.each_object(Class).map { |cls| cls }
     end
 
-    def benchmark(&block)
-      start = Time.now
-      raise(ArgumentError, 'Provide a block.') unless block_given?
-      yield
-      finish = Time.now
-      puts "Time elapsed: #{((finish - stop)*1000).round(3)}ms"
+    def modules
+      ObjectSpace.each_object(Module).map { |cls| cls }
     end
   end
 end