gooby 0.9.4 → 0.9.5

data/lib/gooby/cls_geo_data.rb

@@ -1,181 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class represent a the set of Geographic data defined in file geo.txt
-=end
-
-  class GeoData < GoobyObject
-  
-    attr_reader :filename, :lines, :poi_hash, :poi_array, :track_hash, :track_array, :route_hash, :route_array
-  
-    def initialize(filename)
-      @filename    = filename
-      @filename    = 'data/geo_data.txt'  if @filename == nil
-      @lines       = read_lines(@filename, true)
-      @poi_hash    = Hash.new
-      @poi_array   = Array.new
-      @track_hash  = Hash.new
-      @track_array = Array.new
-      @route_hash  = Hash.new
-      @route_array = Array.new
-      parse_poi
-      parse_tracks
-      parse_routes
-    end
-    
-    private
-    
-    def parse_poi
-      in_poi, poi_number = false, 0
-      @lines.each { |line|
-        line_obj  = Line.new(line, nil, true)
-        tok_count = line_obj.token_count
-        is_point  = line_obj.token_idx_equals(0, '.')
-        
-        if line_obj.is_populated_non_comment          
-          if line_obj.match('points_of_interest_start')
-            in_poi  = true
-          elsif line_obj.match('points_of_interest_end')
-            in_poi  = false  
-          elsif in_poi && tok_count > 2 && is_point
-            poi_number = poi_number + 1
-            tkpt = Trackpoint.new(
-              poi_number, line_obj.tokens[1], line_obj.tokens[2], 
-              '0', '', line_obj.concatinate_tokens(3))
-            add_poi(tkpt)
-          end
-        end
-      }
-    end
-    
-    def parse_tracks
-      in_track, trk_number, tkpt_number = false, 0, 0
-      curr_trk, curr_run = nil, nil
-      @lines.each { |line|
-        line_obj  = Line.new(line, nil, true)
-        tok_count = line_obj.token_count
-        is_point  = line_obj.token_idx_equals(0, '.')
-        
-        if line_obj.is_populated_non_comment
-          if line_obj.match('track_start')
-            in_track    = true
-            trk_number  = trk_number + 1
-            tkpt_number = 0
-            curr_trk    = Track.new(0, line_obj.concatinate_tokens(1))    
-            curr_run    = Run.new(trk_number, line_obj.concatinate_tokens(1))                      
-            curr_run.add_track(curr_trk) 
-          elsif line_obj.match('track_end')
-            in_track = false
-            curr_run.finish 
-            add_track(curr_trk)
-            add_route(curr_run)
-          elsif in_track && tok_count > 2 && is_point
-            tkpt_number = tkpt_number + 1
-            tkpt = Trackpoint.new(
-              tkpt_number, line_obj.tokens[1], line_obj.tokens[2], 
-              '0', '', line_obj.concatinate_tokens(3))
-            curr_trk.add_trackpoint(tkpt)
-          end          
-        end
-      }
-    end
-    
-    def parse_routes
-      in_route, route_number, trk_number, tkpt_number = false, 0, 0, 0
-      curr_trk, curr_run = nil, nil
-      @lines.each { |line|
-        line_obj  = Line.new(line, nil, true)
-        tok_count = line_obj.token_count
-        is_point  = line_obj.token_idx_equals(0, '.')
-        
-        if line_obj.is_populated_non_comment
-          if line_obj.match('route_start')
-            in_route    = true
-            trk_number  = trk_number + 1
-            tkpt_number = 0
-            curr_trk    = Track.new(0, line_obj.concatinate_tokens(1))    
-            curr_run    = Run.new(trk_number, line_obj.concatinate_tokens(1))                      
-            curr_run.add_track(curr_trk) 
-          elsif line_obj.match('route_end')
-            in_route = false
-            curr_run.finish 
-            add_route(curr_run)
-          elsif in_route && tok_count > 2 && is_point
-            tkpt_number = tkpt_number + 1
-            tkpt = Trackpoint.new(
-              tkpt_number, line_obj.tokens[1], line_obj.tokens[2], 
-              '0', '', line_obj.concatinate_tokens(3))
-            curr_trk.add_trackpoint(tkpt)
-          elsif in_route && line_obj.token_idx_equals(0, 'track') && tok_count > 1
-            trk_desc = line_obj.concatinate_tokens(1)
-            trk = @track_hash[trk_desc]
-            if trk
-              trk.trackpoints.each { |tkpt| curr_trk.add_trackpoint(tkpt) }
-            end
-          elsif in_route && line_obj.token_idx_equals(0, 'track_rev') && tok_count > 1
-            trk_desc = line_obj.concatinate_tokens(1)
-            trk = @track_hash[trk_desc]
-            if trk
-              array = trk.trackpoints
-              trk.trackpoints.each { |tkpt| curr_trk.add_trackpoint(tkpt) }
-            end            
-          end          
-        end
-      }      
-    end
-
-    def add_poi(tkpt)
-      if tkpt
-        descr = tkpt.descr
-        if @poi_hash.has_key? descr
-          puts "Duplicate POI key ignored - '#{descr}'"
-        else
-          #puts "Adding POI: #{tkpt.to_poi_csv}"          
-          @poi_hash[descr] = tkpt
-          @poi_array << tkpt
-        end
-      end
-    end
-    
-    def add_track(trk)
-      if trk
-        descr = trk.descr
-        if @track_hash.has_key? descr
-          puts "Duplicate Track key ignored - '#{descr}'"
-        else       
-          @track_hash[descr] = trk
-          @track_array << trk
-        end
-      end
-    end
-
-    def add_route(run)
-      if run
-        descr = run.descr
-        if @route_hash.has_key? descr
-          puts "Duplicate Route key ignored - '#{descr}'"
-        else       
-          @route_hash[descr] = run
-          @route_array << run
-        end
-      end
-    end
-    
-    public
-
-    def to_s
-      return "GeoData lines: #{lines.size} poi: #{@poi_hash.size} tracks: #{@track_hash.size} routes: #{@route_hash.size} "
-    end
-    
-    def dump
-      puts "#{self.class} dump:"
-      @poi_array.each { |tkpt| puts "POI: #{tkpt.to_geo_s}"  }
-      @track_array.each { |trk| trk.dump  }
-      @route_hash.keys.sort.each { |key| 
-        puts "Route: '#{key}'"
-      }      
-    end
-      
-  end 
-
-end # end of module

data/lib/gooby/cls_gooby_command.rb

@@ -1,46 +0,0 @@
-module Gooby
-
-=begin rdoc
-  This class provides "user friendly DSL" functionality for the use
-  of Gooby.
-=end
-  
-  class GoobyCommand < GoobyObject 
-    
-    def initialize
-    end
-    
-    def options(yaml_filename) 
-      Gooby::Options.new(yaml_filename)
-    end
-
-    def split_garmin_forerunner_logbook_xml(xml_filename, out_dir)  
-      splitter = Gooby::ForerunnerXmlSplitter.new(xml_filename, out_dir)  
-      splitter.split
-    end
-    
-    def split_garmin_training_center_xml(tcx_filename, out_dir)  
-      splitter = Gooby::TrainingCenterXmlSplitter.new(tcx_filename, out_dir)  
-      splitter.split
-    end
-        
-    def parse_garmin_forerunner_logbook_xml(xml_filename)  
-      handler = Gooby::ForerunnerXmlParser.new     
-      Document.parse_stream((File.new xml_filename), handler)
-      handler.put_all_run_tkpt_csv(true)
-    end
-    
-    def parse_garmin_training_center_xml(tcx_filename)  
-      handler = Gooby::TrainingCenterXmlParser.new     
-      Document.parse_stream((File.new tcx_filename), handler)
-      handler.put_all_run_tkpt_csv(true)
-    end
-    
-    def generate_google_map(csv_filename, options_obj)  
-      generator = Gooby::GoogleMapGenerator.new(csv_filename)  
-      generator.generate_page(options_obj)
-    end
-         
-  end
-  
-end # end of module

data/lib/gooby/cls_gooby_object.rb

@@ -1,18 +0,0 @@
-module Gooby
-
-=begin rdoc
-  This is the abstract superclass of several Gooby classes.
-  Includes modules GoobyIO, Introspect, and GoobyProjectInfo.
-=end
-  
-  class GoobyObject  
-    
-    include Gooby::GoobyIO  
-    include Gooby::GoobyString
-    include Gooby::Introspect
-    include Gooby::GoobyProjectInfo
-    include Gooby::Con
-    
-  end
-  
-end # end of module

data/lib/gooby/cls_google_map_generator.rb

@@ -1,363 +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 GoogleMapGenerator < GoobyObject 
-  
-    attr_reader :csv_file, :csv_lines, :dttm_idx, :num_idx, :lat_idx, :lng_idx, :alt_idx, :cdist_idx
-    attr_reader :run, :tkpts, :content_hash, :center_longitude, :center_latitude, :gpoint_array, :overlay_points, :notes    
-    attr_reader :center_longitude, :center_latitude
-    
-    # The default csv input file format is as follows:
-    # 1 | 2006-01-15T18:31:10Z | 1279 | 33.42601 | -111.92927 | 347.654 | 26.3514930151813
-    # 1 | 2004-11-13T13:05:20Z | 2 | 37.54318 | -77.43636 | -58.022 | 0.00297286231747969 
-    
-    def initialize(csv_file, dttm_idx=1, num_idx=2, lat_idx=3, lng_idx=4, alt_idx=5, cdist_idx=6)
-      @csv_file  = csv_file
-      @dttm_idx  = dttm_idx
-      @num_idx   = num_idx
-      @lat_idx   = lat_idx
-      @lng_idx   = lng_idx
-      @alt_idx   = alt_idx
-      @cdist_idx = cdist_idx
-      @options   =  Gooby::Options.new(nil)
-      @content_hash = Hash.new('')
-      @run   = Gooby::Run.new(1)
-      @track = Gooby::Track.new(1)
-      @run.add_track(@track)
-      @tkpts = Array.new
-      
-      @csv_lines = read_as_ascii_lines(@csv_file, 10, true) 
-      @csv_lines.each { | line |
-        dline = Gooby::DelimLine.new(line)
-        if (!dline.is_comment?)
-          tkpt = dline.as_trackpoint(@num_idx, @lat_idx, @lng_idx, @alt_idx, @dttm_idx)
-          if tkpt
-            @track.add_trackpoint(tkpt)
-          end
-        end
-      }
-      @run.finish
-    end
-    
-=begin
-Returns a Hash with specific generated content at the following keys:
-=end
-    def generate(options)
-      if (options == nil)
-        @options =  Gooby::Options.new(nil)
-      else
-        @options = options
-      end  
-      @content_hash['when_generated'] = Time.now
-      @content_hash['title'] = @options.get('gmap_title')               
-      filter_trackpoints  
-      compute_center_point
-      generate_key_js
-      generate_map_div
-      generate_messages_div
-      generate_main_js_start
-      generate_main_js_route_overlay
-      generate_main_js_checkpoint_overlays
-      generate_main_js_map_clicked_listeners      
-      generate_main_js_end    
-      @content_hash
-    end
-
-    def filter_trackpoints        
-      count, @tkpts = 0, Array.new
-      firstTkpt = @options.get('gmap_first_tkpt_number')
-      lastTkpt  = @options.get('gmap_last_tkpt_number')
-      @run.tracks.each { |trk| 
-        trk.trackpoints.each { |tkpt|
-          count = count + 1
-          if ((count >= firstTkpt) && (count <= lastTkpt))
-            @tkpts.push(tkpt)
-          end
-        }
-      }   
-    end
-    
-=begin
-Returns a Hash with specific generated content at the following keys:
-=end 
-    def generate_page(options)
-
-      # puts "generate_page #{@csv_file} #{@csv_lines.size}"
-      content_hash = generate(nil)
-      s = String.new(@csv_file)
-      s.gsub("/", " ")
-      tokens = tokenize(s, nil)
-      out_file = "#{tokens[-2]}.html"
-      #content_hash.keys.sort.each { | key | puts key }
-
-s = <<HERE
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
-    <title> Google Map by Gooby </title>
-    #{content_hash['key_js']}
-    #{content_hash['main_js_start']}
-    #{content_hash['main_js_route_overlay']}  
-    #{content_hash['main_js_checkpoint_overlays']}  
-    #{content_hash['main_js_map_clicked_listeners']}  
-    #{content_hash['main_js_end']}
-  </head>
-  <body onload="load()" onunload="GUnload()">
-    <center>
-    <h3> #{content_hash['title']} </h3>
-    <h5> Generated by Gooby #{content_hash['when_generated']} <br> Gooby = Google APIs + Ruby </h5>    
-    #{content_hash['map_div']}    
-    #{content_hash['messages_div']}   
-    </center>
-  </body>
-</html>
-HERE
-
-      # html_file = File.new(out_file, "w+")
-      # html_file.write(s)
-      # html_file.flush
-      # html_file.close  
-      puts s   # Output is redirected by shell.    
-    end
-    
-    private
-    
-    def compute_center_point            
-      highLat  = -999.0
-      highLong = -999.0
-      lowLat   =  999.0      
-      lowLong  =  999.0
-      @tkpts.each { |tkpt|
-        highLat  = tkpt.latitude_as_float  if tkpt.latitude_as_float  > highLat
-        lowLat   = tkpt.latitude_as_float  if tkpt.latitude_as_float  < lowLat  
-        highLong = tkpt.longitude_as_float if tkpt.longitude_as_float > highLong
-        lowLong  = tkpt.longitude_as_float if tkpt.longitude_as_float < lowLong  
-      }
-      @center_longitude = (highLong + lowLong) / 2
-      @center_latitude  = (highLat  + lowLat)  / 2
-      @content_hash['center_longitude'] = @center_longitude
-      @content_hash['center_latitude']  = @center_latitude       
-    end
-          
-    def generate_key_js              
-      key  = @options.get('gmap_key')    
-      key.strip!
-      s    = '<script src="http://maps.google.com/maps?file=api&v=2&key=' 
-      s << key
-      s << '" type="text/javascript"></script>'
-      @content_hash['key_js'] = s
-    end
-    
-    def generate_map_div
-      width  = @options.get('gmap_width')
-      height = @options.get('gmap_height')
-      id     = @options.get('gmap_map_element_id')      
-      s = '<div id="'
-      s << id
-      s << '" style="width: '
-      s << width
-      s << '; height: '
-      s << height
-      s << '"></div>'
-      @content_hash['map_width']  = width  
-      @content_hash['map_height'] = height          
-      @content_hash['map_div']    = s            
-    end
-
-    def generate_messages_div
-      s = "<div id=\"messages\"></div>"
-      @content_hash['messages_div'] = s            
-    end
-    
-    def generate_main_js_start
-      id    = @options.get('gmap_map_element_id')  
-      size  = @options.get('gmap_size_control')
-      type  = @options.get('gmap_type')
-      zoom  = @options.get('gmap_zoom_level')
-      title = @options.get('gmap_title')            
-      if size
-        if size == 'smallmap'
-          size = 'GSmallMapControl'
-        elsif size == 'smallzoom'
-          size = 'GSmallMapControl'          
-        else
-          size = 'GLargeMapControl'          
-        end          
-      end
-        
-      if type
-        if type == 'satellite'
-          type = 'G_SATELLITE_MAP'
-        elsif type == 'hybrid'
-          type = 'G_HYBRID_MAP'
-        else
-          type = 'G_NORMAL_MAP'
-        end
-      else
-        type = 'G_NORMAL_MAP'
-      end
-                         
-      s  =  '<script type="text/javascript">'
-      s << "\n"
-      s << "//<![CDATA[ \n"
-      s << "    function load() { \n"
-      s << "        if (GBrowserIsCompatible()) { \n"
-      s << '            var map = new GMap2(document.getElementById("'
-      s << id
-      s << '")); '
-      s << "\n"
-    
-      if size
-        s << '            map.addControl(new '
-        s << size
-        s << '());'
-        s << "\n"        
-      end
-      
-      if type
-        s << '            map.addControl(new GMapTypeControl());'
-        s << "\n"
-        # s << '            map.setMapType('
-        # s << type
-        # s << ');'
-        s << "\n"        
-      end   
-      s << "            var centerPoint = new GLatLng(#{@center_latitude}, #{@center_longitude}); \n"
-      s << "            map.setCenter(centerPoint, #{zoom}); \n"         
-      s << "\n"
-      @content_hash['main_js_start'] = s 
-      @content_hash['title'] = title
-    end
-    
-    def generate_main_js_route_overlay
-      tkpt_count = @tkpts.size.to_f
-      app_max    = @options.get('gmap_approx_max_points').to_f
-      comments   = @options.get('gmap_gen_comments')   
-      ratio      = tkpt_count / app_max
-      @start_dttm = nil
-      if ratio > 1.0
-        increment = (tkpt_count / app_max).to_i
-      else
-        increment = 1
-      end
-      curr_idx, next_idx, gpoint_count, last_idx = -1, 0, 0, @tkpts.size - 1
-      s = "        var points = new Array(); " 
-      @tkpts.each { |tkpt|
-        curr_idx = curr_idx + 1
-        if curr_idx == 0
-          @start_dttm = tkpt.dttm
-          @start_pos  = tkpt.position
-          time        = Time.parse(@start_dttm.dateTime().to_s)
-        end
-        if ((curr_idx == next_idx) || (curr_idx == last_idx) || (tkpt.is_split()))
-          gpoint_count = gpoint_count + 1
-          s << tkpt.as_glatlng(comments, tkpt_count, curr_idx, gpoint_count, @start_dttm)
-          next_idx = curr_idx + increment
-        end
-      }
-      s << "\n"
-      s << "\n            var routePolyline = new GPolyline(points); "
-      s << "\n            map.addOverlay(routePolyline); "      
-      @content_hash['main_js_route_overlay'] = s 
-      @content_hash['main_js_route_overlay_increment'] = increment                  
-    end
-    
-    def generate_main_js_checkpoint_overlays
-      s =  "\n            // Create a base icon for all of our markers that specifies the "
-  		s << "\n            // shadow, icon dimensions, etc."
-  		s << "\n            var baseIcon = new GIcon();"
-  		s << "\n            baseIcon.shadow = \"http://www.joakim-systems.com/gicons/shadow50.png\";"
-  		s << "\n            baseIcon.iconSize = new GSize(20, 34);"
-  		s << "\n            baseIcon.shadowSize = new GSize(37, 34);"
-  		s << "\n            baseIcon.iconAnchor = new GPoint(9, 34);"
-  		s << "\n            baseIcon.infoWindowAnchor = new GPoint(9, 2);"
-  		s << "\n            baseIcon.infoShadowAnchor = new GPoint(18, 25);"
-  		s << "\n"
-  		
-      curr_idx  = -1
-      last_idx  = @tkpts.size - 1
-      next_checkpoint = 0.0
-      @start_dttm = nil
-      @tkpts.each { | tkpt |
-        curr_idx = curr_idx + 1
-        if curr_idx == 0
-          @start_dttm = tkpt.dttm           
-          info_window_html = tkpt.as_info_window_html('Start', @start_dttm)
-          s << "\n            var iconStart = new GIcon(baseIcon); "
-          s << "\n            iconStart.image = \"http://www.joakim-systems.com/gicons/dd-start.png\";"
-          s << "\n            var pStart = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
-          s << "\n            var mStart = new GMarker(pStart, iconStart);"
-          s << "\n            GEvent.addListener(mStart, \"click\", function() { "
-          s << "\n                mStart.openInfoWindowHtml(#{info_window_html});"
-          s << "\n            });	"
-          s << "\n            map.addOverlay(mStart);"
-          s << "\n " 
-          next_checkpoint = 1.0      
-        elsif curr_idx == last_idx
-          info_window_html = tkpt.as_info_window_html('Finish', @start_dttm)          
-          s << "\n            var iconFinish = new GIcon(baseIcon); "
-          s << "\n            iconFinish.image = \"http://www.joakim-systems.com/gicons/dd-end.png\";"
-          s << "\n            var pFinish = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
-          s << "\n            var mFinish = new GMarker(pFinish, iconFinish);"
-          s << "\n            GEvent.addListener(mFinish, \"click\", function() { "
-          s << "\n                mFinish.openInfoWindowHtml(#{info_window_html});"
-          s << "\n            });	"
-          s << "\n            map.addOverlay(mFinish);"
-          s << "\n " 
-          next_checkpoint = 999999
-        else
-          if (tkpt.cumulativeDistance >= next_checkpoint)
-            integer = next_checkpoint.to_i
-            info_window_html = tkpt.as_info_window_html("#{integer}", @start_dttm)              
-            s << "\n            var icon#{integer} = new GIcon(baseIcon); "
-            s << "\n            icon#{integer}.image = \"http://www.joakim-systems.com/gicons/marker#{integer}.png\";"
-            s << "\n            var p#{integer} = new GPoint(#{tkpt.longitude_as_float}, #{tkpt.latitude_as_float});"
-            s << "\n            var m#{integer} = new GMarker(p#{integer}, icon#{integer});"
-            s << "\n            GEvent.addListener(m#{integer}, \"click\", function() { "
-            s << "\n                m#{integer}.openInfoWindowHtml(#{info_window_html});"
-            s << "\n            });	"
-            s << "\n            map.addOverlay(m#{integer});"
-            s << "\n " 
-            next_checkpoint = next_checkpoint + 1.0   
-          end                         
-        end
-      }
-      s << "\n"    
-      @content_hash['main_js_checkpoint_overlays'] = s 
-    
-    end
-    
-    def generate_main_js_map_clicked_listeners
-      s =  "\n"
-      s << "\n            GEvent.addListener(map, \"click\", function() { "
-      s << "\n                var center = map.getCenter(); \n"
-      s << "\n                document.getElementById(\"messages\").innerHTML = 'click: ' + center.toString(); "
-      s << "\n            });"
-      s << "\n            GEvent.addListener(map, \"moveend\", function() { "
-      s << "\n                var center = map.getCenter(); \n"
-      s << "\n                document.getElementById(\"messages\").innerHTML = 'moveend: ' + center.toString(); "
-      s << "\n            });"
-      @content_hash['main_js_map_clicked_listeners'] = s 
-    end
-    
-    def generate_main_js_end
-      s =  "\n        } "
-      s << "\n    } "
-      s << "\n//]]> \n"        
-      s << "\n</script>" 
-       
-      @content_hash['main_js_end'] = s            
-    end
-       
-  end
-  
-end # end of module

data/lib/gooby/cls_history.rb

@@ -1,33 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class represent a <History> aggregate object from a
-  Forerunner XML file.
-=end
-    
-  class History < GoobyObject 
-  
-    attr_reader :runs
-  
-    def initialize
-      @runs = Array.new
-    end
-  
-  # Adds a Run during XML parsing.
-    def add_run(run)  
-      @runs.push(run)    
-    end
-  
-    def to_s
-      return "Hist: runs: #{@runs.size}"
-    end
-  
-    def print_string
-      s = "History: run count=#{@runs.size} \n"
-      runs.each { | run | s << run.print_string }
-      s
-    end
-    
-  end 
-  
-end # end of module

data/lib/gooby/cls_lap.rb

@@ -1,22 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class represent a <Lap> aggregate object from a
-  Forerunner XML file.
-=end
-  
-  class Lap < GoobyObject
-  
-    attr_accessor :number, :startTime, :duration, :length, :beginPosition, :endPosition
-  
-    def initialize(num)
-      @number = num  
-    end
-
-    def to_s
-      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@beginPosition.to_s} end: #{@endPosition.to_s}"
-    end
-      
-  end 
-
-end # end of module