gooby 0.9.3

data/lib/gooby/cls_forerunner_xml_parser.rb

@@ -0,0 +1,178 @@
+module Gooby
+
+=begin rdoc
+  Instances of this class are used to parse a Forerunner XML file in a SAX-like
+  manner.  Instances of the model classes - History, Run, Track, Trackpoint,
+  etc. are created in this parsing process.  
+
+  See http://www.garmin.com/xmlschemas/ForerunnerLogbookv1.xsd for the XML Schema
+  Definition for the Garmin Forerunner XML.  The Gooby object model mirrors this XSD. 
+=end
+  
+  class ForerunnerXmlParser  
+  
+    DETAIL_TAGS = %w( Notes StartTime Duration Length Latitude Longitude Altitude Time BeginPosition EndPosition )
+  
+    include REXML::StreamListener
+  
+    attr_reader :history, :cvHash, :tagCount
+  
+    def initialize
+      @cvHash            = Hash.new("")
+      @tagCount          = 0
+      @runCount          = 0
+      @lapCount          = 0
+      @trackCount        = 0
+      @trackpoint_count  = 0
+      @currText          = "";
+      @history           = History.new
+      @currRun           = nil
+      @currLap           = nil
+      @currTrack         = nil
+      @currBeginPosition = nil
+      @currEndPosition   = nil
+    end
+  
+    public
+ 
+    # SAX API method; handles 'Run', 'Lap', 'Track'.   
+    def tag_start(tagname, attrs) 
+      @tagCount += 1
+      @currTag = tagname
+      @cvHash[tagname] = ''
+    
+      if detail_tag?(tagname)
+        @inDetail = true
+      end
+    
+      if is_tag?('Run', tagname)
+        @runCount = @runCount + 1
+        @lapCount = 0
+        @trackCount = 0
+        @currRun  = Run.new(@runCount)
+        @history.add_run(@currRun)
+        @cvHash['Notes'] = ''
+        return
+      end
+    
+      if is_tag?('Lap', tagname)
+        @lapCount = @lapCount + 1
+        @currLap  = Lap.new(@lapCount)
+        return
+      end
+    
+      if is_tag?('Track', tagname)
+        @trackCount = @trackCount + 1      
+        @currTrack  = Track.new(@trackCount)
+        @trackpoint_count = 0   
+        return   
+      end
+    
+    end
+
+    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run'. 
+    def tag_end(tagname) 
+      if @inDetail    
+        @cvHash[tagname] = @currText
+      else
+        if is_tag?('Position', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currBeginPosition = Position.new(lat.strip, long.strip, '')
+          @currEndPosition   = Position.new(lat.strip, long.strip, '')       
+        end 
+        
+        if is_tag?('BeginPosition', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currBeginPosition = Position.new(lat.strip, long.strip, '')      
+        end
+        
+        if is_tag?('EndPosition', tagname)
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          @currEndPosition = Position.new(lat.strip, long.strip, '')      
+        end
+              
+        if is_tag?('Trackpoint', tagname)
+          @trackpoint_count = @trackpoint_count + 1
+          lat  = @cvHash['Latitude']
+          long = @cvHash['Longitude']
+          alt  = @cvHash['Altitude']   
+          time = @cvHash['Time']                
+          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
+          @currTrack.add_trackpoint(tp)
+        end
+      
+        if is_tag?('Track', tagname)
+          if @currRun != nil
+            @currRun.add_track(@currTrack)
+          end
+        end
+      
+        if is_tag?('Lap', tagname)
+          @currLap.startTime = @cvHash['StartTime']
+          @currLap.duration  = Duration.new(@cvHash['Duration'])
+          @currLap.length    = @cvHash['Length']                          
+          @currLap.beginPosition = @currBeginPosition
+          @currLap.endPosition   = @currEndPosition        
+          @currRun.add_lap(@currLap)
+        end
+      
+        if is_tag?('Run', tagname)
+          @currRun.notes =  @cvHash['Notes'] 
+        end
+      end
+    
+      @inDetail = false    
+      @currText = ""
+      @currTag  = ""                     
+    end
+
+    # SAX API method.
+    def text(txt)  
+      if @inDetail
+        @currText = @currText + txt   
+      end
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def gdump()      
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def dump()        
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_csv.
+    def put_run_csv() 
+      @history.runs().each { |run| run.put_csv() } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_tkpt_csv.
+    def put_all_run_tkpt_csv(with_header_comment) 
+      @history.runs.each { |run| 
+        run.put_tkpt_csv(with_header_comment)
+      } 
+    end
+
+    private 
+  
+    def is_tag?(tagname, value)
+      tagname == value
+    end
+  
+    def detail_tag?(tagname)
+      DETAIL_TAGS.each { |typ| 
+        if typ == tagname 
+          return true    
+        end
+      }
+      return false
+    end
+  
+  end
+
+end # end of module

data/lib/gooby/cls_forerunner_xml_splitter.rb

@@ -0,0 +1,109 @@
+module Gooby
+
+=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
+
+end # end of module
+

data/lib/gooby/cls_geo_data.rb

@@ -0,0 +1,181 @@
+module Gooby
+
+=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 
+
+end # end of module

data/lib/gooby/cls_gooby_command.rb

@@ -0,0 +1,35 @@
+module Gooby
+
+=begin rdoc
+  This class provides "user friendly DSL" functionality for the use
+  of Gooby.
+=end
+  
+  class GoobyCommand < GoobyObject 
+    
+    def initialize
+    end
+    
+    def options(yaml_filename) 
+      Gooby::Options.new(yaml_filename)
+    end
+
+    def split_forerunner_xml(xml_filename, out_dir)  
+      splitter = Gooby::ForerunnerXmlSplitter.new(xml_filename, out_dir)  
+      splitter.split
+    end
+    
+    def parse_forerunner_xml(xml_filename)  
+      handler = Gooby::ForerunnerXmlParser.new     
+      Document.parse_stream((File.new xml_filename), handler)
+      handler.put_all_run_tkpt_csv(true)
+    end
+
+    def generate_google_map(csv_filename, options_obj)  
+      generator = Gooby::GoogleMapGenerator.new(csv_filename)  
+      generator.generate_page(options_obj)
+    end
+         
+  end
+  
+end # end of module

data/lib/gooby/cls_gooby_object.rb

@@ -0,0 +1,18 @@
+module Gooby
+
+=begin rdoc
+  This is the abstract superclass of several Gooby classes.
+  Includes modules GoobyIO, Introspect, and GoobyProjectInfo.
+=end
+  
+  class GoobyObject  
+    
+    include Gooby::GoobyIO  
+    include Gooby::GoobyString
+    include Gooby::Introspect
+    include Gooby::GoobyProjectInfo
+    include Gooby::Con
+    
+  end
+  
+end # end of module