gooby 0.9.4 → 0.9.5

data/lib/gooby/cls_line.rb

@@ -1,75 +0,0 @@
-module Gooby
-  
-=begin rdoc
-
-=end
-
-  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 # end of module

data/lib/gooby/cls_options.rb

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

data/lib/gooby/cls_position.rb

@@ -1,44 +0,0 @@
-module Gooby
-
-=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.
-=end
-    
-  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 # end of module

data/lib/gooby/cls_run.rb

@@ -1,194 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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