gooby 1.2.0 → 2.0.0

data/lib/gooby_gpx_parser.rb

@@ -0,0 +1,97 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+---
+
+This class is used to parse a gpx xml file, such as from MotionX GPS software on an iPhone.
+
+This implementation, based on one sample file, handles a gpx file with one 'trk'.
+A future implementation may handle multiple 'trk' elements per document, as well as
+'trkseg' aggregates.  The observed structure of a gpx document is:
+
+  gpx
+  gpx|trk
+  gpx|trk|name
+  gpx|trk|desc
+  gpx|trk|trkseg
+  gpx|trk|trkseg|trkpt
+  gpx|trk|trkseg|trkpt|ele
+  gpx|trk|trkseg|trkpt|time
+  
+=end
+
+class GoobyGpxParser < GoobyBaseSaxParser
+      
+  def subclass_initialize
+    @tags, @trackpoints, @mappings,  = [], [], {}, 
+    @name, @desc = '', ''
+  end  
+    
+  def on_start_element(name, attributes, prefix=nil, uri=nil, namespaces=nil)
+    @tags.push(name) 
+    @current_text = ''
+    path = current_path
+    if path == 'gpx|trk|trkseg|trkpt'
+      @current_trackpoint = GoobyTrackpoint.new
+      @current_trackpoint.set('LatitudeDegrees',  attributes['lat'])
+      @current_trackpoint.set('LongitudeDegrees', attributes['lon'])
+      @current_trackpoint.set('Time', get_current_text)      
+      @trackpoints << @current_trackpoint
+    end
+  end
+  
+  def on_end_element(name, prefix=nil, uri=nil)
+    path = current_path
+    if path == 'gpx|trk|name'
+      @name = get_current_text
+    elsif path == 'gpx|trk|desc'
+      @desc = get_current_text
+    elsif path == 'gpx|trk|trkseg|trkpt|ele'
+      @current_trackpoint.set('AltitudeMeters', get_current_text)
+    elsif path == 'gpx|trk|trkseg|trkpt|time'
+      @current_trackpoint.set('Time', get_current_text)
+    end 
+    @current_text = ''
+    @tags.pop
+  end 
+  
+  def current_path
+    @tags.join('|')
+  end
+  
+  # Coumpute the elapsed time and distance of each Trackpoint within the Activity.
+  def post_process
+    cumulative_distance, first_tkpt_dttm, prev_tkpt, activ_id = 0.0, nil, nil, @name
+    @trackpoints.each_with_index { | tkpt, idx |
+      if prev_tkpt
+        incremental_distance = tkpt.proximity(prev_tkpt)
+        cumulative_distance = cumulative_distance + incremental_distance
+        tkpt.set('Distance', cumulative_distance)
+      else
+        first_tkpt_dttm = tkpt.dttm
+        tkpt.set('Distance', 0.0)
+        if activ_id.size < 1
+          activ_id = first_tkpt_dttm
+        end
+      end
+      tkpt.set('Seq', idx + 1)
+      tkpt.set('LapSeq', 1)
+      tkpt.set('ActivityId', activ_id)
+      tkpt.set('LapStartTime', first_tkpt_dttm)
+      tkpt.compute_elapsed_time(first_tkpt_dttm)
+      tkpt.compute_cumulative_pace_and_mph(first_tkpt_dttm)
+      prev_tkpt = tkpt
+    }
+  end
+  
+  def trackpoints_to_csv
+    lines = []
+    @trackpoints.each { | tkpt | 
+      lines << tkpt.to_csv
+    }
+    lines
+  end
+  
+end

data/lib/gooby_help_producer.rb

@@ -0,0 +1,40 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+---
+
+The help information is obtained here by "grepping" the given source code
+filename, and selecting the lines which contain three consecutive hash symbols.
+This enables the documentation to reside with the actual code.
+
+=end
+
+module GoobyHelpProducer
+
+  def produce_help_page(source_filename, print_it=false)
+    help_content, marker, lines = [], '###', IO.readlines(source_filename)
+    lines.each { | line |
+      if line.match(marker)
+        if line.strip == marker
+          help_content << "\n" 
+        else
+          help_content << line.strip[4..999] 
+        end
+      end       
+    }
+    help_content << '' 
+    if ENV['GOOBY_HOME']
+      help_content << "Your GOOBY_HOME directory is currently set to #{ENV['GOOBY_HOME']}"
+    else
+      help_content << "Your GOOBY_HOME directory environment variable has not been set; please do so."
+    end
+    help_content << '' 
+    if print_it 
+      help_content.each { | line | puts line }
+    end
+    help_content
+  end
+ 
+end

data/lib/gooby_introspection.rb

@@ -0,0 +1,25 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module GoobyIntrospection
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  def classname
+    self.class.name
+  end
+
+  module ClassMethods
+    
+    def classname
+      self.name
+    end
+    
+  end
+end

data/lib/gooby_io.rb

@@ -0,0 +1,30 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module GoobyIO
+              
+  def read_file_as_lines(filename)
+    IO.readlines(filename)
+  end
+  
+  def write_lines(out_name, lines)
+    s = ''
+    lines.each { | line | 
+      s << line
+      s << "\n"
+    }
+    write_file(out_name, s)
+  end
+
+  def write_file(out_name, content, mode='w+')
+    out = File.new out_name, mode
+    out.write content
+    out.flush
+    out.close
+  end
+  
+end 

data/lib/gooby_lap.rb

@@ -1,30 +1,39 @@
 =begin
 
-Gooby = Google APIs + Ruby
-Gooby - Copyright 2007 by Chris Joakim.
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
 Gooby is available under GNU General Public License (GPL) license.
 
 =end
 
-module Gooby
-
-=begin rdoc
-  Instances of this class represent a <Lap> aggregate object from a
-  Forerunner XML file.
-=end
+class GoobyLap < GoobyXmlObject
   
-  class Lap < GoobyObject
+  def initialize(attrs=nil)
+    base_initialize
+    if attrs
+      attrs.keys.each { | name | set(name, attrs[name]) }
+    end
+  end  
   
-    attr_accessor :number, :startTime, :duration, :length, :begin_position, :end_position
+  def start_time
+    get('StartTime')
+  end
   
-    def initialize(num)
-      @number = num  
-    end
+  def seconds
+    get('TotalTimeSeconds').to_f
+  end
+    
+  def distance_in_meters
+    get('DistanceMeters').to_f
+  end
+  
+  def max_speed
+    get('MaximumSpeed').to_f
+  end  
 
-    def to_s
-      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@begin_position.to_s} end: #{@end_position.to_s}"
-    end
+  def dump
+    puts "Lap: #{id}, #{sequence}, #{start_time}, #{distance_in_meters}, #{max_speed}"
+  end
+  
+end
 
-  end 
 
-end # end of module

data/lib/gooby_process.rb

@@ -0,0 +1,281 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+class GoobyProcess
+
+  include GoobyConfiguration
+  include GoobyEnvironment
+  include GoobyHelpProducer
+  include GoobyIO
+  
+  attr_reader :method_name, :subsystem, :tmp_dir, :start_time, :exception
+  attr_reader :dispatch, :help_content, :system_test_commands
+
+  def initialize(method_name_symbol, opts={})
+    begin
+      @start_time, @method_name = Time.now, method_name_symbol.to_s
+      if opts
+        opts.keys.each { | key | ENV[key.to_s] = opts[key].to_s }
+      end   
+      if @method_name != 'help'
+        puts "---" 
+        puts "Beginning of Gooby process: '#{method_name_symbol}'" 
+      end
+      self.send(method_name_symbol.to_s) # "dynamic dispatch" to the implementation method
+    rescue Exception => e
+      @exception = e
+      puts "Exception in process #{process_info}"  
+      puts "class:     #{e.class.name}"  
+      puts "exception: #{e.inspect}"    
+      if e.backtrace && e.backtrace.class == Array
+        e.backtrace.each { | line | puts line }
+      else
+        puts e.backtrace
+      end   
+    ensure
+      if @method_name != 'help'      
+        end_time = Time.now     
+        elapsed  = end_time - start_time
+        minutes  = elapsed.to_f / 60.0
+        hours    = elapsed.to_f / 3600.0
+        puts "Process completed #{Time.now.to_s}." 
+        puts sprintf("Elapsed seconds %6.6f = %5.6f minutes = %2.6f hours", elapsed, minutes, hours) 
+        puts "---" 
+      end
+    end
+  end
+  
+  def classname
+    self.class.name
+  end
+  
+  def process_info
+    "'#{classname}.#{method_name.to_s}'"
+  end
+  
+  def gooby_home
+    ENV['GOOBY_HOME']
+  end
+  
+  ### 
+  ### Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+  ### Gooby is available under GNU General Public License (GPL) license.
+  ### Version 2.0.0
+  ###
+  ### Directory Structure:
+  ###   {GOOBY_HOME}              Your chosen directory on your computer in which to store Gooby files.
+  ###                             You must set the "GOOBY_HOME" environment variable on your computer to this
+  ###                             chosen directory name.
+  ###   {GOOBY_HOME}/config       Contains configuration files in yaml format.
+  ###                             File /config/gooby_config.yaml is the "base" configuration file, and is read first.
+  ###                             This file typically remains unchanged after your intial edits to it.  Be sure to
+  ###                             set "gmap_key" to your Google Maps key, and "gmap_icon_url_base" to the URL on
+  ###                             your site where the map icon images are located.
+  ###                             You should create one "map-specific" yaml file for each map you wish to create.
+  ###                             It "inherits" all entries from the base configuration file, gooby_config.yaml.
+  ###                             So just specify the additions or overrides in your map-specific yaml files.
+  ###                             This design allows you generate your various maps, without having to frequently
+  ###                             reset the values the the base configuration file.
+  ###   {GOOBY_HOME}/csv          Gooby places CSV data files in this directory.  All Gooby parsers create a
+  ###                             standard CSV format that you can use to generate either Google maps or Google Earth
+  ###                             maps with.
+  ###   {GOOBY_HOME}/data         You place data files from your desktop GPS software here.
+  ###   {GOOBY_HOME}/out          Gooby places generated Google Map html files and Google Earth kml files here.
+  ###   {GOOBY_HOME}/out/images   Standard set of images here which are used in the generated html & kml files.
+  ###                             Add your own images here, or replace the existing ones, as necessary.
+  ###   {GOOBY_HOME}/samples      Contains a set of sample files for your reference.
+  ###   {GOOBY_HOME}/splits       Gooby places individual 'activity xml files' here, split-out from a large tcx file.
+  ###   {GOOBY_HOME}/tmp          Temporary files.
+  ### 
+  ### List of Gooby commands (in order of typical usage):
+  ###   rake                                    # Default task; same as 'rake gooby:help'.
+  ###   rake gooby:help                         # Display Gooby usage instructions.  
+  ###   rake gooby:extract_activities_from_tcx  # Extract individual Activity xml files from a Garmin tcx file
+  ###   rake gooby:parse_activity_xml_to_csv    # Parse an extracted Activity xml file to a corresponding csv file.
+  ###   rake gooby:parse_track_log_to_csv       # Parse a GPS Track Log file a corresponding csv file.  
+  ###   rake gooby:parse_gpx_to_csv             # Parse a *.gpx file into a corresponding csv file.
+  ###   rake gooby:generate_google_map          # Generate a Google Map from a csv file.
+  ###   rake gooby:generate_google_earth_map    # Generate a Google Earth kml file from a csv file, with optional
+  ###                                             kmz file generation. 
+  ###
+  ### Gooby Command Detail:
+  ###
+  ### command:     rake gooby:help
+  ### description: Displays help information for each Gooby command.
+  ### parameters:  none  
+  def help
+    produce_help_page(__FILE__, true)
+  end 
+   
+  ###   
+  ### ---
+  ### 
+  ### command:     rake gooby:extract_activities_from_tcx
+  ### description: Splits the potentially huge Garmin Training Center tcx file into individual 
+  ###              Activity xml files, and places these in the /splits directory.  Each has a filename 
+  ###              based on the starting date/time of the activity.  
+  ### parameters:  tcx_file - The input file, created by exporting from Garmin Training Center.
+  ###              Defaults to 'data/current.tcx' in your GOOBY_HOME directory.
+  ##  example:     rake gooby:extract_activities_from_tcx tcx_file=data/current.tcx
+  def extract_activities_from_tcx
+    tcx_file = command_line_arg('tcx_file', "#{gooby_home}/data/current.tcx")
+    if File.exist?(tcx_file)
+      puts "processing file: #{tcx_file}"
+      extractor = GoobyTcxExtractor.new
+      extractor.extract(tcx_file, "#{gooby_home}/splits")
+    else
+      puts "file does not exist: #{tcx_file}  GOOBY_HOME is #{gooby_home}"
+    end
+  end
+  
+  ###   
+  ### ---
+  ### 
+  ### command:     rake gooby:parse_activity_xml_to_csv
+  ### description: Parse an extracted Activity xml 'split' file to a corresponding csv file.
+  ### parameters:  config_file - Your yaml configuration file in /config.
+  ###              Defaults to 'config/gooby_config.yaml' in your GOOBY_HOME directory.
+  ### note 1:      The configuration file entry 'activity_xml_file' specifies the xml file that
+  ###              will be read and parsed into csv.
+  ### note 2:      The configuration file entry 'csv_file' specifies the csv file that will be created.
+  ### example:     rake gooby:parse_activity_xml_to_csv config_file=config/big_sur_marathon.yaml
+  def parse_activity_xml_to_csv
+    config_file = command_line_arg('config_file', nil)
+    read_configuration(config_file)    
+    file     = @configuration['activity_xml_file']
+    csv_file = @configuration['csv_file']    
+    if File.exist?(file)
+      puts "processing file: #{file}"
+      parser = GoobyGarminTcxParser.new
+      parser.process_file(file)
+      puts "parser.error #{parser.error}"  if parser.error
+      puts "parser.exception #{parser.exception}"  if parser.exception
+      parser.post_process
+      csv_lines = parser.trackpoints_to_csv
+      # basename = File.basename(file)
+      # basename.gsub!('.xml', '.csv')
+      csv_filename = "#{gooby_home}/#{csv_file}"
+      # csv_filename.gsub!('.xml', '.csv')
+      write_lines(csv_filename, csv_lines)
+      puts "file written; #{csv_filename}"
+    else
+      puts "file does not exist: #{file}"
+    end
+  end
+  
+  ###
+  ### ---
+  ### 
+  ### command:     rake gooby:parse_gpx_to_csv
+  ### description: Parse a *.gpx file into a corresponding csv file.
+  ### parameters:  config_file - Your yaml configuration file in /config.
+  ###              Defaults to 'config/gooby_config.yaml' in your GOOBY_HOME directory. 
+  ### note 1:      The configuration file entry 'gpx_file' specifies the gpx file that
+  ###              will be read and parsed into csv.  
+  ### note 2:      The configuration file entry 'csv_file' specifies the csv file that will be created.
+  ### example:     rake gooby:parse_gpx_to_csv config_file=config/ballantyne.yaml
+  def parse_gpx_to_csv
+    config_file = command_line_arg('config_file', nil)
+    read_configuration(config_file)    
+    file     = @configuration['gpx_file']
+    csv_file = @configuration['csv_file']
+    if File.exist?(file)
+      puts "processing file: #{file}"
+      parser = GoobyGpxParser.new
+      parser.process_file(file)
+      puts "parser.error #{parser.error}"  if parser.error
+      puts "parser.exception #{parser.exception}"  if parser.exception
+      parser.post_process
+      csv_lines = parser.trackpoints_to_csv
+      # basename = File.basename(file)
+      # basename.gsub!('.gpx', '.csv')
+      csv_filename = "#{gooby_home}/#{csv_file}"
+      #csv_filename.gsub!('.gpx', '.csv')
+      write_lines(csv_filename, csv_lines)
+      puts "file written; #{csv_filename}"
+    else
+      puts "file does not exist: #{file}"
+    end
+  end
+  
+  ### 
+  ### ---
+  ### 
+  ### command:     rake gooby:parse_track_log_to_csv
+  ### description: Parse an extracted 'GPS Tracks Log' file from MacGpsPro into csv format.
+  ### parameters:  config_file - Your yaml configuration file in /config.
+  ###              Defaults to 'config/gooby_config.yaml' in your GOOBY_HOME directory.  
+  ### note 1:      The configuration file entry 'track_log_file' specifies the track log file that
+  ###              will be read and parsed into csv.  The filename suffix should be '.txt'.
+  ### note 2:      It is strongly recommended that you manually copy the 'GPS Tracks Log' file
+  ###              from your MacGpsPro installation to the GOOBY_HOME/data directory, and rename it to
+  ###              'gps_track_logs.txt', before running this command.  Then manually edit out the lines 
+  ###              not pertinent to the map you want to generate.  
+  ### note 3:      I use MacGpsPro to read the GPS data from my Garmin eTrex Venture device, since the
+  ###              Garmin Training Center software does not support this device.
+  ### example:     rake gooby:parse_track_log_to_csv config_file=config/crowders_mtn_hike.yaml
+  def parse_track_log_to_csv
+    config_file = command_line_arg('config_file', nil)
+    read_configuration(config_file)    
+    logs_file = @configuration['track_log_file']
+    logs_file = "#{gooby_home}/data/gps_track_logs.txt" if logs_file.nil?
+    csv_file  = @configuration['csv_file']
+    if File.exist?(logs_file)
+      puts "processing file: #{logs_file}"
+      parser = GoobyTracksLogParser.new
+      parser.parse(logs_file)
+      csv_lines = parser.trackpoints_to_csv  
+      csv_filename = "#{gooby_home}/#{csv_file}"
+      write_lines(csv_filename, csv_lines)
+      puts "file written; #{csv_filename}"
+    else
+      puts "file does not exist: #{logs_file}"
+    end
+  end
+
+  ### 
+  ### ---
+  ### 
+  ### command:     rake gooby:generate_google_map
+  ### description: Generate a Google Map html file from a csv file.
+  ### parameters:  config_file - Your yaml configuration file in /config.
+  ###              Defaults to 'config/gooby_config.yaml' in your GOOBY_HOME directory.
+  ### note 1:      The configuration file entry 'csv_file' specifies the csv data file that
+  ###              will be read and used to generate the map.
+  ### example:     rake gooby:generate_google_map config_file=config/big_sur_marathon.yaml 
+  def generate_google_map
+    config_file = command_line_arg('config_file', "#{gooby_home}/config/gooby_config.yaml")
+    generator = GoobyGoogleMapGenerator.new
+    generator.generate(config_file)
+  end
+
+  ### 
+  ### ---
+  ### 
+  ### command:     rake gooby:generate_google_earth_map
+  ### description: Generate a Google Earth kml file from a csv file.
+  ### parameters:  config_file - Your yaml configuration file in /config.
+  ###              Defaults to 'config/gooby_config.yaml' in your GOOBY_HOME directory.
+  ### note 1:      The configuration file entry 'csv_file' specifies the csv data file that
+  ###              will be read and used to generate the map.
+  ### note 2:      Gooby will optionally create a kmz file for you.  A kmz file is essentially a 
+  ###              zip file, which contains your kml file(s), as well as any associated files such
+  ###              as images.  Two parameters are required in your yaml config file for kmz generation:
+  ###              'kmz_build' must be set to true, and 'kmz_build_command' must be the appropriate
+  ###              zip-creating command for your operating system and set of installed software.
+  ###              A Mac OS/X example command is: zip -r gooby_big_sur.kmz .
+  ### example:     rake gooby:generate_google_earth_map config_file=config/big_sur_marathon.yaml
+  def generate_google_earth_map
+    config_file = command_line_arg('config_file', "#{gooby_home}/config/gooby_config.yaml")
+    generator = GoobyGoogleKmlGenerator.new
+    generator.generate(config_file)
+  end
+  
+  ### 
+  ### ---
+  
+end