gooby 1.0.0 → 1.1.0

data/lib/gooby.rb

@@ -6,36 +6,41 @@ 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
-----  ------  ---------------------------
-  51  module  Gooby
-  58  module  GoobyKernel
- 185  module  TestHelper
- 203  class   GoobyObject
- 216  class   CounterHash
- 299  class   DelimLine
- 334  class   DtTm
- 411  class   Duration
- 490  class   ForerunnerXmlParser
- 661  class   ForerunnerXmlSplitter
- 771  class   TrainingCenterXmlParser
- 948  class   TrainingCenterXmlSplitter
-1053  class   GeoData
-1236  class   GoogleMapGenerator
-1605  class   History
-1636  class   Lap
-1651  class   Line
-1721  class   Options
-1796  class   Position
-1840  class   Run
-2029  class   SimpleXmlParser
-2069  class   Track
-2116  class   Trackpoint
-2305  class   CodeScanner
-2597  class   GoobyCommand
+    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.
+
 =end
 
 require 'date'
@@ -43,6 +48,7 @@ require 'find'
 require 'rbconfig'
 require 'rexml/document'
 require 'rexml/streamlistener'
+require 'singleton'
 require 'time'
 require 'yaml'
 
@@ -57,19 +63,19 @@ module Gooby
   
   module GoobyKernel
 
-  # Return a String version number, like '1.0.0'.
+  # Return a String version number, like '1.1.0'.
   
     def project_name
       'Gooby'
     end
     
     def project_version_number   
-      '1.0.0'
+      '1.1.0'
     end
 
   # Return a String date, like '2007/03/21'.  
     def project_date       
-      '2007/03/21'
+      '2007/06/10'
     end
 
     # Return a String containing the project author name.
@@ -372,10 +378,10 @@ module Gooby
       @time.strftime("%Y-%m-%d")
     end
   
-    def yyyy_mm_dd_hh_mm_ss
-      @time.strftime("%Y-%m-%d %H:%M:%S")
+    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
@@ -386,7 +392,7 @@ module Gooby
         t = @time - (anotherDtTm.to_i)
         t.strftime("%H:%M:%S")
       else
-        '??:??:??'  
+        '00:00:00'  
       end
     end
   
@@ -527,6 +533,7 @@ module Gooby
         @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'] = ''
@@ -542,7 +549,6 @@ module Gooby
       if is_tag?('Track', tagname)
         @track_count = @track_count + 1      
         @curr_track  = Track.new(@track_count)
-        @trackpoint_count = 0   
         return   
       end
     end
@@ -555,20 +561,20 @@ module Gooby
         if is_tag?('Position', tagname)
           lat  = @cv_hash['Latitude']
           long = @cv_hash['Longitude']
-          @curr_begin_position = Position.new(lat.strip, long.strip, '')
-          @@curr_end_position   = Position.new(lat.strip, long.strip, '')       
+          @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 = Position.new(lat.strip, long.strip, '')      
+          @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 = Position.new(lat.strip, long.strip, '')      
+          @@curr_end_position = Point.new(lat.strip, long.strip)      
         end
               
         if is_tag?('Trackpoint', tagname)
@@ -576,7 +582,7 @@ module Gooby
           lat  = @cv_hash['Latitude']
           long = @cv_hash['Longitude']
           alt  = @cv_hash['Altitude']   
-          time = @cv_hash['Time']                
+          time = @cv_hash['Time']            
           tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
           @curr_track.add_trackpoint(tp)
         end
@@ -629,10 +635,8 @@ module Gooby
     end
 
   # Iterate all parsed Run objects and print each with put_tkpt_csv.
-    def put_all_run_tkpt_csv(with_header_comment) 
-      @history.runs.each { |run| 
-        run.put_tkpt_csv(with_header_comment)
-      } 
+    def put_all_run_tkpt_csv() 
+      @history.runs.each { |run| run.put_tkpt_csv() } 
     end
 
     private 
@@ -760,7 +764,7 @@ module Gooby
 # =============================================================================
 
 =begin rdoc
-  Instances of this class are used to parse a Garmin TrainingCenter XML file
+  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.  
 
@@ -779,19 +783,21 @@ module Gooby
     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
+      @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
@@ -810,6 +816,7 @@ module Gooby
         @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'] = ''
@@ -817,16 +824,26 @@ module Gooby
       end
     
       if is_tag?('Lap', tagname)
-        @lap_count = @lap_count + 1
+        @lap_count =  @lap_count + 1
         @curr_lap  = Lap.new(@lap_count)
-        # TODO - capture value of 'StartTime' attribute.       
+        
+        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)
-        @trackpoint_count = 0   
         return   
       end
     
@@ -840,20 +857,20 @@ module Gooby
         if is_tag?('Position', tagname)
           lat  = @cv_hash['LatitudeDegrees']
           long = @cv_hash['LongitudeDegrees']
-          @curr_begin_position = Position.new(lat.strip, long.strip, '')
-          @@curr_end_position   = Position.new(lat.strip, long.strip, '')       
+          @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 = Position.new(lat.strip, long.strip, '')      
+          @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 = Position.new(lat.strip, long.strip, '')      
+          @@curr_end_position = Point.new(lat.strip, long.strip)      
         end
               
         if is_tag?('Trackpoint', tagname)
@@ -861,8 +878,14 @@ module Gooby
           lat  = @cv_hash['LatitudeDegrees']
           long = @cv_hash['LongitudeDegrees']
           alt  = @cv_hash['AltitudeMeters']   
-          time = @cv_hash['Time']                
-          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
+          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
       
@@ -872,14 +895,7 @@ module Gooby
           end
         end
       
-        if is_tag?('Lap', tagname)
-          # TotalTimeSeconds DistanceMeters
-          # TODO - rework tnd of Lap for tcx
-          # @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        
+        if is_tag?('Lap', tagname)      
           @curr_run.add_lap(@curr_lap)
         end
       
@@ -916,10 +932,8 @@ module Gooby
     end
 
   # Iterate all parsed Run objects and print each with put_tkpt_csv.
-    def put_all_run_tkpt_csv(with_header_comment) 
-      @history.runs.each { |run| 
-        run.put_tkpt_csv(with_header_comment)
-      } 
+    def put_all_run_tkpt_csv() 
+      @history.runs.each { |run| run.put_tkpt_csv() } 
     end
 
     private 
@@ -1243,7 +1257,10 @@ module Gooby
     # 1 | 2006-01-15T18:31:10Z | 1279 | 33.42601 | -111.92927 | 347.654 | 26.3514930151813
     # 1 | 2004-11-13T13:05:20Z | 2 | 37.54318 | -77.43636 | -58.022 | 0.00297286231747969 
     
-    def initialize(csv_file, dttm_idx=1, num_idx=2, lat_idx=3, lng_idx=4, alt_idx=5, cdist_idx=6)
+    # 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
@@ -1251,30 +1268,31 @@ module Gooby
       @lng_idx   = lng_idx
       @alt_idx   = alt_idx
       @cdist_idx = cdist_idx
-      
-      # Override default csv value indices if specified in the options yaml file.
-      @options   =  Gooby::Options.new(nil)
-      @dttm_idx  = @options.get('csv_dttm_idx')  if @options.get('csv_dttm_idx')
-      @num_idx   = @options.get('csv_num_idx')   if @options.get('csv_num_idx')
-      @lat_idx   = @options.get('csv_lat_idx')   if @options.get('csv_lat_idx')
-      @lng_idx   = @options.get('csv_lng_idx')   if @options.get('csv_lng_idx')
-      @alt_idx   = @options.get('csv_alt_idx')   if @options.get('csv_alt_idx')
-      @title     = @options.get("#{@csv_file}")  
+            
+      # 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 = @options.get('gmap_icon_url_base')
-      @csv_lines = read_as_ascii_lines(@csv_file, 10, true) 
-      @csv_lines.each { | line |
-        dline = Gooby::DelimLine.new(line)
-        if (!dline.is_comment?)
-          tkpt = dline.as_trackpoint(@num_idx, @lat_idx, @lng_idx, @alt_idx, @dttm_idx)
-          if tkpt
-            @track.add_trackpoint(tkpt)
-          end
+      @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
@@ -1283,15 +1301,15 @@ module Gooby
 =begin
 Returns a Hash with specific generated content at the following keys:
 =end
-    def generate(options)
-      if (options == nil)
-        @options =  Gooby::Options.new(nil)
+    def generate(configuration)
+      if (configuration == nil)
+        @configuration = Gooby::Configuration.get_config
       else
-        @options = options
+        @configuration = configuration
       end  
       @content_hash['when_generated'] = Time.now
       @content_hash['title'] = @title
-      @icon_url_base = @options.get('gmap_icon_url_base')               
+      @icon_url_base = @configuration.get('gmap_icon_url_base')               
       filter_trackpoints  
       compute_center_point
       generate_key_js
@@ -1307,8 +1325,8 @@ Returns a Hash with specific generated content at the following keys:
 
     def filter_trackpoints        
       count, @tkpts = 0, Array.new
-      firstTkpt = @options.get('gmap_first_tkpt_number')
-      lastTkpt  = @options.get('gmap_last_tkpt_number')
+      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
@@ -1322,7 +1340,7 @@ Returns a Hash with specific generated content at the following keys:
 =begin
 Returns a Hash with specific generated content at the following keys:
 =end 
-    def generate_page(options)
+    def generate_page(configuration)
 
       # puts "generate_page #{@csv_file} #{@csv_lines.size}"
       content_hash = generate(nil)
@@ -1381,18 +1399,19 @@ HERE
     end
           
     def generate_key_js              
-      key  = @options.get('gmap_key')    
+      key  = @configuration.get('gmap_key')    
       key.strip!
-      s    = '<script src="http://maps.google.com/maps?file=api&v=2&key=' 
+      # <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>'
+      s << "' type='text/javascript'></script>"
       @content_hash['key_js'] = s
     end
     
     def generate_map_div
-      width  = @options.get('gmap_width')
-      height = @options.get('gmap_height')
-      id     = @options.get('gmap_map_element_id')      
+      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: '
@@ -1411,13 +1430,13 @@ HERE
     end
     
     def generate_main_js_start
-      id       = @options.get('gmap_map_element_id')  
-      size     = @options.get('gmap_size_control')
-      type     = @options.get('gmap_type')
-      zoom     = @options.get('gmap_zoom_level')
-      title    = @options.get("#{@csv_file}") 
+      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 = @options.get('gmap_zoom_tab') 
+      zoom_tab = @configuration.get('gmap_zoom_tab') 
       if size
         if size == 'smallmap'
           size = 'GSmallMapControl'
@@ -1474,8 +1493,8 @@ HERE
     
     def generate_main_js_route_overlay
       tkpt_count   = @tkpts.size.to_f
-      app_max      = @options.get('gmap_approx_max_points').to_f
-      gen_comments = @options.get('gmap_gen_comments')   
+      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
@@ -1489,7 +1508,8 @@ HERE
         curr_idx = curr_idx + 1
         if curr_idx == 0
           @start_dttm = tkpt.dttm
-          @start_pos  = tkpt.position
+          @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()))
@@ -1717,28 +1737,42 @@ HERE
   end
 
 # =============================================================================
+=begin
 
-  class Options < GoobyObject
-  
-    attr_reader :yaml_filename, :options
+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
   
-    def initialize(filename)  # Constructor.
-      filename ? @yaml_filename = filename : @yaml_filename = 'gooby_options.yaml'     
-      loadFile()
+    private_class_method :new
+    
+    def Configuration.init(yaml_filename='gooby_config.yaml')
+      return @@singleton_instance if  @@singleton_instance
+       @@singleton_instance = new(yaml_filename)      
     end
- 
-  # Load the @yaml_filename  
-    def loadFile   
-      File.open("#{@yaml_filename}") { |fn| 
-        @options = YAML::load(fn)    
-      }
+    
+    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 = @options["#{name}"]
+      s = @configuration["#{name}"]
     
       # Provide "sensible defaults".
       if s == nil
@@ -1774,44 +1808,102 @@ HERE
       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
-      @options.size
+      @configuration.size
     end
      
   # Return a String containing yaml filename and entry count.  
     def to_s
-      return "Options: filename: #{@yaml_filename} entries: #{@options.size}"
+      return "# Configuration: filename: #{@yaml_filename} entries: #{@configuration.size}"
     end
   end 
 
 # =============================================================================
-
-=begin rdoc
-  Instances of this class represent a <Position> aggregate object from a
-  Forerunner XML file.  Each contains a latitude and longitude.
-  Instances within a Trackpoint will also contain an altitude.
-=end
     
-  class Position < GoobyObject  
+  class Point < GoobyObject  
   
-    attr_accessor :latitude, :longitude, :altitude, :note
+    attr_accessor :number, :latitude, :longitude, :altitude, :note
   
-    def initialize(lat, lng, alt='0', note='')
-      @latitude  = lat.to_s
-      @longitude = lng.to_s
-      @altitude  = alt.to_s
-      @note      = note.to_s
+    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} | #{@longitude} | #{@altitude}"
+      return "#{@latitude}#{csv_delim}#{@longitude}#{csv_delim}#{@altitude}"
     end
     
     def latitude_as_float
@@ -1825,7 +1917,394 @@ HERE
     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  
 
 # =============================================================================
 
@@ -1839,19 +2318,20 @@ HERE
 
   class Run < GoobyObject 
   
-    attr_accessor :number, :descr, :notes, :tracks, :tkpts, :laps, :distance
+    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
-      @options  = Hash.new
+      @configuration = Hash.new
       @logProgress = true
-      @finished = false
+      @finished    = false
     end
 
     public
@@ -1860,7 +2340,7 @@ HERE
     def finish()
        @logProgress = false
        unless @finished
-         @tracks.each { |trk|  
+         @tracks.each { |trk| 
            trk.trackpoints().each { |tkpt|
              tkpt.run_number = @number
              @tkpts.push(tkpt)             
@@ -1868,6 +2348,7 @@ HERE
          }      
          compute_distance_and_pace
          compute_splits
+         set_run_ids
          @finished = true
        end  
      end  
@@ -1920,7 +2401,7 @@ HERE
           return last.hhmmss_diff(first)
         end
       end
-      return "??:??:??" 
+      return "00:00:00" 
     end
 
     def start_yyyy_mm_dd
@@ -1965,12 +2446,14 @@ HERE
       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(with_header_comment=false)
+    def put_tkpt_csv()
       finish() unless @finished    
-      if with_header_comment
-        puts "# Run: #{@number} date: #{start_yyyy_mm_dd} dist: #{distance} dur: #{duration} trks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lap_count} "
-      end
-      @tkpts.each { | tkpt | puts tkpt.to_csv }
+      @tkpts.each { | tkpt | 
+        if (@prev_tkpt == nil)
+          @prev_tkpt = tkpt
+        end
+        puts tkpt.to_csv(@prev_tkpt) 
+      }
     end
     
     def put_laps
@@ -1988,19 +2471,19 @@ HERE
         curr_index = curr_index + 1
         if curr_index == 0
           start_dttm = tkpt.dttm()
-          prev_tkpt  = tkpt          
+          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     
+      @distance = cumulative_dist
     end
   
-    def compute_splits              
+    def compute_splits
       nextSplitDist = 1.00
       prev_splitTkpt = nil
-      loop1Count    = 0;
+      loop1Count = 0;
       @tkpts.each { |tkpt|
         loop1Count = loop1Count + 1
         if tkpt.cumulative_distance() >= nextSplitDist
@@ -2017,6 +2500,15 @@ HERE
         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
 
 # =============================================================================
@@ -2092,201 +2584,117 @@ HERE
     
     def dump
       puts "Track: '#{@descr}'  tkpts: #{size}"
-      @trackpoints.each { |tkpt| puts tkpt.to_csv } # to_geo_s
+      @trackpoints.each { |tkpt| puts tkpt.to_csv } 
     end
   end 
-
-# =============================================================================
-
-=begin rdoc
-  Instances of this class represent a <Trackpoint> aggregate from a Forerunner 
-  XML file.  Additionally, there is distance, pace, and Google Map generation 
-  logic in this class.
-
-  <Trackpoint>
-      <Position>
-          <Latitude>35.49577</Latitude>
-          <Longitude>-80.83281</Longitude>
-          <Altitude>232.296</Altitude>
-      </Position>
-      <Time>2007-01-06T15:27:51Z</Time>
-  </Trackpoint>
-=end
-  
-  class Trackpoint < Position
-  
-    attr_reader :first, :last, :number, :run_number, :dttm, :prev_tkpt, :descr
-    attr_reader :cumulative_distance, :cumulative_pace, :incremental_distance, :split, :prev_split
-    attr_writer :first, :last, :run_number
   
-    def initialize(num, lat, lng, alt, time_string, descr='')
-      @number    = num
-      @run_number = 0
-
-      # initialize superclass variables:
-      @latitude  = lat.to_s
-      @longitude = lng.to_s
-      @altitude  = alt.to_s
-      @note      = note.to_s
-      @dttm      = DtTm.new(time_string)
-      @first     = false
-      @last      = false
-      @prev_tkpt  = nil      
-      @cumulative_distance, @split = 0.0, 0.0
-      @cumulative_pace = ""
-      @descr     = descr
-    end
-  
-    public
-  
-    def position
-      Position.new(@latitude, @longitude, @altitude, @note)
-    end
-    
-    def to_s
-        "Tkpt: #{@number} #{super.to_s} date: #{@dttm.to_s} cdist: #{@cumulative_distance}"
-    end
-  
-    def to_csv
-      ss = position.to_csv
-      "#{@run_number} | #{@dttm.to_s} | #{@number} | #{ss} | #{@cumulative_distance} "
-    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
-        
-      if @prev_tkpt
-        arg1  = latitude().to_f
-        arg2  = @prev_tkpt.latitude().to_f
-        arg3  = latitude().to_f
-        arg4  = @prev_tkpt.latitude().to_f
-        theta = longitude().to_f - @prev_tkpt.longitude().to_f   
-      
-        res1  = Math.sin(deg2rad(arg1))
-        res2  = Math.sin(deg2rad(arg2))
-        res3  = Math.cos(deg2rad(arg3))
-        res4  = Math.cos(deg2rad(arg4))
-        res5  = Math.cos(deg2rad(theta.to_f))
-              
-        incremental_distance =  ((res1 * res2) + (res3 * res4 * res5)).to_f
-
-        if (!incremental_distance.nan?)
-          incremental_distance = Math.acos(incremental_distance.to_f)
-          if (!incremental_distance.nan?)    
-            incremental_distance = rad2deg(incremental_distance)
-            if (!incremental_distance.nan?)
-              incremental_distance = incremental_distance * 60 * 1.1515;
-              if (!incremental_distance.nan?)
-                if units == "K"
-                   incremental_distance = incremental_distance * 1.609344;
-                end 
-                if units == "N"
-                   incremental_distance = incremental_distance * 0.8684;
-                end  
-                @cumulative_distance =  @cumulative_distance + incremental_distance.to_f 
+  # =============================================================================
+
+    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    
-        compute_cumulative_pace(start_dttm)
-        @cumulative_distance
-      else
-        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
-    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
-          ""
+      
+      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
-    end
-  
-    private 
-  
-    def deg2rad(degrees)
-     (((0 + degrees) * Math::PI) / 180)
-    end
-  
-    def rad2deg(radians)
-     (((0 + radians) * 180) / Math::PI)
-    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
+      def reset
+        @matched_points = Hash.new
       end
-      s << "</table>\""
-      s
+      
+      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
-  end  
-
+            
 # =============================================================================
 
 =begin rdoc
@@ -2361,7 +2769,7 @@ HERE
         type  = tokens[0].ljust(6)
         name  = tokens[1]
         count = tokens[2].rjust(6)
-        puts "  #{count}  #{type}  #{name}"        
+        puts "  #{count}  #{type}  #{name}"   
       }
     end
       
@@ -2409,8 +2817,6 @@ HERE
         count = @tokens_hash.value(name)
         puts "method: #{name}   (#{count})" 
       }  
-      # puts @tokens_hash.to_s
-      # puts @tokens_hash.size
     end
   
     def parse_code_lines
@@ -2596,13 +3002,40 @@ HERE
   
   class GoobyCommand < GoobyObject 
     
-    def initialize
+    attr_reader :configuration
+    
+    def initialize(gooby_yaml_filename=nil)
+      @configuration = Gooby::Configuration.init(gooby_yaml_filename)
     end
     
-    def options(yaml_filename) 
-      Gooby::Options.new(yaml_filename)
+    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
@@ -2612,22 +3045,117 @@ HERE
       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(true)
+      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(true)
+      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 generate_google_map(csv_filename, options_obj)  
-      generator = Gooby::GoogleMapGenerator.new(csv_filename)  
-      generator.generate_page(options_obj)
+    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