gooby 0.9.3

data/lib/gooby/cls_run.rb

@@ -0,0 +1,194 @@
+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, :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 # end of module

data/lib/gooby/cls_simple_xml_parser.rb

@@ -0,0 +1,41 @@
+module Gooby
+
+=begin rdoc
+  Sample implementation of a REXML::StreamListener SAX parser.
+=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/cls_test_regen.rb

@@ -0,0 +1,182 @@
+module Gooby
+
+=begin rdoc
+  This class is used to generate, on an ongoing basis, the various Gooby test
+  classes.  Regeneration retains the current test methods, and adds stubs for 
+  new test methods.  All methods, old and new, appear in the merged output in 
+  propper sort sequence.
+=end
+    
+  class TestGenerator < GoobyObject 
+    
+    def initialize
+      tested_files.each { | base_rb_file | 
+        test_file = "tc_#{base_rb_file}"
+        if true
+          @codeLines  = read_lines("lib/#{base_rb_file}") 
+          @testLines  = read_lines("tests/#{test_file}") 
+          @codeHash   = Hash.new     
+          @testHash   = Hash.new     
+          @mergedHash = Hash.new
+          @excludeClasses = %w( TestHelper TestGenerator )    
+          puts "current codeLines = #{@codeLines.size}" 
+          puts "current testLines = #{@testLines.size}" 
+          parse_code_lines
+          parse_test_lines    
+          merge_keys
+          regenerate(test_file)
+        end
+      }
+    end 
+  
+    private
+  
+    #  Produce a Hash with keys and values like the following:
+    #  test|class|Trackpoint|deg2rad      Trackpoint|deg2rad(degrees)
+  
+    def parse_code_lines
+      type      = ''
+      type_name = ''
+      meth_name = ''    
+      @codeLines.each { | line | 
+        line.strip!
+        if (line.match(/^module /))
+          type      = 'module'
+          tokens    = line.split
+          type_name = tokens[1]    
+        elsif (line.match(/^class /))
+          type      = 'class'
+          tokens    = line.split
+          type_name = tokens[1]          
+        elsif (line.match(/^def /))
+          signature = line[4...999]
+          short_method = parse_meth_name("#{signature}")
+          @codeHash["test_#{type}_#{type_name}"] = "#{type_name}"          
+          @codeHash["test_#{type}_#{type_name}_#{short_method}"] = "#{type_name}|#{signature}"           
+        end        
+      }          
+    end 
+
+    def parse_meth_name(string)
+      string.gsub!('(', ' ')
+      string.gsub!(')', ' ')    
+      tokens = string.split
+      tokens[0]
+    end
+  
+    def parse_test_lines
+      in_method  = true
+      method_name = 'a_start'
+      method_lines = Array.new
+      line_num = 0
+    
+      @testLines.each { | line | 
+        line_num = line_num + 1  
+        line.chomp!
+        prefix   = line[0...5]   # '  def'         
+        prefix21 = line[0...21]  # '  ### Start of tests.'
+            
+        if ((prefix == '  def') || (prefix == "\tdef"))
+          in_method   = true 
+          tokens      = line.split
+          method_name = tokens[1] 
+          method_lines = Array.new   
+        end
+        if in_method
+          method_lines << "#{line}"
+        end
+        if prefix21 == '  ### Start of tests.'
+          in_method = false 
+          @testHash["#{method_name}"] = method_lines            
+        end   
+        if ((prefix == '  end') || (prefix == "\tend")) 
+          in_method = false 
+          @testHash["#{method_name}"] = method_lines            
+        end       
+      }      
+    end 
+  
+    def merge_keys
+      @codeHash.keys.sort.each { |key| @mergedHash["#{key}"] = "code" }
+      @testHash.keys.sort.each { |key| @mergedHash["#{key}"] = "test" }       
+    end
+  
+    def regenerate(test_file)
+      code = ''
+      @mergedHash.keys.sort.each { |key|  
+
+        tokens = key.split('_')
+        type, name, meth = tokens[1], tokens[2], tokens[3]  
+        
+        processThisKey = true      
+        @excludeClasses.each { |xc| 
+          if xc == name 
+            processThisKey = false
+          end
+        }
+      
+        next if !processThisKey
+            
+        if @testHash.has_key?(key)
+          # We already have a test method written in the test class, 
+          # so keep this currently existing test code!
+
+          if @codeHash.has_key?(key)
+            comment = nil
+          else
+            if key != 'a_start'
+              comment = "# Warning: possible obsolete test method - #{key}"
+            end
+          end
+        
+          code << "\n"
+          if comment != nil
+            code << "\n#{comment}"
+            code << "\n"
+          end
+          array = @testHash["#{key}"]
+          array.each { |line| code << "\n#{line}" }
+        else
+          # We don't have this test method in the current test class,
+          # so generate a test method stub.
+        
+          code << "\n"
+          code << "\n  def #{key}"
+          code << "\n"
+        
+          if @gen_impl_stub
+            if type = 'class' 
+              code << "\n    #obj = #{type}.new"
+              code << "\n    #result   = obj.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s << '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s      
+            else
+              code << "\n    #result   = #{type}.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s <<  '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s         
+            end
+          end
+          code << "\n  end"
+        end
+      }
+      code << "\nend" # end of class 
+      code << "\n"      
+      fn  = "tests/#{test_file}"
+      out = File.new fn, "w+"
+      out.write code
+      out.flush
+      out.close
+      puts "file written: #{fn}"
+    end
+
+  end
+
+end # end of module

data/lib/gooby/cls_track.rb

@@ -0,0 +1,47 @@
+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 first_tkpt
+      @trackpoints.size > 0 ? @trackpoints[0] : nil
+    end
+ 
+    def last_tkpt
+      @trackpoints.size > 0 ? @trackpoints[-1] : nil
+    end
+      
+    def to_s
+      return "Trk: #{@descr} tkpts: #{size}"
+    end
+    
+    def dump
+      puts "Track: '#{@descr}'  tkpts: #{size}"
+      @trackpoints.each { |tkpt| puts tkpt.to_csv } # to_geo_s
+    end
+    
+  end 
+
+end # end of module

data/lib/gooby/cls_trackpoint.rb

@@ -0,0 +1,200 @@
+module Gooby 
+
+=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, :runNumber, :dttm, :prevTkpt, :descr
+    attr_reader :cumulativeDistance, :cumulativePace, :incrementalDistance, :split, :prevSplit
+    attr_writer :first, :last, :runNumber
+  
+    def initialize(num, lat, lng, alt, time_string, descr='')
+      @number    = num
+      @runNumber = 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
+      @prevTkpt  = nil      
+      @cumulativeDistance, @split = 0.0, 0.0
+      @cumulativePace = ""
+      @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: #{@cumulativeDistance}"
+    end
+  
+    def to_csv
+      ss = position.to_csv
+      "#{@runNumber} | #{@dttm.to_s} | #{@number} | #{ss} | #{@cumulativeDistance} "
+    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
+      @cumulativeDistance = 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  
+                @cumulativeDistance =  @cumulativeDistance + incremental_distance.to_f 
+              end
+            end
+          end
+        end    
+        compute_cumulative_pace(start_dttm)
+        @cumulativeDistance
+      else
+        0  
+      end    
+    end
+  
+    def compute_cumulative_pace(start_dttm)      
+      if @cumulativeDistance > 0
+        secsDiff  = @dttm.seconds_diff(start_dttm)
+        secsMile  = ((secsDiff.to_f) / (@cumulativeDistance.to_f))
+        minsMile  = (secsMile / 60)
+        wholeMins = minsMile.floor 
+        secsBal   = secsMile - (wholeMins * 60)
+        s1 = "#{secsDiff} #{secsMile} #{minsMile} #{wholeMins} #{secsBal} #{@cumulativeDistance} | "
+        s2 = sprintf("%d:%2.1f", minsMile, secsBal)
+        @cumulativePace = "#{s2}"
+      else 
+        @cumulativePace = ""
+      end
+    end
+  
+    def set_split(n, tkpt)
+      @split, @prevSplit = n, tkpt
+    end
+  
+    def is_split()
+     (@split >= 1)
+    end
+  
+    def is_first()
+      @first
+    end
+  
+    def is_last()
+      @last
+    end
+  
+    def split_info(dtTm) 
+      if is_split
+        hhmmss = ''
+        if @prevSplit
+          return "#{@split} #{@dttm.hhmmss_diff(@prevSplit.dttm())}"          
+        else
+          return "#{@split} #{@dttm.hhmmss_diff(dtTm)}"      
+        end
+      else
+          ""
+      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(comments, tkpt_count, curr_idx, gpoint_count, start_dttm)
+      if comments
+        secs_diff = @dttm.seconds_diff(start_dttm)
+        fmt_time  = @dttm.hhmmss_diff(start_dttm)
+          "\n            points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); " +
+            "// #{gpoint_count} (#{curr_idx + 1} of #{tkpt_count}) #{@dttm.to_s} #{secs_diff} #{fmt_time} #{@cumulativeDistance} #{split_info(start_dttm)} "
+      else
+          "\n            points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); "  
+      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>#{@cumulativeDistance}</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>#{@cumulativePace} </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  
+
+end # end of module

data/lib/gooby/mod_introspect.rb

@@ -0,0 +1,26 @@
+module Gooby
+  
+  module Introspect
+  
+  # Return a String w/instance variable and method info.    
+    def introspect         
+      c  = self.class
+      s  = "Class: #{c} "
+      iv = self.instance_variables.sort
+      s << " ivc=#{iv.size}"
+      iv.each { |v| s << " #{v}" } 
+      meth = self.methods.sort
+      s << " mc=#{meth.size}"
+      meth.each { |m| s << " #{m}" }
+      s << ""
+      s
+    end 
+
+  # Return 'self.instance_variables'.
+    def to_yaml_properties   
+      self.instance_variables 
+    end
+  
+  end 
+  
+end # end of module