popcap 0.7.2 → 0.8.0

data/lib/pop_cap/formatters/duration.rb

@@ -1,13 +1,11 @@
+require 'pop_cap/formatter'
+
 module PopCap
   module Formatters
     # Public: This will format a duration tag as strftime.
     #
     # time - Provide a string, float, or integer.
-    class Duration
-      def initialize(time)
-        @time = time
-      end
-
+    class Duration < Formatter
       # Public: This will format a duration tag as strftime.
       # It will raise a warning if the time is greater than 24 hours.
       # Leading zeroes & colons are removed.
@@ -18,22 +16,22 @@ module PopCap
       #   # => '7:00'
       #
       def format
-        return unless @time.to_i > 0
+        return unless value.to_i > 0
         return warning_message if over_twenty_four_hours?
-        remove_leading_zeroes(to_strftime)
+        human_readable_time
       end
 
       private
-      def to_strftime
-        @strftime = Time.at(@time.to_f).gmtime.strftime('%H:%M:%S')
+      def human_readable_time
+        to_strftime.sub(/^(0+|:)+/,'')
       end
 
-      def remove_leading_zeroes(strftime)
-        @strftime.sub(/^(0+|:)+/,'')
+      def to_strftime
+        Time.at(value.to_f).gmtime.strftime('%H:%M:%S')
       end
 
       def over_twenty_four_hours?
-        @time.to_i > 86399
+        value.to_i > 86399
       end
 
       def warning_message

data/lib/pop_cap/formatters/filesize.rb

@@ -1,3 +1,5 @@
+require 'pop_cap/formatter'
+
 module PopCap
   module Formatters
     # Public: This class formats a filesize as human readable,
@@ -5,14 +7,10 @@ module PopCap
     #
     # filesize - Provide a filesize as string, integer, or float.
     #
-    class Filesize
+    class Filesize < Formatter
       ::BASE = 1024
       ::UNITS = %W{B K M G T}
 
-      def initialize(filesize)
-        @filesize = filesize
-      end
-
       # Public: This method will format the filesize.
       # It raises a warning message if size is greater than 999 terabytes.
       #
@@ -22,7 +20,7 @@ module PopCap
       #   # => '11.8M'
       #
       def format
-        return if @filesize.to_i == 0
+        return if value.to_i == 0
         return warning_message if too_large?
         converted_filesize.to_s + measurement_character
       end
@@ -42,7 +40,7 @@ module PopCap
       end
 
       def float
-        Float(@filesize)
+        Float(value)
       end
 
       def is_zero_decimal?
@@ -58,7 +56,7 @@ module PopCap
       end
 
       def too_large?
-        @filesize.to_i > 1099400000000000
+        value.to_i > 1099400000000000
       end
 
       def warning_message

data/lib/pop_cap/tag/formatted_tag.rb

@@ -0,0 +1,31 @@
+module PopCap
+  # Public: This class will apply a provided Formatter to
+  # the supplied value.
+  #
+  class FormattedTag
+    attr_reader :formatter, :value
+
+    # Public: To construct an instance, provide a Formatter
+    # and the value to format.
+    #
+    # formatter - A class of type Formatters::Formatter.
+    # value - The value to format.
+    #
+    def initialize(formatter, value)
+      @formatter, @value = formatter, value
+    end
+
+    # Public: This returns the formatted value.
+    #
+    def format
+      formatter.format(value)
+    end
+
+    # Public: A class level method that initializes the class
+    # and formats the value.
+    #
+    def self.format(formatter, value)
+      new(formatter, value).format
+    end
+  end
+end

data/lib/pop_cap/tag/tag_hash.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+module PopCap
+  # Public: This class formats the JSON output of TagReader.
+  #
+  class TagHash
+    attr_reader :json
+
+    def initialize(json)
+      @json = json
+    end
+
+    # Public: This method returns a Ruby hash.
+    # The keys have been converted to symbols.
+    #
+    def hash
+      renamed_hash.reject { |key,_| key == :size }
+    end
+
+    # Public: This method wraps #new & #hash.
+    #
+    def self.hash(json)
+      new(json).hash
+    end
+
+    private
+    def renamed_hash
+      symbolized_hash.merge({filesize: size_element})
+    end
+
+    def symbolized_hash
+      Hash[merged_hashes.map { |key,val| [key.downcase.to_sym, val] }]
+    end
+
+    def merged_hashes
+      format_hash.merge(tags_hash)
+    end
+
+    def size_element
+      format_hash['size']
+    end
+
+    def format_hash
+      @format ||= parsed_json.reject { |key,_| key == 'tags' }
+    end
+
+    def tags_hash
+      parsed_json['tags']
+    end
+
+    def parsed_json
+      @parsed ||= JSON.parse(json)['format']
+    end
+  end
+end

data/lib/pop_cap/{tag_struct.rb → tag/tag_struct.rb}

@@ -11,6 +11,8 @@ module PopCap
   #   ts.date => 1984
   #
   class TagStruct
+    include Enumerable
+
     def initialize(hash)
       raise(ArgumentError, argument_error_message) unless hash.kind_of?(Hash)
       @hash = hash

data/lib/pop_cap/taggable.rb

@@ -1,21 +1,48 @@
-require 'pop_cap/helper'
-require 'pop_cap/formatters'
-require 'pop_cap/tag_line'
-require 'pop_cap/tag_struct'
+require 'pop_cap/class_support'
+require 'pop_cap/formatter'
+require 'pop_cap/tag/formatted_tag'
+require 'pop_cap/tag/tag_hash'
+require 'pop_cap/tag/tag_struct'
 
 module PopCap
-  # Internal: This module is included in anything with a #raw_tags
+  # Public: This module is included in anything with a #raw_tags
   # attribute.  It is used to parse and build tags from FFmpeg raw output.
   #
   module Taggable
-    include Formatters
-
-    # Internal: This method reloads memoized tags.
+    # Public: This method reloads memoized tags.
+    #
     def reload!
-      @lined, @tags, @hash = nil, nil, nil
+      @unformatted_hash, @formatted_hash, @tag_struct = nil, nil, nil
+    end
+
+    # Public: This method builds an unformatted hash of tags.
+    #
+    # Examples
+    #   class SomeClass
+    #     def raw_tags
+    #     end
+    #   end
+    #
+    #   klass = SomeClass.new
+    #   klass.unformatted
+    #   # =>
+    #       { filename: 'spec/fixtures/sample.flac',
+    #         format_name: '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' }
+    #
+    def unformatted(tag_hash: TagHash)
+      @unformatted_hash ||= tag_hash.hash(self.raw_tags)
     end
 
-    # Internal: This method builds a sanitized hash from #raw_tags.
+    # Public: This method builds an unformatted hash of tags.
     #
     # Examples
     #   class SomeClass
@@ -24,9 +51,9 @@ module PopCap
     #   end
     #
     #   klass = SomeClass.new
-    #   klass.to_hash
+    #   klass.unformatted
     #   # =>
-    #       { filename: 'spec/support/sample.flac',
+    #       { filename: 'spec/fixtures/sample.flac',
     #         format_name: 'flac',
     #         duration: '1.000000',
     #         filesize: '18291',
@@ -38,8 +65,8 @@ module PopCap
     #         title: 'Sample Title',
     #         artist: 'Sample Artist' }
     #
-    def to_hash
-      @hash ||= lined_hash.merge(formatted_hash)
+    def formatted
+      @formatted_hash ||= unformatted.merge(formatted_tags)
     end
 
     # Public: This method builds an tag structure from #to_hash. Also,
@@ -60,7 +87,7 @@ module PopCap
     #    .bit_rate          =>  '146 kb/s'
     #    .date              =>  2012
     #    .duration          =>  '1'
-    #    .filename          =>  'spec/support/sample.flac'
+    #    .filename          =>  'spec/fixtures/sample.flac'
     #    .filesize          =>  '17.9K'
     #    .format_long_name  =>  'raw FLAC'
     #    .format_name       =>  'flac'
@@ -71,30 +98,23 @@ module PopCap
     #    .track             =>  '01'
     #
     def tags
-      @tags ||= build_tag_struct(to_hash)
+      @tag_struct ||= build_tag_struct(formatted)
     end
 
     private
-    def lines
-      self.raw_tags.split("\n")
-    end
-
     def build_tag_struct(hash)
       TagStruct.new(hash)
     end
 
-    def lined_hash
-      @lined ||=
-        lines.inject({}) { |hsh,line| hsh.merge(TagLine.new(line)).to_hash }
+    def formatted_tags(support: ClassSupport)
+      Formatters::Formatter.subclasses.inject({}) do |formatted, formatter|
+        attribute = support.new(formatter).symbolize
+        formatted.merge({attribute => format(formatter, attribute)})
+      end
     end
 
-    def formatted_hash
-      ::INCLUDED_FORMATTERS.inject({}) do |formatted, formatter|
-        key, value = formatter
-        helper = Helper.new(value)
-        klass = helper.constantize
-        formatted.merge({key => klass.new(lined_hash[key]).format})
-      end
+    def format(formatter, attribute, tag: FormattedTag)
+      tag.format(formatter, unformatted[attribute])
     end
   end
 end

data/lib/pop_cap/version.rb

@@ -1,3 +1,3 @@
 module PopCap
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

data/popcap.gemspec

@@ -13,12 +13,11 @@ Gem::Specification.new do |s|
   s.summary     = %q{A library work with audio files on the filesystem .}
   s.description = %q{Read & write metadata tags, convert audio files to alternate formats, manage files on the filesystem.}
 
-  s.required_ruby_version     = '>= 1.9.3'
+  s.required_ruby_version     = '>= 2.0.0'
   s.required_rubygems_version = '>= 1.3.6'
 
   s.add_development_dependency 'reek', '~> 1.2'
   s.add_development_dependency 'rspec', '~> 2.11'
-  s.add_development_dependency 'simplecov', '~> 0.7'
 
   git_files            = `git ls-files -z`.split("\0") rescue ''
   s.files              = git_files

data/spec/integration/convert_audio_file_spec.rb

@@ -7,9 +7,9 @@ module PopCap
     after { PopCapSpecHelper.remove_converted }
 
     it 'creates a new audio file with the specified format & bitrate' do
-      audio_file = AudioFile.new('spec/support/sample.flac')
+      audio_file = AudioFile.new(PopCapSpecHelper::SAMPLE_FILE)
       audio_file.convert(:mp3, 128)
-      expect(File.exists?('spec/support/sample.mp3')).to be_true
+      expect(File.exists?('spec/fixtures/sample.mp3')).to be_true
     end
   end
 end

data/spec/integration/read_metatags_spec.rb

@@ -4,7 +4,7 @@ require 'support/popcap_spec_helper'
 
 describe PopCap do
   let(:audio_file) { PopCap::AudioFile.new(filepath) }
-  let(:filepath) { 'spec/support/sample.flac' }
+  let(:filepath) { PopCapSpecHelper::SAMPLE_FILE }
 
   it '#raw_tags' do
     expect(audio_file.raw_tags).to eq PopCapSpecHelper.raw_tags

data/spec/integration/update_metatags_spec.rb

@@ -4,7 +4,7 @@ require 'support/popcap_spec_helper'
 
 describe PopCap do
   let(:audio_file) { PopCap::AudioFile.new(filepath) }
-  let(:filepath) { 'spec/support/sample.flac' }
+  let(:filepath) { PopCapSpecHelper::SAMPLE_FILE }
 
   context '#update_tags' do
     before { PopCapSpecHelper.setup }

data/spec/lib/pop_cap/audio_file_spec.rb

@@ -5,7 +5,7 @@ require 'support/popcap_spec_helper'
 module PopCap
   describe AudioFile do
     let(:audio_file) { AudioFile.new(filepath) }
-    let(:filepath) { 'spec/support/sample.flac' }
+    let(:filepath) { PopCapSpecHelper::SAMPLE_FILE }
     let(:included_modules) { AudioFile.included_modules }
 
     before { PopCapSpecHelper.setup }
@@ -50,22 +50,16 @@ module PopCap
     context '#reload!' do
       it 'reloads raw tags' do
         audio_file.raw_tags
+        expect(audio_file.instance_variable_get('@raw')).not_to be_nil
         audio_file.reload!
         expect(audio_file.instance_variable_get('@raw')).to be_nil
       end
-
-      it 'calls up to Taggable#reload!' do
-        audio_file.raw_tags
-        audio_file.reload!
-        expect(audio_file.instance_variable_get('@tags')).to be_nil
-        expect(audio_file.instance_variable_get('@to_hash')).to be_nil
-      end
     end
 
     context '#update_tags' do
       it 'reloads after tags updated' do
         audio_file.should_receive(:reload!)
-        expect(audio_file.update_tags({foo: 'foo'}))
+        audio_file.update_tags({foo: 'foo'})
       end
     end
   end

data/spec/lib/pop_cap/class_support_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'pop_cap/class_support'
+
+module PopCap
+  describe ClassSupport do
+    context '#camelize' do
+      it 'converts to CamelCase' do
+        maker = ClassSupport.new('one_two')
+        expect(maker.camelize).to eq('OneTwo')
+      end
+
+      it 'handles symbols' do
+        maker = ClassSupport.new(:one_two_three)
+        expect(maker.camelize).to eq('OneTwoThree')
+      end
+    end
+
+    context '#symbolize' do
+      it 'returns a symbol' do
+        maker = ClassSupport.new('One')
+        expect(maker.symbolize).to eq(:one)
+      end
+
+      it 'handles CamelCase' do
+        maker = ClassSupport.new('OneTwo')
+        expect(maker.symbolize).to eq(:one_two)
+      end
+
+      it 'demodulizes the symbol' do
+        maker = ClassSupport.new('One::Two::ThreeFour')
+        expect(maker.symbolize).to eq(:three_four)
+      end
+    end
+
+    context '#namespace' do
+      it 'accounts for namespacing with a forward slash' do
+        maker = ClassSupport.new('one/two/three_four')
+        expect(maker.namespace).to eq('One::Two::ThreeFour')
+      end
+
+      it 'accounts for mixed case in namespacing' do
+        maker = ClassSupport.new('One/Two/Three_Four')
+        expect(maker.namespace).to eq('One::Two::ThreeFour')
+      end
+    end
+
+    context '#constantize' do
+      it 'converts to a constant' do
+        maker = ClassSupport.new('array')
+        expect(maker.constantize).to eq(Array)
+      end
+
+      it 'handles module namespacing' do
+        maker = ClassSupport.new('file/stat')
+        expect(maker.constantize).to eq(File::Stat)
+      end
+    end
+  end
+end

data/spec/lib/pop_cap/{commander_spec.rb → ffmpeg/commander_spec.rb}

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'pop_cap/commander'
+require 'pop_cap/ffmpeg/commander'
 
 module PopCap
   describe Commander do

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'pop_cap/ffmpeg/converter'
+
+module PopCap
+  describe Converter do
+    let(:bitrate) { %W{-ab 192k}}
+    let(:command) { input + bitrate + output_path }
+    let(:commander) { double('commander') }
+    let(:filepath) { 'path/to/file.flac' }
+    let(:input) { %W{ffmpeg -i #{filepath}} }
+    let(:instance) { double('converter_instance') }
+
+    def shared_expectation(command=command)
+      commander.should_receive(:new).with(*command) { instance }
+      instance.stub_chain(:execute, :success?) { true }
+    end
+
+    describe '.convert' do
+      let(:output_path) { %W{path/to/file.ogg} }
+
+      it 'has a class method for #convert' do
+        shared_expectation
+        Converter.convert(filepath, {format: 'ogg', commander: commander})
+      end
+    end
+
+    describe '#convert' do
+      let(:output_path) { %W{path/to/file.ogg} }
+
+      context 'format' do
+        it 'handles a string' do
+          shared_expectation
+          Converter.new(filepath, {format: 'ogg', commander: commander}).convert
+        end
+
+        it 'handles a symbol' do
+          shared_expectation
+          Converter.new(filepath, {format: :ogg, commander: commander}).convert
+        end
+
+        it 'is case insenstive' do
+          shared_expectation
+          Converter.new(filepath, {format: 'OGG', commander: commander}).convert
+        end
+      end
+
+      context 'bitrate' do
+        let(:output_path) { %W{path/to/file.mp3} }
+
+        it 'defaults to 192 kb/s' do
+          shared_expectation
+          Converter.new(filepath, {format: :mp3, commander: commander}).convert
+        end
+
+        it 'takes an optional bitrate' do
+          options = {format: :mp3, bitrate: 64, commander: commander}
+          bitrate_command = input + %W{-ab 64k} + output_path
+          shared_expectation(bitrate_command)
+          Converter.new(filepath, options).convert
+        end
+
+        it 'handles bitrate as string' do
+          options = {format: :mp3, bitrate: '128', commander: commander}
+          bitrate_command = input + %W{-ab 128k} + output_path
+          shared_expectation(bitrate_command)
+          Converter.new(filepath, options).convert
+        end
+      end
+
+      context 'm4a' do
+        let(:output_path) { %W{path/to/file.m4a} }
+
+        it 'uses strict mode' do
+          strict = input + %W{-strict -2} + bitrate + output_path
+          shared_expectation(strict)
+          Converter.new(filepath, {format: :m4a, commander: commander}).convert
+        end
+      end
+
+      context 'errors' do
+        it 'raises error if could not convert file' do
+          expect do
+            commander.should_receive(:new).with(*command) { instance }
+            instance.stub_chain(:execute, :success?) { false }
+            Converter.new(filepath, {format: :ogg,
+                          commander: commander}).convert
+          end.to raise_error(FFmpegError, "Error converting #{filepath}.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+require 'pop_cap/ffmpeg/ffmpeg'
+
+module PopCap
+  describe FFmpeg do
+
+    let(:filepath) { File.realpath(PopCapSpecHelper::SAMPLE_FILE) }
+    let(:ffmpeg) { FFmpeg.new(filepath) }
+
+    it 'returns its filepath' do
+      expect(ffmpeg.filepath).to eq filepath
+    end
+
+    it 'sets default commander to Commander' do
+      expect(ffmpeg.commander).to eq Commander
+    end
+
+    it '#new takes an options hash' do
+      opts = {foo: 'foo'}
+      ffmpeg = FFmpeg.new(filepath, opts)
+      expect(ffmpeg.options).to eq({foo: 'foo'})
+    end
+
+    it 'has a custom error message' do
+      expect(ffmpeg.error_message('loving')).to eq "Error loving #{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
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'pop_cap/ffmpeg/tag_reader'
+
+module PopCap
+  describe TagReader do
+    let(:commander) { double('commander') }
+    let(:instance) { double('commander_instance') }
+    let(:file) { 'path/to/file.flac' }
+    let(:reader) { TagReader.new(file, {commander: commander}) }
+    let(:command) { %W{ffprobe -show_format -print_format json #{file}} }
+
+    let(:shared_example) do
+      commander.should_receive(:new).with(*command) { instance }
+      instance.stub_chain(:execute, :success?) { true }
+      instance.stub_chain(:execute, :stdout) { instance }
+    end
+
+    it 'test' do
+      puts JSON.parse(TagReader.read('spec/fixtures/sample.flac'))
+    end
+
+    describe '.read' do
+      before { shared_example }
+
+      it 'has a class method for #read' do
+        instance.stub(:valid_encoding?) { true }
+        JSON.stub(:load)
+        TagReader.read(file, {commander: commander})
+      end
+    end
+
+    describe '#read' do
+      before { shared_example }
+      after { reader.read }
+
+      it 'returns the output as JSON' do
+        instance.stub(:valid_encoding?) { true }
+        JSON.should_receive(:load).with(instance) { instance }
+        instance.should_receive(:to_json)
+      end
+
+      it 'does not encode valid byte strings' do
+        instance.stub(:valid_encoding?) { true }
+        JSON.stub(:load)
+        instance.should_not_receive(:encode!)
+      end
+
+      it 'encodes invalid byte strings as UTF-8' do
+        instance.stub(:valid_encoding?) { false }
+        instance.stub_chain(:encoding, :name) { 'UTF-8' }
+        instance.should_receive(:encode!).
+          with('UTF-16', 'UTF-8', undef: :replace, invalid: :replace)
+        instance.should_receive(:encode!).with('UTF-8')
+      end
+    end
+
+    context 'errors' do
+      it 'raises error if could not read tags' do
+        expect do
+          commander.should_receive(:new).with(*command) { instance }
+          instance.stub_chain(:execute, :success?) { false }
+          reader.read
+        end.to raise_error(FFmpegError, "Error reading #{file}.")
+      end
+    end
+  end
+end