Gooby 0.9.0

data/lib/cls_simple_xml_parser.rb

@@ -0,0 +1,46 @@
+=begin rdoc
+
+Sample implementation of a REXML::StreamListener SAX parser.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end 
+
+module Gooby
+  
+  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

data/lib/cls_test_regen.rb

@@ -0,0 +1,187 @@
+=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.
+
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end 
+
+module Gooby
+  
+  class TestGenerator < GoobyObject 
+    
+    def initialize
+      tested_files.each { | base_rb_file | 
+        test_file = "tst_#{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   

data/lib/cls_track.rb

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

data/lib/cls_trackpoint.rb

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