[~] cat >foo.txt
foo
[~] cat >bar.txt
bar
[~] ruby -e 'puts ARGF.read' foo.txt bar.txt
foo
bar

[~] echo zap | ruby -e 'puts ARGF.read'
zap

- Erik

--

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", "Pranks",
"Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz
+Funk", "Fusion", "Trance", "Classical", "Instrumental", "Acid",
"House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
"Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
"Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-
Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern
Rock", "Comedy", "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/
Funk", "Jungle", "Native American", "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", "Bebob", "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", "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum
Solo", "A capella", "Euro-House", "Dance Hall"]
FIELDS = [:song, :artist, :album, :year, :comment, :genre]

def find_track_number(fields)
  if fields[:comment][-2] == 0 && fields[:comment][-1] != 0
    fields[:track_number] = fields[:comment].slice!(-2..-1)[1]
    fields[:comment].strip!
  end
end

abort "Usage: #{File.basename($PROGRAM_NAME)} <dir>" unless ARGV.size
== 1
Dir["#{ARGV.first}/*.mp3"].each do |path|
  File.open(path, 'rb') do |f|
    f.seek(-128, IO::SEEK_END)
    bytes = f.read
    next if bytes.slice!(0..2) != "TAG"

class ID3
  genre_list = <<-GENRES
Blues
... # snipped for brevity
Dance Hall
  GENRES

  GENRE_LIST = genre_list.split("\n")
  TAGS = [ :title, :artist, :album, :year, :comment, :track, :genre ]

  attr_accessor *TAGS

  def initialize(filename)
    id3 = File.open(filename) do |mp3|
      mp3.seek(-128, IO::SEEK_END)
      mp3.read
    end

    raise "No ID3 tags" if id3 !~ /^TAG/

    @title, @artist, @album, @year, @comment, @genre =
id3.unpack('xxxA30A30A30A4A30C1')
    @comment, @track = @comment.unpack('Z*@28C1') if @comment =~ /
\0.$/

    @genre = GENRE_LIST[@genre]
  end
end

__BEGIN__
#Note: this script assumes Ruby 1.8.6 style handeling of strings.  Some
changes
#will need to be made for Ruby 1.9 to work correctly

require 'genre.rb' #an array of the official genera list

def id3(filename)
  id3 =  File.open(filename,'r') do |file|
    file.seek(-128,IO::SEEK_END) #get to the end of the file
    file.read(128)
  end
  return "" unless id3 #protect against read error
  if id3.slice(0,3) == "TAG"
     #Skip the first 3 bytes grab three thirty byte fields
     #and a 4 byte field dropping trailing whitespace.
     #While we can assume the old style comment field and
     #take 30 bytes (we'll com back for the track number later)
     #we must use 'Z' instead of 'A' to avoid having the track
     #show up in our comment field.
     #The last byte is the genre index.
    song,artist,album,year,comment,genre = id3.unpack
"x3A30A30A30A4Z30C"
     #grab the track with a pain slice
    track = id3.slice(-2) if id3.slice(-3) == 0 && id3.slice(-2) != 0
    desc = "#{artist}: #{album}(#{year})\n"
    desc << "  #{song}.  "
    desc << "tr. #{track}" if track
    desc <<"\n"
    desc << "  Comment:  #{comment.chomp(" ")}\n" if comment.length != 0
    desc << "    Genre:  #{Genres[genre]}\n"
    return desc
  end

  return "" #tag not forund

end

#usage id3.rb filename [filename*]
ARGV.each do |filename|
  puts filename
  puts id3(filename) if File.exists? filename
  puts "\n"
end

__END__

I think the only real difference between what I'm seeing on this list
and my own solution is the unpack string.  The 'Comment' filed must use
'Z' and strip trailing white space separately otherwise the track number
could get pulled and stuck on the end of the output.

I like the use of ARGF in other implementations.  Something new to put
in my hat.

class ID3

   @@recLen = 0

   def ID3.field(name, len, flags=[])
      class_eval(%Q[
         def #{name}
            @data[#{@@recLen}, #{len}].strip
         end
      ])

      unless flags.include?(:readonly)
         class_eval(%Q[
            def #{name}=(val)
               # need to pad val to len
               @data[#{@@recLen}, #{len}] = val.ljust(#{len}, "\000")
            end
         ])
      end
      @@recLen += len
   end

   # --------------------------------------------------------------
   #     name, length,       flags
   field :sig,      3,  [:readonly]
   field :song,    30
   field :album,   30
   field :artist,  30
   field :year,     4
   field :comment, 30
   field :genre,    1

   TAG_SIG  = "TAG"
   TAG_SIZE = @@recLen
   raise "ID3 tag size not 128!" unless TAG_SIZE == 128

   # --------------------------------------------------------------

   def ID3.createFromBuffer(buffer)
      ID3.new(buffer)
   end

   def ID3.createFromFile(fname)
      size = File.size?(fname)
      raise "Missing or empty file" unless size
      raise "Invalid file" if size < TAG_SIZE

      # Read the tag and pass to createFromBuffer
      open(fname, "rb") do |f|
         f.seek(-TAG_SIZE, IO::SEEK_END)
         createFromBuffer(f.read(TAG_SIZE))
      end
   end

   # --------------------------------------------------------------

   def initialize(data)
      @data = data

      raise "Wrong buffer size" unless @data.size == TAG_SIZE
      raise "ID3 tag not found" unless self.sig == TAG_SIG
   end

end

The secret to binary parsing in Ruby is generally the String.unpack() method and
the majority of the solutions capitalized on this technique.  Technically, ID3
tags are mainly in plain text, with some null characters thrown in.  Still, I
think it's a good idea to get into the unpack() mindset anytime you start
slicing up binary data.

I want to take a look at Eugene Kalenkovich's code below.  It's a pretty typical
usage of unpack() to parse some data.  It also includes a nicety when reading
the file that I'm ashamed to admit I didn't think of.  Let's start with that:

        def fileTail (file, offset)
          f=File.new(file)
          f.seek(-offset,IO::SEEK_END)
          f.read
        end

        # ...

In my own code, I read the whole file into memory and indexed out the last 128
bytes.  That's almost always the wrong approach and Eugene shows the correct
strategy above.  This code just opens the file, seek()s to offset bytes before
the end, and read()s the needed data.  That scales much better when the data
sizes are significant.

As a quick aside, file_tail() would probably be a more Rubyish method name.

The code now builds a data structure class to hold the tag details.  It starts
like this:

        # ...

        class ID3Tag
          GENRES=["Blues","Classic Rock","Country",…,"Dance Hall"]
          attr_reader :title, :artist, :album, :year, :comment, :genre, :track

          # ...

You can see that this class is mainly just a data structure that defines readers
for all of the elements in a tag.  I've trimmed the GENRES listing here, but the
code included the full set.

I will say that some found more clever means to load the GENRES Array.  Several
people did fancy heredoc manipulations, but the most clever pulled the list out
of the quiz document using open-uri and hpricot.  That was especially wise this
time since I made so many mistakes in the quiz description.

We're now ready for the actual parsing code:

          # ...

          def initialize fname
            tag,@title,@artist,@album,@year,@comment,@genre=
              fileTail(fname,128).unpack "A3A30A30A30A4A30C"
            raise "No ID3 Info" if tag!='TAG'
            s_com,flag,tra...@comment.unpack "A28CC"
            if flag==0 and track!=0
              @comment=s_com
              @track=track
            end
            @genre=GENRES[@genre]
            @genre="Unknown" if  !@genre
          end
        end

        # ...

As you can see, the majority of the work is done on the first line with a single
call to unpack().  The template fed to unpack() is the key to the whole puzzle.
An "A" in the unpack() template instructs it to extract a String, removing any
trailing spaces or null characters.  By default the String is just one character
long, but you can provide a number after the "A" to increase that count.  The
only other character used in the template is a "C" which is used to extract one
character as an Integer.  The unpack() call returns an Array which Eugene just
mass-assigns to the relevant variables.

The rest is simple.  The code checks the first chunk for the identifying "TAG"
String and throws an error if it's not there.  Then another call to unpack(),
with a template much like the first, pulls the track field out of the comment.
The if statement makes sure that assignment only happens when it is present.
The final two lines are just a longhand form of:

        @genre = GENRES[@genre] || "Unknown"

With all of the fields stored away in the proper variables, reader calls can be
used to extract as needed.  Eugene's actual application code just punted on that
point though:

        # ...

        p ID3Tag.new(ARGV[0])

My thanks to all who have helped me with my Erlang comparisons these last two
weeks.  I promise, we're on to new topics now.