I tried using the wiki at rubygarden.org but it just made a mess… probably
not designed for things this big.
Anyhow, here’s a (longish) program I’ve written as my first “real” ruby
program. I’m reading from the “Programming Ruby” book at rubycentral.com,
and what do you know, I actually do have a jukebox of sorts. Actually it’s
a radio station I do some work for. So I expanded the example code some.
Have a look and poke some holes.
It reads a file that looks like this:
18 And Life; Skid Row
19th Nervous Breakdown; Rolling Stones
2000 Light Years From Home; Rolling Stones
20th Centry Fox; Doors
2112 (Parts 1-7); Rush
29 Palms; Robert Plant
30 Days In The Hole; Humble Pie
5:15; Who
867-5309; Tommy Tutone
#9 Dream; John Lennon
Abacab; Genesis
Adam Raised a Cain; Bruce Springsteen
A Day In The Life; Beatles
A Face In The Crowd; Tom Petty
After Midnight; Eric Clapton
After The Gold Rush; Neil Young
Against The Wind; Bob Seger
A Hard Day’s Night; Beatles
It reads the file and can create a word list that could be used for a
full-text search, a listing by artist, and a listing by artist in HTML with
a clickable index.
Here’s the code. Your input is appreciated.
#!/usr/local/bin/ruby -w
require ‘optparse’
class SongList
def initialize
@songs = Array.new
@index = WordIndex.new
@aindex = ArtistIndex.new
end
def append(aSong)
aSong.name.sub!(/\s+$/,‘’) # lose leading and trailing
aSong.artist.sub!(/\s+$/,‘’) # whitespace
aSong.name.sub!(/^\s+/,‘’)
aSong.artist.sub!(/^\s+/,‘’)
@songs.push(aSong)
@index.index(aSong, aSong.name, aSong.artist)
@aindex.aindex(aSong, aSong.artist)
self
end
def
return @songs[key] if key.kind_of?(Integer)
return @songs.find { |aSong| aSong.name == key }
end
def lookup(aWord)
@index.lookup(aWord)
end
def wordlist
@index.wordlist
end
def wordindex(outFile)
@index.wordlist.each do |aWord|
outFile.puts aWord
@index.lookup(aWord).each do |aSong|
outFile.puts “\t” + aSong.name + "; " + aSong.artist
end
end
end
def alookup(artist)
@aindex.alookup(artist)
end
def listartists
@aindex.listartists
end
def listsongs(outFile)
@aindex.listartists.each do |anArtist|
outFile.puts anArtist
@aindex.alookup(anArtist).sort
{|a,b| a.name <=> b.name}.each do |aSong|
outFile.puts “\t” + aSong.name
end
end
end
def html(outFile)
outFile.print “<a name="top" id="top">\n”
@aindex.listartists.each do |anArtist|
safeKey = anArtist.gsub(/[\s.-,/\']/, ‘’)
outFile.print “<a href="##{safeKey}">”
outFile.print “<div class="artistx">#{anArtist}\n”
end
@aindex.listartists.each do |anArtist|
safeKey = anArtist.gsub(/[\s.-,/\']/, ‘’)
htmlDetail(outFile, anArtist, safeKey)
end
end
def htmlDetail(outFile, anArtist, safeKey)
outFile.print “<div class="artist">”
outFile.print “<a name="#{safeKey}" id="#{safeKey}">”
outFile.print “#{anArtist}\n”
outFile.print “<a href="#top" class="toplink">top\n”
@aindex.alookup(anArtist).sort
{|a,b| a.name <=> b.name}.each do |aSong|
outFile.print “\t<div class="song">”
outFile.print “#{aSong.name}\n”
end
end
end #class SongList
class WordIndex
def initialize
@index = Hash.new(nil)
end
def index(anObject, *phrases)
phrases.each do |aPhrase|
aPhrase.scan(/\w[-\w]+/) do |aWord| # extract each word
aWord.downcase!
@index[aWord] = if @index[aWord].nil?
@index[aWord].push(anObject)
end
end
end
def lookup(aWord)
@index[aWord.downcase]
end
def wordlist
@index.keys.sort
end
end
class ArtistIndex
def initialize
@aindex = Hash.new(nil)
end
def aindex (anObject, artist)
@aindex[artist] = if @aindex[artist].nil?
@aindex[artist].push(anObject)
end
def alookup(artist)
@aindex[artist]
end
def listartists
@aindex.keys.sort
end
end
class Song
def initialize(name, artist)
@name = name
@artist = artist
end
attr_reader :name, :artist
def to_s
“Song: #{@name}–#{@artist}”
end
end
def build_data(inFile); # Read the data and build structures
$songs = SongList.new # inFile is an open file descriptor
inFile.each do |line|
name, artist = line.chomp.split(/\s*;\s*/)
unless name and artist
puts “input data format error”
exit
end
$songs.append Song.new(name, artist)
end
end
#---------------Main Begins Here--------------------------
$0 = File.basename($0)
vars = {}
ARGV.options do
opts>
opts.banner = “\nUsage: #{$0} [options] [input filename]\n\n”
“Reads from stdin if [input filename] is \n”
“not present.\n\n”
“Data format is "Song Title; Artist"\n\n”
opts.on_head(“Options:”)
opts.on(“-w”, “–wordindex WORDINDEXFILE”, String,
“Generate Word Index”,
“in WORDINDEXFILE”) {|vars[:wordIndexFile]|}
opts.on(“-g”, “–generatehtml HTMLFILE”, String,
“Generate HTML File”,
“in HTMLFILE”) {|vars[:htmlFile]|}
opts.on(“-l”, “–list LISTFILE”, String,
“Generate List File”,
“in LISTFILE”) {|vars[:listFile]|}
opts.on_tail(“-h”, “–help”, “show this message”) {puts opts; exit}
opts.parse!
end
if vars.length < 1
puts “Nothing to do”
puts ARGV.options
exit
end
if ARGV.length > 1
puts “Too many arguments”
exit
end
if ARGV.length == 1
then
unless FileTest.readable?(ARGV[0]) # test if input file exists
puts ARGV[0] + " not readable"
exit
end
inFile=File.open(ARGV[0]) # open inputfile
build_data(inFile) # and read/build data
inFile.close
else
build_data($stdin) # just use stdin if no input file
end
if vars[:wordIndexFile] # Generate word index file if -w
outFile = File.new(vars[:wordIndexFile], “w”)
$songs.wordindex(outFile)
outFile.close
end
if vars[:listFile] # Generate listing file if -l
outFile = File.new(vars[:listFile], “w”)
$songs.listsongs(outFile)
outFile.close
end
if vars[:htmlFile] # Generate html file if -g
outFile = File.new(vars[:htmlFile], “w”)
$songs.html(outFile)
outFile.close
end
Beyond that you may wish to explore a bit of unit