gooby 1.1.0 → 1.2.0

data/lib/gooby_csv_run.rb

@@ -0,0 +1,28 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+  class CsvRun < 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
+
+end # end of module

data/lib/gooby_delim_line.rb

@@ -0,0 +1,42 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=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
+
+end # end of module

data/lib/gooby_dttm.rb

@@ -0,0 +1,87 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=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
+
+end # end of module

data/lib/gooby_duration.rb

@@ -0,0 +1,86 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=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
+
+end # end of module

data/lib/gooby_forerunner_xml_parser.rb

@@ -0,0 +1,191 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+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 :uom, :history, :cvHash, :tagCount
+  
+    def initialize(uom)
+      @uom                 = uom
+      @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']   
+          hb   = @cv_hash['HeartRateBpm']              
+          time = @cv_hash['Time']            
+          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, hb, time, @uom)
+          @curr_track.add_trackpoint(tp)
+
+          @cv_hash['Latitude']  = ''
+          @cv_hash['Longitude'] = ''
+          @cv_hash['Altitude']  = ''
+          @cv_hash['HeartRateBpm'] = ''
+          @cv_hash['Time'] = ''
+        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
+
+end # end of module

data/lib/gooby_forerunner_xml_splitter.rb

@@ -0,0 +1,115 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+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