gooby 0.9.4 → 0.9.5

data/lib/gooby/cls_counter_hash.rb

@@ -1,78 +0,0 @@
-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
- 
-  # 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
-
-  # 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}]"
-      }
-      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/cls_delim_line.rb

@@ -1,35 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class represent a delimited line of text, such as csv.
-=end
-  
-  class DelimLine < GoobyObject
-  
-    attr_reader :line, :trim, :delim, :tokens
-    
-    def initialize(line, trim=true, delim=default_delimiter)
-      @line  = line
-      @trim  = trim
-      @delim = delim
-      @tokens = @line.split(@delim)  
-      if trim
-        @tokens.each { | token | token.strip! }
-      end
-    end
-
-    def as_trackpoint(num_idx, lat_idx, lng_idx, alt_idx, dttm_idx)
-      Trackpoint.new(@tokens[num_idx], @tokens[lat_idx], @tokens[lng_idx], @tokens[alt_idx], @tokens[dttm_idx])
-    end
-  
-    def is_comment?
-      @line.strip.match('^#') ? true : false
-    end
-  
-    def to_s
-      "DelimLine: length: #{@line.size} trim: #{@trim} delim: #{@delim} tokens: #{@tokens.size}"
-    end
-  
-  end
-
-end # end of module

data/lib/gooby/cls_dttm.rb

@@ -1,79 +0,0 @@
-module Gooby
-  
-=begin rdoc
-  Instances of this class represent a Date and Time as parsed from a value 
-  such as '2006-01-15T13:41:40Z' in an XML file produced by a GPS device.
-  It wrappers both a DateTime and Time object.
-=end
-  
-  class DtTm < GoobyObject  
-    
-    attr_accessor :rawdata, :dateTime, :time, :valid
-  
-  # Constructor; arg is a String like '2006-01-15T13:41:40Z'.  
-    def initialize(raw)  
-      if raw
-        @rawdata = raw.strip
-        if @rawdata.size > 18
-          @dateTime = DateTime.parse(@rawdata[0..18])
-          @time  = Time.parse(@dateTime.to_s)
-          @valid = true
-        else
-          @valid = false
-        end     
-      else
-        @rawdata = ''
-        @valid   = false          
-      end
-    end
-  
-    public
- 
-  # Return @time.to_i  
-    def to_i() 
-      (@time) ? @time.to_i : invalid_time
-    end
-  
-  # Calculates and returns diff between another instance.  
-    def seconds_diff(anotherDtTm)  
-      if anotherDtTm
-        to_i - anotherDtTm.to_i
-      else
-        invalid_time
-      end
-    end
-  
-    def yyyy_mm_dd
-      @time.strftime("%Y-%m-%d")
-    end
-  
-    def yyyy_mm_dd_hh_mm_ss
-      @time.strftime("%Y-%m-%d %H:%M:%S")
-    end
-  
-    def hh_mm_ss
-      @time.strftime("%H:%M:%S")
-    end
-  
-  # Calculate and return time diff in 'hh:mm:ss' format.
-    def hhmmss_diff(anotherDtTm)  
-      if anotherDtTm  
-        t = @time - (anotherDtTm.to_i)
-        t.strftime("%H:%M:%S")
-      else
-        '??:??:??'  
-      end
-    end
-  
-    def to_s
-      "#{@rawdata}"
-    end
-  
-  # Return a String with state values for debugging.
-    def print_string  
-      "DtTm: #{yyyy_mm_dd_hh_mm_ss} #{to_i} #{@rawdata}"
-    end
-    
-  end
-  
-end # end of module

data/lib/gooby/cls_duration.rb

@@ -1,79 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class represent the contents of a Forerunner extract
-  <Duration> tag, such as:
-  <Duration>PT507.870S</Duration>
-=end
-  
-  class Duration < GoobyObject  
-    
-    attr_accessor :rawdata, :seconds, :minutes, :mmss
-  
-  # Constructor; arg is a String like 'PT507.870S'.
-    def initialize(raw)  
-      if raw
-        @rawdata  = scrub(raw)
-        @seconds  = @rawdata.to_f
-        @minutes  = @seconds / 60
-        @base_min = @minutes.floor
-        @frac_min = @minutes - @base_min
-        @frac_sec = @frac_min * 60
-        
-        @mmss = ''
-        if (@base_min < 10) 
-          @mmss << "0#{@base_min}:"
-        else
-          @mmss << "#{@base_min}:"          
-        end
-        if (@frac_sec < 10) 
-          @mmss << "0#{@frac_sec}"
-        else
-          @mmss << "#{@frac_sec}"          
-        end  
-        if (@mmss.size > 8) 
-          @mmss = @mmss[0..8]
-        end     
-      else
-        @rawdata = ''
-        @seconds = invalidDistance 
-        @minutes = invalidMinutes
-        @mmss    = '??:??.?'         
-      end
-    end
-    
-    private
-    
-    def scrub(raw)
-      if (raw)
-        raw.strip!
-        newStr = ''
-        raw.each_byte { | b |
-          if ((b >= 48) && (b <= 57))
-            newStr << b
-          end
-          if (b == 46) 
-            newStr << b
-          end
-        }
-        return newStr
-      else
-        ''
-      end
-    end
-  
-    public 
-    
-    def to_s
-      "#{@mmss}"
-    end
-  
-  # Return a String with state values for debugging.
-    def print_string  
-      "Duration: #{@rawdata} sec: #{@seconds} min: #{@minutes} mmss: #{@mmss} bm: #{@base_min} fm: #{@frac_min} fs: #{@frac_sec}"
-    end
-    
-  end
-  
-end # end of module
-

data/lib/gooby/cls_forerunner_xml_parser.rb

@@ -1,178 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class are used to parse a Forerunner XML file in a SAX-like
-  manner.  Instances of the model classes - History, Run, Track, Trackpoint,
-  etc. are created in this parsing process.  
-
-  See http://www.garmin.com/xmlschemas/ForerunnerLogbookv1.xsd for the XML Schema
-  Definition for the Garmin Forerunner XML.  The Gooby object model mirrors this XSD. 
-=end
-  
-  class ForerunnerXmlParser  
-  
-    DETAIL_TAGS = %w( Notes StartTime Duration Length Latitude Longitude Altitude Time BeginPosition EndPosition )
-  
-    include REXML::StreamListener
-  
-    attr_reader :history, :cvHash, :tagCount
-  
-    def initialize
-      @cvHash            = Hash.new("")
-      @tagCount          = 0
-      @runCount          = 0
-      @lapCount          = 0
-      @trackCount        = 0
-      @trackpoint_count  = 0
-      @currText          = "";
-      @history           = History.new
-      @currRun           = nil
-      @currLap           = nil
-      @currTrack         = nil
-      @currBeginPosition = nil
-      @currEndPosition   = nil
-    end
-  
-    public
- 
-    # SAX API method; handles 'Run', 'Lap', 'Track'.   
-    def tag_start(tagname, attrs) 
-      @tagCount += 1
-      @currTag = tagname
-      @cvHash[tagname] = ''
-    
-      if detail_tag?(tagname)
-        @inDetail = true
-      end
-    
-      if is_tag?('Run', tagname)
-        @runCount = @runCount + 1
-        @lapCount = 0
-        @trackCount = 0
-        @currRun  = Run.new(@runCount)
-        @history.add_run(@currRun)
-        @cvHash['Notes'] = ''
-        return
-      end
-    
-      if is_tag?('Lap', tagname)
-        @lapCount = @lapCount + 1
-        @currLap  = Lap.new(@lapCount)
-        return
-      end
-    
-      if is_tag?('Track', tagname)
-        @trackCount = @trackCount + 1      
-        @currTrack  = Track.new(@trackCount)
-        @trackpoint_count = 0   
-        return   
-      end
-    
-    end
-
-    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run'. 
-    def tag_end(tagname) 
-      if @inDetail    
-        @cvHash[tagname] = @currText
-      else
-        if is_tag?('Position', tagname)
-          lat  = @cvHash['Latitude']
-          long = @cvHash['Longitude']
-          @currBeginPosition = Position.new(lat.strip, long.strip, '')
-          @currEndPosition   = Position.new(lat.strip, long.strip, '')       
-        end 
-        
-        if is_tag?('BeginPosition', tagname)
-          lat  = @cvHash['Latitude']
-          long = @cvHash['Longitude']
-          @currBeginPosition = Position.new(lat.strip, long.strip, '')      
-        end
-        
-        if is_tag?('EndPosition', tagname)
-          lat  = @cvHash['Latitude']
-          long = @cvHash['Longitude']
-          @currEndPosition = Position.new(lat.strip, long.strip, '')      
-        end
-              
-        if is_tag?('Trackpoint', tagname)
-          @trackpoint_count = @trackpoint_count + 1
-          lat  = @cvHash['Latitude']
-          long = @cvHash['Longitude']
-          alt  = @cvHash['Altitude']   
-          time = @cvHash['Time']                
-          tp   = Trackpoint.new(@trackpoint_count, lat, long, alt, time)
-          @currTrack.add_trackpoint(tp)
-        end
-      
-        if is_tag?('Track', tagname)
-          if @currRun != nil
-            @currRun.add_track(@currTrack)
-          end
-        end
-      
-        if is_tag?('Lap', tagname)
-          @currLap.startTime = @cvHash['StartTime']
-          @currLap.duration  = Duration.new(@cvHash['Duration'])
-          @currLap.length    = @cvHash['Length']                          
-          @currLap.beginPosition = @currBeginPosition
-          @currLap.endPosition   = @currEndPosition        
-          @currRun.add_lap(@currLap)
-        end
-      
-        if is_tag?('Run', tagname)
-          @currRun.notes =  @cvHash['Notes'] 
-        end
-      end
-    
-      @inDetail = false    
-      @currText = ""
-      @currTag  = ""                     
-    end
-
-    # SAX API method.
-    def text(txt)  
-      if @inDetail
-        @currText = @currText + txt   
-      end
-    end
-
-  # Iterate all parsed Run objects and print each with to_s.
-    def gdump()      
-      @history.runs().each { |run| puts run.to_s } 
-    end
-
-  # Iterate all parsed Run objects and print each with to_s.
-    def dump()        
-      @history.runs().each { |run| puts run.to_s } 
-    end
-
-  # Iterate all parsed Run objects and print each with put_csv.
-    def put_run_csv() 
-      @history.runs().each { |run| run.put_csv() } 
-    end
-
-  # Iterate all parsed Run objects and print each with put_tkpt_csv.
-    def put_all_run_tkpt_csv(with_header_comment) 
-      @history.runs.each { |run| 
-        run.put_tkpt_csv(with_header_comment)
-      } 
-    end
-
-    private 
-  
-    def is_tag?(tagname, value)
-      tagname == value
-    end
-  
-    def detail_tag?(tagname)
-      DETAIL_TAGS.each { |typ| 
-        if typ == tagname 
-          return true    
-        end
-      }
-      return false
-    end
-  
-  end
-
-end # end of module

data/lib/gooby/cls_forerunner_xml_splitter.rb

@@ -1,109 +0,0 @@
-module Gooby
-
-=begin rdoc
-  Instances of this class are used to split a large ForerunnerLogbook
-  XML file into individual 'run_' files.
-=end
-  
-  class ForerunnerXmlSplitter < GoobyObject 
-    
-    attr_reader :out_dir, :forerunner_files, :out_files_hash
-    
-    def initialize(xml_file, out_dir)
-      @out_dir = out_dir
-      @forerunner_files = Array.new
-      @forerunner_files << xml_file
-      @out_files_hash   = Hash.new
-    end
-    
-    def split
-      @forerunner_files.each { |f| process_file(f) }
-      write_files
-    end
-    
-    private 
-    
-    def process_file(forerunnerXmlFile)
-      @file_name = forerunnerXmlFile
-      @xml_lines = read_lines(@file_name, false) 
-      @line_num  = 0
-      @run_num   = 0
-      @curr_run_lines = Array.new
-      @curr_run_tkpts = 0
-      @start_line_num = 0
-      @end_line_num   = 0
-      @first_start_time = nil
-    
-      @xml_lines.each { |line|
-        @line_num = @line_num + 1              
-        if (line.match(/<Run>/))
-          @run_num = @run_num + 1
-          @start_line_num = @line_num
-          @curr_run_lines = Array.new
-          @curr_run_lines << line
-        elsif (line.match(/<StartTime>/)) # <StartTime>2007-01-13T15:37:06Z</StartTime>
-          @curr_run_lines << line   
-          if @first_start_time == nil
-            clone = String.new(line)     
-            clone.gsub!(/[<>]/, ' ')  
-            clone.gsub!(/[-:T]/, '_')
-            clone.gsub!(/[Z]/, '') 
-            tokens = clone.split
-            @first_start_time = tokens[1]
-          end          
-        elsif (line.match(/<Trackpoint>/)) 
-           @curr_run_tkpts =  @curr_run_tkpts + 1
-           @curr_run_lines << line 
-        elsif (line.match(/<\/Run>/))
-          @end_line_num = @line_num 
-           @curr_run_lines << line           
-          end_run 
-        elsif (@curr_run_lines.size > 0)
-          @curr_run_lines << line 
-        end
-      }
-    end
-  
-    def end_run
-      out_file = "#{@out_dir}/run_#{@first_start_time}.xml"
-      comment = "<!-- file: #{out_file}  lines: #{@curr_run_lines.size} (#{@start_line_num} to #{@end_line_num})  tkpts: #{@curr_run_tkpts} --> \n"
-      @curr_run_lines.insert(0, comment)
-          
-      prev_entry = @out_files_hash[out_file]
-      if prev_entry
-        if (@curr_run_lines.size >= prev_entry.size)
-          puts "previous entry overlaid for #{out_file}.  curr=#{@curr_run_lines.size}  prev=#{prev_entry.size}"
-          @out_files_hash[out_file] = @curr_run_lines
-        else
-          puts "previous entry retained for #{out_file}.  curr=#{@curr_run_lines.size}  prev=#{prev_entry.size}"
-        end
-      else
-          puts "new entry for #{out_file}.  curr=#{@curr_run_lines.size}"
-          @out_files_hash[out_file] = @curr_run_lines          
-      end
-      
-      @curr_run_lines   = Array.new
-      @curr_run_tkpts   = 0
-      @start_line_num   = 0
-      @end_line_num     = 0
-      @first_start_time = nil                
-    end
-    
-    def write_files
-      out_names = @out_files_hash.keys.sort
-      puts "Writing #{out_names.size} extract files..."
-      out_names.each { |out_name| 
-        lines = @out_files_hash[out_name]
-        out = File.new out_name, "w+"
-        lines.each { |line| out.write line }
-        out.flush
-        out.close
-        puts "File written: #{out_name}"
-      }
-      puts "output files written."
-    end
-    
-  end
-
-end # end of module
-