gooby 1.2.0 → 2.0.0

data/lib/gooby_run.rb

@@ -1,213 +0,0 @@
-=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 <Run> aggregate object from a
-  Forerunner XML file.  
-
-  Additionally, there is distance, pace, and Google Map generation logic 
-  in this class.
-=end 
-
-  class Run < GoobyObject 
-  
-    attr_accessor :number, :run_id, :descr, :notes, :tracks, :tkpts, :laps, :distance
-  
-    def initialize(number=0, descr='')
-      @number = number
-      @run_id = nil      
-      @descr  = descr
-      @notes  = ''         
-      @tracks = Array.new
-      @tkpts  = Array.new
-      @laps   = Array.new 
-      @distance = 0
-      @configuration = Hash.new
-      @logProgress = true
-      @finished    = false
-    end
-
-    public
-  
-   # This method is invoked at end-of-parsing.  
-    def finish()
-       @logProgress = false
-       unless @finished
-         @tracks.each { |trk| 
-           trk.trackpoints().each { |tkpt|
-             tkpt.run_number = @number
-             @tkpts.push(tkpt)             
-           }
-         }      
-         compute_distance_and_pace
-         compute_splits
-         set_run_ids
-         @finished = true
-       end  
-     end  
-   
-    public  
-  
-    def add_track(trk)
-      if trk != nil
-        @tracks.push(trk) 
-      end   
-    end
-  
-    def trackpoint_count()
-      @tkpts.size()
-    end
-  
-    def add_lap(lap)
-      @laps.push(lap)    
-    end
-  
-    def lap_count()
-      @laps.size    
-    end
-  
-    def start_dttm()
-      count = 0
-      @tracks.each { |trk| 
-        trk.trackpoints().each { |tkpt|
-          return tkpt.dttm()
-        }
-      }
-      return nil    
-    end
-  
-    def end_dttm()
-      lastOne = nil
-      @tracks.each { |trk| 
-        trk.trackpoints().each { |tkpt|
-          lastOne = tkpt.dttm()
-        }
-      }
-      lastOne
-    end
-  
-    def duration()
-      first = start_dttm()
-      last  = end_dttm()
-      if first
-        if last
-          return last.hhmmss_diff(first)
-        end
-      end
-      return "00:00:00" 
-    end
-
-    def start_yyyy_mm_dd
-      if start_dttm() 
-        start_dttm().yyyy_mm_dd()
-      else
-          ""
-      end
-    end
-  
-    def start_hh_mm_ss
-      if start_dttm() 
-        start_dttm().hh_mm_ss()
-      else
-          ""
-      end
-    end    
-  
-    def end_hh_mm_ss
-      if end_dttm() 
-        end_dttm().hh_mm_ss()
-      else
-          ""
-      end
-    end
-  
-    def to_s
-      finish() unless @finished 
-      s = "Run: #{@number} date: #{start_yyyy_mm_dd} distance: #{distance} duration: #{duration} "
-      s << "  tracks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lap_count} "
-      s << "  notes: #{@notes} "
-      s
-    end
-  
-    def print_string     
-      finish() unless @finished       
-      "Run number=#{@number}  tracks=#{@tracks.size} tkpts=#{@tkpts.size} laps=#{@laps.size} distance=#{@distance} "
-    end
-  
-    def put_csv()
-      finish() unless @finished
-      puts "#{@number}|#{}|#{start_yyyy_mm_dd()}|#{start_hh_mm_ss()}|#{end_hh_mm_ss}|#{duration()}|#{@distance}|#{@tracks.size}|#{trackpoint_count()}|#{lap_count}|#{@notes.strip}" 
-    end
-  
-    def put_tkpt_csv()
-      finish() unless @finished    
-      @tkpts.each { | tkpt | 
-        @prev_tkpt = tkpt  if (@prev_tkpt == nil)
-        puts tkpt.to_csv(@prev_tkpt) 
-      }
-    end
-    
-    def put_laps
-      @laps.each { | lap | puts lap.to_s }      
-    end
-  
-    private 
-  
-    def compute_distance_and_pace
-      cumulative_dist = 0.to_f;
-      curr_index = -1
-      prev_tkpt  = nil
-      start_dttm = nil
-      @tkpts.each { | tkpt |
-        curr_index = curr_index + 1
-        if curr_index == 0
-          start_dttm = tkpt.dttm()
-          prev_tkpt  = tkpt
-        else
-          cumulative_dist = tkpt.compute_distance_and_pace(curr_index, start_dttm, cumulative_dist, prev_tkpt)  
-          prev_tkpt = tkpt      
-        end
-      }
-      @distance = cumulative_dist
-    end
-  
-    def compute_splits
-      nextSplitDist = 1.00
-      prev_splitTkpt = nil
-      loop1Count = 0;
-      @tkpts.each { |tkpt|
-        loop1Count = loop1Count + 1
-        if tkpt.cumulative_distance() >= nextSplitDist
-          tkpt.set_split(0 + nextSplitDist, prev_splitTkpt)
-          nextSplitDist = nextSplitDist + 1.00
-          prev_splitTkpt = tkpt
-        end
-      } 
-      # set first and last booleans
-      count = 0
-      @tkpts.each { |tkpt|
-        count = count + 1
-        tkpt.first = true  if count == 1
-        tkpt.last  = true  if count == loop1Count
-      }         
-    end
-    
-    def set_run_ids
-      @tkpts.each { |tkpt|
-        if (@run_id == nil)
-          @run_id = tkpt.dttm.rawdata
-        end
-        tkpt.run_id = @run_id
-      }
-    end
-
-  end
-
-end # end of module

data/lib/gooby_simple_xml_parser.rb

@@ -1,50 +0,0 @@
-=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
-  Sample implementation of a REXML::StreamListener SAX parser.
-  This class isn't actually used in Gooby, but is retained for future use.
-=end 
-
-  class SimpleXmlParser
-   
-    include REXML::StreamListener
-  
-    attr_accessor :tag_count, :watched_tags
-  
-    def initialize
-      @tag_count = 0
-      @counter_hash = CounterHash.new
-    end
-  
-    public
-
-  # SAX API method.  Increments the tagname in the counter hash.  
-    def tag_start(tag_name, attrs)   
-      @tag_count = @tag_count + 1
-      @counter_hash.increment(tag_name)
-    end
-
-  # SAX API method.  No impl.
-    def tag_end(tagname)   
-    end
-  
-  # SAX API method.  No impl.  
-    def text(txt)
-    end
-
-  # Prints the state of this object (the counter hash).
-    def dump   
-      puts @counter_hash.to_s
-    end
-
-  end
-
-end # end of module

data/lib/gooby_test_helper.rb

@@ -1,23 +0,0 @@
-=begin
-
-Gooby = Google APIs + Ruby
-Gooby - Copyright 2007 by Chris Joakim.
-Gooby is available under GNU General Public License (GPL) license.
-
-=end
-
-module Gooby
-
-  module TestHelper  
-    
-    def setup
-      puts "test: #{name}"
-    end
-    
-    def teardown
-      @debug = false
-    end
-
-  end
-
-end # end of module

data/lib/gooby_track.rb

@@ -1,47 +0,0 @@
-=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 <Track> aggregate object from a Forerunner
-  XML file.  Note that a <Run> may contain more than one <Track> aggregates.
-=end
-  
-  class Track < GoobyObject
-  
-    attr_reader :number, :descr, :trackpoints
-  
-    def initialize(num=0, descr='')
-      @number = num      
-      @descr  = descr
-      @trackpoints = Array.new      
-    end
-  
-    public
-  
-    def add_trackpoint(tkpt)
-      @trackpoints.push(tkpt)   
-    end
-  
-    def size
-      @trackpoints.size
-    end
-      
-    def to_s
-      return "Trk: #{@descr} tkpts: #{size}"
-    end
-    
-    def dump
-      puts "Track: '#{@descr}'  tkpts: #{size}"
-      @trackpoints.each { |tkpt| puts tkpt.to_csv } 
-    end
-    
-  end 
-  
-end # end of module

data/lib/gooby_track_point.rb

@@ -1,229 +0,0 @@
-=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 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, hb, time_string, uom, 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
-      @altitude  = alt.to_f
-      @uom       = uom       
-      @altitude  = @altitude * 3.2736  if (@uom == 'm')
-      @heartbeat = hb.to_s
-      if ((@heartbeat == nil) || (@heartbeat == ''))
-        @heartbeat = -1
-      end
-      @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 && (first_lap_start_time_s.size > 0) && 
-          curr_lap_start_time_s  && (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}#{@heartbeat}"      
-      csv << "#{delim}#{@cumulative_distance}"
-      csv << "#{delim}#{uom}"      
-      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|heartbeat|run_distance|uom|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)
-      @prev_tkpt = prev_trackpoint
-      @cumulative_distance = prev_cumulative_dist.to_f
-      @run_start_dttm = start_dttm
-        
-      if @prev_tkpt
-        @incremental_distance = proximity(@prev_tkpt, @uom)         
-        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 
-        fractMins = minsMile - (wholeMins.to_f)
-        fractSecs = fractMins * 60
-        secsStr   = fractSecs.to_s
-        tokens    = secsStr.split('.')
-        whole, fract = '', ''
-        if tokens.size > 1
-          whole = tokens[0]
-          fract = tokens[1]
-          fract = fract[0,3] if fract.size > 3
-          if (whole.to_f < 10)
-            secsStr = "0#{whole}.#{fract}"
-          else
-            secsStr = "#{whole}.#{fract}"
-          end  
-        end 
-        #s1 = " | #{secsDiff} #{secsMile} #{minsMile} #{wholeMins} #{fractMins} #{fractSecs} #{whole} #{fract} #{@cumulative_distance} "
-        s2 = sprintf("%d:%5s", minsMile, secsStr)
-        @cumulative_pace = "#{s2} per #{@uom}"
-      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
-          if (@uom == 'km')
-            s << "<tr><td colspan='2'><b>Kilometer #{checkpoint}</b></td></tr>"
-          else
-            s << "<tr><td colspan='2'><b>Mile #{checkpoint}</b></td></tr>"
-          end
-        end
-        s << "<tr><td>Distance:</td><td>#{@cumulative_distance} #{@uom}</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}</td></tr>"
-        if (@heartbeat && (@heartbeat.size > 1) && (@heartbeat.to_i > 0))
-          s << "<tr><td>Heartbeat:</td><td>#{@heartbeat}</td></tr>"
-        end
-        s
-      end
-      s << "</table>\""
-      s
-    end
-    
-  end  
-
-end # end of module