gooby 1.2.0 → 2.0.0

data/lib/gooby_command.rb

@@ -1,210 +0,0 @@
-=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 GoobyCommand < GoobyObject 
-    
-    attr_reader :configuration, :csv_points, :csv_col_names
-    
-    def initialize(gooby_yaml_filename=nil)
-      @configuration = Gooby::Configuration.init(gooby_yaml_filename)
-    end
-    
-    def display_configuration
-      #puts @configuration.to_s
-      @configuration.print_all
-    end
-    
-    def display_version
-      s = "# #{project_name} #{project_version_number} #{project_date}.  #{project_copyright}."
-      puts s
-    end
-
-    def split_garmin_export_file(argv)
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 3)
-        puts ""
-        puts "Invalid program args; three args required - format, input filename, output directory"
-        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
-        puts "  the second arg is the input filename - which is a garmin export file"
-        puts "  the third arg is the output directory where the split files are written to\n\n"
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        format   = argv[0].downcase
-        filename = argv[1]
-        out_dir  = argv[2]
-        
-        if (format == 'garmin201')
-          split_garmin_forerunner_logbook_xml(filename, out_dir)
-        else
-          split_garmin_training_center_xml(filename, out_dir) 
-        end
-      end
-    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_xml_file(argv)
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 2)
-        puts ""
-        puts "Invalid program args; three args required - format, uom, input (xml) filename"
-        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
-        puts "  the second arg, unit-of-measure, should be either 'english' or 'metric'." 
-        puts "  the third arg, input xml filename, was produced by the Gooby 'splitter.rb' program."
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        format   = argv[0].downcase
-        uom      = argv[1].downcase        
-        filename = argv[2]
-        puts Trackpoint.csv_header        
-        if (format == 'garmin201')
-          parse_garmin_forerunner_logbook_xml(filename, uom)
-        else
-          parse_garmin_training_center_xml(filename, uom) 
-        end
-      end
-    end    
-        
-    def parse_garmin_forerunner_logbook_xml(xml_filename, uom)  
-      handler = Gooby::ForerunnerXmlParser.new(uom)    
-      Document.parse_stream((File.new xml_filename), handler)
-      handler.put_all_run_tkpt_csv()
-    end
-    
-    def parse_garmin_training_center_xml(tcx_filename, uom)  
-      handler = Gooby::TrainingCenterXmlParser.new(uom)   
-      Document.parse_stream((File.new tcx_filename), handler)
-      handler.put_all_run_tkpt_csv()
-    end
-
-    def read_csv_files(array_of_filenames, record_index=0)
-      @csv_reader = Gooby::CsvReader.new(array_of_filenames)
-      @csv_points = @csv_reader.read
-      @csv_col_names = @csv_reader.col_names
-      puts @csv_reader.to_s
-      if (record_index > 0)
-        @csv_reader.display_formatted_record(record_index) 
-      end
-      @csv_points
-    end
-    
-    def been_there(course_id, proximity=0.0070, uom='deg')
-      unless @csv_points
-        puts "You must first invoke method 'read_csv_files' with a list of parsed CSV filenames."
-        return
-      end
-      course = configuration.get_course("#{course_id}")
-      unless course
-        puts "Unable to find course id '#{course_id}' in the gooby config yaml file."
-        return
-      end
-      puts ''
-      # collect the csv_points into run arrays
-      @curr_run_id = 'x'      
-      @csv_runs = Array.new  
-      @csv_points.each { |csv_point|      
-        if (csv_point.run_id == @curr_run_id)
-          @curr_run.add_point(csv_point)  
-        else
-          @curr_run_id = csv_point.run_id
-          @curr_run = Gooby::CsvRun.new(@curr_run_id)
-          @curr_run.add_point(csv_point)
-          @csv_runs << @curr_run
-        end
-      }
-      
-      # iterate the runs - looking for a match vs the course
-      @csv_runs.each { |csv_run|
-        puts "Scanning run id '#{csv_run.id}', point count= #{csv_run.points.size}" if false
-        run_points = csv_run.points
-        course.reset
-        course.points.each { |course_point|
-          closest_diff  = 999
-          closest_point = nil
-          run_points.each { |run_point|
-            diff  = course_point.degrees_diff(run_point) 
-            if ((diff < proximity) && (diff < closest_diff))
-                closest_diff  = diff
-                closest_point = run_point
-                closest_point.degrees_diff = diff
-                course.matched(course_point.number, run_point)
-            end            
-          }
-        }
-        if course.matched?
-          puts "Course '#{course.name}' matched vs run id '#{csv_run.id}'" 
-          course.display_matches
-        else
-          puts "course not matched" if false
-        end
-      }
-    end
-    
-    def first_trackpoints_as_poi(date_string)
-      # cat 2007_poi.csv | sort +4n > 2007_poi_sorted.csv
-      home_point = Point.new('35.495469007128285', '-80.83213448524475', '752.5755445824', 'Home at South Faulkner Way Stopsign') # TODO
-      # poi.123  35.484114   -80.820274    788.7661681152  2007-06-30 10:48:32 1.01214244648463
-      @csv_points.each { |csv_point|
-      proximity = home_point.proximity(csv_point, 'm')
-      if (csv_point.lap_number == 1)
-        if date_string
-          if csv_point.date == date_string
-            puts sprintf("%s %s %s %s %s %s %s", 'poi.   ', 
-              character_align('.', csv_point.latitude,  3, 7), 
-              character_align('.', csv_point.longitude, 4, 7), 
-              character_align('.', csv_point.altitude,  5, 11),
-              character_align('.', proximity.to_s,  3, 20),              
-              csv_point.date,  
-              csv_point.time,
-              csv_point.distance)
-          end
-        else
-          puts sprintf("%s %s %s %s %s %s %s", 'poi.   ', 
-            character_align('.', csv_point.latitude,  3, 7), 
-            character_align('.', csv_point.longitude, 4, 7), 
-            character_align('.', csv_point.altitude,  5, 11),
-            character_align('.', proximity.to_s,  3, 20),   
-            csv_point.date,  
-            csv_point.time,
-            csv_point.distance)
-        end
-      end
-      }
-    end
-        
-    def generate_google_map(argv)  
-      if (argv == nil)
-        puts "ERROR: no ARGV args passed."
-      elsif (argv.size < 1)
-        puts ""
-        puts "Invalid program args; one required - input csv filename"
-        puts "  the first arg, csv filename, was produced by the Gooby 'parser.rb' program."
-        puts "Please correct the program arguments and try again. \n\n"
-      else
-        csv_filename  = argv[0]
-        configuration = Gooby::Configuration.get_config
-        generator = Gooby::GoogleMapGenerator.new(csv_filename)  
-        generator.generate_page(configuration)
-      end      
-    end
-  
-  end
-  
-end # end of module

data/lib/gooby_course.rb

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

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

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