popcap 0.7.2

data/lib/pop_cap/formatters/bit_rate.rb

@@ -0,0 +1,29 @@
+module PopCap
+  module Formatters
+    # Public: This is a formatter for the bit_rate tag.  It is used
+    # to make the bitrate human readable.
+    #
+    # bitrate - The bitrate can be sent as a string or integer.
+    #
+    class BitRate
+      def initialize(bitrate)
+        @bitrate = bitrate
+      end
+
+      # Public: This method returns a bitrate represented in kilobytes.
+      #
+      # It returns nil for anything that is not a number greater than
+      # zero.
+      #
+      # Examples
+      #   br = BitRate.new(128456)
+      #   br.format
+      #   # => '128 kb/s'
+      #
+      def format
+        return unless @bitrate.to_i > 0
+        @bitrate.to_s[0..-4] + ' kb/s'
+      end
+    end
+  end
+end

data/lib/pop_cap/formatters/date.rb

@@ -0,0 +1,42 @@
+module PopCap
+  module Formatters
+    # Public: This is a formatter for the date tag.  It is used
+    # to match and return the year.
+    #
+    # date - The date can be sent as a string or integer.
+    # options - An optional hash for a start & end date range.
+    #           The start_date defaults to 1800, end_date defaults
+    #           to 2100.
+    #
+    class Date
+      attr_reader :start_date, :end_date
+
+      def initialize(date, options={})
+        @date = date.to_s
+        @start_date = options[:start_date] || 1800
+        @end_date = options[:end_date] || 2100
+      end
+
+      # Public:  This method returns a year if it is matched.
+      #
+      # Examples
+      #   date = Date.new('October 5, 1975')
+      #   date.format
+      #   # => '1975'
+      #
+      def format
+        return unless ( date_match && within_date_range? )
+        @match[0].to_i
+      end
+
+      private
+      def date_match
+        @match ||= @date.match(/\b\d{4}\b/)
+      end
+
+      def within_date_range?
+        (start_date..end_date).include?(@match[0].to_i)
+      end
+    end
+  end
+end

data/lib/pop_cap/formatters/duration.rb

@@ -0,0 +1,44 @@
+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
+
+      # 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.
+      #
+      # Examples
+      #   dur = Duration.new(420)
+      #   dur.format
+      #   # => '7:00'
+      #
+      def format
+        return unless @time.to_i > 0
+        return warning_message if over_twenty_four_hours?
+        remove_leading_zeroes(to_strftime)
+      end
+
+      private
+      def to_strftime
+        @strftime = Time.at(@time.to_f).gmtime.strftime('%H:%M:%S')
+      end
+
+      def remove_leading_zeroes(strftime)
+        @strftime.sub(/^(0+|:)+/,'')
+      end
+
+      def over_twenty_four_hours?
+        @time.to_i > 86399
+      end
+
+      def warning_message
+        'Warning: Time is greater than 24 hours.'
+      end
+    end
+  end
+end

data/lib/pop_cap/formatters/filesize.rb

@@ -0,0 +1,69 @@
+module PopCap
+  module Formatters
+    # Public: This class formats a filesize as human readable,
+    # following a UNIX formatting standard.
+    #
+    # filesize - Provide a filesize as string, integer, or float.
+    #
+    class Filesize
+      ::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.
+      #
+      # Examples
+      #   fs = Filesize.new(12345678)
+      #   fs.format
+      #   # => '11.8M'
+      #
+      def format
+        return if @filesize.to_i == 0
+        return warning_message if too_large?
+        converted_filesize.to_s + measurement_character
+      end
+
+      private
+      def binary_filesize
+        float / ::BASE ** exponent
+      end
+
+      def converted_filesize
+        rounded = rounded_filesize
+        is_zero_decimal? ? rounded.ceil : rounded
+      end
+
+      def exponent
+        (Math.log(float)/Math.log(::BASE)).to_i
+      end
+
+      def float
+        Float(@filesize)
+      end
+
+      def is_zero_decimal?
+        rounded_filesize.denominator == 1
+      end
+
+      def measurement_character
+        ::UNITS[exponent]
+      end
+
+      def rounded_filesize
+        binary_filesize.round(1)
+      end
+
+      def too_large?
+        @filesize.to_i > 1099400000000000
+      end
+
+      def warning_message
+        'Warning: Number is larger than 999 terabytes.'
+      end
+    end
+  end
+end

data/lib/pop_cap/formatters.rb

@@ -0,0 +1,33 @@
+module PopCap
+  # Internal: This module requires all formatters in "formatters/."
+  #
+  module Formatters
+    # Internal: This constant is a hash of all files in "formatters/."
+    # To add new custom formatters to Taggable#tags, add the formatter
+    # to "formatters/."
+    #
+    # Formatters should follow this format:
+    #
+    # Examples
+    #   attribute - :custom_formatter
+    #   path - lib/pop_cap/formatters/custom_formatter.rb
+    #   class - CustomFormatter
+    #   format instance method - #format
+    #
+    #   # lib/pop_cap/formatters/custom_formatter.rb
+    #   class CustomFormatter
+    #     def format
+    #       # code that formats
+    #     end
+    #   end
+    #
+    ::INCLUDED_FORMATTERS= {}
+
+    Dir["#{File.dirname(__FILE__)}/formatters/*.rb"].each do |path|
+      @file_name = File.basename(path , '.rb')
+      @required = 'pop_cap/formatters/' + @file_name
+      require @required
+      ::INCLUDED_FORMATTERS[@file_name.to_sym] = @required
+    end
+  end
+end

data/lib/pop_cap/helper.rb

@@ -0,0 +1,53 @@
+module PopCap
+  # Public: This class adds helper methods to construct a class.
+  #
+  # name - This is the name of the class.
+  #
+  # Examples
+  #   Helper.new('array')
+  #   Helper.new('active_support')
+  #   Helper.new('active_record/base')
+  #
+  class Helper
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    # Public: This method camel cases a string or symbol.
+    #
+    # Examples
+    #   helper = Helper.new('active_support')
+    #   helper.camelize
+    #   # => 'ActiveSupport'
+    #
+    def camelize
+      @name.split('_').map { |word| word.capitalize }.join
+    end
+
+    # Public: This namespaces a string by converting a filepath
+    # to a namespaced constant.
+    #
+    # Examples
+    #   helper = Helper.new('active_record/base')
+    #   helper.namespace
+    #   # => 'ActiveRecord::Base'
+    #
+    def namespace
+      camelize.split('/').map do |word|
+        _,head,tail = word.partition(%r(^[a-zA-Z]))
+        head.upcase + tail
+      end.join('::')
+    end
+
+    # Public: This converts a string into a constant.
+    #
+    # Examples
+    #   helper = Helper.new('active_record/base')
+    #   helper.constantize
+    #   # => ActiveSupport::Base
+    #
+    def constantize
+      Object.module_eval(namespace)
+    end
+  end
+end

data/lib/pop_cap/tag_key.rb

@@ -0,0 +1,32 @@
+module PopCap
+  # Internal: This class sanitizes the raw output of FFmpeg to
+  # be used as a hash key.
+  #
+  # key - This is a single key as created by TagLine.
+  #
+  class TagKey
+    def initialize(key)
+      @key = key
+    end
+
+    # Internal: This method removes unwanted strings, downcases,
+    # & symbolizes a key.  Additionally, it renames keys named
+    # 'size' to 'filesize' in order to avoid potential conflicts
+    # with Ruby's build-in method of the same name.
+    #
+    # Examples
+    #   tk = TagKey.new('size')
+    #   tk.format
+    #   # => :filesize
+    #
+    def format
+      return '' if ( @key.nil? || @key.empty? )
+
+      @key.
+        sub(/^TAG:/,'').
+        sub(/^size\b/,'filesize').
+        downcase.
+        to_sym
+    end
+  end
+end

data/lib/pop_cap/tag_line.rb

@@ -0,0 +1,36 @@
+require 'pop_cap/tag_key'
+require 'pop_cap/formatters'
+
+module PopCap
+  # Internal: This class sanitizes the raw output of FFmpeg to
+  # and builds a hash.
+  #
+  # line - This is a single line of raw output from FFmpeg.
+  #
+  class TagLine
+    include
+    def initialize(line)
+      @line = line
+    end
+
+    # Internal: This method builds a hash by splitting on the
+    # first equal sign in a single line of content from FFmpeg.
+    # It uses TagKey to create the key for the hash.
+    #
+    # Examples
+    #   tl = TagLine.new('TAG:ARTIST=David Bowie')
+    #   to.to_hash
+    #   # => {artist: 'David Bowie'}
+    #
+    def to_hash
+      return {} unless ( @line && is_a_tag? )
+      key,val = @line.split('=',2)
+      {TagKey.new(key).format => val}
+    end
+
+    private
+    def is_a_tag?
+      @line.match('=')
+    end
+  end
+end

data/lib/pop_cap/tag_struct.rb

@@ -0,0 +1,45 @@
+module PopCap
+  # Public: This class is a simple implementation of a Ruby struct
+  # like object.  It has a custom #to_s method & creates getter methods.
+  #
+  # new - This method takes a hash.  It raises an error if anything else
+  # is provided.
+  #
+  # Examples
+  #   ts = TagStruct.new({artist: 'Artist', date: 1984})
+  #   ts.artist => 'Artist'
+  #   ts.date => 1984
+  #
+  class TagStruct
+    def initialize(hash)
+      raise(ArgumentError, argument_error_message) unless hash.kind_of?(Hash)
+      @hash = hash
+      define_instance_methods
+    end
+
+    # Public: This method shows the class name & hash values as a string.
+    #
+    # Examples
+    #   ts = TagStruct.new({artist: 'Artist', date: 1984})
+    #   puts ts
+    #   #=> '#<PopCap::TagStruct artist: Artist, date: 1984>'
+    #
+    def to_s
+      methods = @hash.map { |key,val| %(#{key}: #{val}) }.join(', ')
+      "#<#{self.class.name} " + methods + '>'
+    end
+
+    private
+    def argument_error_message
+      'Initialize with a hash.'
+    end
+
+    def define_instance_methods
+      @hash.each do |key, val|
+        unless self.class.respond_to? key
+          define_singleton_method(key) { val }
+        end
+      end
+    end
+  end
+end

data/lib/pop_cap/taggable.rb

@@ -0,0 +1,100 @@
+require 'pop_cap/helper'
+require 'pop_cap/formatters'
+require 'pop_cap/tag_line'
+require 'pop_cap/tag_struct'
+
+module PopCap
+  # Internal: 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.
+    def reload!
+      @lined, @tags, @hash = nil, nil, nil
+    end
+
+    # Internal: This method builds a sanitized hash from #raw_tags.
+    #
+    # Examples
+    #   class SomeClass
+    #     def raw_tags
+    #     end
+    #   end
+    #
+    #   klass = SomeClass.new
+    #   klass.to_hash
+    #   # =>
+    #       { filename: 'spec/support/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 to_hash
+      @hash ||= lined_hash.merge(formatted_hash)
+    end
+
+    # Public: This method builds an tag structure from #to_hash. Also,
+    # TagFormatters are applied to any tag with a custom formatter.
+    #
+    # Examples
+    #   class SomeClass
+    #     def raw_tags
+    #     end
+    #   end
+    #
+    #   klass = SomeClass.new
+    #   klass.tags
+    #
+    #   # =>
+    #    .album             =>  'Sample Album'
+    #    .artist            =>  'Sample Artist'
+    #    .bit_rate          =>  '146 kb/s'
+    #    .date              =>  2012
+    #    .duration          =>  '1'
+    #    .filename          =>  'spec/support/sample.flac'
+    #    .filesize          =>  '17.9K'
+    #    .format_long_name  =>  'raw FLAC'
+    #    .format_name       =>  'flac'
+    #    .genre             =>  'Sample Genre'
+    #    .nb_streams        =>  '1'
+    #    .start_time        =>  'N/A'
+    #    .title             =>  'Sample Title'
+    #    .track             =>  '01'
+    #
+    def tags
+      @tags ||= build_tag_struct(to_hash)
+    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 }
+    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
+    end
+  end
+end

data/lib/pop_cap/version.rb

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

data/lib/popcap.rb

@@ -0,0 +1,5 @@
+require 'pop_cap/audio_file'
+require 'pop_cap/version'
+
+module PopCap
+end

data/popcap.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'popcap'
+
+Gem::Specification.new do |s|
+  s.name        = 'popcap'
+  s.version     = PopCap::VERSION
+  s.authors     = ["Culley Smith"]
+  s.email       = ["culley.smith@gmail.com"]
+  s.homepage    = %q{http://madstance.com}
+  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_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
+  s.test_files         = `git ls-files -z -- {test,spec,features}/*`.split("\0")
+  s.require_paths      = ['lib']
+end

data/spec/integration/convert_audio_file_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+require 'pop_cap/audio_file'
+
+module PopCap
+  describe 'Convert Audio Files' do
+    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.convert(:mp3, 128)
+      expect(File.exists?('spec/support/sample.mp3')).to be_true
+    end
+  end
+end

data/spec/integration/read_metatags_spec.rb

@@ -0,0 +1,12 @@
+require 'popcap'
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+
+describe PopCap do
+  let(:audio_file) { PopCap::AudioFile.new(filepath) }
+  let(:filepath) { 'spec/support/sample.flac' }
+
+  it '#raw_tags' do
+    expect(audio_file.raw_tags).to eq PopCapSpecHelper.raw_tags
+  end
+end

data/spec/integration/update_metatags_spec.rb

@@ -0,0 +1,20 @@
+require 'popcap'
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+
+describe PopCap do
+  let(:audio_file) { PopCap::AudioFile.new(filepath) }
+  let(:filepath) { 'spec/support/sample.flac' }
+
+  context '#update_tags' do
+    before { PopCapSpecHelper.setup }
+    after { PopCapSpecHelper.teardown }
+
+    it 'updates tags for file' do
+      expect(audio_file.tags.artist).to eq 'Sample Artist'
+      updates = {artist: 'New Artist'}
+      audio_file.update_tags(updates)
+      expect(audio_file.tags.artist).to eq 'New Artist'
+    end
+  end
+end

data/spec/lib/pop_cap/audio_file_spec.rb

@@ -0,0 +1,72 @@
+require 'pop_cap/audio_file'
+require 'spec_helper'
+require 'support/popcap_spec_helper'
+
+module PopCap
+  describe AudioFile do
+    let(:audio_file) { AudioFile.new(filepath) }
+    let(:filepath) { 'spec/support/sample.flac' }
+    let(:included_modules) { AudioFile.included_modules }
+
+    before { PopCapSpecHelper.setup }
+    after { PopCapSpecHelper.teardown }
+
+    subject { audio_file }
+
+    context '#filepath' do
+      its(:filepath) { should eq File.realpath(filepath) }
+
+      it 'raises an error if file does not exist' do
+        expect do
+          AudioFile.new('not here.file')
+        end.to raise_error(FileNotFound, 'not here.file')
+      end
+    end
+
+    context 'ffmpeg methods' do
+      it { expect(audio_file).to respond_to(:convert) }
+      it { expect(audio_file).to respond_to(:raw_tags) }
+      it { expect(audio_file).to respond_to(:update_tags) }
+    end
+
+    context 'included modules' do
+      it 'includes Fileable' do
+        expect(included_modules).to include Fileable
+      end
+
+      it 'includes Taggable' do
+        expect(included_modules).to include Taggable
+      end
+    end
+
+    context '#raw_tags' do
+      it 'is memoized' do
+        audio_file.raw_tags
+        expect(audio_file.instance_variable_get('@raw')).
+          to eq PopCapSpecHelper.raw_tags
+      end
+    end
+
+    context '#reload!' do
+      it 'reloads raw tags' do
+        audio_file.raw_tags
+        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'}))
+      end
+    end
+  end
+end