gooby 0.9.3

data/lib/gooby.rb

@@ -0,0 +1,2265 @@
+# Packaged on Sat Mar 03 16:56:38 EST 2007 
+
+=begin
+
+This file contains the classes and modules for the Gooby project.
+Gooby = Google APIs + Ruby
+
+See file 'tests/ts_gooby.rb' for the regression test suite.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+require 'date'
+require 'find'
+require 'rbconfig'
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'time'
+require 'yaml'
+
+module Gooby
+
+=begin rdoc
+  This module is used to embed information about the Gooby project and
+  version into the codebase.
+
+  Gooby - Copyright 2007 by Chris Joakim.
+  Gooby is available under GNU General Public License (GPL) license.
+=end
+  
+  module GoobyProjectInfo
+
+  # Return a String version number, like '1.0.0'.
+    def project_version_number   
+      '0.9.3'
+    end
+
+  # Return a String date, like '2007/02/25'.  
+    def project_date       
+      '2007/03/03'
+    end
+ 
+  # Return a String year, like '2007'. 
+    def project_year       
+      project_date[0...4]  # start, length
+    end
+ 
+  # Return a String containing copyright, year, and author.
+    def project_copyright
+      "Copyright (C) #{project_year} #{project_author}"
+    end
+  
+  # Return a String containing GNU/GPL, and the gpl.html URL.  
+    def project_license    
+      'GNU General Public License (GPL).  See http://www.gnu.org/copyleft/gpl.html'
+    end
+  
+    # Return a String containing the project author name.
+    def project_author
+      'Chris Joakim'
+    end
+  
+    def google_maps_api_level
+      '2'
+    end
+  
+    def some_new_thing
+      '2'
+    end
+      
+    def tested_files
+      array = Array.new
+      array << 'cls_counter_hash.rb'
+      array << 'cls_delim_line.rb'
+      array << 'cls_dttm.rb'
+      array << 'cls_duration.rb'
+      array << 'cls_forerunner_xml_parser.rb'
+      array << 'cls_geo_data.rb'
+      array << 'cls_gooby_object.rb'
+      array << 'cls_google_map_generator.rb'
+      array << 'cls_history.rb'
+      array << 'cls_lap.rb'
+      array << 'cls_line.rb'
+      array << 'cls_options.rb'
+      array << 'cls_position.rb'
+      array << 'cls_run.rb'
+      array << 'cls_simple_xml_parser.rb'
+      array << 'cls_track.rb'
+      array << 'cls_trackpoint.rb'
+      array << 'mod_constants.rb'
+      array << 'mod_introspect.rb'
+      array << 'mod_io.rb'
+      array << 'mod_project_info.rb'
+      array << 'mod_string.rb'
+      array
+    end
+  
+  end
+  
+  
+  module Con
+
+    public 
+
+    def default_delimiter
+      return '|'
+    end
+
+    def invalid_distance
+      return -99999999
+    end
+
+    def invalid_minutes
+      return -99999999
+    end
+                
+    def invalid_time
+      return -99999999
+    end
+   
+    def invalid_latitude
+      return -1
+    end
+  
+    def invalid_longitude
+      return -1
+    end
+  
+    def invalid_altitude
+       return -1
+    end
+    
+  end
+  
+  
+  module Introspect
+  
+  # Return a String w/instance variable and method info.    
+    def introspect         
+      c  = self.class
+      s  = "Class: #{c} "
+      iv = self.instance_variables.sort
+      s << " ivc=#{iv.size}"
+      iv.each { |v| s << " #{v}" } 
+      meth = self.methods.sort
+      s << " mc=#{meth.size}"
+      meth.each { |m| s << " #{m}" }
+      s << ""
+      s
+    end 
+
+  # Return 'self.instance_variables'.
+    def to_yaml_properties   
+      self.instance_variables 
+    end
+  
+  end 
+  
+  
+  module GoobyIO
+
+  # Return an Array of lines in file, optionally stripped.  
+    def read_lines(filename, strip=false)  
+
+      array = IO.readlines(filename)
+      if strip
+        array = strip_lines(array)
+      end
+      return array
+    end
+ 
+  # Return an Array of lines in file per the given delimeter, optionally stripped.   
+    def read_as_ascii_lines(filename, delim=10, strip=false)  
+      
+      array = Array.new  
+      file  = File.new(filename)
+      currLine = ''
+      bytesRead = 0
+      linesRead = 0
+      
+      file.each_byte { |b| 
+        bytesRead = bytesRead + 1
+        if (b == delim) # delim is 13 for quicken, 10 for address book xml
+          array << currLine
+          currLine = ''
+          linesRead = linesRead + 1
+        else
+          if (b < 127)
+            currLine << "#{b.chr}"
+          end
+        end  
+      }
+    
+      if currLine.size > 0
+        array << currLine
+      end
+      if strip
+        array = strip_lines(array)
+      end
+      return array    
+    end
+
+  # Strip the lines/Strings; return a new Array.
+    def strip_lines(array)  
+ 
+      newArray = Array.new
+      if (array != nil)
+        array.each { |line| line.strip! ; newArray << line }
+      end
+      return newArray
+    end
+      
+  end
+
+  
+  module GoobyString
+
+    def tokenize(string, delim, strip=false)  
+      if string
+        tokens = string.split(delim)
+        if strip
+          tokens.each { |tok| tok.strip! }
+        end
+        tokens
+      else
+        Array.new
+      end
+    end
+
+  end
+   
+  
+  module TestHelper  
+    
+    def setup
+      puts "test: #{name}"
+    end
+    
+    def teardown
+      @debug = false
+    end
+  
+  end
+  
+
+=begin rdoc
+  This is the abstract superclass of several Gooby classes.
+  Includes modules GoobyIO, Introspect, and GoobyProjectInfo.
+=end
+  
+  class GoobyObject  
+    
+    include Gooby::GoobyIO  
+    include Gooby::GoobyString
+    include Gooby::Introspect
+    include Gooby::GoobyProjectInfo
+    include Gooby::Con
+    
+  end
+  
+
+=begin rdoc
+  This class wrappers a Hash object and provides increment/decrement functionality 
+  for a given key.  It is used to sum the number of things (i.e. - xml tags) in a 
+  collection.
+=end
+    
+  class CounterHash < GoobyObject
+
+    def initialize
+      @hash = Hash.new(0)  
+    end
+ 
+  # Return the Integer count for the given key; zero default.  
+    def value(key)   
+      (@hash.has_key?(key)) ? @hash[key] : 0  
+    end
+ 
+  # Increment the count for the given key.  
+    def increment(key) 
+      if key == nil
+        return
+      end       
+      if (@hash.has_key?(key)) 
+        val = @hash[key]
+        @hash[key] = val + 1  
+      else
+        @hash[key] = 1
+      end  
+    end
+
+  # Decrement the count for the given key.  
+    def decrement(key) 
+      if key == nil
+        return
+      end      
+      if (@hash.has_key?(key)) 
+        val = @hash[key]
+        @hash[key] = val - 1
+      else
+        @hash[key] = -1
+      end    
+    end
+ 
+  # Return an Array of the sorted keys.  
+    def sorted_keys        
+      @hash.keys.sort
+    end
+ 
+  # Return a String containing all key=val pairs.  
+    def to_s               
+      s = "CHash:"
+      sorted_keys.each { |key|
+        val = @hash[key]
+        s << " key: [#{key}] val: [#{val}]"
+      }
+      s
+    end
+ 
+  # Return an XML String containing all key=val pairs, optionally aligned.  
+    def to_xml(aligned=false)  
+      s = "<CHash>"
+      sorted_keys.each { |key|
+        val = @hash[key]
+        (aligned) ? s << "\n " : s << ''
+        s << " <entry key='#{key}' value='#{val}'/>"
+      }
+      if aligned
+        s << "\n "
+      end    
+      s << " </CHash>"
+      s   
+    end  
+    
+  end
+  
+
+=begin rdoc
+  Instances of this class represent a delimited line of text, such as csv.
+=end
+  
+  class DelimLine < GoobyObject
+  
+    attr_reader :line, :trim, :delim, :tokens
+    
+    def initialize(line, trim=true, delim=default_delimiter)
+      @line  = line
+      @trim  = trim
+      @delim = delim
+      @tokens = @line.split(@delim)  
+      if trim
+        @tokens.each { | token | token.strip! }
+      end
+    end
+
+    def as_trackpoint(num_idx, lat_idx, lng_idx, alt_idx, dttm_idx)
+      Trackpoint.new(@tokens[num_idx], @tokens[lat_idx], @tokens[lng_idx], @tokens[alt_idx], @tokens[dttm_idx])
+    end
+  
+    def is_comment?
+      @line.strip.match('^#') ? true : false
+    end
+  
+    def to_s
+      "DelimLine: length: #{@line.size} trim: #{@trim} delim: #{@delim} tokens: #{@tokens.size}"
+    end
+  
+  end
+
+  
+=begin rdoc
+  Instances of this class represent a Date and Time as parsed from a value 
+  such as '2006-01-15T13:41:40Z' in an XML file produced by a GPS device.
+  It wrappers both a DateTime and Time object.
+=end
+  
+  class DtTm < GoobyObject  
+    
+    attr_accessor :rawdata, :dateTime, :time, :valid
+  
+  # Constructor; arg is a String like '2006-01-15T13:41:40Z'.  
+    def initialize(raw)  
+      if raw
+        @rawdata = raw.strip
+        if @rawdata.size > 18
+          @dateTime = DateTime.parse(@rawdata[0..18])
+          @time  = Time.parse(@dateTime.to_s)
+          @valid = true
+        else
+          @valid = false
+        end     
+      else
+        @rawdata = ''
+        @valid   = false          
+      end
+    end
+  
+    public
+ 
+  # Return @time.to_i  
+    def to_i() 
+      (@time) ? @time.to_i : invalid_time
+    end
+  
+  # Calculates and returns diff between another instance.  
+    def seconds_diff(anotherDtTm)  
+      if anotherDtTm
+        to_i - anotherDtTm.to_i
+      else
+        invalid_time
+      end
+    end
+  
+    def yyyy_mm_dd
+      @time.strftime("%Y-%m-%d")
+    end
+  
+    def yyyy_mm_dd_hh_mm_ss
+      @time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  
+    def hh_mm_ss
+      @time.strftime("%H:%M:%S")
+    end
+  
+  # Calculate and return time diff in 'hh:mm:ss' format.
+    def hhmmss_diff(anotherDtTm)  
+      if anotherDtTm  
+        t = @time - (anotherDtTm.to_i)
+        t.strftime("%H:%M:%S")
+      else
+        '??:??:??'  
+      end
+    end
+  
+    def to_s
+      "#{@rawdata}"
+    end
+  
+  # Return a String with state values for debugging.
+    def print_string  
+      "DtTm: #{yyyy_mm_dd_hh_mm_ss} #{to_i} #{@rawdata}"
+    end
+    
+  end
+  
+
+=begin rdoc
+  Instances of this class represent the contents of a Forerunner extract
+  <Duration> tag, such as:
+  <Duration>PT507.870S</Duration>
+=end
+  
+  class Duration < GoobyObject  
+    
+    attr_accessor :rawdata, :seconds, :minutes, :mmss
+  
+  # Constructor; arg is a String like 'PT507.870S'.
+    def initialize(raw)  
+      if raw
+        @rawdata  = scrub(raw)
+        @seconds  = @rawdata.to_f
+        @minutes  = @seconds / 60
+        @base_min = @minutes.floor
+        @frac_min = @minutes - @base_min
+        @frac_sec = @frac_min * 60
+        
+        @mmss = ''
+        if (@base_min < 10) 
+          @mmss << "0#{@base_min}:"
+        else
+          @mmss << "#{@base_min}:"          
+        end
+        if (@frac_sec < 10) 
+          @mmss << "0#{@frac_sec}"
+        else
+          @mmss << "#{@frac_sec}"          
+        end  
+        if (@mmss.size > 8) 
+          @mmss = @mmss[0..8]
+        end     
+      else
+        @rawdata = ''
+        @seconds = invalidDistance 
+        @minutes = invalidMinutes
+        @mmss    = '??:??.?'         
+      end
+    end
+    
+    private
+    
+    def scrub(raw)
+      if (raw)
+        raw.strip!
+        newStr = ''
+        raw.each_byte { | b |
+          if ((b >= 48) && (b <= 57))
+            newStr << b
+          end
+          if (b == 46) 
+            newStr << b
+          end
+        }
+        return newStr
+      else
+        ''
+      end
+    end
+  
+    public 
+    
+    def to_s
+      "#{@mmss}"
+    end
+  
+  # Return a String with state values for debugging.
+    def print_string  
+      "Duration: #{@rawdata} sec: #{@seconds} min: #{@minutes} mmss: #{@mmss} bm: #{@base_min} fm: #{@frac_min} fs: #{@frac_sec}"
+    end
+    
+  end
+  
+
+=begin rdoc
+  Instances of this class are used to parse a Forerunner XML file in a SAX-like
+  manner.  Instances of the model classes - History, Run, Track, Trackpoint,
+  etc. are created in this parsing process.  
+
+  See http://www.garmin.com/xmlschemas/ForerunnerLogbookv1.xsd for the XML Schema
+  Definition for the Garmin Forerunner XML.  The Gooby object model mirrors this XSD. 
+=end
+  
+  class ForerunnerXmlParser  
+  
+    DETAIL_TAGS = %w( Notes StartTime Duration Length Latitude Longitude Altitude Time BeginPosition EndPosition )
+  
+    include REXML::StreamListener
+  
+    attr_reader :history, :cvHash, :tagCount
+  
+    def initialize
+      @cvHash            = Hash.new("")
+      @tagCount          = 0
+      @runCount          = 0
+      @lapCount          = 0
+      @trackCount        = 0
+      @trackpoint_count  = 0
+      @currText          = "";
+      @history           = History.new
+      @currRun           = nil
+      @currLap           = nil
+      @currTrack         = nil
+      @currBeginPosition = nil
+      @currEndPosition   = nil
+    end
+  
+    public
+ 
+    # SAX API method; handles 'Run', 'Lap', 'Track'.   
+    def tag_start(tagname, attrs) 
+      @tagCount += 1
+      @currTag = tagname
+      @cvHash[tagname] = ''
+    
+      if detail_tag?(tagname)
+        @inDetail = true
+      end
+    
+      if is_tag?('Run', tagname)
+        @runCount = @runCount + 1
+        @lapCount = 0
+        @trackCount = 0
+        @currRun  = Run.new(@runCount)
+        @history.add_run(@currRun)
+        @cvHash['Notes'] = ''
+        return
+      end
+    
+      if is_tag?('Lap', tagname)
+        @lapCount = @lapCount + 1
+        @currLap  = Lap.new(@lapCount)
+        return
+      end
+    
+      if is_tag?('Track', tagname)
+        @trackCount = @trackCount + 1      
+        @currTrack  = Track.new(@trackCount)
+        @trackpoint_count = 0   
+        return   
+      end
+    
+    end
+
+    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run'. 
+    def tag_end(tagname) 
+      if @inDetail    
+        @cvHash[tagname] = @currText
+      else
+        if is_tag?('Position', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currBeginPosition = Position.new(lat.strip, long.strip, '')
+          @currEndPosition   = Position.new(lat.strip, long.strip, '')       
+        end 
+        
+        if is_tag?('BeginPosition', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currBeginPosition = Position.new(lat.strip, long.strip, '')      
+        end
+        
+        if is_tag?('EndPosition', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currEndPosition = Position.new(lat.strip, long.strip, '')      
+        end
+              
+        if is_tag?('Trackpoint', tagname)
+          @trackpoint_count = @trackpoint_count + 1
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          alt  = @cvHash['Altitude']   
+          time = @cvHash['Time']                
+          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
+          @currTrack.add_trackpoint(tp)
+        end
+      
+        if is_tag?('Track', tagname)
+          if @currRun != nil
+            @currRun.add_track(@currTrack)
+          end
+        end
+      
+        if is_tag?('Lap', tagname)
+          @currLap.startTime = @cvHash['StartTime']
+          @currLap.duration  = Duration.new(@cvHash['Duration'])
+          @currLap.length    = @cvHash['Length']                          
+          @currLap.beginPosition = @currBeginPosition
+          @currLap.endPosition   = @currEndPosition        
+          @currRun.add_lap(@currLap)
+        end
+      
+        if is_tag?('Run', tagname)
+          @currRun.notes =  @cvHash['Notes'] 
+        end
+      end
+    
+      @inDetail = false    
+      @currText = ""
+      @currTag  = ""                     
+    end
+
+    # SAX API method.
+    def text(txt)  
+      if @inDetail
+        @currText = @currText + txt   
+      end
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def gdump()      
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def dump()        
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_csv.
+    def put_run_csv() 
+      @history.runs().each { |run| run.put_csv() } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_tkpt_csv.
+    def put_all_run_tkpt_csv(with_header_comment) 
+      @history.runs.each { |run| 
+        run.put_tkpt_csv(with_header_comment)
+      } 
+    end
+
+    private 
+  
+    def is_tag?(tagname, value)
+      tagname == value
+    end
+  
+    def detail_tag?(tagname)
+      DETAIL_TAGS.each { |typ| 
+        if typ == tagname 
+          return true    
+        end
+      }
+      return false
+    end
+  
+  end
+
+
+=begin rdoc
+  Instances of this class are used to split a large ForerunnerLogbook
+  XML file into individual 'run_' files.
+=end
+  
+  class ForerunnerXmlSplitter < GoobyObject 
+    
+    attr_reader :out_dir, :forerunner_files, :out_files_hash
+    
+    def initialize(xml_file, out_dir)
+      @out_dir = out_dir
+      @forerunner_files = Array.new
+      @forerunner_files << xml_file
+      @out_files_hash   = Hash.new
+    end
+    
+    def split
+      @forerunner_files.each { |f| process_file(f) }
+      write_files
+    end
+    
+    private 
+    
+    def process_file(forerunnerXmlFile)
+      @file_name = forerunnerXmlFile
+      @xml_lines = read_lines(@file_name, false) 
+      @line_num  = 0
+      @run_num   = 0
+      @curr_run_lines = Array.new
+      @curr_run_tkpts = 0
+      @start_line_num = 0
+      @end_line_num   = 0
+      @first_start_time = nil
+    
+      @xml_lines.each { |line|
+        @line_num = @line_num + 1              
+        if (line.match(/<Run>/))
+          @run_num = @run_num + 1
+          @start_line_num = @line_num
+          @curr_run_lines = Array.new
+          @curr_run_lines << line
+        elsif (line.match(/<StartTime>/)) # <StartTime>2007-01-13T15:37:06Z</StartTime>
+          @curr_run_lines << line   
+          if @first_start_time == nil
+            clone = String.new(line)     
+            clone.gsub!(/[<>]/, ' ')  
+            clone.gsub!(/[-:T]/, '_')
+            clone.gsub!(/[Z]/, '') 
+            tokens = clone.split
+            @first_start_time = tokens[1]
+          end          
+        elsif (line.match(/<Trackpoint>/)) 
+           @curr_run_tkpts =  @curr_run_tkpts + 1
+           @curr_run_lines << line 
+        elsif (line.match(/<\/Run>/))
+          @end_line_num = @line_num 
+           @curr_run_lines << line           
+          end_run 
+        elsif (@curr_run_lines.size > 0)
+          @curr_run_lines << line 
+        end
+      }
+    end
+  
+    def end_run
+      out_file = "#{@out_dir}/run_#{@first_start_time}.xml"
+      comment = "<!-- file: #{out_file}  lines: #{@curr_run_lines.size} (#{@start_line_num} to #{@end_line_num})  tkpts: #{@curr_run_tkpts} --> \n"
+      @curr_run_lines.insert(0, comment)
+          
+      prev_entry = @out_files_hash[out_file]
+      if prev_entry
+        if (@curr_run_lines.size >= prev_entry.size)
+          puts "previous entry overlaid for #{out_file}.  curr=#{@curr_run_lines.size}  prev=#{prev_entry.size}"
+          @out_files_hash[out_file] = @curr_run_lines
+        else
+          puts "previous entry retained for #{out_file}.  curr=#{@curr_run_lines.size}  prev=#{prev_entry.size}"
+        end
+      else
+          puts "new entry for #{out_file}.  curr=#{@curr_run_lines.size}"
+          @out_files_hash[out_file] = @curr_run_lines          
+      end
+      
+      @curr_run_lines   = Array.new
+      @curr_run_tkpts   = 0
+      @start_line_num   = 0
+      @end_line_num     = 0
+      @first_start_time = nil                
+    end
+    
+    def write_files
+      out_names = @out_files_hash.keys.sort
+      puts "Writing #{out_names.size} extract files..."
+      out_names.each { |out_name| 
+        lines = @out_files_hash[out_name]
+        out = File.new out_name, "w+"
+        lines.each { |line| out.write line }
+        out.flush
+        out.close
+        puts "File written: #{out_name}"
+      }
+      puts "output files written."
+    end
+    
+  end
+
+
+=begin rdoc
+  Instances of this class represent a the set of Geographic data defined in file geo.txt
+=end
+
+  class GeoData < GoobyObject
+  
+    attr_reader :filename, :lines, :poi_hash, :poi_array, :track_hash, :track_array, :route_hash, :route_array
+  
+    def initialize(filename)
+      @filename    = filename
+      @filename    = 'data/geo_data.txt'  if @filename == nil
+      @lines       = read_lines(@filename, true)
+      @poi_hash    = Hash.new
+      @poi_array   = Array.new
+      @track_hash  = Hash.new
+      @track_array = Array.new
+      @route_hash  = Hash.new
+      @route_array = Array.new
+      parse_poi
+      parse_tracks
+      parse_routes
+    end
+    
+    private
+    
+    def parse_poi
+      in_poi, poi_number = false, 0
+      @lines.each { |line|
+        line_obj  = Line.new(line, nil, true)
+        tok_count = line_obj.token_count
+        is_point  = line_obj.token_idx_equals(0, '.')
+        
+        if line_obj.is_populated_non_comment          
+          if line_obj.match('points_of_interest_start')
+            in_poi  = true
+          elsif line_obj.match('points_of_interest_end')
+            in_poi  = false  
+          elsif in_poi && tok_count > 2 && is_point
+            poi_number = poi_number + 1
+            tkpt = Trackpoint.new(
+              poi_number, line_obj.tokens[1], line_obj.tokens[2], 
+              '0', '', line_obj.concatinate_tokens(3))
+            add_poi(tkpt)
+          end
+        end
+      }
+    end
+    
+    def parse_tracks
+      in_track, trk_number, tkpt_number = false, 0, 0
+      curr_trk, curr_run = nil, nil
+      @lines.each { |line|
+        line_obj  = Line.new(line, nil, true)
+        tok_count = line_obj.token_count
+        is_point  = line_obj.token_idx_equals(0, '.')
+        
+        if line_obj.is_populated_non_comment
+          if line_obj.match('track_start')
+            in_track    = true
+            trk_number  = trk_number + 1
+            tkpt_number = 0
+            curr_trk    = Track.new(0, line_obj.concatinate_tokens(1))    
+            curr_run    = Run.new(trk_number, line_obj.concatinate_tokens(1))                      
+            curr_run.add_track(curr_trk) 
+          elsif line_obj.match('track_end')
+            in_track = false
+            curr_run.finish 
+            add_track(curr_trk)
+            add_route(curr_run)
+          elsif in_track && tok_count > 2 && is_point
+            tkpt_number = tkpt_number + 1
+            tkpt = Trackpoint.new(
+              tkpt_number, line_obj.tokens[1], line_obj.tokens[2], 
+              '0', '', line_obj.concatinate_tokens(3))
+            curr_trk.add_trackpoint(tkpt)
+          end          
+        end
+      }
+    end
+    
+    def parse_routes
+      in_route, route_number, trk_number, tkpt_number = false, 0, 0, 0
+      curr_trk, curr_run = nil, nil
+      @lines.each { |line|
+        line_obj  = Line.new(line, nil, true)
+        tok_count = line_obj.token_count
+        is_point  = line_obj.token_idx_equals(0, '.')
+        
+        if line_obj.is_populated_non_comment
+          if line_obj.match('route_start')
+            in_route    = true
+            trk_number  = trk_number + 1
+            tkpt_number = 0
+            curr_trk    = Track.new(0, line_obj.concatinate_tokens(1))    
+            curr_run    = Run.new(trk_number, line_obj.concatinate_tokens(1))                      
+            curr_run.add_track(curr_trk) 
+          elsif line_obj.match('route_end')
+            in_route = false
+            curr_run.finish 
+            add_route(curr_run)
+          elsif in_route && tok_count > 2 && is_point
+            tkpt_number = tkpt_number + 1
+            tkpt = Trackpoint.new(
+              tkpt_number, line_obj.tokens[1], line_obj.tokens[2], 
+              '0', '', line_obj.concatinate_tokens(3))
+            curr_trk.add_trackpoint(tkpt)
+          elsif in_route && line_obj.token_idx_equals(0, 'track') && tok_count > 1
+            trk_desc = line_obj.concatinate_tokens(1)
+            trk = @track_hash[trk_desc]
+            if trk
+              trk.trackpoints.each { |tkpt| curr_trk.add_trackpoint(tkpt) }
+            end
+          elsif in_route && line_obj.token_idx_equals(0, 'track_rev') && tok_count > 1
+            trk_desc = line_obj.concatinate_tokens(1)
+            trk = @track_hash[trk_desc]
+            if trk
+              array = trk.trackpoints
+              trk.trackpoints.each { |tkpt| curr_trk.add_trackpoint(tkpt) }
+            end            
+          end          
+        end
+      }      
+    end
+
+    def add_poi(tkpt)
+      if tkpt
+        descr = tkpt.descr
+        if @poi_hash.has_key? descr
+          puts "Duplicate POI key ignored - '#{descr}'"
+        else
+          #puts "Adding POI: #{tkpt.to_poi_csv}"          
+          @poi_hash[descr] = tkpt
+          @poi_array << tkpt
+        end
+      end
+    end
+    
+    def add_track(trk)
+      if trk
+        descr = trk.descr
+        if @track_hash.has_key? descr
+          puts "Duplicate Track key ignored - '#{descr}'"
+        else       
+          @track_hash[descr] = trk
+          @track_array << trk
+        end
+      end
+    end
+
+    def add_route(run)
+      if run
+        descr = run.descr
+        if @route_hash.has_key? descr
+          puts "Duplicate Route key ignored - '#{descr}'"
+        else       
+          @route_hash[descr] = run
+          @route_array << run
+        end
+      end
+    end
+    
+    public
+
+    def to_s
+      return "GeoData lines: #{lines.size} poi: #{@poi_hash.size} tracks: #{@track_hash.size} routes: #{@route_hash.size} "
+    end
+    
+    def dump
+      puts "#{self.class} dump:"
+      @poi_array.each { |tkpt| puts "POI: #{tkpt.to_geo_s}"  }
+      @track_array.each { |trk| trk.dump  }
+      @route_hash.keys.sort.each { |key| 
+        puts "Route: '#{key}'"
+      }      
+    end
+      
+  end 
+
+
+=begin rdoc
+  Instances of this class represent a <Run> aggregate object from a
+  Forerunner XML file.  
+
+  Additionally, there is distance, pace, and Google Map generation logic 
+  in this class.
+=end
+  
+  class GoogleMapGenerator < GoobyObject 
+  
+    attr_reader :csv_file, :csv_lines, :dttm_idx, :num_idx, :lat_idx, :lng_idx, :alt_idx, :cdist_idx
+    attr_reader :run, :tkpts, :content_hash, :center_longitude, :center_latitude, :gpoint_array, :overlay_points, :notes    
+    attr_reader :center_longitude, :center_latitude
+    
+    # The default csv input file format is as follows:
+    # 1 | 2006-01-15T18:31:10Z | 1279 | 33.42601 | -111.92927 | 347.654 | 26.3514930151813
+    # 1 | 2004-11-13T13:05:20Z | 2 | 37.54318 | -77.43636 | -58.022 | 0.00297286231747969 
+    
+    def initialize(csv_file, dttm_idx=1, num_idx=2, lat_idx=3, lng_idx=4, alt_idx=5, cdist_idx=6)
+      @csv_file  = csv_file
+      @dttm_idx  = dttm_idx
+      @num_idx   = num_idx
+      @lat_idx   = lat_idx
+      @lng_idx   = lng_idx
+      @alt_idx   = alt_idx
+      @cdist_idx = cdist_idx
+      @options   =  Gooby::Options.new(nil)
+      @content_hash = Hash.new('')
+      @run   = Gooby::Run.new(1)
+      @track = Gooby::Track.new(1)
+      @run.add_track(@track)
+      @tkpts = Array.new
+      
+      @csv_lines = read_as_ascii_lines(@csv_file, 10, true) 
+      @csv_lines.each { | line |
+        dline = Gooby::DelimLine.new(line)
+        if (!dline.is_comment?)
+          tkpt = dline.as_trackpoint(@num_idx, @lat_idx, @lng_idx, @alt_idx, @dttm_idx)
+          if tkpt
+            @track.add_trackpoint(tkpt)
+          end
+        end
+      }
+      @run.finish
+    end
+    
+=begin
+Returns a Hash with specific generated content at the following keys:
+=end
+    def generate(options)
+      if (options == nil)
+        @options =  Gooby::Options.new(nil)
+      else
+        @options = options
+      end  
+      @content_hash['when_generated'] = Time.now
+      @content_hash['title'] = @options.get('gmap_title')               
+      filter_trackpoints  
+      compute_center_point
+      generate_key_js
+      generate_map_div
+      generate_messages_div
+      generate_main_js_start
+      generate_main_js_route_overlay
+      generate_main_js_checkpoint_overlays
+      generate_main_js_map_clicked_listeners      
+      generate_main_js_end    
+      @content_hash
+    end
+
+    def filter_trackpoints        
+      count, @tkpts = 0, Array.new
+      firstTkpt = @options.get('gmap_first_tkpt_number')
+      lastTkpt  = @options.get('gmap_last_tkpt_number')
+      @run.tracks.each { |trk| 
+        trk.trackpoints.each { |tkpt|
+          count = count + 1
+          if ((count >= firstTkpt) && (count <= lastTkpt))
+            @tkpts.push(tkpt)
+          end
+        }
+      }   
+    end
+    
+=begin
+Returns a Hash with specific generated content at the following keys:
+=end 
+    def generate_page(options)
+
+      # puts "generate_page #{@csv_file} #{@csv_lines.size}"
+      content_hash = generate(nil)
+      s = String.new(@csv_file)
+      s.gsub("/", " ")
+      tokens = tokenize(s, nil)
+      out_file = "#{tokens[-2]}.html"
+      #content_hash.keys.sort.each { | key | puts key }
+
+s = <<HERE
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
+    <title> Google Map by Gooby </title>
+    #{content_hash['key_js']}
+    #{content_hash['main_js_start']}
+    #{content_hash['main_js_route_overlay']}  
+    #{content_hash['main_js_checkpoint_overlays']}  
+    #{content_hash['main_js_map_clicked_listeners']}  
+    #{content_hash['main_js_end']}
+  </head>
+  <body onload="load()" onunload="GUnload()">
+    <center>
+    <h3> #{content_hash['title']} </h3>
+    <h5> Generated by Gooby #{content_hash['when_generated']} <br> Gooby = Google APIs + Ruby </h5>    
+    #{content_hash['map_div']}    
+    #{content_hash['messages_div']}   
+    </center>
+  </body>
+</html>
+HERE
+
+      # html_file = File.new(out_file, "w+")
+      # html_file.write(s)
+      # html_file.flush
+      # html_file.close  
+      puts s   # Output is redirected by shell.    
+    end
+    
+    private
+    
+    def compute_center_point            
+      highLat  = -999.0
+      highLong = -999.0
+      lowLat   =  999.0      
+      lowLong  =  999.0
+      @tkpts.each { |tkpt|
+        highLat  = tkpt.latitude_as_float  if tkpt.latitude_as_float  > highLat
+        lowLat   = tkpt.latitude_as_float  if tkpt.latitude_as_float  < lowLat  
+        highLong = tkpt.longitude_as_float if tkpt.longitude_as_float > highLong
+        lowLong  = tkpt.longitude_as_float if tkpt.longitude_as_float < lowLong  
+      }
+      @center_longitude = (highLong + lowLong) / 2
+      @center_latitude  = (highLat  + lowLat)  / 2
+      @content_hash['center_longitude'] = @center_longitude
+      @content_hash['center_latitude']  = @center_latitude       
+    end
+          
+    def generate_key_js              
+      key  = @options.get('gmap_key')    
+      key.strip!
+      s    = '<script src="http://maps.google.com/maps?file=api&v=2&key=' 
+      s << key
+      s << '" type="text/javascript"></script>'
+      @content_hash['key_js'] = s
+    end
+    
+    def generate_map_div
+      width  = @options.get('gmap_width')
+      height = @options.get('gmap_height')
+      id     = @options.get('gmap_map_element_id')      
+      s = '<div id="'
+      s << id
+      s << '" style="width: '
+      s << width
+      s << '; height: '
+      s << height
+      s << '"></div>'
+      @content_hash['map_width']  = width  
+      @content_hash['map_height'] = height          
+      @content_hash['map_div']    = s            
+    end
+
+    def generate_messages_div
+      s = "<div id=\"messages\"></div>"
+      @content_hash['messages_div'] = s            
+    end
+    
+    def generate_main_js_start
+      id    = @options.get('gmap_map_element_id')  
+      size  = @options.get('gmap_size_control')
+      type  = @options.get('gmap_type')
+      zoom  = @options.get('gmap_zoom_level')
+      title = @options.get('gmap_title')            
+      if size
+        if size == 'smallmap'
+          size = 'GSmallMapControl'
+        elsif size == 'smallzoom'
+          size = 'GSmallMapControl'          
+        else
+          size = 'GLargeMapControl'          
+        end          
+      end
+        
+      if type
+        if type == 'satellite'
+          type = 'G_SATELLITE_MAP'
+        elsif type == 'hybrid'
+          type = 'G_HYBRID_MAP'
+        else
+          type = 'G_NORMAL_MAP'
+        end
+      else
+        type = 'G_NORMAL_MAP'
+      end
+                         
+      s  =  '<script type="text/javascript">'
+      s << "\n"
+      s << "//<![CDATA[ \n"
+      s << "    function load() { \n"
+      s << "        if (GBrowserIsCompatible()) { \n"
+      s << '            var map = new GMap2(document.getElementById("'
+      s << id
+      s << '")); '
+      s << "\n"
+    
+      if size
+        s << '            map.addControl(new '
+        s << size
+        s << '());'
+        s << "\n"        
+      end
+      
+      if type
+        s << '            map.addControl(new GMapTypeControl());'
+        s << "\n"
+        # s << '            map.setMapType('
+        # s << type
+        # s << ');'
+        s << "\n"        
+      end   
+      s << "            var centerPoint = new GLatLng(#{@center_latitude}, #{@center_longitude}); \n"
+      s << "            map.setCenter(centerPoint, #{zoom}); \n"         
+      s << "\n"
+      @content_hash['main_js_start'] = s 
+      @content_hash['title'] = title
+    end
+    
+    def generate_main_js_route_overlay
+      tkpt_count = @tkpts.size.to_f
+      app_max    = @options.get('gmap_approx_max_points').to_f
+      comments   = @options.get('gmap_gen_comments')   
+      ratio      = tkpt_count / app_max
+      @start_dttm = nil
+      if ratio > 1.0
+        increment = (tkpt_count / app_max).to_i
+      else
+        increment = 1
+      end
+      curr_idx, next_idx, gpoint_count, last_idx = -1, 0, 0, @tkpts.size - 1
+      s = "        var points = new Array(); " 
+      @tkpts.each { |tkpt|
+        curr_idx = curr_idx + 1
+        if curr_idx == 0
+          @start_dttm = tkpt.dttm
+          @start_pos  = tkpt.position
+          time        = Time.parse(@start_dttm.dateTime().to_s)
+        end
+        if ((curr_idx == next_idx) || (curr_idx == last_idx) || (tkpt.is_split()))
+          gpoint_count = gpoint_count + 1
+          s << tkpt.as_glatlng(comments, tkpt_count, curr_idx, gpoint_count, @start_dttm)
+          next_idx = curr_idx + increment
+        end
+      }
+      s << "\n"
+      s << "\n            var routePolyline = new GPolyline(points); "
+      s << "\n            map.addOverlay(routePolyline); "      
+      @content_hash['main_js_route_overlay'] = s 
+      @content_hash['main_js_route_overlay_increment'] = increment                  
+    end
+    
+    def generate_main_js_checkpoint_overlays
+      s =  "\n            // Create a base icon for all of our markers that specifies the "
+  		s << "\n            // shadow, icon dimensions, etc."
+  		s << "\n            var baseIcon = new GIcon();"
+  		s << "\n            baseIcon.shadow = \"http://www.joakim-systems.com/gicons/shadow50.png\";"
+  		s << "\n            baseIcon.iconSize = new GSize(20, 34);"
+  		s << "\n            baseIcon.shadowSize = new GSize(37, 34);"
+  		s << "\n            baseIcon.iconAnchor = new GPoint(9, 34);"
+  		s << "\n            baseIcon.infoWindowAnchor = new GPoint(9, 2);"
+  		s << "\n            baseIcon.infoShadowAnchor = new GPoint(18, 25);"
+  		s << "\n"
+  		
+      curr_idx  = -1
+      last_idx  = @tkpts.size - 1
+      next_checkpoint = 0.0
+      @start_dttm = nil
+      @tkpts.each { | tkpt |
+        curr_idx = curr_idx + 1
+        if curr_idx == 0
+          @start_dttm = tkpt.dttm           
+          info_window_html = tkpt.as_info_window_html('Start', @start_dttm)
+          s << "\n            var iconStart = new GIcon(baseIcon); "
+          s << "\n            iconStart.image = \"http://www.joakim-systems.com/gicons/dd-start.png\";"
+          s << "\n            var pStart = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
+          s << "\n            var mStart = new GMarker(pStart, iconStart);"
+          s << "\n            GEvent.addListener(mStart, \"click\", function() { "
+          s << "\n                mStart.openInfoWindowHtml(#{info_window_html});"
+          s << "\n            });	"
+          s << "\n            map.addOverlay(mStart);"
+          s << "\n " 
+          next_checkpoint = 1.0      
+        elsif curr_idx == last_idx
+          info_window_html = tkpt.as_info_window_html('Finish', @start_dttm)          
+          s << "\n            var iconFinish = new GIcon(baseIcon); "
+          s << "\n            iconFinish.image = \"http://www.joakim-systems.com/gicons/dd-end.png\";"
+          s << "\n            var pFinish = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
+          s << "\n            var mFinish = new GMarker(pFinish, iconFinish);"
+          s << "\n            GEvent.addListener(mFinish, \"click\", function() { "
+          s << "\n                mFinish.openInfoWindowHtml(#{info_window_html});"
+          s << "\n            });	"
+          s << "\n            map.addOverlay(mFinish);"
+          s << "\n " 
+          next_checkpoint = 999999
+        else
+          if (tkpt.cumulativeDistance >= next_checkpoint)
+            integer = next_checkpoint.to_i
+            info_window_html = tkpt.as_info_window_html("#{integer}", @start_dttm)              
+            s << "\n            var icon#{integer} = new GIcon(baseIcon); "
+            s << "\n            icon#{integer}.image = \"http://www.joakim-systems.com/gicons/marker#{integer}.png\";"
+            s << "\n            var p#{integer} = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
+            s << "\n            var m#{integer} = new GMarker(p#{integer}, icon#{integer});"
+            s << "\n            GEvent.addListener(m#{integer}, \"click\", function() { "
+            s << "\n                m#{integer}.openInfoWindowHtml(#{info_window_html});"
+            s << "\n            });	"
+            s << "\n            map.addOverlay(m#{integer});"
+            s << "\n " 
+            next_checkpoint = next_checkpoint + 1.0   
+          end                         
+        end
+      }
+      s << "\n"    
+      @content_hash['main_js_checkpoint_overlays'] = s 
+    
+    end
+    
+    def generate_main_js_map_clicked_listeners
+      s =  "\n"
+      s << "\n            GEvent.addListener(map, \"click\", function() { "
+      s << "\n                var center = map.getCenter(); \n"
+      s << "\n                document.getElementById(\"messages\").innerHTML = 'click: ' + center.toString(); "
+      s << "\n            });"
+      s << "\n            GEvent.addListener(map, \"moveend\", function() { "
+      s << "\n                var center = map.getCenter(); \n"
+      s << "\n                document.getElementById(\"messages\").innerHTML = 'moveend: ' + center.toString(); "
+      s << "\n            });"
+      @content_hash['main_js_map_clicked_listeners'] = s 
+    end
+    
+    def generate_main_js_end
+      s =  "\n        } "
+      s << "\n    } "
+      s << "\n//]]> \n"        
+      s << "\n</script>" 
+       
+      @content_hash['main_js_end'] = s            
+    end
+       
+  end
+  
+
+=begin rdoc
+  Instances of this class represent a <History> aggregate object from a
+  Forerunner XML file.
+=end
+    
+  class History < GoobyObject 
+  
+    attr_reader :runs
+  
+    def initialize
+      @runs = Array.new
+    end
+  
+  # Adds a Run during XML parsing.
+    def add_run(run)  
+      @runs.push(run)    
+    end
+  
+    def to_s
+      return "Hist: runs: #{@runs.size}"
+    end
+  
+    def print_string
+      s = "History: run count=#{@runs.size} \n"
+      runs.each { | run | s << run.print_string }
+      s
+    end
+    
+  end 
+  
+
+=begin rdoc
+  Instances of this class represent a <Lap> aggregate object from a
+  Forerunner XML file.
+=end
+  
+  class Lap < GoobyObject
+  
+    attr_accessor :number, :startTime, :duration, :length, :beginPosition, :endPosition
+  
+    def initialize(num)
+      @number = num  
+    end
+
+    def to_s
+      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@beginPosition.to_s} end: #{@endPosition.to_s}"
+    end
+      
+  end 
+
+  
+=begin rdoc
+
+=end
+
+  class Line < GoobyObject  
+  
+    attr_accessor :raw_data, :tokens
+  
+    def initialize(raw='', delim=nil, strip=false)
+      if strip
+        @raw_data = raw.strip
+      else
+        @raw_data = raw
+      end
+      
+      @tokens   = tokenize(@raw_data, delim, strip=false)  
+    end
+  
+    public
+    
+    def token(idx)
+      @tokens[idx]
+    end
+    
+    def token_count
+      @tokens.size
+    end
+
+    def token_idx_equals(idx, value)
+      if idx < token_count
+        if @tokens[idx] == value
+          return true
+        end
+      end
+      false
+    end
+    
+    def match(pattern)
+      @raw_data.match(pattern)
+    end
+    
+    def is_comment
+      s = @raw_data.strip
+      (s.match('^#')) ? true : false
+    end
+
+    def is_populated_non_comment
+      s = @raw_data.strip
+      if s.size == 0
+        return false
+      end
+      if is_comment
+        return false
+      end
+      return true   
+    end
+    
+    def concatinate_tokens(start_idx = 0)
+      s = ''
+      idx = -1
+      @tokens.each { |tok| 
+        idx = idx + 1
+        if idx >= start_idx
+          s << tok
+          s << ' '
+        end
+      }
+      s.strip!
+      s
+    end
+  end
+
+  
+  class Options < GoobyObject
+  
+    attr_reader :yamlFilename, :options
+  
+    def initialize(filename)  # Constructor.
+      filename ? @yamlFilename = filename : @yamlFilename = 'gooby_options.yaml'     
+      loadFile()
+    end
+  
+    public
+ 
+  # Load the @yamlFilename  
+    def loadFile   
+      File.open("#{@yamlFilename}") { |fn| 
+        @options = YAML::load(fn)    
+      }
+    end
+
+    def get(name)    
+      if name == nil
+        return ''
+      end
+      s = @options["#{name}"]
+    
+      # Provide "sensible defaults".
+      if s == nil
+        if (name == '') 
+          return ''
+        elsif (name == 'gmap_first_tkpt_number')  
+          return 1
+        elsif (name == 'gmap_last_tkpt_number')   
+          return 5000
+        elsif (name == 'gmap_map_element_id')     
+          return 'map'  
+        elsif (name == 'gmap_height')             
+          return '600'
+        elsif (name == 'gmap_key')                
+          return 'enter your Google Map Key here'       
+        elsif (name == 'gmap_type_control')       
+          return true
+        elsif (name == 'gmap_approx_max_points')  
+          return '200'
+        elsif (name == 'gmap_gen_comments')       
+          return true
+        elsif (name == 'gmap_size_control')       
+          return nil
+        elsif (name == 'gmap_type')               
+          return 'G_NORMAL_MAP'  
+        elsif (name == 'gmap_zoom_level')         
+          return 5 
+        else 
+          return ''
+        end
+      end
+      s
+    end
+     
+  # Return a String containing yaml filename and entry count.  
+    def to_s
+      return "Options: filename: #{@yamlFilename} entries: #{@options.size}"
+    end
+  
+  end 
+
+
+=begin rdoc
+  Instances of this class represent a <Position> aggregate object from a
+  Forerunner XML file.  Each contains a latitude and longitude.
+  Instances within a Trackpoint will also contain an altitude.
+=end
+    
+  class Position < GoobyObject  
+  
+    attr_accessor :latitude, :longitude, :altitude, :note
+  
+    def initialize(lat, lng, alt='0', note='')
+      @latitude  = lat.to_s
+      @longitude = lng.to_s
+      @altitude  = alt.to_s
+      @note      = note.to_s
+    end
+  
+    public
+  
+    def to_s
+      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
+    end
+  
+    def to_csv
+      return "#{@latitude} | #{@longitude} | #{@altitude}"
+    end
+    
+    def latitude_as_float
+      @latitude ? @latitude.to_f : invalid_latitude
+    end
+  
+    def longitude_as_float
+      @longitude ? @longitude.to_f : invalid_longitude
+    end
+  
+    def altitude_as_float
+      @altitude ? @altitude.to_f : invalid_altitude
+    end
+  
+  end
+
+
+=begin rdoc
+  Instances of this class represent a <Run> aggregate object from a
+  Forerunner XML file.  
+
+  Additionally, there is distance, pace, and Google Map generation logic 
+  in this class.
+=end 
+
+  class Run < GoobyObject 
+  
+    attr_accessor :number, :descr, :notes, :tracks, :tkpts, :laps, :distance
+  
+    def initialize(number=0, descr='')
+      @number = number
+      @descr  = descr
+      @notes  = ''         
+      @tracks = Array.new
+      @tkpts  = Array.new
+      @laps   = Array.new 
+      @distance = 0
+      @options  = Hash.new
+      @logProgress = true
+      @finished = false
+    end
+
+    public
+  
+   # This method is invoked at end-of-parsing.  
+    def finish()
+       @logProgress = false
+       unless @finished
+         @tracks.each { |trk|  
+           trk.trackpoints().each { |tkpt|
+             tkpt.runNumber = @number
+             @tkpts.push(tkpt)             
+           }
+         }      
+         compute_distance_and_pace
+         compute_splits
+         @finished = true
+       end  
+     end  
+   
+    public  
+  
+    def add_track(trk)
+      if trk != nil
+        @tracks.push(trk) 
+      end   
+    end
+  
+    def trackpoint_count()
+      @tkpts.size()
+    end
+  
+    def add_lap(lap)
+      @laps.push(lap)    
+    end
+  
+    def lapCount()
+      @laps.size    
+    end
+  
+    def start_dttm()
+      count = 0
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          return tkpt.dttm()
+        }
+      }
+      return nil    
+    end
+  
+    def end_dttm()
+      lastOne = nil
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          lastOne = tkpt.dttm()
+        }
+      }
+      lastOne
+    end
+  
+    def duration()
+      first = start_dttm()
+      last  = end_dttm()
+      if first
+        if last
+          return last.hhmmss_diff(first)
+        end
+      end
+      return "??:??:??" 
+    end
+
+    def start_yyyy_mm_dd
+      if start_dttm() 
+        start_dttm().yyyy_mm_dd()
+      else
+          ""
+      end
+    end
+  
+    def start_hh_mm_ss
+      if start_dttm() 
+        start_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end    
+  
+    def end_hh_mm_ss
+      if end_dttm() 
+        end_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end
+  
+    def to_s
+      finish() unless @finished 
+      s = "Run: #{@number} date: #{start_yyyy_mm_dd} distance: #{distance} duration: #{duration} "
+      s << "  tracks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lapCount} "
+      s << "  notes: #{@notes} "
+      s
+    end
+  
+    def print_string     
+      finish() unless @finished       
+      "Run number=#{@number}  tracks=#{@tracks.size} tkpts=#{@tkpts.size} laps=#{@laps.size} distance=#{@distance} "
+    end
+  
+    def put_csv()
+      finish() unless @finished
+      puts "#{@number}|#{}|#{start_yyyy_mm_dd()}|#{start_hh_mm_ss()}|#{end_hh_mm_ss}|#{duration()}|#{@distance}|#{@tracks.size}|#{trackpoint_count()}|#{lapCount}|#{@notes.strip}" 
+    end
+  
+    def put_tkpt_csv(with_header_comment=false)
+      finish() unless @finished    
+      if with_header_comment
+        puts "# Run: #{@number} date: #{start_yyyy_mm_dd} dist: #{distance} dur: #{duration} trks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lapCount} "
+      end
+      @tkpts.each { | tkpt | puts tkpt.to_csv }
+    end
+    
+    def put_laps
+      @laps.each { | lap | puts lap.to_s }      
+    end
+  
+    private 
+  
+    def compute_distance_and_pace
+      cumulative_dist = 0.to_f;
+      curr_index = -1
+      prev_tkpt  = nil
+      start_dttm = nil
+      @tkpts.each { | tkpt |
+        curr_index = curr_index + 1
+        if curr_index == 0
+          start_dttm = tkpt.dttm()
+          prev_tkpt  = tkpt          
+        else
+          cumulative_dist = tkpt.compute_distance_and_pace(curr_index, start_dttm, cumulative_dist, prev_tkpt, 'M')  
+          prev_tkpt = tkpt      
+        end
+      }
+      @distance = cumulative_dist     
+    end
+  
+    def compute_splits              
+      nextSplitDist = 1.00
+      prevSplitTkpt = nil
+      loop1Count    = 0;
+      @tkpts.each { |tkpt|
+        loop1Count = loop1Count + 1
+        if tkpt.cumulativeDistance() >= nextSplitDist
+          tkpt.set_split(0 + nextSplitDist, prevSplitTkpt)
+          nextSplitDist = nextSplitDist + 1.00
+          prevSplitTkpt = tkpt
+        end
+      } 
+      # set first and last booleans
+      count = 0
+      @tkpts.each { |tkpt|
+        count = count + 1
+        tkpt.first = true  if count == 1
+        tkpt.last  = true  if count == loop1Count
+      }         
+    end
+    
+  end
+  
+
+=begin rdoc
+  Sample implementation of a REXML::StreamListener SAX parser.
+=end 
+
+  class SimpleXmlParser
+   
+    include REXML::StreamListener
+  
+    attr_accessor :tag_count, :watched_tags
+  
+    def initialize
+      @tag_count = 0
+      @counter_hash = CounterHash.new
+    end
+  
+    public
+
+  # SAX API method.  Increments the tagname in the counter hash.  
+    def tag_start(tag_name, attrs)   
+      @tag_count = @tag_count + 1
+      @counter_hash.increment(tag_name)
+    end
+
+  # SAX API method.  No impl.
+    def tag_end(tagname)   
+    end
+  
+  # SAX API method.  No impl.  
+    def text(txt)
+    end
+
+  # Prints the state of this object (the counter hash).
+    def dump   
+      puts @counter_hash.to_s
+    end
+  
+  end
+
+
+=begin rdoc
+  This class is used to generate, on an ongoing basis, the various Gooby test
+  classes.  Regeneration retains the current test methods, and adds stubs for 
+  new test methods.  All methods, old and new, appear in the merged output in 
+  propper sort sequence.
+=end
+    
+  class TestGenerator < GoobyObject 
+    
+    def initialize
+      tested_files.each { | base_rb_file | 
+        test_file = "tc_#{base_rb_file}"
+        if true
+          @codeLines  = read_lines("lib/#{base_rb_file}") 
+          @testLines  = read_lines("tests/#{test_file}") 
+          @codeHash   = Hash.new     
+          @testHash   = Hash.new     
+          @mergedHash = Hash.new
+          @excludeClasses = %w( TestHelper TestGenerator )    
+          puts "current codeLines = #{@codeLines.size}" 
+          puts "current testLines = #{@testLines.size}" 
+          parse_code_lines
+          parse_test_lines    
+          merge_keys
+          regenerate(test_file)
+        end
+      }
+    end 
+  
+    private
+  
+    #  Produce a Hash with keys and values like the following:
+    #  test|class|Trackpoint|deg2rad      Trackpoint|deg2rad(degrees)
+  
+    def parse_code_lines
+      type      = ''
+      type_name = ''
+      meth_name = ''    
+      @codeLines.each { | line | 
+        line.strip!
+        if (line.match(/^module /))
+          type      = 'module'
+          tokens    = line.split
+          type_name = tokens[1]    
+        elsif (line.match(/^class /))
+          type      = 'class'
+          tokens    = line.split
+          type_name = tokens[1]          
+        elsif (line.match(/^def /))
+          signature = line[4...999]
+          short_method = parse_meth_name("#{signature}")
+          @codeHash["test_#{type}_#{type_name}"] = "#{type_name}"          
+          @codeHash["test_#{type}_#{type_name}_#{short_method}"] = "#{type_name}|#{signature}"           
+        end        
+      }          
+    end 
+
+    def parse_meth_name(string)
+      string.gsub!('(', ' ')
+      string.gsub!(')', ' ')    
+      tokens = string.split
+      tokens[0]
+    end
+  
+    def parse_test_lines
+      in_method  = true
+      method_name = 'a_start'
+      method_lines = Array.new
+      line_num = 0
+    
+      @testLines.each { | line | 
+        line_num = line_num + 1  
+        line.chomp!
+        prefix   = line[0...5]   # '  def'         
+        prefix21 = line[0...21]  # '  ### Start of tests.'
+            
+        if ((prefix == '  def') || (prefix == "\tdef"))
+          in_method   = true 
+          tokens      = line.split
+          method_name = tokens[1] 
+          method_lines = Array.new   
+        end
+        if in_method
+          method_lines << "#{line}"
+        end
+        if prefix21 == '  ### Start of tests.'
+          in_method = false 
+          @testHash["#{method_name}"] = method_lines            
+        end   
+        if ((prefix == '  end') || (prefix == "\tend")) 
+          in_method = false 
+          @testHash["#{method_name}"] = method_lines            
+        end       
+      }      
+    end 
+  
+    def merge_keys
+      @codeHash.keys.sort.each { |key| @mergedHash["#{key}"] = "code" }
+      @testHash.keys.sort.each { |key| @mergedHash["#{key}"] = "test" }       
+    end
+  
+    def regenerate(test_file)
+      code = ''
+      @mergedHash.keys.sort.each { |key|  
+
+        tokens = key.split('_')
+        type, name, meth = tokens[1], tokens[2], tokens[3]  
+        
+        processThisKey = true      
+        @excludeClasses.each { |xc| 
+          if xc == name 
+            processThisKey = false
+          end
+        }
+      
+        next if !processThisKey
+            
+        if @testHash.has_key?(key)
+          # We already have a test method written in the test class, 
+          # so keep this currently existing test code!
+
+          if @codeHash.has_key?(key)
+            comment = nil
+          else
+            if key != 'a_start'
+              comment = "# Warning: possible obsolete test method - #{key}"
+            end
+          end
+        
+          code << "\n"
+          if comment != nil
+            code << "\n#{comment}"
+            code << "\n"
+          end
+          array = @testHash["#{key}"]
+          array.each { |line| code << "\n#{line}" }
+        else
+          # We don't have this test method in the current test class,
+          # so generate a test method stub.
+        
+          code << "\n"
+          code << "\n  def #{key}"
+          code << "\n"
+        
+          if @gen_impl_stub
+            if type = 'class' 
+              code << "\n    #obj = #{type}.new"
+              code << "\n    #result   = obj.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s << '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s      
+            else
+              code << "\n    #result   = #{type}.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s <<  '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s         
+            end
+          end
+          code << "\n  end"
+        end
+      }
+      code << "\nend" # end of class 
+      code << "\n"      
+      fn  = "tests/#{test_file}"
+      out = File.new fn, "w+"
+      out.write code
+      out.flush
+      out.close
+      puts "file written: #{fn}"
+    end
+
+  end
+
+
+=begin rdoc
+  Instances of this class represent a <Track> aggregate object from a Forerunner
+  XML file.  Note that a <Run> may contain more than one <Track> aggregates.
+=end
+  
+  class Track < GoobyObject
+  
+    attr_reader :number, :descr, :trackpoints
+  
+    def initialize(num=0, descr='')
+      @number = num      
+      @descr  = descr
+      @trackpoints = Array.new      
+    end
+  
+    public
+  
+    def add_trackpoint(tkpt)
+      @trackpoints.push(tkpt)    
+    end
+  
+    def size
+      @trackpoints.size
+    end
+  
+    def first_tkpt
+      @trackpoints.size > 0 ? @trackpoints[0] : nil
+    end
+ 
+    def last_tkpt
+      @trackpoints.size > 0 ? @trackpoints[-1] : nil
+    end
+      
+    def to_s
+      return "Trk: #{@descr} tkpts: #{size}"
+    end
+    
+    def dump
+      puts "Track: '#{@descr}'  tkpts: #{size}"
+      @trackpoints.each { |tkpt| puts tkpt.to_csv } # to_geo_s
+    end
+    
+  end 
+
+
+=begin rdoc
+  Instances of this class represent a <Trackpoint> aggregate from a Forerunner 
+  XML file.  Additionally, there is distance, pace, and Google Map generation 
+  logic in this class.
+
+  <Trackpoint>
+      <Position>
+          <Latitude>35.49577</Latitude>
+          <Longitude>-80.83281</Longitude>
+          <Altitude>232.296</Altitude>
+      </Position>
+      <Time>2007-01-06T15:27:51Z</Time>
+  </Trackpoint>
+=end
+  
+  class Trackpoint < Position
+  
+    attr_reader :first, :last, :number, :runNumber, :dttm, :prevTkpt, :descr
+    attr_reader :cumulativeDistance, :cumulativePace, :incrementalDistance, :split, :prevSplit
+    attr_writer :first, :last, :runNumber
+  
+    def initialize(num, lat, lng, alt, time_string, descr='')
+      @number    = num
+      @runNumber = 0
+
+      # initialize superclass variables:
+      @latitude  = lat.to_s
+      @longitude = lng.to_s
+      @altitude  = alt.to_s
+      @note      = note.to_s
+      @dttm      = DtTm.new(time_string)
+      @first     = false
+      @last      = false
+      @prevTkpt  = nil      
+      @cumulativeDistance, @split = 0.0, 0.0
+      @cumulativePace = ""
+      @descr     = descr
+    end
+  
+    public
+  
+    def position
+      Position.new(@latitude, @longitude, @altitude, @note)
+    end
+    
+    def to_s
+        "Tkpt: #{@number} #{super.to_s} date: #{@dttm.to_s} cdist: #{@cumulativeDistance}"
+    end
+  
+    def to_csv
+      ss = position.to_csv
+      "#{@runNumber} | #{@dttm.to_s} | #{@number} | #{ss} | #{@cumulativeDistance} "
+    end
+    
+    def to_geo_s
+      ss = position.to_csv
+      "Tkpt: #{@number} | #{ss} | #{@descr}"
+    end
+    
+    def compute_distance_and_pace(curr_index, start_dttm, prev_cumulative_dist, prev_trackpoint, units)     
+      @prev_tkpt = prev_trackpoint
+      @cumulativeDistance = prev_cumulative_dist.to_f
+        
+      if @prev_tkpt
+        arg1  = latitude().to_f
+        arg2  = @prev_tkpt.latitude().to_f
+        arg3  = latitude().to_f
+        arg4  = @prev_tkpt.latitude().to_f
+        theta = longitude().to_f - @prev_tkpt.longitude().to_f   
+      
+        res1  = Math.sin(deg2rad(arg1))
+        res2  = Math.sin(deg2rad(arg2))
+        res3  = Math.cos(deg2rad(arg3))
+        res4  = Math.cos(deg2rad(arg4))
+        res5  = Math.cos(deg2rad(theta.to_f))
+              
+        incremental_distance =  ((res1 * res2) + (res3 * res4 * res5)).to_f
+
+        if (!incremental_distance.nan?)
+          incremental_distance = Math.acos(incremental_distance.to_f)
+          if (!incremental_distance.nan?)    
+            incremental_distance = rad2deg(incremental_distance)
+            if (!incremental_distance.nan?)
+              incremental_distance = incremental_distance * 60 * 1.1515;
+              if (!incremental_distance.nan?)
+                if units == "K"
+                   incremental_distance = incremental_distance * 1.609344;
+                end 
+                if units == "N"
+                   incremental_distance = incremental_distance * 0.8684;
+                end  
+                @cumulativeDistance =  @cumulativeDistance + incremental_distance.to_f 
+              end
+            end
+          end
+        end    
+        compute_cumulative_pace(start_dttm)
+        @cumulativeDistance
+      else
+        0  
+      end    
+    end
+  
+    def compute_cumulative_pace(start_dttm)      
+      if @cumulativeDistance > 0
+        secsDiff  = @dttm.seconds_diff(start_dttm)
+        secsMile  = ((secsDiff.to_f) / (@cumulativeDistance.to_f))
+        minsMile  = (secsMile / 60)
+        wholeMins = minsMile.floor 
+        secsBal   = secsMile - (wholeMins * 60)
+        s1 = "#{secsDiff} #{secsMile} #{minsMile} #{wholeMins} #{secsBal} #{@cumulativeDistance} | "
+        s2 = sprintf("%d:%2.1f", minsMile, secsBal)
+        @cumulativePace = "#{s2}"
+      else 
+        @cumulativePace = ""
+      end
+    end
+  
+    def set_split(n, tkpt)
+      @split, @prevSplit = n, tkpt
+    end
+  
+    def is_split()
+     (@split >= 1)
+    end
+  
+    def is_first()
+      @first
+    end
+  
+    def is_last()
+      @last
+    end
+  
+    def split_info(dtTm) 
+      if is_split
+        hhmmss = ''
+        if @prevSplit
+          return "#{@split} #{@dttm.hhmmss_diff(@prevSplit.dttm())}"          
+        else
+          return "#{@split} #{@dttm.hhmmss_diff(dtTm)}"      
+        end
+      else
+          ""
+      end
+    end
+  
+    private 
+  
+    def deg2rad(degrees)
+     (((0 + degrees) * Math::PI) / 180)
+    end
+  
+    def rad2deg(radians)
+     (((0 + radians) * 180) / Math::PI)
+    end
+
+    public 
+    
+    def as_glatlng(comments, tkpt_count, curr_idx, gpoint_count, start_dttm)
+      if comments
+        secs_diff = @dttm.seconds_diff(start_dttm)
+        fmt_time  = @dttm.hhmmss_diff(start_dttm)
+          "\n            points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); " +
+            "// #{gpoint_count} (#{curr_idx + 1} of #{tkpt_count}) #{@dttm.to_s} #{secs_diff} #{fmt_time} #{@cumulativeDistance} #{split_info(start_dttm)} "
+      else
+          "\n            points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); "  
+      end      
+    end
+  
+    def as_info_window_html(checkpoint, start_dttm)
+      s = "\"<table align='left'>"
+      if checkpoint
+        secs_diff = @dttm.seconds_diff(start_dttm)
+        fmt_time  = @dttm.hhmmss_diff(start_dttm)
+                
+        if checkpoint == 'Start'
+          s << "<tr><td colspan='2'><b>Start!</b></td></tr>"
+        elsif checkpoint == 'Finish'
+          s << "<tr><td colspan='2'><b>Finish!</b></td></tr>"
+        else
+          s << "<tr><td colspan='2'><b>Checkpoint #{checkpoint}</b></td></tr>"
+        end
+        s << "<tr><td>Distance: </td><td>#{@cumulativeDistance}</td></tr>"
+        s << "<tr><td>Time of Day: </td><td>#{@dttm.to_s} </td></tr>" 
+        s << "<tr><td>Elapsed Time: </td><td>#{fmt_time} </td></tr>"  
+        s << "<tr><td>Average Pace: </td><td>#{@cumulativePace} </td></tr>"      
+        s << "<tr><td>Lat/Lng: </td><td>#{latitude_as_float} , #{longitude_as_float} </td></tr>" 
+        s << "<tr><td>Altitude: </td><td>#{altitude_as_float}m </td></tr>"
+        s
+      end
+      s << "</table>\""
+      s
+    end
+        
+  end  
+
+
+=begin rdoc
+  This class provides "user friendly DSL" functionality for the use
+  of Gooby.
+=end
+  
+  class GoobyCommand < GoobyObject 
+    
+    def initialize
+    end
+    
+    def options(yaml_filename) 
+      Gooby::Options.new(yaml_filename)
+    end
+
+    def split_forerunner_xml(xml_filename, out_dir)  
+      splitter = Gooby::ForerunnerXmlSplitter.new(xml_filename, out_dir)  
+      splitter.split
+    end
+    
+    def parse_forerunner_xml(xml_filename)  
+      handler = Gooby::ForerunnerXmlParser.new     
+      Document.parse_stream((File.new xml_filename), handler)
+      handler.put_all_run_tkpt_csv(true)
+    end
+
+    def generate_google_map(csv_filename, options_obj)  
+      generator = Gooby::GoogleMapGenerator.new(csv_filename)  
+      generator.generate_page(options_obj)
+    end
+         
+  end
+  
+end # end of module