gooby 1.1.0 → 1.2.0

data/data/hrm1.csv

@@ -0,0 +1,5 @@
+#cols: primary_key|run_id|date|time|tkpt_num|latitude|longitude|altitude|heartbeat|run_distance|uom|run_elapsed|lap_tkpt_number|lap_distance|lap_elapsed
+2007-07-16T23:42:44Z.1|2007-07-16T23:42:44Z|2007-07-16|23:42:44|1|35.495497|-80.832159|241.908936|75|0.0|mi|00:00:00|1|0|00:00:00
+2007-07-16T23:42:44Z.2|2007-07-16T23:42:44Z|2007-07-16|23:42:46|2|35.495499|-80.832152|241.428223|75|0.000417102641276755|mi|00:00:02|2|0.000417102641276755|00:00:02
+2007-07-16T23:42:44Z.5|2007-07-16T23:42:44Z|2007-07-16|23:42:54|5|35.495522|-80.832229|242.870239|74|0.00503094417417941|mi|00:00:10|3|0.00503094417417941|00:00:10
+2007-07-16T23:42:44Z.6|2007-07-16T23:42:44Z|2007-07-16|23:47:46|6|35.495465|-80.832151|242.389648|87|0.0109261260004515|mi|00:05:02|4|0.0109261260004515|00:05:02

data/lib/gooby.rb

@@ -1,43 +1,6 @@
 =begin
 
 Gooby = Google APIs + Ruby
-This file contains the classes and modules for the Gooby project.
-
-See file 'tests/ts_gooby.rb' for the regression test suite.
-
-Index of Modules and Classes in this file:
-    line  type    Module or Class name
-    ----  ------  ---------------------------
-      57  module  Gooby
-      64  module  GoobyKernel
-     191  module  TestHelper
-     209  class   GoobyObject
-     222  class   CounterHash
-     305  class   DelimLine
-     340  class   DtTm
-     417  class   Duration
-     496  class   ForerunnerXmlParser
-     665  class   ForerunnerXmlSplitter
-     775  class   TrainingCenterXmlParser
-     962  class   TrainingCenterXmlSplitter
-    1067  class   GeoData
-    1250  class   GoogleMapGenerator
-    1625  class   History
-    1656  class   Lap
-    1671  class   Line
-    1749  class   Configuration
-    1848  class   Point
-    1987  class   CsvPoint
-    2042  class   CvsRun
-    2060  class   CsvReader
-    2121  class   Trackpoint
-    2319  class   Run
-    2521  class   SimpleXmlParser
-    2561  class   Track
-    2593  class   Course
-    2713  class   CodeScanner
-    3003  class   GoobyCommand
-  
 Gooby - Copyright 2007 by Chris Joakim.
 Gooby is available under GNU General Public License (GPL) license.
 
@@ -52,3110 +15,30 @@ require 'singleton'
 require 'time'
 require 'yaml'
 
-# =============================================================================
-
-module Gooby
-
-=begin rdoc
-  This module is used to embed information about the Gooby project and
-  version into the codebase.
-=end
-  
-  module GoobyKernel
-
-  # Return a String version number, like '1.1.0'.
-  
-    def project_name
-      'Gooby'
-    end
-    
-    def project_version_number   
-      '1.1.0'
-    end
-
-  # Return a String date, like '2007/03/21'.  
-    def project_date       
-      '2007/06/10'
-    end
-
-    # Return a String containing the project author name.
-    def project_author
-      'Chris Joakim'
-    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
-
-    def project_embedded_comment
-      "#{project_name} #{project_version_number}"
-    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 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
-
-    def tokenize(string, delim=nil, strip=false)  
-      if string
-        tokens = string.split(delim)
-        if strip
-          tokens.each { |tok| tok.strip! }
-        end
-        tokens
-      else
-        Array.new
-      end
-    end
-    
-    def default_delimiter
-      return '|'
-    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 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::GoobyKernel  
-  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
-    
-    def size
-      @hash.size
-    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
-    
-    def increment_tokens(text)
-      tokens = tokenize(text)
-      tokens.each { |token| increment(token) }
-    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}]\n"
-      }
-      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
-          @date_time = DateTime.parse(@rawdata[0..18])
-          @time  = Time.parse(@date_time.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(delim=' ')
-      @time.strftime("%Y-%m-%d#{delim}%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
-        '00:00:00'  
-      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
-      @cv_hash            = Hash.new("")
-      @tag_count          = 0
-      @run_count          = 0
-      @lap_count          = 0
-      @track_count        = 0
-      @trackpoint_count   = 0
-      @curr_text          = "";
-      @history            = History.new
-      @curr_run           = nil
-      @curr_lap           = nil
-      @curr_track         = nil
-      @curr_begin_position = nil
-      @@curr_end_position   = nil
-    end
-  
-    public
- 
-    # SAX API method; handles 'Run', 'Lap', 'Track'.   
-    def tag_start(tagname, attrs) 
-      @tag_count += 1
-      @currTag = tagname
-      @cv_hash[tagname] = ''
-    
-      if detail_tag?(tagname)
-        @inDetail = true
-      end
-    
-      if is_tag?('Run', tagname)
-        @run_count = @run_count + 1
-        @lap_count = 0
-        @track_count = 0
-        @trackpoint_count = 0        
-        @curr_run  = Run.new(@run_count)
-        @history.add_run(@curr_run)
-        @cv_hash['Notes'] = ''
-        return
-      end
-    
-      if is_tag?('Lap', tagname)
-        @lap_count = @lap_count + 1
-        @curr_lap  = Lap.new(@lap_count)
-        return
-      end
-    
-      if is_tag?('Track', tagname)
-        @track_count = @track_count + 1      
-        @curr_track  = Track.new(@track_count)
-        return   
-      end
-    end
-
-    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run'. 
-    def tag_end(tagname) 
-      if @inDetail    
-        @cv_hash[tagname] = @curr_text
-      else
-        if is_tag?('Position', tagname)
-          lat  = @cv_hash['Latitude']
-          long = @cv_hash['Longitude']
-          @curr_begin_position = Point.new(lat.strip, long.strip)
-          @@curr_end_position  = Point.new(lat.strip, long.strip)       
-        end 
-        
-        if is_tag?('BeginPosition', tagname)
-          lat  = @cv_hash['Latitude']
-          long = @cv_hash['Longitude']
-          @curr_begin_position = Point.new(lat.strip, long.strip)      
-        end
-        
-        if is_tag?('EndPosition', tagname)
-          lat  = @cv_hash['Latitude']
-          long = @cv_hash['Longitude']
-          @@curr_end_position = Point.new(lat.strip, long.strip)      
-        end
-              
-        if is_tag?('Trackpoint', tagname)
-          @trackpoint_count = @trackpoint_count + 1
-          lat  = @cv_hash['Latitude']
-          long = @cv_hash['Longitude']
-          alt  = @cv_hash['Altitude']   
-          time = @cv_hash['Time']            
-          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
-          @curr_track.add_trackpoint(tp)
-        end
-      
-        if is_tag?('Track', tagname)
-          if @curr_run != nil
-            @curr_run.add_track(@curr_track)
-          end
-        end
-      
-        if is_tag?('Lap', tagname)
-          @curr_lap.startTime = @cv_hash['StartTime']
-          @curr_lap.duration  = Duration.new(@cv_hash['Duration'])
-          @curr_lap.length    = @cv_hash['Length']                          
-          @curr_lap.begin_position = @curr_begin_position
-          @curr_lap.end_position   = @@curr_end_position        
-          @curr_run.add_lap(@curr_lap)
-        end
-      
-        if is_tag?('Run', tagname)
-          @curr_run.notes =  @cv_hash['Notes'] 
-        end
-      end
-    
-      @inDetail = false    
-      @curr_text = ""
-      @currTag  = ""                     
-    end
-
-    # SAX API method.
-    def text(txt)  
-      if @inDetail
-        @curr_text = @curr_text + 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() 
-      @history.runs.each { |run| run.put_tkpt_csv() } 
-    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 are used to parse a Garmin TrainingCenter XML(TCX) 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/TrainingCenterDatabasev2.xsd for the XML
-  Schema Definition for Garmin TrainingCenter XML.  
-=end
-  
-  class TrainingCenterXmlParser  
-  
-    DETAIL_TAGS = %w( Notes StartTime Duration Length Time
-                      TotalTimeSeconds DistanceMeters   
-                      LatitudeDegrees LongitudeDegrees AltitudeMeters BeginPosition EndPosition )
-  
-    include REXML::StreamListener
-  
-    attr_reader :history, :cvHash, :tagCount
-  
-    def initialize
-      @cv_hash               = Hash.new("")
-      @tag_count             = 0
-      @run_count             = 0
-      @lap_count             = 0
-      @track_count           = 0
-      @trackpoint_count      = 0
-      @curr_text             = "";
-      @history               = History.new
-      @curr_run              = nil
-      @curr_lap              = nil
-      @curr_track            = nil
-      @curr_begin_position   = nil
-      @@curr_end_position    = nil
-      @first_lap_start_time  = nil
-      @curr_lap_start_time   = ''
-    end
-  
-    public
- 
-    # SAX API method; handles 'Activity', 'Lap', 'Track'.   
-    def tag_start(tagname, attrs) 
-      @tag_count += 1
-      @currTag = tagname
-      @cv_hash[tagname] = ''
-    
-      if detail_tag?(tagname)
-        @inDetail = true
-      end
-    
-      if is_tag?('Activity', tagname)
-        @run_count = @run_count + 1
-        @lap_count = 0
-        @track_count = 0
-        @trackpoint_count = 0
-        @curr_run  = Run.new(@run_count)
-        @history.add_run(@curr_run)
-        @cv_hash['Notes'] = ''
-        return
-      end
-    
-      if is_tag?('Lap', tagname)
-        @lap_count =  @lap_count + 1
-        @curr_lap  = Lap.new(@lap_count)
-        
-        attrs.each { |attr|
-          name = attr[0]
-          val  = attr[1]
-          if (name && (name == 'StartTime')) 
-            if (@first_lap_start_time == nil)
-              @first_lap_start_time = "#{val}"
-            end
-            @curr_lap_start_time = "#{val}" 
-          end
-        }
-        # TODO - capture value of 'StartTime' attribute.
-        return
-      end
-    
-      if is_tag?('Track', tagname)
-        @track_count = @track_count + 1      
-        @curr_track  = Track.new(@track_count)
-        return   
-      end
-    
-    end
-
-    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run'. 
-    def tag_end(tagname) 
-      if @inDetail    
-        @cv_hash[tagname] = @curr_text
-      else
-        if is_tag?('Position', tagname)
-          lat  = @cv_hash['LatitudeDegrees']
-          long = @cv_hash['LongitudeDegrees']
-          @curr_begin_position = Point.new(lat.strip, long.strip)
-          @@curr_end_position  = Point.new(lat.strip, long.strip)       
-        end 
-        
-        if is_tag?('BeginPosition', tagname)
-          lat  = @cv_hash['LatitudeDegrees']
-          long = @cv_hash['LongitudeDegrees']
-          @curr_begin_position = Point.new(lat.strip, long.strip)      
-        end
-        
-        if is_tag?('EndPosition', tagname)
-          lat  = @cv_hash['LatitudeDegrees']
-          long = @cv_hash['LongitudeDegrees']
-          @@curr_end_position = Point.new(lat.strip, long.strip)      
-        end
-              
-        if is_tag?('Trackpoint', tagname)
-          @trackpoint_count = @trackpoint_count + 1
-          lat  = @cv_hash['LatitudeDegrees']
-          long = @cv_hash['LongitudeDegrees']
-          alt  = @cv_hash['AltitudeMeters']   
-          time = @cv_hash['Time'] 
-
-          hash = Hash.new('')
-          hash['lap_number']           = "#{@lap_count}"          
-          hash['first_lap_start_time'] = "#{@first_lap_start_time}"
-          hash['curr_lap_start_time']  = "#{@curr_lap_start_time}"
-                           
-          tp = Trackpoint.new(@trackpoint_count, lat, long, alt, time, hash)
-          @curr_track.add_trackpoint(tp)
-        end
-      
-        if is_tag?('Track', tagname)
-          if @curr_run != nil
-            @curr_run.add_track(@curr_track)
-          end
-        end
-      
-        if is_tag?('Lap', tagname)      
-          @curr_run.add_lap(@curr_lap)
-        end
-      
-        if is_tag?('Activity', tagname)
-          @curr_run.notes =  @cv_hash['Notes'] 
-        end
-      end
-    
-      @inDetail = false    
-      @curr_text = ""
-      @currTag  = ""                     
-    end
-
-    # SAX API method.
-    def text(txt)  
-      if @inDetail
-        @curr_text = @curr_text + 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() 
-      @history.runs.each { |run| run.put_tkpt_csv() } 
-    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 Garmin TrainingCenter
-  *.tcx file into individual 'activity_' files.
-=end
-  
-  class TrainingCenterXmlSplitter < GoobyObject 
-    
-    attr_reader :out_dir, :training_center_files, :out_files_hash
-    
-    def initialize(tcx_file, out_dir)
-      @out_dir = out_dir
-      @training_center_files = Array.new
-      @training_center_files << tcx_file
-      @out_files_hash = Hash.new
-    end
-    
-    def split
-      @training_center_files.each { |f| process_file(f) }
-      write_files
-    end
-    
-    private 
-    
-    def process_file(training_center_tcx_file)
-      @file_name = training_center_tcx_file
-      @tcx_lines = read_lines(@file_name, false) 
-      @line_num  = 0
-      @activity_num   = 0
-      @curr_activity_lines = Array.new
-      @curr_activity_tkpts = 0
-      @start_line_num = 0
-      @end_line_num   = 0
-      @activity_start_time = nil
-    
-      @tcx_lines.each { |line|
-        @line_num = @line_num + 1              
-        if (line.match(/<Activity /))
-          @activity_num = @activity_num + 1
-          @start_line_num = @line_num
-          @curr_activity_lines = Array.new
-          @curr_activity_lines << line
-        elsif (line.match(/<Id>/)) # <Id>2007-03-03T15:58:57Z</Id>  <StartTime>2007-01-13T15:37:06Z</StartTime>
-          @curr_activity_lines << line   
-          if @activity_start_time == nil
-            clone = String.new(line)     
-            clone.gsub!(/[<>]/, ' ')  
-            clone.gsub!(/[-:T]/, '_')
-            clone.gsub!(/[Z]/, '') 
-            tokens = clone.split
-            @activity_start_time = tokens[1]
-          end          
-        elsif (line.match(/<Trackpoint>/)) 
-           @curr_activity_tkpts =  @curr_activity_tkpts + 1
-           @curr_activity_lines << line 
-        elsif (line.match(/<\/Activity/))
-          @end_line_num = @line_num 
-           @curr_activity_lines << line           
-          end_run 
-        elsif (@curr_activity_lines.size > 0)
-          @curr_activity_lines << line 
-        end
-      }
-    end
-  
-    def end_run
-      out_file = "#{@out_dir}/activity_#{@activity_start_time}.xml"
-      comment = "<!-- file: #{out_file}  lines: #{@curr_activity_lines.size} (#{@start_line_num} to #{@end_line_num})  tkpts: #{@curr_activity_tkpts} --> \n"
-      @curr_activity_lines.insert(0, comment)
-          
-      prev_entry = @out_files_hash[out_file]
-      if prev_entry
-        if (@curr_activity_lines.size >= prev_entry.size)
-          puts "previous entry overlaid for #{out_file}.  curr=#{@curr_activity_lines.size}  prev=#{prev_entry.size}"
-          @out_files_hash[out_file] = @curr_activity_lines
-        else
-          puts "previous entry retained for #{out_file}.  curr=#{@curr_activity_lines.size}  prev=#{prev_entry.size}"
-        end
-      else
-          puts "new entry for #{out_file}.  curr=#{@curr_activity_lines.size}"
-          @out_files_hash[out_file] = @curr_activity_lines          
-      end
-      
-      @curr_activity_lines   = Array.new
-      @curr_activity_tkpts   = 0
-      @start_line_num   = 0
-      @end_line_num     = 0
-      @activity_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 
-    
-    # primary_key|run_id|date|time|tkpt_num|latitude|longitude|altitude_ft|run_distance|run_elapsed|lap_tkpt_number|lap_distance|lap_elapsed
-    # 2005-03-05T13:00:29Z.2|2005-03-05T13:00:29Z|2005-03-05|13:00:49|2|35.22054|-80.84506|738.4161312|0.046918021941152|00:00:20|2|0.046918021941152|00:00:20
-    
-    def initialize(csv_file, dttm_idx=1, num_idx=4, lat_idx=5, lng_idx=6, alt_idx=7, cdist_idx=8)
-      @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
-            
-      # Override default csv value indices if specified in the configuration yaml file.
-      @configuration =  Gooby::Configuration.get_config
-      @dttm_idx  = @configuration.get('csv_dttm_idx')  if @configuration.get('csv_dttm_idx')
-      @num_idx   = @configuration.get('csv_num_idx')   if @configuration.get('csv_num_idx')
-      @lat_idx   = @configuration.get('csv_lat_idx')   if @configuration.get('csv_lat_idx')
-      @lng_idx   = @configuration.get('csv_lng_idx')   if @configuration.get('csv_lng_idx')
-      @alt_idx   = @configuration.get('csv_alt_idx')   if @configuration.get('csv_alt_idx')
-      @title     = @configuration.get("#{@csv_file}")  
-            
-      @content_hash = Hash.new('')
-      @run   = Gooby::Run.new(1)
-      @track = Gooby::Track.new(1)
-      @run.add_track(@track)
-      @tkpts = Array.new
-      @icon_url_base = @configuration.get('gmap_icon_url_base')
-      
-      list = Array.new
-      list << @csv_file
-      @cvs_reader = Gooby::CsvReader.new(list)
-      @cvs_points = @cvs_reader.read
-      @cvs_points.each { |cvs_point| 
-        tkpt = cvs_point.as_trackpoint
-        if tkpt
-          @track.add_trackpoint(tkpt)
-        end
-      }
-      @run.finish
-    end
-    
-=begin
-Returns a Hash with specific generated content at the following keys:
-=end
-    def generate(configuration)
-      if (configuration == nil)
-        @configuration = Gooby::Configuration.get_config
-      else
-        @configuration = configuration
-      end  
-      @content_hash['when_generated'] = Time.now
-      @content_hash['title'] = @title
-      @icon_url_base = @configuration.get('gmap_icon_url_base')               
-      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 = @configuration.get('gmap_first_tkpt_number')
-      lastTkpt  = @configuration.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(configuration)
-
-      # 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"/>
-    <meta name="description" content="Google Map generated with #{project_embedded_comment}">
-    <meta name="keywords" content="Google Map #{project_embedded_comment} GPS">
-    <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> #{@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
-      puts s   # Redirect output via 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  = @configuration.get('gmap_key')    
-      key.strip!
-      # <script src="http://maps.google.com/maps?file=api&v=2&key=<%= @gmap_key -%>"  type="text/javascript"></script>
-      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  = @configuration.get('gmap_width')
-      height = @configuration.get('gmap_height')
-      id     = @configuration.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       = @configuration.get('gmap_map_element_id')  
-      size     = @configuration.get('gmap_size_control')
-      type     = @configuration.get('gmap_type')
-      zoom     = @configuration.get('gmap_zoom_level')
-      title    = @configuration.get("#{@csv_file}") 
-      title    = '' if title == nil
-      zoom_tab = @configuration.get('gmap_zoom_tab') 
-      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}); // #{project_embedded_comment} \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      = @configuration.get('gmap_approx_max_points').to_f
-      gen_comments = @configuration.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.point
-          
-          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(false, gen_comments, tkpt_count, curr_idx, @start_dttm)
-          next_idx = curr_idx + increment
-        else
-          s << tkpt.as_glatlng(true, gen_comments, tkpt_count, curr_idx, @start_dttm)
-        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 = \"#{@icon_url_base}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 = \"#{@icon_url_base}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 = \"#{@icon_url_base}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.cumulative_distance >= 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 = \"#{@icon_url_base}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, :begin_position, :end_position
-  
-    def initialize(num)
-      @number = num  
-    end
-
-    def to_s
-      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@begin_position.to_s} end: #{@end_position.to_s}"
-    end
-  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
-
-# =============================================================================
-=begin
-
-This is a singleton class whose values are loaded from a YAML file when your
-GoobyCommand class is created.  The default filename is 'gooby_config.yaml"'.
-
-The YAML file contains configuration parameters, such as your Google Map key,
-map HTML options, points of interest, and courses.
- 
-=end
-  class Configuration < GoobyObject
-
-    @@singleton_instance = nil
-
-    attr_reader :yaml_filename, :configuration
-  
-    private_class_method :new
-    
-    def Configuration.init(yaml_filename='gooby_config.yaml')
-      return @@singleton_instance if  @@singleton_instance
-       @@singleton_instance = new(yaml_filename)      
-    end
-    
-    def self.get_config
-      @@singleton_instance
-    end
-    
-    def initialize(yaml_filename) 
-      @yaml_filename = yaml_filename
-      File.open("#{@yaml_filename}") { |fn| @configuration = YAML::load(fn) }
-    end
-
-    def get(name)    
-      if name == nil
-        return ''
-      end
-      s = @configuration["#{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_icon_url_base')             
-          return 'http://www.your-web-site.com/gicons/'          
-        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
-
-    def print_all
-      @configuration.keys.sort.each { |key| puts "#{key}: #{@configuration["#{key}"]}" }
-    end
-
-    def print_all_poi
-      @configuration.keys.sort.each { |key|
-        if (key.match(/poi[\.]/))
-          val = @configuration["#{key}"]
-          poi = Point.new(val)
-          puts poi.to_s
-        end
-      }
-    end
-    
-    def get_poi(number)
-      val = @configuration["poi.#{number}"]
-      (val) ? Point.new(val) : nil
-    end
-    
-    def get_course(number)
-      val = @configuration["course.#{number}"]
-      (val) ? Course.new(val) : nil
-    end
-    
-    def size
-      @configuration.size
-    end
-     
-  # Return a String containing yaml filename and entry count.  
-    def to_s
-      return "# Configuration: filename: #{@yaml_filename} entries: #{@configuration.size}"
-    end
-  end 
-
-# =============================================================================
-    
-  class Point < GoobyObject  
-  
-    attr_accessor :number, :latitude, :longitude, :altitude, :note
-  
-    def initialize(*args)
-      @number, @latitude, @longitude, @altitude, @note = '', '', '', '', ''
-      if args
-        if args.size == 1
-          initialize_from_string(args[0]) # yaml 
-        else
-          initialize_from_array(args)
-        end      
-      end
-    end
-    
-    def csv_delim
-      '|'
-    end
-    
-    def initialize_from_array(args)
-      @latitude  = args[0] if args.size > 0
-      @longitude = args[1] if args.size > 1
-      @altitude  = args[2] if args.size > 2
-      @note      = args[3] if args.size > 3
-    end
-    
-    def initialize_from_string(yaml_value_string) 
-      tokens = yaml_value_string.split
-      if (tokens.size > 2)
-        @latitude    = tokens[0]
-        @longitude   = tokens[1]
-        @note        = ''
-        count        = 0
-        tokens.each { |tok|
-          count = count + 1
-          if (count > 2)
-            @note << tok
-            @note << ' '
-          end
-        } 
-      end
-    end
-      
-    public
-  
-    def to_s
-      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
-    end
-
-    def to_formatted_string
-      s =  "lat: #{@latitude.to_s.ljust(20)}"
-      s << " lng: #{@longitude.to_s.ljust(20)}"
-      s << " poi.#{@number.to_s.ljust(12)}"  if @number
-      s << " #{@note}" if @note
-      s      
-    end
-  
-    def to_csv
-      return "#{@latitude}#{csv_delim}#{@longitude}#{csv_delim}#{@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
-    
-    def degrees_diff(another_point)      
-      if (another_point)
-        puts "this:  #{to_s}" if false
-        puts "other: #{another_point.to_s}"  if false
-        puts "lats:  #{latitude_as_float}  #{another_point.latitude_as_float}"  if false
-        puts "lngs:  #{longitude_as_float}  #{another_point.longitude_as_float}"  if false
-        lat_diff = latitude_as_float  - another_point.latitude_as_float
-        lng_diff = longitude_as_float - another_point.longitude_as_float
-        diff = lat_diff.abs + lng_diff.abs
-        puts "diff: #{diff} #{lat_diff} #{lng_diff}"  if false
-        diff
-      else
-        360
-      end
-    end 
-    
-    def proximity(another_point, units)
-      if (another_point)
-        arg1  = latitude_as_float
-        arg2  = another_point.latitude_as_float
-        arg3  = latitude_as_float
-        arg4  = another_point.latitude_as_float
-        theta = longitude_as_float - another_point.longitude_as_float  
-        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))
-        dist  = ((res1 * res2) + (res3 * res4 * res5)).to_f
-        
-        if (!dist.nan?)
-          dist = Math.acos(dist.to_f)
-          if (!dist.nan?)    
-            dist = rad2deg(dist)
-            if (!dist.nan?)
-              dist = dist * 60 * 1.1515;
-              if (!dist.nan?)
-                if units == "K"
-                   dist = dist * 1.609344;
-                end 
-                if units == "N"
-                   dist = dist * 0.8684;
-                end  
-              end
-            end
-          end
-          return dist.to_f
-        else
-          return 0
-        end
-      else
-        return 0
-      end
-    end  
-  
-    def deg2rad(degrees)
-      (((0 + degrees) * Math::PI) / 180)
-    end
-  
-    def rad2deg(radians)
-      (((0 + radians) * 180) / Math::PI)
-    end
-  end
-
-# =============================================================================
-
-  class CsvPoint < Point
-    
-    attr_reader   :rawdata, :tokens
-    attr_reader   :id, :run_id, :date, :time, :tkpt_num, :distance, :elapsed 
-    attr_reader   :lap_number, :lap_distance, :lap_elapsed
-    attr_accessor :course_distance, :course_elapsed, :degrees_diff
-
-    def initialize(csv_line)
-      @rawdata = "#{csv_line}"
-      @tokens  = @rawdata.split(csv_delim)
-      if (tokens.size > 12)
-        @id           = tokens[0]  # <-- consists of @run_id.@tkpt_num for uniqueness and use as a DB table primary key.
-        @run_id       = tokens[1]
-        @date         = tokens[2]
-        @time         = tokens[3]
-        @tkpt_num     = tokens[4].strip.to_i
-        @latitude     = tokens[5].to_f
-        @longitude    = tokens[6].to_f 
-        @altitude     = tokens[7].strip.to_f 
-        @distance     = tokens[8].strip.to_f 
-        @elapsed      = tokens[9]
-        @lap_number   = tokens[10].strip.to_i 
-        @lap_distance = tokens[11].strip.to_f                                                     
-        @lap_elapsed  = tokens[12]
-      end
-    end
-
-    def as_trackpoint
-      tkpt = Trackpoint.new(@tkpt_num,  @latitude, @longitude, @altitude, "#{date}T#{time}Z")
-      tkpt.lap_number   = @lap_number
-      tkpt.lap_distance = @lap_distance
-      tkpt.lap_elapsed  = @lap_elapsed
-      tkpt
-    end
-    
-    def to_s
-      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
-    end  
-    
-    def to_formatted_string
-      s =  "lat: #{@latitude.to_s.ljust(20)}"
-      s << " lng: #{@longitude.to_s.ljust(20)}"
-      s << " time:            #{@time}"
-      pad = ''.ljust(70)
-      s << "\n#{pad} course elapsed:  #{@course_elapsed}"
-      s << "\n#{pad} distance:        #{@distance}"
-      s << "\n#{pad} course distance: #{@course_distance}"
-      s << "\n#{pad} altitude:        #{@altitude}"
-      s << "\n#{pad} degrees diff:    #{@degrees_diff}"
-      s
-    end
-  end
-
-# =============================================================================
-
-  class CvsRun < GoobyObject
-  
-    attr_reader :id, :points
-    
-    def initialize(id)
-      @id     = "#{id}"
-      @points = Array.new  
-    end
-    
-    def add_point(point)
-      if point
-        @points << point  
-      end  
-    end
-  end
-  
-# =============================================================================
-
-  class CsvReader < GoobyObject
-
-    attr_reader :files, :cvs_points
-    
-    def initialize(array_of_filenames=nil)
-      @files      = Array.new
-      @cvs_points = Array.new
-      if array_of_filenames
-        array_of_filenames.each { |filename| add_file(filename) } 
-      end
-    end
-    
-    def add_file(filename)
-      if (filename)
-        if (File.exist?(filename))
-          @files << filename
-        end
-      end
-    end
-    
-    def read
-      @files.each { |filename|
-        lines = read_lines(filename, true)
-        lines.each { |line|
-          if (line.match('^#'))
-            if (line.match('^#cols: '))
-              col_names_header = line[7, line.size]
-              @col_names = col_names_header.split('|')
-            end
-          else
-            if (line.size > 50)
-               @cvs_points << Gooby::CsvPoint.new(line)
-            end
-          end
-        }
-      }
-      @cvs_points
-    end 
-    
-    def display_formatted_record(record_index=2)
-      tokens = @cvs_points[record_index].rawdata.split('|')
-      puts "\nCsvReader.display_formatted_record  hdr_cols=#{@col_names.size} data_cols=#{tokens.size}"
-      size   = 0
-      @col_names.each { |col_name|
-        size = size + 1
-        if size <= tokens.size
-          value = tokens[size - 1]
-          puts "#{col_name.strip.ljust(20)} #{(size - 1).to_s.ljust(3)} #{value}"
-        end
-      }
-    end
-    
-    def to_s
-      s = "CsvReader - file count: #{files.size}  total points: #{cvs_points.size}"
-      @files.each { |file| s << "\n  file: #{file} "}
-      s
-    end         
-  end
-  
-# =============================================================================
-  
-  class Trackpoint < Point
-    
-    attr_accessor  :first, :last, :number, :run_number, :dttm, :prev_tkpt, :lap_number, :lap_seq, :lap_distance, :lap_elapsed
-    attr_accessor  :cumulative_distance, :cumulative_pace, :incremental_distance, :split, :prev_split
-    attr_accessor  :first, :last, :run_id, :run_number
-    attr_accessor  :run_start_dttm 
-  
-    def initialize(num, lat, lng, alt, time_string, auxInfoHash=Hash.new(''))
-      @number       = num
-      @run_number   = 0
-      @auxInfoHash  = auxInfoHash
-      @lap_seq      = 1
-      @lap_distance = 0
-      lap_num = @auxInfoHash['lap_number']
-      if (lap_num && lap_num.size > 0)
-        @lap_number = lap_num.to_i
-      else
-        @lap_number = 0
-      end
-      # initialize superclass variables:
-      @latitude  = lat.to_s
-      @longitude = lng.to_s
-      feet = alt.to_f * 3.2736  # Convert from meters (in the Garmin xml) to feet.
-      @altitude  = feet.to_s
-      @note      = note.to_s
-      @dttm      = DtTm.new(time_string)
-      @first     = false
-      @last      = false
-      @prev_tkpt  = nil      
-      @cumulative_distance, @incremental_distance, @split = 0.0, 0.0, 0.0
-      @cumulative_pace = ""
-    end
-  
-    public
-
-    def point
-      Point.new(@latitude, @longitude, @altitude, @note)
-    end
-      
-    def position
-      Point.new(@latitude, @longitude, @altitude, @note)
-    end
-    
-    def to_s
-      "Tkpt: #{@number} #{super.to_s} date: #{@dttm.to_s} cdist: #{@cumulative_distance}"
-    end
-  
-    def to_csv(prev_tkpt=nil)    
-      first_lap_start_time_s = @auxInfoHash['first_lap_start_time']
-      curr_lap_start_time_s  = @auxInfoHash['curr_lap_start_time']
-      lap_elapsed   = ''
-      total_elapsed = ''
-      
-      if ((first_lap_start_time_s.size > 0) && (curr_lap_start_time_s.size > 0)) # garmin205 & 305
-        first_lap_start_time = DtTm.new(first_lap_start_time_s)
-        first_lap_start_time = @run_start_dttm
-        curr_lap_start_time  = DtTm.new(curr_lap_start_time_s)
-        lap_elapsed   = @dttm.hhmmss_diff(curr_lap_start_time) 
-        total_elapsed = @dttm.hhmmss_diff(first_lap_start_time)
-      else # garmin 201
-        total_elapsed = @dttm.hhmmss_diff(@run_start_dttm)
-        lap_elapsed   = total_elapsed
-      end
-
-      delim = csv_delim
-      csv =  "#{@run_id}.#{@number}" # <-- primary key
-      csv << "#{delim}#{@run_id}"      
-      csv << "#{delim}#{@dttm.yyyy_mm_dd_hh_mm_ss('|')}"
-      csv << "#{delim}#{@number}"
-      csv << "#{delim}#{position.to_csv}"
-      csv << "#{delim}#{@cumulative_distance}"
-      csv << "#{delim}#{total_elapsed}"
-      csv << "#{delim}#{@lap_seq}"
-      csv << "#{delim}#{@lap_distance}"
-      csv << "#{delim}#{lap_elapsed}"
-      csv
-    end
-    
-    def self.csv_header
-      "#cols: primary_key|run_id|date|time|tkpt_num|latitude|longitude|altitude_ft|run_distance|run_elapsed|lap_tkpt_number|lap_distance|lap_elapsed"
-    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
-      @cumulative_distance = prev_cumulative_dist.to_f
-      @run_start_dttm = start_dttm
-        
-      if @prev_tkpt
-        @incremental_distance = proximity(@prev_tkpt, units)         
-        if (!@incremental_distance.nan?)
-          @cumulative_distance =  @cumulative_distance + @incremental_distance.to_f
-          if (@lap_number == prev_trackpoint.lap_number)
-            @lap_seq      = prev_trackpoint.lap_seq + 1                  
-            @lap_distance = prev_trackpoint.lap_distance + @incremental_distance
-          else
-            @lap_seq = 1
-            @lap_distance = @incremental_distance
-          end
-        end
-        compute_cumulative_pace(start_dttm)
-        @cumulative_distance
-      else
-        @lap_seq = 1
-        0  
-      end    
-    end
-  
-    def compute_cumulative_pace(start_dttm)      
-      if @cumulative_distance > 0
-        secsDiff  = @dttm.seconds_diff(start_dttm)
-        secsMile  = ((secsDiff.to_f) / (@cumulative_distance.to_f))
-        minsMile  = (secsMile / 60)
-        wholeMins = minsMile.floor 
-        secsBal   = secsMile - (wholeMins * 60)
-        s1 = "#{secsDiff} #{secsMile} #{minsMile} #{wholeMins} #{secsBal} #{@cumulative_distance} | "
-        s2 = sprintf("%d:%2.1f", minsMile, secsBal)
-        @cumulative_pace = "#{s2}"
-      else 
-        @cumulative_pace = ""
-      end
-    end
-  
-    def set_split(n, tkpt)
-      @split, @prev_split = n, tkpt
-    end
-  
-    def is_split()
-     (@split >= 1)
-    end
-  
-    def split_info(dtTm) 
-      if is_split
-        hhmmss = ''
-        if @prev_split
-          return "#{@split} #{@dttm.hhmmss_diff(@prev_split.dttm())}"
-        else
-          return "#{@split} #{@dttm.hhmmss_diff(dtTm)}"
-        end
-      else
-          ""
-      end
-    end
-
-    public 
-    
-    def as_glatlng(comment_out, gen_comments, tkpt_count, curr_idx, start_dttm)
-      comment_out ? comment = '// ' : comment = ''
-      if gen_comments
-        secs_diff = @dttm.seconds_diff(start_dttm)
-        fmt_time  = @dttm.hhmmss_diff(start_dttm)
-          "\n            #{comment}points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); " +
-            "// (#{curr_idx + 1} of #{tkpt_count}) #{@dttm.to_s} #{secs_diff} #{fmt_time} #{@cumulative_distance} #{split_info(start_dttm)} #{project_embedded_comment} "
-      else
-          "\n            #{comment}points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); // #{project_embedded_comment} "  
-      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>#{@cumulative_distance}</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>#{@cumulative_pace} </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
-  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, :run_id, :descr, :notes, :tracks, :tkpts, :laps, :distance
-  
-    def initialize(number=0, descr='')
-      @number = number
-      @run_id = nil      
-      @descr  = descr
-      @notes  = ''         
-      @tracks = Array.new
-      @tkpts  = Array.new
-      @laps   = Array.new 
-      @distance = 0
-      @configuration = 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.run_number = @number
-             @tkpts.push(tkpt)             
-           }
-         }      
-         compute_distance_and_pace
-         compute_splits
-         set_run_ids
-         @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 lap_count()
-      @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 "00:00:00" 
-    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: #{lap_count} "
-      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()}|#{lap_count}|#{@notes.strip}" 
-    end
-  
-    def put_tkpt_csv()
-      finish() unless @finished    
-      @tkpts.each { | tkpt | 
-        if (@prev_tkpt == nil)
-          @prev_tkpt = tkpt
-        end
-        puts tkpt.to_csv(@prev_tkpt) 
-      }
-    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
-      prev_splitTkpt = nil
-      loop1Count = 0;
-      @tkpts.each { |tkpt|
-        loop1Count = loop1Count + 1
-        if tkpt.cumulative_distance() >= nextSplitDist
-          tkpt.set_split(0 + nextSplitDist, prev_splitTkpt)
-          nextSplitDist = nextSplitDist + 1.00
-          prev_splitTkpt = 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
-    
-    def set_run_ids
-      @tkpts.each { |tkpt|
-        if (@run_id == nil)
-          @run_id = tkpt.dttm.rawdata
-        end
-        tkpt.run_id = @run_id
-      }
-    end
-  end
-
-# =============================================================================
-
-=begin rdoc
-  Sample implementation of a REXML::StreamListener SAX parser.
-  This class isn't actually used in Gooby, but is retained for future use.
-=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
-  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 to_s
-      return "Trk: #{@descr} tkpts: #{size}"
-    end
-    
-    def dump
-      puts "Track: '#{@descr}'  tkpts: #{size}"
-      @trackpoints.each { |tkpt| puts tkpt.to_csv } 
-    end
-  end 
-  
-  # =============================================================================
-
-    class Course < GoobyObject  
-
-      attr_accessor :name, :distance, :point_numbers, :points
-
-      def initialize(yaml_csv)
-        @name, @distance = '', 0.0
-        @point_numbers, @points, @bad_points = Array.new, Array.new, Array.new
-        @points_hash, @matched_points = Hash.new, Hash.new
-        tokens    = yaml_csv.split(',')
-        @name     = tokens[0]      if tokens.size > 0
-        @distance = tokens[1].to_f if tokens.size > 1 
-        if tokens.size > 2
-          index = 0
-          tokens.each { |tok|
-            index = index + 1
-            if (index > 2)
-              poi = Configuration.get_config.get_poi(tok)
-              if (poi)
-                poi.number     =  "#{tok}"
-                @point_numbers << "#{tok}"
-                @points        << poi
-                @points_hash["#{tok}"] = poi
-              else
-                @bad_points << tok
-              end
-            end
-          }
-        end 
-      end
-      
-      def has_errors
-        (@bad_points.size > 0) ? true : false
-      end
-      
-      def matched(number, point)
-        @matched_points["#{number}"] = point if point
-      end
-      
-      def matched?
-        (@matched_points.size == @point_numbers.size) ? true : false
-      end
-      
-      def display_matches
-        puts ''
-        calculate_matches
-        @point_numbers.each { |num|
-          point  = @points_hash["#{num}"]
-          mpoint = @matched_points["#{num}"]
-          puts ''
-          puts "  Course Point:    #{point.to_formatted_string}"   if point
-          puts "    Matched Point: #{mpoint.to_formatted_string}"  if mpoint
-        }
-        puts ''
-      end
-
-      def reset
-        @matched_points = Hash.new
-      end
-      
-      def to_s
-        "#{@name} #{@distance}  points: #{@points.size} errors: #{has_errors}" 
-      end 
-      
-      def dump
-        puts "Course:   #{@name}"
-        puts "Distance: #{@distance}"
-        points.each { |pt| puts pt } #{@points.size} errors: #{has_errors}" 
-      end 
-      
-      private
-      
-      def calculate_matches        
-        # first, identify the high and low distance points and their indices.
-        idx, low_dist, low_dist_idx, low_time, high_dist, high_dist_idx = -1, 999999.0, 0, '', -1.0, 0
-        @point_numbers.each { |num|
-          idx = idx + 1
-          mpoint = @matched_points["#{num}"]
-          if mpoint && mpoint.distance < low_dist
-            low_dist     = mpoint.distance
-            low_dist_idx = idx
-            low_time     = mpoint.elapsed
-          end
-          if mpoint && mpoint.distance > high_dist
-            high_dist     = mpoint.distance
-            high_dist_idx = idx
-          end          
-        }   
-        low_dttm = DtTm.new("2007-06-09T#{low_time}Z")
-        
-        # reorder the entries in @point_numbers if necessary - 'low-to-high distance'.
-        if (high_dist_idx < low_dist_idx)
-          @point_numbers.reverse!
-        end
-                
-        @point_numbers.each { |num|
-          mpoint = @matched_points["#{num}"]
-          if mpoint
-            mpoint.course_distance = mpoint.distance - low_dist
-            dttm = DtTm.new("2007-06-09T#{mpoint.elapsed}Z")
-            mpoint.course_elapsed  = dttm.hhmmss_diff(low_dttm) 
-          end
-        }        
-      end           
-    end
-            
-# =============================================================================
-
-=begin rdoc
-  This class reads and scans the Gooby code for various purposes.  
-  
-  Primarily, it is used to regenerate, on an ongoing basis, the various 
-  regression tests in file 'ts_gooby.rb'.  Regeneration retains the current 
-  test methods, adds stubs for new test methods, and flags obsolete methods. 
-  
-  It is also used to create a Gooby class, module, and method "quick reference"
-  - somewhat similar to the TextMate symbol list.  
-  
-  TODO: Method indexing and where used" functionality.
-=end
-    
-  class CodeScanner < GoobyObject 
-         
-    def initialize(argv)
-
-      function = 'outline'
-      if (argv.size > 0)
-        function = argv[0]
-      end
-            
-      @codebase_file = 'gooby.rb'
-      @testbase_file = 'ts_gooby.rb'
-      @code_lines    = read_lines("lib/#{@codebase_file}") 
-      @test_lines    = read_lines("tests/#{@testbase_file}") 
-      
-      puts "code lines = #{@code_lines.size}" 
-      puts "test lines = #{@test_lines.size}"
-
-      @tokens_hash       = CounterHash.new      
-      @module_names_hash = CounterHash.new 
-      @class_names_hash  = CounterHash.new
-      @method_names_hash = CounterHash.new
-      @mc_line_num_array = Array.new
-      @type_names        = Hash.new      
-      @code_hash         = Hash.new
-      @test_hash         = Hash.new
-      @api_hash          = Hash.new
-      @merged_hash       = Hash.new
-      @exclude_classes   = Array.new 
-                        
-      regenerate_test_suite  if (function == 'regenerate_test_suite')
-      regenerate_test_suite  if (function == 'tests') 
-
-      model_class_outline    if (function == 'model_class_outline')  
-      model_class_outline    if (function == 'outline')  
-               
-      quick_reference_guide  if (function == 'quick_reference_guide')      
-      quick_reference_guide  if (function == 'qrg')   
-      
-      mcm_references         if (function == 'mcm_references')  
-      mcm_references         if (function == 'mcm') 
-    end 
-
-    private
-    
-    def regenerate_test_suite
-      @exclude_classes = %w( TestHelper CodeScanner )    
-      parse_code_lines
-      parse_test_lines    
-      merge_keys
-      regenerate(@testbase_file)
-    end
-    
-    def model_class_outline
-      parse_code_lines     
-      @mc_line_num_array.each { |line|
-        tokens = tokenize(line)
-        type  = tokens[0].ljust(6)
-        name  = tokens[1]
-        count = tokens[2].rjust(6)
-        puts "  #{count}  #{type}  #{name}"   
-      }
-    end
-      
-    def quick_reference_guide
-      parse_code_lines
-      determine_longest_names
-      quick_reference_guide_report('module')
-      quick_reference_guide_report('class')
-    end
-  
-    def quick_reference_guide_report(obj_type)
-      @api_hash.keys.sort.each { |key| 
-        val = @api_hash[key]
-        tokens = tokenize(key, '|')
-        if (tokens[0] == obj_type)
-          s1 = tokens[0].ljust(6)
-          s2 = tokens[1].ljust(@longest_classname + 1)
-          s3 = tokens[2]
-          # s = sprintf("%6s '%30s %s'", tokens[0], tokens[1], tokens[2])
-          puts "#{s1} #{s2} #{s3}"
-        end
-      }
-    end
-    
-    def determine_longest_names
-      @longest_classname = 0
-      @api_hash.keys.sort.each { |key| 
-        tokens = tokenize(@api_hash[key], '|')
-        @longest_classname = tokens[1].size  if tokens[1].size > @longest_classname
-      }     
-    end
-        
-    def mcm_references
-      parse_code_lines
-      determine_longest_names      
-      @module_names_hash.sorted_keys.each { |name|
-        count = @tokens_hash.value(name)
-        puts "module: #{name}   (#{count})" 
-      }
-      @class_names_hash.sorted_keys.each { |name|
-        count = @tokens_hash.value(name)
-        puts "class:  #{name}   (#{count})" 
-      }
-      @method_names_hash.sorted_keys.each { |name|
-        count = @tokens_hash.value(name)
-        puts "method: #{name}   (#{count})" 
-      }  
-    end
-  
-    def parse_code_lines
-      type      = ''
-      type_name = ''
-      meth_name = '' 
-      line_number = 0   
-      @code_lines.each { | line | 
-        line_number = line_number + 1
-        line.strip!
-        if (line.match(/^module /))
-          type      = 'module'
-          tokens    = line.split
-          type_name = tokens[1]  
-          @module_names_hash.increment(type_name)  
-          @mc_line_num_array << "module #{type_name} #{line_number}"       
-        elsif (line.match(/^class /))
-          type      = 'class'
-          tokens    = line.split
-          type_name = tokens[1]   
-          @class_names_hash.increment(type_name)   
-          @mc_line_num_array << "class #{type_name} #{line_number}"                            
-        elsif (line.match(/^def /))
-          signature = line[4...999]
-          short_method = parse_meth_name("#{signature}")
-          @code_hash["test_#{type}_#{type_name}"] = "#{type_name}"          
-          @code_hash["test_#{type}_#{type_name}_#{short_method}"] = "#{type_name}|#{signature}"  
-          @api_hash["#{type}|#{type_name}|#{signature}" ] = "#{type}|#{type_name}|#{signature}" 
-          @method_names_hash.increment(short_method)                                 
-        end 
-        increment_tokens(line)       
-      }          
-    end 
-    
-    def increment_tokens(line)
-      # see http://www.asciitable.com/
-      s = ''
-      line.each_byte { |b|
-        keep = false
-        keep = true if ((b >= 65) && (b <= 90))  # A-Z
-        keep = true if ((b >= 97) && (b <= 122)) # a-z
-        keep = true if ((b >= 48) && (b <= 57))  # 0-9
-        keep = true if (b == 95) # _
-        keep = true if (b == 64) # @
-        keep = true if (b == 63) # ?
-        keep = true if (b == 33) # !        
-        if keep
-          s << b.chr
-        else
-          s << ' '
-        end        
-      } 
-      @tokens_hash.increment_tokens(s)        
-    end
-
-    def parse_meth_name(string)
-      string.gsub!('(', ' ')
-      string.gsub!(')', ' ')    
-      tokens = string.split
-      tokens[0]
-    end
-  
-    def parse_test_lines
-      in_zone      = true
-      method_name  = 'a_start'
-      method_lines = Array.new
-      line_num = 0
-    
-      @test_lines.each { | line | 
-        line_num = line_num + 1  
-        line.chomp!
-        prefix   = line[0...5]   # '  def' or '   end' 
-        prefix42 = line [0..42]        
-            
-        if ((prefix == '  def') || (prefix == "\tdef"))
-          in_zone      = true 
-          tokens       = line.split
-          method_name  = tokens[1] 
-          method_lines = Array.new   
-        end
-                
-        if in_zone
-          method_lines << "#{line}"
-        end
-        if (prefix42 == '  # beginning of tests - keep this marker')
-          in_zone = false
-          @test_hash["aaa"] = method_lines                
-        end
-        if ((prefix == '  end') || (prefix == "\tend"))       
-          in_zone = false 
-          @test_hash["#{method_name}"] = method_lines            
-        end       
-      }      
-    end 
-  
-    def merge_keys
-      @merged_hash = Hash.new
-      @code_hash.keys.sort.each { |key| @merged_hash["#{key}"] = "code" }
-      @test_hash.keys.sort.each { |key| @merged_hash["#{key}"] = "test" }       
-    end
-  
-    def regenerate(test_file)
-      code = ''
-      @merged_hash.keys.sort.each { |key|
-        tokens = key.split('_')
-        type, name, meth = tokens[1], tokens[2], tokens[3]  
-        
-        processThisKey = true      
-        @exclude_classes.each { |xc| 
-          if xc == name 
-            processThisKey = false
-          end
-        }
-      
-        next if !processThisKey
-            
-        if @test_hash.has_key?(key)
-          # We already have a test method written in the test class, 
-          # so keep this currently existing test code!
-
-          if @code_hash.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 = @test_hash["#{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
-  This class provides "user friendly DSL" functionality for the use
-  of Gooby.  See 'bin/example_usage.rb' for examples using this class.
-=end
-  
-  class GoobyCommand < GoobyObject 
-    
-    attr_reader :configuration
-    
-    def initialize(gooby_yaml_filename=nil)
-      @configuration = Gooby::Configuration.init(gooby_yaml_filename)
-    end
-    
-    def display_version
-      s = "# #{project_name} #{project_version_number} #{project_date}.  #{project_copyright}."
-      puts s
-    end
-
-    def split_garmin_export_file(argv)
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 3)
-        puts ""
-        puts "Invalid program args; three args required - format, input filename, output directory"
-        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
-        puts "  the second arg is the input filename - which is a garmin export file"
-        puts "  the third arg is the output directory where the split files are written to\n\n"
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        format   = argv[0].downcase
-        filename = argv[1]
-        out_dir  = argv[2]
-        
-        if (format == 'garmin201')
-          split_garmin_forerunner_logbook_xml(filename, out_dir)
-        else
-          split_garmin_training_center_xml(filename, out_dir) 
-        end
-      end
-    end
-    
-    def split_garmin_forerunner_logbook_xml(xml_filename, out_dir)  
-      splitter = Gooby::ForerunnerXmlSplitter.new(xml_filename, out_dir)  
-      splitter.split
-    end
-    
-    def split_garmin_training_center_xml(tcx_filename, out_dir)  
-      splitter = Gooby::TrainingCenterXmlSplitter.new(tcx_filename, out_dir)  
-      splitter.split
-    end
-    
-    def parse_garmin_xml_file(argv)
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 2)
-        puts ""
-        puts "Invalid program args; two args required - format, input (xml) filename, output directory"
-        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
-        puts "  the second arg, input xml filename, was produced by the Gooby 'splitter.rb' program."
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        format   = argv[0].downcase
-        filename = argv[1]
-        puts Trackpoint.csv_header        
-        if (format == 'garmin201')
-          parse_garmin_forerunner_logbook_xml(filename)
-        else
-          parse_garmin_training_center_xml(filename) 
-        end
-      end
-    end    
-        
-    def parse_garmin_forerunner_logbook_xml(xml_filename)  
-      handler = Gooby::ForerunnerXmlParser.new     
-      Document.parse_stream((File.new xml_filename), handler)
-      handler.put_all_run_tkpt_csv()
-    end
-    
-    def parse_garmin_training_center_xml(tcx_filename)  
-      handler = Gooby::TrainingCenterXmlParser.new     
-      Document.parse_stream((File.new tcx_filename), handler)
-      handler.put_all_run_tkpt_csv()
-    end
-
-    def read_csv_files(array_of_filenames, record_index=0)
-      @cvs_reader = Gooby::CsvReader.new(array_of_filenames)
-      @cvs_points = @cvs_reader.read
-      puts @cvs_reader.to_s
-      if (record_index > 0)
-        @cvs_reader.display_formatted_record(record_index) 
-      end
-      @cvs_points
-    end
-    
-    def been_there(course_id, proximity=0.0070, uom='deg')
-      unless @cvs_points
-        puts "You must first invoke method 'read_csv_files' with a list of parsed CSV filenames."
-        return
-      end
-      course = configuration.get_course("#{course_id}")
-      unless course
-        puts "Unable to find course id '#{course_id}' in the gooby config yaml file."
-        return
-      end
-      puts ''
-      # collect the cvs_points into run arrays
-      @curr_run_id = 'x'      
-      @cvs_runs = Array.new  
-      @cvs_points.each { |cvs_point|      
-        if (cvs_point.run_id == @curr_run_id)
-          @curr_run.add_point(cvs_point)  
-        else
-          @curr_run_id = cvs_point.run_id
-          @curr_run = Gooby::CvsRun.new(@curr_run_id)
-          @curr_run.add_point(cvs_point)
-          @cvs_runs << @curr_run
-        end
-      }
-      
-      # iterate the runs - looking for a match vs the course
-      @cvs_runs.each { |cvs_run|
-        puts "Scanning run id '#{cvs_run.id}', point count= #{cvs_run.points.size}" if false
-        run_points = cvs_run.points
-        course.reset
-        course.points.each { |course_point|
-          closest_diff  = 999
-          closest_point = nil
-          run_points.each { |run_point|
-            diff  = course_point.degrees_diff(run_point) 
-            if ((diff < proximity) && (diff < closest_diff))
-                closest_diff  = diff
-                closest_point = run_point
-                closest_point.degrees_diff = diff
-                course.matched(course_point.number, run_point)
-            end            
-          }
-        }
-        if course.matched?
-          puts "Course '#{course.name}' matched vs run id '#{cvs_run.id}'" 
-          course.display_matches
-        else
-          puts "course not matched" if false
-        end
-      }
-    end
-    
-    def generate_google_map(argv)  
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 1)
-        puts ""
-        puts "Invalid program args; one required - input csv filename"
-        puts "  the first arg, csv filename, was produced by the Gooby 'parser.rb' program."
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        csv_filename  = argv[0]
-        configuration = Gooby::Configuration.get_config
-        generator = Gooby::GoogleMapGenerator.new(csv_filename)  
-        generator.generate_page(configuration)
-      end
-      
-    end
-  end
-end # end of module
+require 'gooby_kernel'
+require 'gooby_test_helper'
+require 'gooby_object'
+require 'gooby_counter_hash'
+require 'gooby_delim_line'
+require 'gooby_dttm'
+require 'gooby_duration'
+require 'gooby_forerunner_xml_parser'
+require 'gooby_forerunner_xml_splitter'
+require 'gooby_training_center_xml_parser'
+require 'gooby_training_center_xml_splitter'
+require 'gooby_google_map_generator'
+require 'gooby_history'
+require 'gooby_lap'
+require 'gooby_line'
+require 'gooby_configuration'
+require 'gooby_point'
+require 'gooby_csv_point'
+require 'gooby_csv_run'
+require 'gooby_csv_reader'
+require 'gooby_track_point'
+require 'gooby_run'
+require 'gooby_simple_xml_parser'
+require 'gooby_track'
+require 'gooby_course'
+require 'gooby_code_scanner'
+require 'gooby_command'