ruby-mp3info 0.6.5 → 0.6.6

data/History.txt

@@ -1,3 +1,10 @@
+=== 0.6.6 / 2008-05-27
+
+* avoid reading tag that are too big (> 50Mb)
+* ruby 1.9 support (thanks to Dave Thomas)
+* FIXED: bug #20311 'Multiple APIC frames may be stored incorrectly'
+* FIXED: bug #20312 'doesn't use v2.2 frames for extracting meta data'
+
 === 0.6.5 / 2008-04-19
 
 * added Mp3Info#audio_content method, to return "audio-only" boundaries from mp3, i.e. data without tags

data/lib/mp3info.rb

@@ -1,4 +1,5 @@
-# $Id: mp3info.rb 82 2008-04-19 10:59:02Z moumar $
+# coding:utf-8
+# $Id: mp3info.rb 88 2008-05-26 22:22:31Z moumar $
 # License:: Ruby
 # Author:: Guillaume Pierronnet (mailto:moumar_AT__rubyforge_DOT_org)
 # Website:: http://ruby-mp3info.rubyforge.org/
@@ -17,7 +18,7 @@ end
 
 class Mp3Info
 
-  VERSION = "0.6.5"
+  VERSION = "0.6.6"
 
   LAYER = [ nil, 3, 2, 1]
   BITRATE = [
@@ -67,7 +68,21 @@ class Mp3Info
 
   TAG1_SIZE = 128
   #MAX_FRAME_COUNT = 6  #number of frame to read for encoder detection
-  V1_V2_TAG_MAPPING = { 
+  
+  # map to fill the "universal" tag (#tag attribute)
+  # for id3v2.2
+  TAG_MAPPING_2_2 = { 
+    "title"    => "TT2",
+    "artist"   => "TP2", 
+    "album"    => "TAL",
+    "year"     => "TYE",
+    "tracknum" => "TRK",
+    "comments" => "COM",
+    "genre_s"  => "TCO"
+  }
+
+  # for id3v2.3 and 2.4
+  TAG_MAPPING_2_3 = { 
     "title"    => "TIT2",
     "artist"   => "TPE1", 
     "album"    => "TALB",
@@ -144,7 +159,6 @@ class Mp3Info
     }
   end
 
-
   # Remove id3v1 tag from +filename+
   def self.removetag1(filename)
     if self.hastag1?(filename)
@@ -163,7 +177,7 @@ class Mp3Info
   # Instantiate Mp3Info object with name +filename+ and an
   # options hash for ID3v2#new underlying object
   def initialize(filename, id3v2_options = {})
-    $stderr.puts("#{self.class}::new() does not take block; use #{self.class}::open() instead") if block_given?
+    warn("#{self.class}::new() does not take block; use #{self.class}::open() instead") if block_given?
     @filename = filename
     @id3v2_options = id3v2_options
     reload
@@ -193,16 +207,21 @@ class Mp3Info
 
       if hastag2?
 	@tag = {}
-      #creation of a sort of "universal" tag, regardless of the tag version
-	V1_V2_TAG_MAPPING.each do |key1, key2| 
-	  t2 = @tag2[key2]
-	  next unless t2
-	  @tag[key1] = t2.is_a?(Array) ? t2.first : t2
-
-	  if key1 == "tracknum"
-	    val = @tag2[key2].is_a?(Array) ? @tag2[key2].first : @tag2[key2]
-	    @tag[key1] = val.to_i
+        # creation of a sort of "universal" tag, regardless of the tag version
+        tag2_mapping = @tag2.version =~ /^2\.2/ ? TAG_MAPPING_2_2 : TAG_MAPPING_2_3
+	tag2_mapping.each do |key, tag2_name| 
+	  tag_value = (@tag2[tag2_name].is_a?(Array) ? @tag2[tag2_name].first : @tag2[tag2_name])
+	  next unless tag_value
+	  @tag[key] = tag_value.is_a?(Array) ? tag_value.first : tag_value
+
+	  if %w{year tracknum}.include?(key)
+	    @tag[key] = tag_value.to_i
 	  end
+          # this is a special case with id3v2.2, which uses
+          # old fashionned id3v1 genres
+          if tag2_name == "TCO" && tag_value =~ /^\((\d+)\)$/
+            @tag["genre_s"] = GENRES[$1.to_i]
+          end
 	end
       end
 
@@ -270,7 +289,7 @@ class Mp3Info
 	  percent_diff = ((@length.to_i-tlen)/tlen.to_f)
 	  if percent_diff.abs > 0.05
 	    # without the xing header, this is the best guess without reading
-	    #  every single frame
+	    # every single frame
 	    @vbr = true
 	    @length = @tag2["TLEN"].to_i/1000
 	    @bitrate = (@streamsize / @bitrate) >> 10
@@ -359,9 +378,11 @@ class Mp3Info
 	  @tag1[k] = v
 	end
       end
-      
-      V1_V2_TAG_MAPPING.each do |key1, key2|
-        @tag2[key2] = @tag[key1] if @tag[key1]
+
+      # ruby-mp3info can only write v2.3 tags
+      TAG_MAPPING_2_3.each do |key, tag2_name|
+        @tag2.delete(TAG_MAPPING_2_2[key])
+        @tag2[tag2_name] = @tag[key] if @tag[key]
       end
     end
 
@@ -402,7 +423,6 @@ class Mp3Info
       raise(Mp3InfoError, "file is not writable") unless File.writable?(@filename)
       tempfile_name = nil
       File.open(@filename, 'rb+') do |file|
-	
 	#if tag2 already exists, seek to end of it
 	if @tag2.valid?
 	  file.seek(@tag2.io_position)
@@ -474,47 +494,23 @@ private
       @file.seek(pos)
     end
   end
-
-  ### reads in id3 field strings, stripping out non-printable chars
-  ###  len (fixnum) = number of chars in field
-  ### returns string
-  def read_id3_string(len)
-    #FIXME handle unicode strings
-    #return @file.read(len)
-    s = ""
-    len.times do
-      c = @file.getc
-      # only append printable characters
-      s << c if c >= 32 and c < 254
-    end
-    return s.strip
-    #return (s[0..2] == "eng" ? s[3..-1] : s)
-  end
   
   ### gets id3v1 tag information from @file
   ### assumes @file is pointing to char after "TAG" id
   def gettag1
     @tag1_parsed = true
-=begin
-    # FIXME remove that
-    pos = @file.pos
-    p @file.read
-    @file.seek(pos)
-    # FIXME remove that
-=end
-    @tag1["title"] = read_id3_string(30)
-    @tag1["artist"] = read_id3_string(30)
-    @tag1["album"] = read_id3_string(30)
-    year_t = read_id3_string(4).to_i
+    @tag1["title"] = @file.read(30).sub(/\0*$/, '')
+    @tag1["artist"] = @file.read(30).sub(/\0*$/, '')
+    @tag1["album"] = @file.read(30).sub(/\0*$/, '')
+    year_t = @file.read(4).to_i
     @tag1["year"] = year_t unless year_t == 0
     comments = @file.read(30)
-    if comments[-2] == 0
-      @tag1["tracknum"] = comments[-1].to_i
+    if comments.getbyte(-2) == 0
+      @tag1["tracknum"] = comments.getbyte(-1).to_i
       comments.chop! #remove the last char
     end
-    #@tag1["comments"] = comments.sub!(/\0.*$/, '')
-    @tag1["comments"] = comments.strip
-    @tag1["genre"] = @file.getc
+    @tag1["comments"] = comments.sub(/\0*$/, '')
+    @tag1["genre"] = @file.getbyte
     @tag1["genre_s"] = GENRES[@tag1["genre"]] || ""
 
     # clear empty tags
@@ -534,10 +530,10 @@ private
     #dummyproof = @file.stat.size - @file.pos => WAS TOO MUCH
     dummyproof = [ @file.stat.size - @file.pos, 2000000 ].min
     dummyproof.times do |i|
-      if @file.getc == 0xff
+      if @file.getbyte == 0xff
         data = @file.read(3)
         raise(Mp3InfoError, "end of file reached") if @file.eof?
-        head = 0xff000000 + (data[0] << 16) + (data[1] << 8) + data[2]
+        head = 0xff000000 + (data.getbyte(0) << 16) + (data.getbyte(1) << 8) + data.getbyte(2)
         if check_head(head)
             return head
         else
@@ -563,9 +559,9 @@ private
 
   ### returns the selected bit range (b, a) as a number
   ### NOTE: b > a  if not, returns 0
-  def bits(n, b, a)
+  def bits(number, b, a)
     t = 0
-    b.downto(a) { |i| t += t + n[i] }
+    b.downto(a) { |i| t += t + number[i] }
     t
   end
 end

data/lib/mp3info/extension_modules.rb

@@ -11,15 +11,31 @@ class Mp3Info
 	self[m]
       end
     end
+  end  
+  
+  class ::String
+    if RUBY_VERSION < "1.9.0"
+      alias getbyte []
+    else
+      def getbyte(i)
+        self[i].ord
+      end
+    end
   end
 
-  module Mp3FileMethods #:nodoc:
+  module Mp3FileMethods #:nodoc: 
+    if RUBY_VERSION < "1.9.0"
+      def getbyte
+        getc
+      end
+    end
+                        
     def get32bits
-      (getc << 24) + (getc << 16) + (getc << 8) + getc
+      (getbyte << 24) + (getbyte << 16) + (getbyte << 8) + getbyte
     end
 
     def get_syncsafe
-      (getc << 21) + (getc << 14) + (getc << 7) + getc
-    end
+      (getbyte << 21) + (getbyte << 14) + (getbyte << 7) + getbyte
+    end                 
   end
 end

data/lib/mp3info/id3v2.rb

@@ -126,7 +126,7 @@ class ID3v2 < DelegateClass(Hash)
     @version_maj = @version_min = nil
   end
 
-  # does this tag correctly read ?
+  # does this tag has been correctly read ?
   def valid?
     @valid
   end
@@ -136,9 +136,14 @@ class ID3v2 < DelegateClass(Hash)
     @hash_orig != @hash
   end
   
-  # full version of this tag (like 2.3.0)
+  # full version of this tag (like "2.3.0") or nil
+  # if tag was not correctly read
   def version
-    "2.#{@version_maj}.#{@version_min}"
+    if valid?
+      "2.#{@version_maj}.#{@version_min}"
+    else
+      nil
+    end
   end
 
   ### gets id3v2 tag information from io object (must support #seek() method)
@@ -164,7 +169,7 @@ class ID3v2 < DelegateClass(Hash)
     @io.seek(original_pos + @tag_length, IO::SEEK_SET)
 
     # skip padding zeros at the end of the tag
-    while @io.getc == 0; end
+    while @io.getbyte == 0; end
 
     @io.seek(-1, IO::SEEK_CUR)
     @io_position = @io.pos
@@ -185,12 +190,18 @@ class ID3v2 < DelegateClass(Hash)
     @hash.each do |k, v|
       next unless v
       next if v.respond_to?("empty?") and v.empty?
+      # doesn't encode id3v2.2 tags, which have 3 characters
+      next if k.size != 4 
       data = encode_tag(k, v.to_s, WRITE_VERSION)
       #data << "\x00"*2 #End of tag
 
       tag << k[0,4]   #4 characte max for a tag's key
       #tag << to_syncsafe(data.size) #+1 because of the language encoding byte
-      tag << [data.size].pack("N") #+1 because of the language encoding byte
+      size = data.size
+      if RUBY_VERSION >= "1.9.0"
+        size = data.dup.force_encoding("binary").size
+      end
+      tag << [size].pack("N") #+1 because of the language encoding byte
       tag << "\x00"*2 #flags
       tag << data
     end
@@ -200,7 +211,7 @@ class ID3v2 < DelegateClass(Hash)
     tag_str << [ WRITE_VERSION, 0, "0000" ].pack("CCB4")
     tag_str << [to_syncsafe(tag.size)].pack("N")
     tag_str << tag
-    p tag_str if $DEBUG
+    puts "tag in binary format: #{tag_str.inspect}" if $DEBUG
     tag_str
   end
 
@@ -210,11 +221,11 @@ class ID3v2 < DelegateClass(Hash)
     puts "encode_tag(#{name.inspect}, #{value.inspect}, #{version})" if $DEBUG
 
     text_encoding_index = @text_encoding_index 
-    if (name[0] == ?T || name == "COMM" ) && version == 3
+    if (name.index("T") == 0 || name == "COMM" ) && version == 3
       # in id3v2.3 tags, there is only 2 encodings possible
       transcoded_value = value
       if text_encoding_index >= 2
-	transcoded_value = Iconv.iconv(TEXT_ENCODINGS[1], TEXT_ENCODINGS[text_encoding_index], value)[0]
+	transcoded_value = Iconv.iconv(TEXT_ENCODINGS[1], TEXT_ENCODINGS[text_encoding_index], value).first
 	text_encoding_index = 1
       end
     end
@@ -235,16 +246,16 @@ class ID3v2 < DelegateClass(Hash)
     case name
       when "COMM"
         #FIXME improve this
-	encoding, lang, str = raw_value.unpack("ca3a*")
+	encoding, lang, str = raw_value.unpack("ca3a*") 
 	out = raw_value.split(0.chr).last
       when /^T/
-	encoding = raw_value[0]     # language encoding (see TEXT_ENCODINGS constant)
+	encoding = raw_value.getbyte(0) # language encoding (see TEXT_ENCODINGS constant)   
 	out = raw_value[1..-1] 
 	# we need to convert the string in order to match
 	# the requested encoding
 	if out && encoding != @text_encoding_index
 	  begin
-	    Iconv.iconv(@options[:encoding], TEXT_ENCODINGS[encoding], out)[0]
+	    Iconv.iconv(@options[:encoding], TEXT_ENCODINGS[encoding], out).first
 	  rescue Iconv::Failure
 	    out
 	  end
@@ -261,11 +272,11 @@ class ID3v2 < DelegateClass(Hash)
   def read_id3v2_3_frames
     loop do # there are 2 ways to end the loop
       name = @io.read(4)
-      if name[0] == 0 or name == "MP3e" #bug caused by old tagging application "mp3ext" ( http://www.mutschler.de/mp3ext/ )
+      if name.getbyte(0) == 0 or name == "MP3e" #bug caused by old tagging application "mp3ext" ( http://www.mutschler.de/mp3ext/ )
         @io.seek(-4, IO::SEEK_CUR)    # 1. find a padding zero,
 	seek_to_v2_end
         break
-      else
+      else               
 	if @version_maj == 4
 	  size = @io.get_syncsafe
 	else
@@ -284,12 +295,12 @@ class ID3v2 < DelegateClass(Hash)
   def read_id3v2_2_frames
     loop do
       name = @io.read(3)
-      if name[0] == 0
+      if name.getbyte(0) == 0
         @io.seek(-3, IO::SEEK_CUR)
 	seek_to_v2_end
         break
       else
-        size = (@io.getc << 16) + (@io.getc << 8) + @io.getc
+        size = (@io.getbyte << 16) + (@io.getbyte << 8) + @io.getbyte
 	add_value_to_tag2(name, size)
         break if @io.pos >= @tag_length
       end
@@ -301,8 +312,17 @@ class ID3v2 < DelegateClass(Hash)
   ### create an array if the key already exists in the tag
   def add_value_to_tag2(name, size)
     puts "add_value_to_tag2" if $DEBUG
+
+    if size > 50_000_000
+      raise ID3v2Error, "tag size too big for tag '#{name}'"
+    end
+      
     data_io = @io.read(size)
     data = decode_tag(name, data_io)
+    # remove padding zeros for textual tags
+    if name =~ /^T/
+      data.sub!(/\0*$/, '')
+    end
 
     if self["TPOS"] =~ /(\d+)\s*\/\s*(\d+)/
       self["disc_number"] = $1.to_i
@@ -311,7 +331,7 @@ class ID3v2 < DelegateClass(Hash)
 
     if self.keys.include?(name)
       unless self[name].is_a?(Array)
-        self[name] = self[name].to_a
+        self[name] = [ self[name] ]
       end
       self[name] << data
     else
@@ -323,7 +343,7 @@ class ID3v2 < DelegateClass(Hash)
   ### runs thru @file one char at a time looking for best guess of first MPEG
   ###  frame, which should be first 0xff byte after id3v2 padding zero's
   def seek_to_v2_end
-    until @io.getc == 0xff
+    until @io.getbyte == 0xff
       raise EOFError if @io.eof?
     end
     @io.seek(-1, IO::SEEK_CUR)

data/test/test_ruby-mp3info.rb

@@ -1,16 +1,18 @@
-#!/usr/bin/ruby -w
+#!/usr/bin/env ruby1.9
+# coding:utf-8
 
 $:.unshift("lib/")
 
 require "test/unit"
-require "base64"
 require "mp3info"
 require "fileutils"
 require "tempfile"
+require "zlib"
+require "yaml"
 
 class Mp3InfoTest < Test::Unit::TestCase
 
-  TEMP_FILE = File.join(File.dirname($0), "test_mp3info.mp3")
+  TEMP_FILE = File.join(File.dirname(__FILE__), "test_mp3info.mp3")
 
   DUMMY_TAG2 = {
     "COMM" => "comments",
@@ -32,58 +34,20 @@ class Mp3InfoTest < Test::Unit::TestCase
     "genre" => 233
   }
 
+  FIXTURES = YAML::load_file( File.join(File.dirname(__FILE__), "fixtures.yml") )
+
   def setup
-    # Command to create a dummy MP3
-    # dd if=/dev/zero bs=1024 count=15 | lame --preset cbr 128 -r -s 44.1 --bitwidth 16 - - | ruby -rbase64 -e 'print Base64.encode64($stdin.read)'
-    @valid_mp3 = Base64.decode64 <<EOF
-//uQZAAAAAAAaQYAAAAAAA0gwAAAAAABpBwAAAAAADSDgAAATEFNRTMuOTNV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVTEFNRTMuOTNVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVV//uSZL6P8AAAaQAAAAAAAA0gAAAAAAABpAAAAAAAADSA
-AAAAVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUxBTUUzLjkzVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVf/7kmT/j/AAAGkAAAAAAAANIAAA
-AAAAAaQAAAAAAAA0gAAAAFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVM
-QU1FMy45M1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVX/+5Jk/4/w
-AABpAAAAAAAADSAAAAAAAAGkAAAAAAAANIAAAABVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVTEFNRTMuOTNVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVV//uSZP+P8AAAaQAAAAAAAA0gAAAAAAABpAAAAAAAADSAAAAAVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
-VVVVVVVVVVVVVVVVVVVVVVVVVQ==
-EOF
+    # Command to create a gzip'ed dummy MP3
+    # $ dd if=/dev/zero bs=1024 count=15 | \
+    #   lame --quiet --preset cbr 128 -r -s 44.1 --bitwidth 16 - - | \
+    #   ruby -rbase64 -rzlib -ryaml -e 'print(Zlib::Deflate.deflate($stdin.read)'
+    # vbr:
+    # $ dd if=/dev/zero of=#{tempfile.path} bs=1024 count=30000 |
+    #     system("lame -h -v -b 112 -r -s 44.1 --bitwidth 16 - /tmp/vbr.mp3
+    @valid_mp3, @valid_mp3_2_2, @vbr_mp3 = %w{empty_mp3 2_2_tagged vbr}.collect do |fixture_key|
+      Zlib::Inflate.inflate(FIXTURES[fixture_key])
+    end
+                  
     @tag = {
       "title" => "title",
       "artist" => "artist",
@@ -135,18 +99,9 @@ EOF
   end
   
   def test_vbr_mp3_length
-    temp_file_vbr = File.join(File.dirname($0), "test_vbr_length.mp3")
-
-    unless File.exists?(temp_file_vbr)
-      tempfile = Tempfile.new("ruby-mp3info_test")
-      tempfile.close
-      system("dd if=/dev/zero of=#{tempfile.path} bs=1024 count=30000")
-      raise "cannot find lame binary in path" unless system("which lame")
-      system("lame -h -v -b 112 -r -s 44.1 --bitwidth 16 #{tempfile.path} #{temp_file_vbr}")
-      tempfile.close!
-    end
+    File.open(TEMP_FILE, "w") { |f| f.write(@vbr_mp3) }
 
-    Mp3Info.open(temp_file_vbr) do |info|
+    Mp3Info.open(TEMP_FILE) do |info|
       assert(info.vbr)
       assert_equal(1152, info.samples_per_frame)
       assert_in_delta(174.210612, info.length, 0.000001)
@@ -162,7 +117,7 @@ EOF
 
   def test_writetag1
     Mp3Info.open(TEMP_FILE) { |info| info.tag1 = @tag }
-    Mp3Info.open(TEMP_FILE) { |info| assert(info.tag1 == @tag) }
+    Mp3Info.open(TEMP_FILE) { |info| assert_equal(info.tag1, @tag) }
   end
 
   def test_valid_tag1_1
@@ -266,7 +221,7 @@ EOF
     return if `which id3v2`.empty?
     start = false
     id3v2_output = {}
-    `id3v2 -l #{TEMP_FILE}`.each do |line|
+    `id3v2 -l #{TEMP_FILE}`.split(/\n/).each do |line|
       if line =~ /^id3v2 tag info/
         start = true 
 	next    
@@ -293,7 +248,9 @@ EOF
     ["PRIV", "APIC"].each do |k|
       tag[k] = random_string(50)
     end
-    assert_equal(tag, write_temp_file(tag))
+
+    got_tag = write_temp_file(tag)
+    assert_equal(tag, got_tag)
   end
 
   def test_id3v2_bigtag
@@ -318,6 +275,56 @@ EOF
     end
   end
 
+  def test_reading2_2_tags
+    File.open(TEMP_FILE, "w") { |f| f.write(@valid_mp3_2_2) }
+
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      assert_equal "2.2.0", mp3.tag2.version
+      expected_tag = { 
+        "TCO" => "Hip Hop/Rap",
+        "TP1" => "Grems Aka Supermicro",
+        "TT2" => "Intro",
+        "TAL" => "Air Max",
+        "TEN" => "iTunes v7.0.2.16",
+        "TYE" => "2006",
+        "TRK" => "1/17",
+        "TPA" => "1/1" }
+      tag = mp3.tag2.dup
+      assert_equal 4, tag["COM"].size
+      tag.delete("COM")
+      assert_equal expected_tag, tag
+
+      expected_tag = { 
+        "genre_s"       => "Hip Hop/Rap",
+        "title"         => "Intro",
+        "comments"      => "\000engiTunPGAP\0000\000\000",
+        "year"          => 2006,
+        "album"         => "Air Max",
+        "tracknum"      => 1 }
+      # test universal tag
+      assert_equal expected_tag, mp3.tag
+    end
+  end
+
+  def test_writing_universal_tag_from_2_2_tags
+    File.open(TEMP_FILE, "w") { |f| f.write(@valid_mp3_2_2) }
+    Mp3Info.open(TEMP_FILE) do |mp3|
+      mp3.tag.artist = "toto"
+      mp3.tag.comments = "comments"
+      mp3.flush
+      expected_tag = { 
+        "artist"=>"toto",
+        "genre_s"=>"Hip Hop/Rap",
+        "title"=>"Intro",
+        "comments"=>"comments",
+        "year"=>2006,
+        "album"=>"Air Max",
+        "tracknum"=>1}
+
+      assert_equal expected_tag, mp3.tag
+    end
+  end
+
   def test_remove_tag
     Mp3Info.open(TEMP_FILE) do |mp3|
       tag = mp3.tag
@@ -334,14 +341,17 @@ EOF
 
   def test_good_parsing_of_a_pathname
     fn = "Freak On `(Stone´s Club Mix).mp3"
-    File.rename(TEMP_FILE, fn)
+    FileUtils.cp(TEMP_FILE, fn)
     begin
-      mp3 = Mp3Info.new(fn)
-      mp3.tag.title = fn
-      mp3.close
-      mp3.reload
-      assert_equal fn, mp3.tag.title 
-      mp3.close
+      Mp3Info.open(fn) do |mp3|
+        mp3.tag.title = fn
+        mp3.flush
+        if RUBY_VERSION < "1.9.0"
+          assert_equal fn, mp3.tag.title
+        else
+          assert_equal fn, mp3.tag.title.force_encoding("utf-8")
+        end
+      end
     ensure
       File.delete(fn)
     end
@@ -363,11 +373,15 @@ EOF
     end
 
     Mp3Info.open(TEMP_FILE, :encoding => "utf-8") do |mp3|
-      assert_equal "all\xc3\xa9", mp3.tag2['TEST']
+      assert_equal "allé", mp3.tag2['TEST']
     end
 
     Mp3Info.open(TEMP_FILE, :encoding => "iso-8859-1") do |mp3|
-      assert_equal "all\xe9", mp3.tag2['TEST']
+      if RUBY_VERSION < "1.9.0"
+        assert_equal "all\xe9", mp3.tag2['TEST']
+      else
+        assert_equal "all\xe9".force_encoding("binary"), mp3.tag2['TEST']
+      end
     end
   end
 
@@ -377,7 +391,11 @@ EOF
     end
 
     Mp3Info.open(TEMP_FILE, :encoding => "iso-8859-1") do |mp3|
-      assert_equal "all\xe9", mp3.tag2['TEST']
+      if RUBY_VERSION < "1.9.0"
+        assert_equal "all\xe9", mp3.tag2['TEST']
+      else
+        assert_equal "all\xe9".force_encoding("iso-8859-1"), mp3.tag2['TEST']
+      end
     end
   end
 
@@ -422,8 +440,6 @@ EOF
     end
     Digest::MD5.new.update(data).hexdigest
   end
-  def compute_md5(content)
-  end
 
   def write_temp_file(tag)
     Mp3Info.open(TEMP_FILE) do |mp3|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-mp3info
 version: !ruby/object:Gem::Version 
-  version: 0.6.5
+  version: 0.6.6
 platform: ruby
 authors: 
 - Guillaume Pierronnet
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-19 00:00:00 +02:00
+date: 2008-05-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.1
+        version: 1.5.3
     version: 
 description: "* written in pure ruby  * read low-level informations like bitrate, length, samplerate, etc... * read, write, remove id3v1 and id3v2 tags * only 2.3 version is supported for writings id3v2 tags  == SYNOPSIS:  a good exercise is to read the test.rb to understand how the library works deeper  require \"mp3info\" # read and display infos & tags Mp3Info.open(\"myfile.mp3\") do |mp3info| puts mp3info end  # read/write tag1 and tag2 with Mp3Info#tag attribute # when reading tag2 have priority over tag1 # when writing, each tag is written. Mp3Info.open(\"myfile.mp3\") do |mp3| puts mp3.tag.title    puts mp3.tag.artist    puts mp3.tag.album puts mp3.tag.tracknum mp3.tag.title = \"track title\" mp3.tag.artist = \"artist name\" end  Mp3Info.open(\"myfile.mp3\") do |mp3| # you can access four letter v2 tags like this puts mp3.tag2.TIT2 mp3.tag2.TIT2 = \"new TIT2\" # or like that mp3.tag2[\"TIT2\"] # at this time, only COMM tag is processed after reading and before writing # according to ID3v2#options hash mp3.tag2.options[:lang] = \"FRE\" mp3.tag2.COMM = \"my comment in french, correctly handled when reading and writing\" end"
 email: moumar@rubyforge.org