apetag 1.0.0

data/apetag.rb

@@ -0,0 +1,489 @@
+#!/usr/bin/env ruby
+# This library implements a APEv2 parser/generator.
+# If called from the command line, it prints out the contents of the APEv2 tag for the given filename arguments.
+#
+# ruby-apetag is a pure Ruby library for manipulating APEv2 (and ID3v1.1) tags.
+# It aims for standards compliance with the APE spec (1). APEv2 is the standard
+# tagging format for Musepack (.mpc) and Monkey's Audio files (.ape), and it can
+# also be used with mp3s as an alternative to the mess that is ID3v2.x
+# (technically, it can be used on any file type and is not limited to storing
+# just audio file metadata).
+#
+# The module is in written in pure Ruby, so it should be useable on all 
+# platforms that Ruby supports.  It has been tested on OpenBSD.  
+# The minimum python version required should be 1.8, but it has only been tested
+# on 1.8.4.  Modifying the code to work with previous version shouldn't be
+# difficult, though there aren't any plans to do so.
+#
+# The library is complete, but it hasn't been used, so there may still be
+# some bugs in it.  I haven't found any bugs in my normal use of it that I
+# haven't already fixed, though. RDoc documentation is available, as is
+# Test::Unit based testing.
+#
+# General Use:
+#
+#  require 'apetag'
+#  a = ApeTag.new('file.mp3')
+#  a.exists? # if it already has an APEv2 tag
+#  a.raw # the raw APEv2+ID3v1.1 tag already on the file
+#  a.fields # a hash of fields, keys are strings, values are list of strings
+#  a.pretty_print # string suitable for pretty printing
+#  a.update{|fields| fields['Artist']='Test Artist'; fields.delete('Year')}
+#   # Update the tag with the added/changed/deleted fields
+#   # Note that you should do: a.update{|fields| fields.replace('Test'=>'Test')}
+#   # and NOT: a.update{|fields| fields = {'Test'=>'Test'}}
+#   # You need to update/modify the fields given, not reassign it
+#  a.remove! # remove the APEv2 and ID3v1.1 tags.
+#
+# To run the tests for the library, run test_apetag.rb.
+#
+# If you find any bugs, would like additional documentation, or want to submit a
+# patch, please use Rubyforge (http://rubyforge.org/projects/apetag/).
+#
+# The most current source code can be accessed via anonymous SVN at 
+# svn://suven.no-ip.org/ruby-apetag/.  Note that the library isn't modified on a
+# regular basis, so it is unlikely to be different from the latest release.
+#
+# (1) http://wiki.hydrogenaudio.org/index.php?title=APEv2_specification
+#
+# Copyright (c) 2007 Jeremy Evans
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy 
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights 
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+# copies of the Software, and to permit persons to whom the Software is 
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in 
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+# SOFTWARE.
+
+require 'set'
+
+# Error raised by the library
+class ApeTagError < StandardError
+end
+
+# The individual items in the APE tag.
+# Because all items can contain a list of values, this is a subclass of Array.
+class ApeItem < Array
+  MIN_SIZE = 11 # 4+4+2+1 (length, flags, minimum key length, key-value separator)
+  BAD_KEYS = Set.new(%w'id3 tag oggs mp+')
+  BAD_KEY_RE = Regexp.new("[\0-\x1f\x80-\xff]")
+  ITEM_TYPES = %w'utf8 binary external reserved'
+  
+  attr_reader :read_only, :ape_type, :key, :key_downcased
+  
+  # Creates an APE tag with the appropriate key and value.
+  # If value is a valid ApeItem, just updates the key.
+  # If value is an Array, creates an ApeItem with the key and all of its values.
+  # Otherwise, creates an ApeItem with the key and the singular value.
+  # Raise ApeTagError if key or or value is invalid.
+  def self.create(key, value)
+    if value.is_a?(self) && value.valid?
+      value.key = key
+      return value
+    end
+    value = [value] unless value.is_a?(Array)
+    new(key, value)
+  end
+  
+  # Parse an ApeItem from the given data string starting at the provided offset.
+  # Check for validity and populate the object with the parsed data.
+  # Return the offset of the next item (or end of string).
+  # Raise ApeTagError if the parsed data is invalid.
+  def self.parse(data, offset)
+    length, flags = data[offset...(offset+8)].unpack('VN')
+    raise ApeTagError, "Invalid item length at offset #{offset}" if length + offset + MIN_SIZE > data.length
+    raise ApeTagError, "Invalid item flags at offset #{offset}" if flags > 7
+    key_end = data.index("\0", offset += 8)
+    raise ApeTagError, "Missing key-value separator at offset #{offset}" unless key_end
+    raise ApeTagError, "Invalid item length at offset #{offset}" if (next_item_start=length + key_end + 1) > data.length
+    item = ApeItem.new(data[offset...key_end], data[(key_end+1)...next_item_start].split("\0"))
+    item.read_only = flags & 1 > 0
+    item.ape_type = ITEM_TYPES[flags/2]
+    return [item, next_item_start]
+  end
+  
+  # Set key and value.
+  # Set read_only to false and ape_type to utf8.
+  # Raise ApeTagError if key or value is invalid.
+  def initialize(key, value)
+    self.key = key
+    self.read_only = false
+    self.ape_type = ITEM_TYPES[0]
+    super(value)
+    raise ApeTagError, "Invalid item value encoding (non UTF-8)" unless valid_value?
+  end
+  
+  # Set ape_type if valid, otherwise raise ApeTagError.
+  def ape_type=(type)
+    raise ApeTagError, "Invalid APE type" unless valid_ape_type?(type)
+    @ape_type=type
+  end
+  
+  # Set key if valid, otherwise raise ApeTagError.
+  def key=(key)
+    raise ApeTagError, "Invalid APE key" unless valid_key?(key)
+    @key = key
+    @key_downcased = key.downcase
+  end
+  
+  # The on disk representation of the entire ApeItem.
+  # Raise ApeTagError if ApeItem is invalid.
+  def raw
+    raise ApeTagError, "Invalid key, value, APE type, or Read-Only Flag" unless valid? 
+    flags = ITEM_TYPES.index(ape_type) * 2 + (read_only ? 1 : 0)
+    sv = string_value
+    "#{[sv.length, flags].pack('VN')}#{key}\0#{sv}"
+  end
+  
+  # Set read only flag if valid, otherwise raise ApeTagError.
+  def read_only=(flag)
+    raise ApeTagError, "Invalid Read-Only Flag" unless valid_read_only?(flag)
+    @read_only = flag
+  end
+  
+  # The on disk representation of the ApeItem's values.
+  def string_value
+    join("\0")
+  end
+  
+  # Check if current item is valid
+  def valid?
+    valid_ape_type?(ape_type) && valid_read_only?(read_only) && valid_key?(key) && valid_value?
+  end
+  
+  # Check if given type is a valid APE type (a member of ApeItem::ITEM_TYPES).
+  def valid_ape_type?(type)
+    ITEM_TYPES.include?(type)
+  end
+  
+  # Check if the given key is a valid APE key (string, 2 <= length <= 255, not in ApeItem::BAD_KEYS, not containing invalid characters).
+  def valid_key?(key)
+    key.is_a?(String) && key.length >= 2 && key.length <= 255 && !BAD_KEYS.include?(key.downcase) && key !~ BAD_KEY_RE
+  end
+  
+  # Check if the given read only flag is valid (boolean).
+  def valid_read_only?(flag)
+    [true, false].include?(flag)
+  end
+  
+  # Check if the string value is valid UTF-8.
+  def valid_value?
+    begin
+      string_value.unpack('U*') if ape_type == 'utf8' || ape_type == 'external'
+    rescue ArgumentError
+      false
+    else
+      true
+    end
+  end
+end
+
+# Contains all of the ApeItems found in the filename/file given.
+# MAX_SIZE and MAX_ITEM_COUNT constants are recommended defaults, they can be
+# increased if necessary.
+class ApeTag
+  MAX_SIZE = 8192
+  MAX_ITEM_COUNT = 64
+  HEADER_FLAGS = "\x00\x00\x00\xA0"
+  FOOTER_FLAGS = "\x00\x00\x00\x80"
+  PREAMBLE = "APETAGEX\xD0\x07\x00\x00"
+  RECOMMENDED_KEYS = %w'Title Artist Album Year Comment Genre Track Subtitle
+    Publisher Conductor Composer Copyright Publicationright File EAN/UPC ISBN
+    Catalog LC Media Index Related ISRC Abstract Language Bibliography
+    Introplay Dummy' << 'Debut Album' << 'Record Date' << 'Record Location'
+  ID3_GENRES = 'Blues, Classic Rock, Country, Dance, Disco, Funk, Grunge, 
+    Hip-Hop, Jazz, Metal, New Age, Oldies, Other, Pop, R & B, Rap, Reggae, 
+    Rock, Techno, Industrial, Alternative, Ska, Death Metal, Prank, Soundtrack,
+    Euro-Techno, Ambient, Trip-Hop, Vocal, Jazz + Funk, Fusion, Trance, 
+    Classical, Instrumental, Acid, House, Game, Sound Clip, Gospel, Noise, 
+    Alternative Rock, Bass, Soul, Punk, Space, Meditative, Instrumental Pop, 
+    Instrumental Rock, Ethnic, Gothic, Darkwave, Techno-Industrial, Electronic,
+    Pop-Fol, Eurodance, Dream, Southern Rock, Comedy, Cult, Gangsta, Top 40,
+    Christian Rap, Pop/Funk, Jungle, Native US, Cabaret, New Wave, Psychadelic,
+    Rave, Showtunes, Trailer, Lo-Fi, Tribal, Acid Punk, Acid Jazz, Polka, 
+    Retro, Musical, Rock & Roll, Hard Rock, Folk, Folk-Rock, National Folk, 
+    Swing, Fast Fusion, Bebop, Latin, Revival, Celtic, Bluegrass, Avantgarde, 
+    Gothic Rock, Progressive Rock, Psychedelic Rock, Symphonic Rock, Slow Rock,
+    Big Band, Chorus, Easy Listening, Acoustic, Humour, Speech, Chanson, Opera,
+    Chamber Music, Sonata, Symphony, Booty Bass, Primus, Porn Groove, Satire, 
+    Slow Jam, Club, Tango, Samba, Folklore, Ballad, Power Ballad, Rhytmic Soul,
+    Freestyle, Duet, Punk Rock, Drum Solo, Acapella, Euro-House, Dance Hall, 
+    Goa, Drum & Bass, Club-House, Hardcore, Terror, Indie, BritPop, Negerpunk, 
+    Polsk Punk, Beat, Christian Gangsta Rap, Heavy Metal, Black Metal, 
+    Crossover, Contemporary Christian, Christian Rock, Merengue, Salsa, 
+    Trash Meta, Anime, Jpop, Synthpop'.split(',').collect{|g| g.strip}
+  ID3_GENRES_HASH = Hash.new(255.chr)
+  ID3_GENRES.each_with_index{|g,i| ID3_GENRES_HASH[g] = i.chr }
+  FILE_OBJ_METHODS = %w'close seek read pos write truncate'
+  YEAR_RE = Regexp.new('\d{4}')
+  MP3_RE = Regexp.new('\.mp3\z')
+  
+  @@check_id3 = true
+  
+  attr_reader :filename, :file, :tag_size, :tag_start, :tag_data, :tag_header, :tag_footer, :tag_item_count, :check_id3
+  
+  # Set whether to check for id3 tags by default on file objects (defaults to true)
+  def self.check_id3=(flag)
+    raise ApeTagError, "check_id3 must be boolean" unless [true, false].include?(flag)
+    @@check_id3 = flag
+  end
+  
+  # Set the filename or file object to operate on.  If the object has all methods
+  # in FILE_OBJ_METHODS, it is treated as a file, otherwise, it is treated as a filename.
+  # If the filename is invalid, Errno::ENOENT or Errno::EINVAL will probably be raised when calling methods.
+  # Optional argument check_id3 checks for ID3 tags.
+  # If check_id3 is not specified and filename is a file object, the ApeTag default is used.
+  # If check_id3 is not specified and filename is a filename, it checks for ID3 tags only if 
+  # the filename ends with ".mp3".
+  # If files have APE tags but no ID3 tags, ID3 tags will never be added.
+  # If files have neither tag, check_id3 will decide whether to add an ID3 tag.
+  # If files have both tags, make sure check_id3 is true or it will miss both tags.
+  def initialize(filename, check_id3 = nil)
+    if FILE_OBJ_METHODS.each{|method| break unless filename.respond_to?(method)}
+      @file = filename
+      @check_id3 = check_id3.nil? ? @@check_id3 : check_id3 
+    else
+      @filename = filename.to_s
+      @check_id3 = check_id3 unless check_id3.nil?
+      @check_id3 = !MP3_RE.match(@filename).nil? if @check_id3.nil?
+    end
+  end
+  
+  # Check the file for an APE tag.  Returns true or false. Raises ApeTagError for corrupt tags.  
+  def exists?
+    @has_tag.nil? ? access_file('rb'){has_tag} : @has_tag
+  end
+  
+  # Remove an APE tag from a file, if one exists.
+  # Returns true.  Raises ApeTagError for corrupt tags.
+  def remove!
+    access_file('rb+'){file.truncate(tag_start) if has_tag}
+    @has_tag, @fields, @id3, @tag_size, @tag_start, @tag_data, @tag_header, @tag_footer, @tag_item_count = []
+    true
+  end
+  
+  # A hash of ApeItems found in the file, or an empty hash if the file
+  # doesn't have an APE tag.  Raises ApeTagError for corrupt tags.
+  def fields
+    @fields || access_file('rb'){get_fields}
+  end
+  
+  # Pretty print tags, with one line per field, showing key and value.
+  def pretty_print
+    begin
+      fields.values.sort_by{|value| value.key_downcased}.collect{|value| "#{value.key}: #{value.join(', ')}"}.join("\n")
+    rescue ApeTagError
+      "CORRUPT TAG!"
+    rescue Errno::ENOENT, Errno::EINVAL
+      "FILE NOT FOUND!"
+    end
+  end
+  
+  # The raw APEv2 + ID3v1.1 tag.  If one or the other is empty that part will be missing.
+  # Raises ApeTagError for corrupt tags.
+  def raw
+    exists? 
+    "#{tag_header}#{tag_data}#{tag_footer}#{id3}"
+  end
+  
+  # Yields a hash of ApeItems found in the file, or an empty hash if the file
+  # doesn't have an APE tag.  This hash should be modified (not reassigned) inside
+  # the block.  An APEv2+ID3v1.1 tag with the new fields will overwrite the previous
+  # tag.  If the file doesn't have an APEv2 tag, one will be created and appended to it.
+  # If the file doesn't have an ID3v1.1 tag, one will be generated from the ApeTag fields
+  # and appended to it.  If the file already has an ID3v1.1 tag, the data in it is ignored,
+  # and it is overwritten.  Raises ApeTagError if either the existing tag is invalid
+  # or the tag to be written would be invalid.
+  def update(&block)
+    access_file('rb+') do 
+      yield get_fields
+      normalize_fields
+      update_id3
+      update_ape
+      write_tag
+    end
+    fields
+  end
+  
+  private
+    # If working with a file object, yield the object.
+    # If working with a filename, open the file to be accessed using the correct mode,
+    # yield the file.  Return the value returned by the block passed.
+    def access_file(how, &block)
+      if @filename
+        File.open(filename, how) do |file|
+          @file = file
+          return_value = yield
+          @file.close
+          @file = nil
+          return_value
+        end
+      else
+        yield
+      end
+    end  
+    
+    # If working with a filename, use the file system's size for that filename.
+    # If working with a file that has a size method (e.g. StringIO), call that.
+    # Otherwise, seek to the end of the file and return the position.
+    def file_size
+      if @filename
+        File.size(filename)
+      elsif file.respond_to?(:size)
+        file.size
+      else
+        file.seek(0, IO::SEEK_END) && file.pos
+      end
+    end
+    
+    # Parse the raw tag data to get the tag fields (a hash of ApeItems), or an empty hash
+    # if the file has no APE tag.
+    def get_fields
+      return @fields if @fields
+      return @fields = Hash.new unless has_tag
+      ape_items = Hash.new
+      ape_item_keys = Set.new
+      offset = 0
+      last_possible_item_start = tag_data.length - ApeItem::MIN_SIZE
+      tag_item_count.times do
+        raise ApeTagError, "End of tag reached but more items specified" if offset > last_possible_item_start
+        item, offset = ApeItem.parse(tag_data, offset)
+        raise ApeTagError, "Multiple items with same key (#{item.key.inspect})" if ape_item_keys.include?(item.key_downcased)
+        ape_item_keys.add(item.key_downcased)
+        ape_items[item.key] = item
+      end
+      raise ApeTagError, "Data remaing after specified number of items parsed" if offset != tag_data.length
+      @fields = ape_items
+    end
+    
+    # Get various information about the tag (if it exists), and check it for validity if a tag is present.
+    def get_tag_information
+      unless file_size >= id3.length + 64 
+        @has_tag = false
+        @tag_start = file_size - id3.length
+        return
+      end
+      file.seek(-32-id3.length, IO::SEEK_END)
+      tag_footer = file.read(32)
+      unless tag_footer[0...12] == PREAMBLE && tag_footer[20...24] == FOOTER_FLAGS
+        @has_tag = false
+        @tag_start = file_size - id3.length
+        return
+      end
+      @tag_footer = tag_footer
+      @tag_size, @tag_item_count = tag_footer[12...20].unpack('VV')
+      @tag_size += 32
+      raise ApeTagError, "Tag size (#{tag_size}) smaller than minimum size" if tag_size < 64 
+      raise ApeTagError, "Tag size (#{tag_size}) larger than possible" if tag_size + id3.length > file_size
+      raise ApeTagError, "Tag size (#{tag_size}) is larger than #{MAX_SIZE}" if tag_size > MAX_SIZE
+      raise ApeTagError, "Item count (#{tag_item_count}) is larger than #{MAX_ITEM_COUNT}" if tag_item_count > MAX_ITEM_COUNT
+      raise ApeTagError, "Item count (#{tag_item_count}) is larger than possible" if tag_item_count > tag_size-64/ApeItem::MIN_SIZE
+      file.seek(-tag_size-id3.length, IO::SEEK_END)
+      @tag_start=file.pos
+      @tag_header=file.read(32)
+      @tag_data=file.read(tag_size-64)
+      raise ApeTagError, "Missing header" unless tag_header[0...12] == PREAMBLE && tag_header[20...24] == HEADER_FLAGS
+      raise ApeTagError, "Header and footer size does match" unless tag_size == tag_header[12...16].unpack('V')[0] + 32
+      raise ApeTagError, "Header and footer item count does match" unless tag_item_count == tag_header[16...20].unpack('V')[0]
+      @has_tag = true
+    end
+    
+    # Check if the file has a tag or not
+    def has_tag
+      return @has_tag unless @has_tag.nil?
+      get_tag_information
+      @has_tag
+    end
+    
+    # Get the raw id3 string for the file (this is ignored).
+    # If check_id3 is false, it doesn't check for the ID3, which means that
+    # the APE tag will probably not be recognized if the file ends with an ID3 tag.
+    def id3
+      return @id3 unless @id3.nil?
+      return @id3 = '' if file_size < 128 || check_id3 == false
+      file.seek(-128, IO::SEEK_END)
+      data = file.read(128)
+      @id3 = data[0...3] == 'TAG' && data[125] == 0 ? data : ''
+    end
+    
+    # Turn fields hash from a hash of arbitrary objects to a hash of ApeItems
+    # Check that multiple identical keys are not present.
+    def normalize_fields
+      new_fields = Hash.new
+      new_fields_keys = Set.new
+      fields.each do |key, value|
+        new_fields[key] = value = ApeItem.create(key, value)
+        raise ApeTagError, "Multiple items with same key (#{value.key.inspect})" if new_fields_keys.include?(value.key_downcased)
+        new_fields_keys.add(value.key_downcased)
+      end
+      @fields = new_fields
+    end
+    
+    # Update internal variables to reflect the new APE tag.  Check that produced
+    # tag is still valid.
+    def update_ape
+      entries = fields.values.collect{|value| value.raw}.sort{|a,b| x = a.length <=> b.length; x != 0 ? x : a <=> b}
+      @tag_data = entries.join
+      @tag_item_count = entries.length
+      @tag_size = tag_data.length + 64
+      base_start = "#{PREAMBLE}#{[tag_size-32, tag_item_count].pack('VV')}"
+      base_end = "\0"*8
+      @tag_header = "#{base_start}#{HEADER_FLAGS}#{base_end}"
+      @tag_footer = "#{base_start}#{FOOTER_FLAGS}#{base_end}"
+      raise ApeTagError, "Updated tag has too many items (#{tag_item_count})" if tag_item_count > MAX_ITEM_COUNT
+      raise ApeTagError, "Updated tag too large (#{tag_size})" if tag_size > MAX_SIZE
+    end
+    
+    # Update the ID3v1.1 tag variable to use the fields from the APEv2 tag.
+    # If the file doesn't have an ID3 and the file already has an APE tag or
+    # check_id3 is not set, an ID3 won't be added.
+    def update_id3
+      return if id3.length == 0 && (has_tag || check_id3 == false)
+      id3_fields = Hash.new('')
+      id3_fields['genre'] = 255.chr
+      fields.values.each do |value|
+        case value.key_downcased
+          when /\Atrack/
+            id3_fields['track'] = value.string_value.to_i
+            id3_fields['track'] = 0 if id3_fields['track'] > 255
+            id3_fields['track'] = id3_fields['track'].chr
+          when /\Agenre/
+            id3_fields['genre'] = ID3_GENRES_HASH[value.first]
+          when /\Adate\z/
+            match = YEAR_RE.match(value.string_value)
+            id3_fields['year'] = match[0] if match 
+          when /\A(title|artist|album|year|comment)\z/
+            id3_fields[value.key_downcased] = value.join(', ')
+        end
+      end
+      @id3 = ["TAG", id3_fields['title'], id3_fields['artist'], id3_fields['album'],
+              id3_fields['year'], id3_fields['comment'], "\0", id3_fields['track'],
+              id3_fields['genre']].pack("a3a30a30a30a4a28a1a1a1")
+    end
+    
+    # Write the APEv2 and ID3v1.1 tags to disk.
+    def write_tag
+      file.seek(tag_start, IO::SEEK_SET)
+      file.write(raw)
+      file.truncate(file.pos)
+      @has_tag = true
+    end
+end
+
+# If called directly from the command line, treat all arguments as filenames, and pretty print the APE tag's fields for each filename.
+if __FILE__ == $0
+  ARGV.each do |filename| 
+    puts filename, '-'*filename.length, ApeTag.new(filename).pretty_print, ''
+  end
+end

data/test/test_apetag.rb

@@ -0,0 +1,422 @@
+#!/usr/bin/env ruby
+require 'apetag'
+require 'stringio'
+require 'test/unit'
+
+EMPTY_APE_TAG = "APETAGEX\320\a\0\0 \0\0\0\0\0\0\0\0\0\0\240\0\0\0\0\0\0\0\0APETAGEX\320\a\0\0 \0\0\0\0\0\0\0\0\0\0\200\0\0\0\0\0\0\0\0TAG\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377"
+EXAMPLE_APE_TAG = "APETAGEX\xd0\x07\x00\x00\xb0\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00Track\x001\x04\x00\x00\x00\x00\x00\x00\x00Date\x002007\t\x00\x00\x00\x00\x00\x00\x00Comment\x00XXXX-0000\x0b\x00\x00\x00\x00\x00\x00\x00Title\x00Love Cheese\x0b\x00\x00\x00\x00\x00\x00\x00Artist\x00Test Artist\x16\x00\x00\x00\x00\x00\x00\x00Album\x00Test Album\x00Other AlbumAPETAGEX\xd0\x07\x00\x00\xb0\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00TAGLove Cheese\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Test Artist\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Test Album, Other Album\x00\x00\x00\x00\x00\x00\x002007XXXX-0000\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xff"
+EXAMPLE_APE_TAG2 = "APETAGEX\xd0\x07\x00\x00\x99\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00Blah\x00Blah\x04\x00\x00\x00\x00\x00\x00\x00Date\x002007\t\x00\x00\x00\x00\x00\x00\x00Comment\x00XXXX-0000\x0b\x00\x00\x00\x00\x00\x00\x00Artist\x00Test Artist\x16\x00\x00\x00\x00\x00\x00\x00Album\x00Test Album\x00Other AlbumAPETAGEX\xd0\x07\x00\x00\x99\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00TAG\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Test Artist\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Test Album, Other Album\x00\x00\x00\x00\x00\x00\x002007XXXX-0000\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff"
+EMPTY_APE_ONLY_TAG, EXAMPLE_APE_ONLY_TAG, EXAMPLE_APE_ONLY_TAG2 = [EMPTY_APE_TAG, EXAMPLE_APE_TAG, EXAMPLE_APE_TAG2].collect{|x|x[0...-128]}
+EXAMPLE_APE_FIELDS = {"Track"=>["1"], "Comment"=>["XXXX-0000"], "Album"=>["Test Album", "Other Album"], "Title"=>["Love Cheese"], "Artist"=>["Test Artist"], "Date"=>["2007"]}
+EXAMPLE_APE_FIELDS2 = {"Blah"=>["Blah"], "Comment"=>["XXXX-0000"], "Album"=>["Test Album", "Other Album"], "Artist"=>["Test Artist"], "Date"=>["2007"]}
+EXAMPLE_APE_TAG_PRETTY_PRINT = "Album: Test Album, Other Album\nArtist: Test Artist\nComment: XXXX-0000\nDate: 2007\nTitle: Love Cheese\nTrack: 1"
+
+class ApeTagTest < Test::Unit::TestCase
+  def get_ape_tag(f, check_id3)
+    f.is_a?(ApeTag) ? f : ApeTag.new(f, check_id3)
+  end
+  
+  def get_size(x)
+    get_ape_tag(x, nil).send :file_size
+  end
+
+  def item_test(item, check_id3)
+    f = item
+    id3_size = check_id3 ? 128 : 0
+    size = get_size(f)
+    assert_equal false, get_ape_tag(f, check_id3).exists?
+    assert_equal size, get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).remove!
+    assert_equal size, get_size(f)
+    assert_equal "", get_ape_tag(f, check_id3).raw
+    assert_equal size, get_size(f)
+    assert_equal Hash.new, get_ape_tag(f, check_id3).fields
+    assert_equal size, get_size(f)
+    assert_equal Hash.new, get_ape_tag(f, check_id3).update{|x|}
+    assert_equal (size+=64+id3_size), get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).exists?
+    assert_equal size, get_size(f)
+    assert_equal (check_id3 ? EMPTY_APE_TAG : EMPTY_APE_ONLY_TAG), get_ape_tag(f, check_id3).raw, "#{item.inspect} #{check_id3}"
+    assert_equal size, get_size(f)
+    assert_equal Hash.new, get_ape_tag(f, check_id3).fields
+    assert_equal size, get_size(f)
+    assert_equal Hash.new, get_ape_tag(f, check_id3).update{|x|}
+    assert_equal size, get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).remove!
+    assert_equal (size-=64+id3_size), get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS, get_ape_tag(f, check_id3).update{|x| x.replace(EXAMPLE_APE_FIELDS)}
+    assert_equal (size+=208+id3_size), get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).exists?
+    assert_equal size, get_size(f)
+    assert_equal (check_id3 ? EXAMPLE_APE_TAG : EXAMPLE_APE_ONLY_TAG), get_ape_tag(f, check_id3).raw
+    assert_equal EXAMPLE_APE_TAG_PRETTY_PRINT, get_ape_tag(f, check_id3).pretty_print
+    assert_equal size, get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS, get_ape_tag(f, check_id3).fields
+    assert_equal size, get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS, get_ape_tag(f, check_id3).update{|x|}
+    assert_equal size, get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS2, get_ape_tag(f, check_id3).update {|x| x.delete('Track'); x.delete('Title'); x['Blah']='Blah'}
+    assert_equal (size-=23), get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).exists?
+    assert_equal size, get_size(f)
+    assert_equal (check_id3 ? EXAMPLE_APE_TAG2 : EXAMPLE_APE_ONLY_TAG2), get_ape_tag(f, check_id3).raw
+    assert_equal size, get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS2, get_ape_tag(f, check_id3).fields
+    assert_equal size, get_size(f)
+    assert_equal EXAMPLE_APE_FIELDS2, get_ape_tag(f, check_id3).update{|x|}
+    assert_equal size, get_size(f)
+    assert_equal true, get_ape_tag(f, check_id3).remove!
+    assert_equal "", get_ape_tag(f, check_id3).raw
+    assert_equal (size-=185+id3_size), get_size(f)
+  end
+
+  # Test to make sure different file sizes don't cause any problems.
+  # Use both StringIOs, Files, and Strings.
+  # Use both a single ApeTag for each test and a new ApeTag for each to test
+  # that ApeTag state is created and saved correctly.
+  def test_blanks
+    filename = 'test.apetag'
+    File.new(filename,'wb').close
+    [0,1,63,64,65,127,128,129,191,192,193,8191,8192,8193].each do |x|
+      [true, false].each do |check_id3|
+        s = StringIO.new(' ' * x)
+        item_test(s, check_id3)
+        item_test(ApeTag.new(s, check_id3), check_id3)
+        f = File.new(filename,'rb+')
+        f.write(' ' * x)
+        item_test(f, check_id3)
+        item_test(ApeTag.new(f, check_id3), check_id3)
+        f.close()
+        item_test(filename, check_id3)
+        item_test(ApeTag.new(filename, check_id3), check_id3)
+      end
+    end
+    File.delete(filename)
+  end
+  
+  # Test ApeItem instance methods
+  def test_ape_item
+    ai = ApeItem.new('BlaH', ['BlAh'])
+    # Test valid defaults
+    assert_equal ['BlAh'], ai
+    assert_equal false, ai.read_only
+    assert_equal 'utf8', ai.ape_type
+    assert_equal 'BlaH', ai.key
+    assert_equal 'blah', ai.key_downcased
+    assert_equal 'BlAh', ai.string_value
+    assert_equal "\04\0\0\0\0\0\0\0BlaH\0BlAh", ai.raw
+    assert_equal true, ai.valid?
+    
+    # Test valid read_only settings
+    assert_nothing_raised{ai.read_only=true}
+    assert_nothing_raised{ai.read_only=false}
+    assert_raises(ApeTagError){ai.read_only=nil}
+    assert_raises(ApeTagError){ai.read_only='Blah'}
+    assert_equal true, ai.valid?
+    
+    # Test valid ape_type settings
+    ApeItem::ITEM_TYPES.each{|type| assert_nothing_raised{ai.ape_type=type}}
+    assert_raises(ApeTagError){ai.ape_type='Blah'}
+    
+    # Test valid key settings
+    ((("\0".."\x1f").to_a+("\x80".."\xff").to_a).collect{|x|"#{x}  "} +
+      [nil, 1, '', 'x', 'x'*256]+ApeItem::BAD_KEYS.to_a).each{|x|assert_raises(ApeTagError){ai.key=x}}
+    ("\x20".."\x7f").to_a.collect{|x|"#{x}  "}+ApeItem::BAD_KEYS.to_a.collect{|x|"#{x}  "} +
+      ['xx', 'x'*255].each{|x| assert_nothing_raised{ai.key=x}}
+    
+    # Test valid raw and string value for different settings
+    ai.key="BlaH"
+    assert_equal "\04\0\0\0\0\0\0\06BlaH\0BlAh", ai.raw
+    assert_equal 'BlAh', ai.string_value
+    ai.read_only=true
+    assert_equal "\04\0\0\0\0\0\0\07BlaH\0BlAh", ai.raw
+    assert_equal 'BlAh', ai.string_value
+    ai << 'XYZ'
+    assert_equal "\010\0\0\0\0\0\0\07BlaH\0BlAh\0XYZ", ai.raw
+    assert_equal "BlAh\0XYZ", ai.string_value
+  end
+  
+  # Test ApeItem.create methods
+  def test_ape_item_create
+    ai = ApeItem.new('BlaH', ['BlAh'])
+    ac = ApeItem.create('BlaH', ai)
+    # Test same key and ApeItem passed gives same item with key
+    assert_equal ai.object_id, ac.object_id
+    assert_equal 'BlaH', ai.key
+    assert_equal 'BlaH', ac.key
+    # Test different key and ApeItem passed gives same item with different key
+    ac = ApeItem.create('XXX', ai)
+    assert_equal ai.object_id, ac.object_id
+    assert_equal 'XXX', ai.key
+    assert_equal 'XXX', ac.key
+    
+    # Test create fails with invalid key
+    assert_raises(ApeTagError){ApeItem.create('', ai)}
+    # Test create fails with invalid UTF-8 value
+    assert_raises(ApeTagError){ApeItem.create('xx',["\xfe"])}
+    # Test create doesn't fail with valid UTF-8 value
+    assert_nothing_raised{ApeItem.create('xx',[[12345, 1345].pack('UU')])}
+    
+    # Test create with empty array
+    ac = ApeItem.create('Blah', [])
+    assert_equal ApeItem, ac.class
+    assert_equal 0, ac.length
+    assert_equal '', ac.string_value
+    
+    # Test create works with string
+    ac = ApeItem.create('Blah', 'Blah')
+    assert_equal ApeItem, ac.class
+    assert_equal 1, ac.length
+    assert_equal 'Blah', ac.string_value
+    
+    # Test create works with random object (Hash in this case)
+    ac = ApeItem.create('Blah', 'xfe'=>132)
+    assert_equal ApeItem, ac.class
+    assert_equal 1, ac.length
+    assert_equal 'xfe132', ac.string_value
+    
+    # Test create works with array of mixed objects
+    ac = ApeItem.create('Blah', ['sadf', 'adsfas', 11, {'xfe'=>132}])
+    assert_equal ApeItem, ac.class
+    assert_equal 4, ac.length
+    assert_equal "sadf\0adsfas\00011\0xfe132", ac.string_value
+  end
+  
+  # Test ApeItem.parse
+  def test_ape_item_parse
+    data = "\010\0\0\0\0\0\0\07BlaH\0BlAh\0XYZ"
+    # Test simple item parsing
+    ai, offset = ApeItem.parse(data, 0)
+    assert_equal 2, ai.length
+    assert_equal offset, data.length
+    assert_equal "BlAh\0XYZ", ai.string_value
+    assert_equal true, ai.read_only
+    assert_equal 'reserved', ai.ape_type
+    assert_equal 'BlaH', ai.key
+    
+    # Test parsing with bad key
+    assert_raises(ApeTagError){ApeItem.parse("\0\0\0\0\0\0\0\07x\0", 0)}
+    
+    # Test parsing with no key end
+    assert_raises(ApeTagError){ApeItem.parse(data[0...-1], 0)}
+    
+    # Test parsing with bad start value
+    assert_raises(ApeTagError){ApeItem.parse(data, 1)}
+    
+    # Test parsing with bad/good flags
+    data[4] = 8
+    assert_raises(ApeTagError){ApeItem.parse(data, 0)}
+    data[4] = 0
+    assert_nothing_raised{ApeItem.parse(data, 0)}
+    
+    # Test parsing with length longer than string
+    data[0] = 9
+    assert_raises(ApeTagError){ApeItem.parse(data, 0)}
+    
+    # Test parsing with length shorter than string gives valid ApeItem
+    # Of course, the next item will probably be parsed incorrectly
+    data[0] = 3
+    assert_nothing_raised{ai, offset = ApeItem.parse(data, 0)}
+    assert_equal 16, offset
+    assert_equal "BlaH", ai.key
+    assert_equal "BlA", ai.string_value
+    
+    # Test parsing gets correct key end
+    data[12] = '3'
+    assert_nothing_raised{ai, offset = ApeItem.parse(data, 0)}
+    assert_equal "BlaH3BlAh", ai.key
+    assert_equal "XYZ", ai.string_value
+    
+    # Test parsing of invalid UTF-8
+    data = "\012\0\0\0\07\0\0\0BlaH\0BlAh\0XYZ\0\xff"
+    assert_raises(ApeTagError){ApeItem.parse(data, 0)}
+  end
+  
+  # Test parsing of whole tags that have been monkeyed with
+  def test_bad_tags
+    data = EMPTY_APE_TAG.dup
+    # Test default case OK
+    assert_nothing_raised{ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test footer size less than minimum size (32)
+    data[44] = 31
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    data[44] = 0
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test tag size > 8192, when both larger than file and smaller than file
+    data[44] = 225
+    data[45] = 31
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(' '*8192+data)).raw}
+    
+    data = EMPTY_APE_TAG.dup
+    # Test unmatching header and footer tag size, with footer size wrong
+    data[44] = 33
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test matching header and footer but size to large for file
+    data[12] = 33
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test that header and footer size isn't too large for file, but doesn't
+    # find the header
+    data=" #{data}"
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test unmatching header and footer tag size, with header size wrong
+    data[45] = 32
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    data = EMPTY_APE_TAG.dup
+    # Test item count greater than maximum (64)
+    data[48] = 65
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test item count greater than possible given tag size
+    data[48] = 1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test unmatched header and footer item size, header size wrong
+    data[48] = 0
+    data[16] = 1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).raw}
+    
+    # Test unmatched header and footer item size, footer size wrong
+    data = EXAMPLE_APE_TAG.dup
+    data[48] -=1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test missing/corrupt header
+    data = EMPTY_APE_TAG.dup
+    data[0] = 0
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test parsing bad first item size
+    data = EXAMPLE_APE_TAG.dup
+    data[32] +=1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test parsing bad first item invalid key
+    data = EXAMPLE_APE_TAG.dup
+    data[40] = 0
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test parsing bad first item key end
+    data = EXAMPLE_APE_TAG.dup
+    data[45] = 1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test parsing bad second item length too long
+    data = EXAMPLE_APE_TAG.dup
+    data[47] = 255
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+
+    # Test parsing case insensitive duplicate keys 
+    data = EXAMPLE_APE_TAG.dup
+    data[40...45] = 'Album'
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    data[40...45] = 'album'
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    data[40...45] = 'ALBUM'
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test parsing incorrect item counts
+    data = EXAMPLE_APE_TAG.dup
+    data[16] -= 1
+    data[192] -= 1
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    data[16] += 2
+    data[192] += 2
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(data)).fields}
+    
+    # Test updating with duplicate keys added 
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['album']='blah'}}
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['ALBUM']='blah'}}
+    # Test updating without duplicate keys added
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album']='blah'}}
+    
+    # Test updating an existing ApeItem via various array methods
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album'] += ['blah']}}
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album'] << 'blah'}}
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album'].replace(['blah'])}}
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album'].pop}}
+    assert_nothing_raised{ApeTag.new(StringIO.new(EXAMPLE_APE_TAG.dup)).update{|x| x['Album'].shift}}
+    
+    # Test updating with invalid value
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| x['Album']="\xfe"}}
+    
+    # Test updating with invalid key
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| x['x']=""}}
+    
+    # Test updating with too many items 
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| 65.times{|i|x["blah#{i}"]=""}}}
+    # Test updating with just enough items
+    assert_nothing_raised{ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| 64.times{|i|x["blah#{i}"]=""}}}
+    
+    # Test updating with too large a tag
+    assert_raises(ApeTagError){ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| x['xx']=' '*8118}}
+    # Test updating with just enough tag
+    assert_nothing_raised{ApeTag.new(StringIO.new(EMPTY_APE_TAG.dup)).update{|x| x['xx']=' '*8117}}
+  end
+  
+  def test_check_id3
+    x = StringIO.new()
+    assert_equal 0, x.size
+    
+    # Test ApeTag defaults to adding id3s on file objects without ape tags
+    ApeTag.new(x).update{}
+    assert_equal 192, x.size
+    # Test ApeTag doesn't find tag if not checking id3s and and id3 is present
+    ApeTag.new(x, false).remove!
+    assert_equal 192, x.size
+    # Test ApeTag doesn't add id3s if ape tag exists but id3 does not
+    x.truncate(64)
+    assert_equal 64, x.size
+    ApeTag.new(x).update{}
+    assert_equal 64, x.size
+    ApeTag.new(x).remove!
+    assert_equal 0, x.size
+    
+    # Test ApeTag without checking doesn't add id3
+    ApeTag.new(x, false).update{}
+    assert_equal 64, x.size
+    ApeTag.new(x).remove!
+    assert_equal 0, x.size
+    
+    # Test ApeTag with explicit check_id3 argument works
+    ApeTag.new(x, true).update{}
+    assert_equal 192, x.size
+    ApeTag.new(x, false).remove!
+    assert_equal 192, x.size
+    ApeTag.new(x).remove!
+    assert_equal 0, x.size
+    
+    # Test whether check_id3 class variable works
+    ApeTag.check_id3 = false
+    ApeTag.new(x).update{}
+    assert_equal 64, x.size
+    ApeTag.new(x).remove!
+    assert_equal 0, x.size
+    ApeTag.check_id3 = true
+    assert_raises(ApeTagError){ApeTag.check_id3 = 0}
+    
+    # Test non-mp3 filename defaults to no id3
+    filename = 'test.apetag'
+    File.new(filename,'wb').close
+    ApeTag.new(filename).update{}
+    assert_equal 64, get_size(filename)
+    ApeTag.new(filename).remove!
+    assert_equal 0, get_size(filename)
+    File.delete(filename)
+    
+    # Test mp3 filename defaults to id3
+    filename = 'test.apetag.mp3'
+    File.new(filename,'wb').close
+    ApeTag.new(filename).update{}
+    assert_equal 192, get_size(filename)
+    ApeTag.new(filename).remove!
+    assert_equal 0, get_size(filename)
+    File.delete(filename)
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: apetag
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-01-14 00:00:00 -08:00
+summary: APEv2 Tag Parser/Generator
+require_paths: 
+- .
+email: jeremyevans0@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: apetag
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Jeremy Evans
+files: 
+- apetag.rb
+test_files: 
+- test/test_apetag.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+