gooby 1.1.0 → 1.2.0

data/lib/gooby_configuration.rb

@@ -0,0 +1,123 @@
+=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
+
+This is a singleton class whose values are loaded from a YAML file when your
+GoobyCommand class is created.  The default filename is 'gooby_config.yaml"'.
+
+The YAML file contains configuration parameters, such as your Google Map key,
+map HTML options, points of interest, and courses.
+ 
+=end
+  class Configuration < GoobyObject
+
+    @@singleton_instance = nil
+    
+    attr_reader :yaml_filename, :configuration
+  
+    private_class_method :new
+    
+    def Configuration.init(yaml_filename='gooby_config.yaml')
+      return @@singleton_instance if  @@singleton_instance
+       @@singleton_instance = new(yaml_filename)      
+    end
+    
+    def self.get_config
+      @@singleton_instance
+    end
+    
+    def initialize(yaml_filename) 
+      @yaml_filename = yaml_filename
+      File.open("#{@yaml_filename}") { |fn| @configuration = YAML::load(fn) }
+    end
+    
+    def get(name)    
+      if name == nil
+        return ''
+      end
+      s = @configuration["#{name}"]
+    
+      # Provide "sensible defaults".
+      if s == nil
+        if (name == '') 
+          return ''
+        elsif (name == 'english_metric')  
+          return 'english'
+        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_icon_url_base')             
+          return 'http://www.your-web-site.com/gicons/'          
+        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
+
+    def print_all
+      @configuration.keys.sort.each { |key| 
+        value = get(key)
+        puts "#{key}: #{value}" 
+      }
+    end
+
+    def print_all_poi
+      @configuration.keys.sort.each { |key|
+        if (key.match(/poi[\.]/))
+          val = @configuration["#{key}"]
+          poi = Point.new(val)
+          puts poi.to_s
+        end
+      }
+    end
+    
+    def get_poi(number)
+      val = @configuration["poi.#{number}"]
+      (val) ? Point.new(val) : nil
+    end
+    
+    def get_course(number)
+      val = @configuration["course.#{number}"]
+      (val) ? Course.new(val) : nil
+    end
+    
+    def size
+      @configuration.size
+    end
+     
+  # Return a String containing yaml filename and entry count.  
+    def to_s
+      return "# Configuration: filename: #{@yaml_filename} entries: #{@configuration.size}"
+    end
+    
+  end 
+
+end # end of module

data/lib/gooby_counter_hash.rb

@@ -0,0 +1,95 @@
+=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
+  This class wrappers a Hash object and provides increment/decrement functionality 
+  for a given key.  It is used to sum the number of things (i.e. - xml tags) in a 
+  collection.
+=end
+    
+  class CounterHash < GoobyObject
+
+    def initialize
+      @hash = Hash.new(0)  
+    end
+    
+    def size
+      @hash.size
+    end
+ 
+  # Return the Integer count for the given key; zero default.  
+    def value(key)   
+      (@hash.has_key?(key)) ? @hash[key] : 0  
+    end
+ 
+  # Increment the count for the given key.  
+    def increment(key) 
+      if key == nil
+        return
+      end       
+      if (@hash.has_key?(key)) 
+        val = @hash[key]
+        @hash[key] = val + 1  
+      else
+        @hash[key] = 1
+      end  
+    end
+    
+    def increment_tokens(text)
+      tokens = tokenize(text)
+      tokens.each { |token| increment(token) }
+    end
+
+  # Decrement the count for the given key.  
+    def decrement(key) 
+      if key == nil
+        return
+      end      
+      if (@hash.has_key?(key)) 
+        val = @hash[key]
+        @hash[key] = val - 1
+      else
+        @hash[key] = -1
+      end    
+    end
+ 
+  # Return an Array of the sorted keys.  
+    def sorted_keys        
+      @hash.keys.sort
+    end
+ 
+  # Return a String containing all key=val pairs.  
+    def to_s               
+      s = "CHash:"
+      sorted_keys.each { |key|
+        val = @hash[key]
+        s << " key: [#{key}] val: [#{val}]\n"
+      }
+      s
+    end
+ 
+  # Return an XML String containing all key=val pairs, optionally aligned.  
+    def to_xml(aligned=false)  
+      s = "<CHash>"
+      sorted_keys.each { |key|
+        val = @hash[key]
+        (aligned) ? s << "\n " : s << ''
+        s << " <entry key='#{key}' value='#{val}'/>"
+      }
+      if aligned
+        s << "\n "
+      end    
+      s << " </CHash>"
+      s   
+    end  
+
+  end
+
+end # end of module

data/lib/gooby_course.rb

@@ -0,0 +1,117 @@
+=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 Course < GoobyObject  
+
+    attr_accessor :name, :distance, :point_numbers, :points
+
+    def initialize(yaml_csv)
+      @name, @distance = '', 0.0
+      @point_numbers, @points, @bad_points = Array.new, Array.new, Array.new
+      @points_hash, @matched_points = Hash.new, Hash.new
+      tokens    = yaml_csv.split(',')
+      @name     = tokens[0]      if tokens.size > 0
+      @distance = tokens[1].to_f if tokens.size > 1 
+      if tokens.size > 2
+        index = 0
+        tokens.each { |tok|
+          index = index + 1
+          if (index > 2)
+            poi = Configuration.get_config.get_poi(tok)
+            if (poi)
+              poi.number     =  "#{tok}"
+              @point_numbers << "#{tok}"
+              @points        << poi
+              @points_hash["#{tok}"] = poi
+            else
+              @bad_points << tok
+            end
+          end
+        }
+      end 
+    end
+    
+    def has_errors
+      (@bad_points.size > 0) ? true : false
+    end
+    
+    def matched(number, point)
+      @matched_points["#{number}"] = point if point
+    end
+    
+    def matched?
+      (@matched_points.size == @point_numbers.size) ? true : false
+    end
+    
+    def display_matches
+      puts ''
+      calculate_matches
+      @point_numbers.each { |num|
+        point  = @points_hash["#{num}"]
+        mpoint = @matched_points["#{num}"]
+        puts ''
+        puts "  Course Point:    #{point.to_formatted_string}"   if point
+        puts "    Matched Point: #{mpoint.to_formatted_string}"  if mpoint
+      }
+      puts ''
+    end
+
+    def reset
+      @matched_points = Hash.new
+    end
+    
+    def to_s
+      "#{@name} #{@distance}  points: #{@points.size} errors: #{has_errors}" 
+    end 
+    
+    def dump
+      puts "Course:   #{@name}"
+      puts "Distance: #{@distance}"
+      points.each { |pt| puts pt } #{@points.size} errors: #{has_errors}" 
+    end 
+    
+    private
+    
+    def calculate_matches        
+      # first, identify the high and low distance points and their indices.
+      idx, low_dist, low_dist_idx, low_time, high_dist, high_dist_idx = -1, 999999.0, 0, '', -1.0, 0
+      @point_numbers.each { |num|
+        idx = idx + 1
+        mpoint = @matched_points["#{num}"]
+        if mpoint && mpoint.distance < low_dist
+          low_dist     = mpoint.distance
+          low_dist_idx = idx
+          low_time     = mpoint.elapsed
+        end
+        if mpoint && mpoint.distance > high_dist
+          high_dist     = mpoint.distance
+          high_dist_idx = idx
+        end          
+      }   
+      low_dttm = DtTm.new("2007-06-09T#{low_time}Z")
+      
+      # reorder the entries in @point_numbers if necessary - 'low-to-high distance'.
+      if (high_dist_idx < low_dist_idx)
+        @point_numbers.reverse!
+      end
+              
+      @point_numbers.each { |num|
+        mpoint = @matched_points["#{num}"]
+        if mpoint
+          mpoint.course_distance = mpoint.distance - low_dist
+          dttm = DtTm.new("2007-06-09T#{mpoint.elapsed}Z")
+          mpoint.course_elapsed  = dttm.hhmmss_diff(low_dttm) 
+        end
+      } 
+    end 
+    
+  end
+
+end # end of module

data/lib/gooby_csv_point.rb

@@ -0,0 +1,71 @@
+=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 CsvPoint < Point
+    
+    attr_reader   :rawdata, :tokens
+    attr_reader   :id, :run_id, :date, :time, :tkpt_num, :distance, :elapsed, :uom 
+    attr_reader   :lap_number, :lap_distance, :lap_elapsed
+    attr_accessor :course_distance, :course_elapsed, :degrees_diff
+
+    def initialize(csv_line)
+      @rawdata = "#{csv_line}"
+      @tokens  = @rawdata.split(csv_delim)
+      if (@tokens.size > 14)
+        @id           = @tokens[0]  # <-- consists of @run_id.@tkpt_num for uniqueness and use as a DB table primary key.
+        @run_id       = @tokens[1]
+        @date         = @tokens[2]
+        @time         = @tokens[3]
+        @tkpt_num     = @tokens[4].strip.to_i
+        @latitude     = @tokens[5].to_f
+        @longitude    = @tokens[6].to_f 
+        @altitude     = @tokens[7].strip.to_f 
+        @heartbeat    = @tokens[8].strip.to_f         
+        @distance     = @tokens[9].strip.to_f 
+        @uom          = @tokens[10].strip
+        @elapsed      = @tokens[11]
+        @lap_number   = @tokens[12].strip.to_i 
+        @lap_distance = @tokens[13].strip.to_f                                                     
+        @lap_elapsed  = @tokens[14]
+      end
+    end
+
+    def token_count
+      @tokens ? @tokens.size : 0
+    end
+    
+    def as_trackpoint
+      tkpt = Trackpoint.new(@tkpt_num,  @latitude, @longitude, @altitude, @heartbeat, "#{date}T#{time}Z", @uom)
+      tkpt.lap_number   = @lap_number
+      tkpt.lap_distance = @lap_distance
+      tkpt.lap_elapsed  = @lap_elapsed
+      tkpt
+    end
+    
+    def to_s
+      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
+    end  
+    
+    def to_formatted_string
+      s =  "lat: #{@latitude.to_s.ljust(20)}"
+      s << " lng: #{@longitude.to_s.ljust(20)}"
+      s << " time:            #{@time}"
+      pad = ''.ljust(70)
+      s << "\n#{pad} course elapsed:  #{@course_elapsed}"
+      s << "\n#{pad} distance:        #{@distance}"
+      s << "\n#{pad} heartbeat:       #{@heartbeat}" if (@heartbeat && (@heartbeat.to_f > 0))
+      s << "\n#{pad} course distance: #{@course_distance}"
+      s << "\n#{pad} altitude:        #{@altitude}"
+      s << "\n#{pad} degrees diff:    #{@degrees_diff}"
+      s
+    end
+  end
+
+end # end of module

data/lib/gooby_csv_reader.rb

@@ -0,0 +1,71 @@
+=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 CsvReader < GoobyObject
+
+    attr_reader :files, :csv_points, :col_names
+    
+    def initialize(array_of_filenames=nil)
+      @files      = Array.new
+      @csv_points = Array.new
+      if array_of_filenames
+        array_of_filenames.each { |filename| add_file(filename) } 
+      end
+    end
+    
+    def add_file(filename)
+      if (filename)
+        if (File.exist?(filename))
+          @files << filename
+        end
+      end
+    end
+    
+    def read
+      @files.each { |filename|
+        lines = read_lines(filename, true)
+        lines.each { |line|
+          if (line.match('^#'))
+            if (line.match('^#cols: '))
+              col_names_header = line[7, line.size]
+              @col_names = col_names_header.split('|')
+            end
+          else
+            if (line.size > 50)
+               @csv_points << Gooby::CsvPoint.new(line)
+            end
+          end
+        }
+      }
+      @csv_points
+    end 
+    
+    def display_formatted_record(record_index=2)
+      tokens = @csv_points[record_index].rawdata.split('|')
+      puts "\nCsvReader.display_formatted_record  hdr_cols=#{@col_names.size} data_cols=#{tokens.size}"
+      size   = 0
+      @col_names.each { |col_name|
+        size = size + 1
+        if size <= tokens.size
+          value = tokens[size - 1]
+          puts "#{col_name.strip.ljust(20)} #{(size - 1).to_s.ljust(3)} #{value}"
+        end
+      }
+    end
+    
+    def to_s
+      s = "CsvReader - file count: #{files.size}  total points: #{csv_points.size}"
+      @files.each { |file| s << "\n  file: #{file} "}
+      s
+    end         
+
+  end
+
+end # end of module