Gooby 0.9.0

data/lib/cls_history.rb

@@ -0,0 +1,38 @@
+=begin rdoc
+
+Instances of this class represent a <History> aggregate object from a
+Forerunner XML file.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+  
+  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 
+  
+end  

data/lib/cls_lap.rb

@@ -0,0 +1,27 @@
+=begin rdoc
+
+Instances of this class represent a <Lap> aggregate object from a
+Forerunner XML file.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end 
+
+module Gooby
+  
+  class Lap < GoobyObject
+  
+    attr_accessor :number, :startTime, :duration, :length, :beginPosition, :endPosition
+  
+    def initialize(num)
+      @number = num  
+    end
+
+    def to_s
+      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@beginPosition.to_s} end: #{@endPosition.to_s}"
+    end
+      
+  end 
+
+end

data/lib/cls_line.rb

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

data/lib/cls_options.rb

@@ -0,0 +1,74 @@
+=begin rdoc
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+  
+  class Options < GoobyObject
+  
+    attr_reader :yamlFilename, :options
+  
+    def initialize(filename)  # Constructor.
+      filename ? @yamlFilename = filename : @yamlFilename = 'gooby_options.yaml'     
+      loadFile()
+    end
+  
+    public
+ 
+  # Load the @yamlFilename  
+    def loadFile   
+      File.open("#{@yamlFilename}") { |fn| 
+        @options = YAML::load(fn)    
+      }
+    end
+
+    def get(name)    
+      if name == nil
+        return ''
+      end
+      s = @options["#{name}"]
+    
+      # Provide "sensible defaults".
+      if s == nil
+        if (name == '') 
+          return ''
+        elsif (name == 'gmap_first_tkpt_number')  
+          return 1
+        elsif (name == 'gmap_last_tkpt_number')   
+          return 5000
+        elsif (name == 'gmap_map_element_id')     
+          return 'map'  
+        elsif (name == 'gmap_height')             
+          return '600'
+        elsif (name == 'gmap_key')                
+          return 'enter your Google Map Key here'       
+        elsif (name == 'gmap_type_control')       
+          return true
+        elsif (name == 'gmap_approx_max_points')  
+          return '200'
+        elsif (name == 'gmap_gen_comments')       
+          return true
+        elsif (name == 'gmap_size_control')       
+          return nil
+        elsif (name == 'gmap_type')               
+          return 'G_NORMAL_MAP'  
+        elsif (name == 'gmap_zoom_level')         
+          return 5 
+        else 
+          return ''
+        end
+      end
+      s
+    end
+     
+  # Return a String containing yaml filename and entry count.  
+    def to_s
+      return "Options: filename: #{@yamlFilename} entries: #{@options.size}"
+    end
+  
+  end 
+
+end

data/lib/cls_position.rb

@@ -0,0 +1,49 @@
+=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.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end 
+
+module Gooby
+  
+  class Position < GoobyObject  
+  
+    attr_accessor :latitude, :longitude, :altitude, :note
+  
+    def initialize(lat, lng, alt='0', note='')
+      @latitude  = lat.to_s
+      @longitude = lng.to_s
+      @altitude  = alt.to_s
+      @note      = note.to_s
+    end
+  
+    public
+  
+    def to_s
+      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
+    end
+  
+    def to_csv
+      return "#{@latitude} | #{@longitude} | #{@altitude}"
+    end
+    
+    def latitude_as_float
+      @latitude ? @latitude.to_f : invalid_latitude
+    end
+  
+    def longitude_as_float
+      @longitude ? @longitude.to_f : invalid_longitude
+    end
+  
+    def altitude_as_float
+      @altitude ? @altitude.to_f : invalid_altitude
+    end
+  
+  end
+
+end

data/lib/cls_run.rb

@@ -0,0 +1,199 @@
+=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.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end 
+
+module Gooby
+  
+  class Run < GoobyObject 
+  
+    attr_accessor :number, :descr, :notes, :tracks, :tkpts, :laps, :distance
+  
+    def initialize(number=0, descr='')
+      @number = number
+      @descr  = descr
+      @notes  = ''         
+      @tracks = Array.new
+      @tkpts  = Array.new
+      @laps   = Array.new 
+      @distance = 0
+      @options  = Hash.new
+      @logProgress = true
+      @finished = false
+    end
+
+    public
+  
+   # This method is invoked at end-of-parsing.  
+    def finish()
+       @logProgress = false
+       unless @finished
+         @tracks.each { |trk|  
+           trk.trackpoints().each { |tkpt|
+             tkpt.runNumber = @number
+             @tkpts.push(tkpt)             
+           }
+         }      
+         compute_distance_and_pace
+         compute_splits
+         @finished = true
+       end  
+     end  
+   
+    public  
+  
+    def add_track(trk)
+      if trk != nil
+        @tracks.push(trk) 
+      end   
+    end
+  
+    def trackpoint_count()
+      @tkpts.size()
+    end
+  
+    def add_lap(lap)
+      @laps.push(lap)    
+    end
+  
+    def lapCount()
+      @laps.size    
+    end
+  
+    def start_dttm()
+      count = 0
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          return tkpt.dttm()
+        }
+      }
+      return nil    
+    end
+  
+    def end_dttm()
+      lastOne = nil
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          lastOne = tkpt.dttm()
+        }
+      }
+      lastOne
+    end
+  
+    def duration()
+      first = start_dttm()
+      last  = end_dttm()
+      if first
+        if last
+          return last.hhmmss_diff(first)
+        end
+      end
+      return "??:??:??" 
+    end
+
+    def start_yyyy_mm_dd
+      if start_dttm() 
+        start_dttm().yyyy_mm_dd()
+      else
+          ""
+      end
+    end
+  
+    def start_hh_mm_ss
+      if start_dttm() 
+        start_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end    
+  
+    def end_hh_mm_ss
+      if end_dttm() 
+        end_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end
+  
+    def to_s
+      finish() unless @finished 
+      s = "Run: #{@number} date: #{start_yyyy_mm_dd} distance: #{distance} duration: #{duration} "
+      s << "  tracks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lapCount} "
+      s << "  notes: #{@notes} "
+      s
+    end
+  
+    def print_string     
+      finish() unless @finished       
+      "Run number=#{@number}  tracks=#{@tracks.size} tkpts=#{@tkpts.size} laps=#{@laps.size} distance=#{@distance} "
+    end
+  
+    def put_csv()
+      finish() unless @finished
+      puts "#{@number}|#{}|#{start_yyyy_mm_dd()}|#{start_hh_mm_ss()}|#{end_hh_mm_ss}|#{duration()}|#{@distance}|#{@tracks.size}|#{trackpoint_count()}|#{lapCount}|#{@notes.strip}" 
+    end
+  
+    def put_tkpt_csv(with_header_comment=false)
+      finish() unless @finished    
+      if with_header_comment
+        puts "# Run: #{@number} date: #{start_yyyy_mm_dd} dist: #{distance} dur: #{duration} trks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lapCount} "
+      end
+      @tkpts.each { | tkpt | puts tkpt.to_csv }
+    end
+    
+    def put_laps
+      @laps.each { | lap | puts lap.to_s }      
+    end
+  
+    private 
+  
+    def compute_distance_and_pace
+      cumulative_dist = 0.to_f;
+      curr_index = -1
+      prev_tkpt  = nil
+      start_dttm = nil
+      @tkpts.each { | tkpt |
+        curr_index = curr_index + 1
+        if curr_index == 0
+          start_dttm = tkpt.dttm()
+          prev_tkpt  = tkpt          
+        else
+          cumulative_dist = tkpt.compute_distance_and_pace(curr_index, start_dttm, cumulative_dist, prev_tkpt, 'M')  
+          prev_tkpt = tkpt      
+        end
+      }
+      @distance = cumulative_dist     
+    end
+  
+    def compute_splits              
+      nextSplitDist = 1.00
+      prevSplitTkpt = nil
+      loop1Count    = 0;
+      @tkpts.each { |tkpt|
+        loop1Count = loop1Count + 1
+        if tkpt.cumulativeDistance() >= nextSplitDist
+          tkpt.set_split(0 + nextSplitDist, prevSplitTkpt)
+          nextSplitDist = nextSplitDist + 1.00
+          prevSplitTkpt = tkpt
+        end
+      } 
+      # set first and last booleans
+      count = 0
+      @tkpts.each { |tkpt|
+        count = count + 1
+        tkpt.first = true  if count == 1
+        tkpt.last  = true  if count == loop1Count
+      }         
+    end
+    
+  end
+  
+end