gooby 1.2.0 → 2.0.0

data/lib/gooby_history.rb

@@ -1,41 +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
-
-=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_kernel.rb

@@ -1,163 +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
-
-=begin rdoc
-  This module is used to embed information about the Gooby project and
-  version into the codebase.
-=end
-  
-  module GoobyKernel
-  
-    def project_name
-      'Gooby'
-    end
-    
-    def project_version_number   
-      '1.2.0'
-    end
-
-  # Return a String date, like '2007/03/21'.  
-    def project_date       
-      '2007/07/22'
-    end
-
-    # Return a String containing the project author name.
-    def project_author
-      'Chris Joakim'
-    end
-  
-  # Return a String year, like '2007'. 
-    def project_year       
-      project_date[0...4]  # start, length
-    end
- 
-  # Return a String containing copyright, year, and author.
-    def project_copyright
-      "Copyright (C) #{project_year} #{project_author}"
-    end
-
-    def project_embedded_comment
-      "#{project_name} #{project_version_number}"
-    end
-    
-  # Return a String containing GNU/GPL, and the gpl.html URL.  
-    def project_license    
-      'GNU General Public License (GPL).  See http://www.gnu.org/copyleft/gpl.html'
-    end
-
-  # Return an Array of lines in file, optionally stripped.  
-    def read_lines(filename, strip=false)  
-
-      array = IO.readlines(filename)
-      if strip
-        array = strip_lines(array)
-      end
-      return array
-    end
- 
-  # Return an Array of lines in file per the given delimeter, optionally stripped.   
-    def read_as_ascii_lines(filename, delim=10, strip=false)  
-      
-      array = Array.new  
-      file  = File.new(filename)
-      currLine = ''
-      bytesRead = 0
-      linesRead = 0
-      
-      file.each_byte { |b| 
-        bytesRead = bytesRead + 1
-        if (b == delim) # delim is 13 for quicken, 10 for address book xml
-          array << currLine
-          currLine = ''
-          linesRead = linesRead + 1
-        else
-          if (b < 127)
-            currLine << "#{b.chr}"
-          end
-        end  
-      }
-    
-      if currLine.size > 0
-        array << currLine
-      end
-      if strip
-        array = strip_lines(array)
-      end
-      return array    
-    end
-
-  # Strip the lines/Strings; return a new Array.
-    def strip_lines(array)  
- 
-      newArray = Array.new
-      if (array != nil)
-        array.each { |line| line.strip! ; newArray << line }
-      end
-      return newArray
-    end
-
-    def tokenize(string, delim=nil, strip=false)  
-      if string
-        tokens = string.split(delim)
-        if strip
-          tokens.each { |tok| tok.strip! }
-        end
-        tokens
-      else
-        Array.new
-      end
-    end
-    
-    def character_align(character, number, left_length, right_length)
-      tokens    = number.to_s.split("#{character}")
-      integer   = tokens[0].to_s
-      fraction  = tokens[1].to_s
-      lpad_size = left_length - integer.size
-      rpad_size = right_length - fraction.size
-      if lpad_size > 0  
-        lpad_size.times do |i|
-          integer  = " #{integer}"
-        end
-      end
-      if rpad_size > 0
-        rpad_size.times do |i|
-          fraction = "#{fraction} "
-        end
-      end
-       "#{integer}.#{fraction}"
-    end
-    
-    def default_delimiter
-      return '|'
-    end
-                
-    def invalid_time
-      return -99999999
-    end
-   
-    def invalid_latitude
-      return -1
-    end
-  
-    def invalid_longitude
-      return -1
-    end
-  
-    def invalid_altitude
-       return -1
-    end
-    
-    def invalid_heartbeat
-       return -1
-    end
-    
-  end
-
-end # end of module

data/lib/gooby_line.rb

@@ -1,80 +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 Line < GoobyObject  
-  
-    attr_accessor :raw_data, :tokens
-  
-    def initialize(raw='', delim=nil, strip=false)
-      if strip
-        @raw_data = raw.strip
-      else
-        @raw_data = raw
-      end
-      
-      @tokens   = tokenize(@raw_data, delim, strip=false)  
-    end
-  
-    public
-    
-    def token(idx)
-      @tokens[idx]
-    end
-    
-    def token_count
-      @tokens.size
-    end
-
-    def token_idx_equals(idx, value)
-      if idx < token_count
-        if @tokens[idx] == value
-          return true
-        end
-      end
-      false
-    end
-    
-    def match(pattern)
-      @raw_data.match(pattern)
-    end
-    
-    def is_comment
-      s = @raw_data.strip
-      (s.match('^#')) ? true : false
-    end
-
-    def is_populated_non_comment
-      s = @raw_data.strip
-      if s.size == 0
-        return false
-      end
-      if is_comment
-        return false
-      end
-      return true   
-    end
-    
-    def concatinate_tokens(start_idx = 0)
-      s = ''
-      idx = -1
-      @tokens.each { |tok| 
-        idx = idx + 1
-        if idx >= start_idx
-          s << tok
-          s << ' '
-        end
-      }
-      s.strip!
-      s
-    end
-
-  end
-
-end # end of module

data/lib/gooby_object.rb

@@ -1,22 +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
-
-=begin rdoc
-  This is the abstract superclass of several Gooby classes.  
-  It includes module GoobyKernel.
-=end
-  
-  class GoobyObject  
-    
-    include Gooby::GoobyKernel  
-    
-  end
-
-end # end of module

data/lib/gooby_point.rb

@@ -1,172 +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 Point < GoobyObject  
-  
-    attr_accessor :number, :latitude, :longitude, :altitude, :uom, :note
-  
-    def initialize(*args)
-      @number, @latitude, @longitude, @altitude, @uom, @heartbeat, @note = '', '', '', '', 'm', -1, ''
-      if args
-        if args.size == 1
-          initialize_from_string(args[0]) # yaml 
-        else
-          initialize_from_array(args)
-        end      
-      end
-    end
-    
-    def csv_delim
-      '|'
-    end
-    
-    def english_system
-      if @uom
-        (@uom == 'm') ? true : false
-      else
-        return true  # english is the default
-      end
-    end
-    
-    def metric_system
-      return false if !english_system
-    end
-        
-    def initialize_from_array(args)
-      @latitude  = args[0] if args.size > 0
-      @longitude = args[1] if args.size > 1
-      @altitude  = args[2] if args.size > 2
-      @note      = args[3] if args.size > 3
-    end
-    
-    def initialize_from_string(yaml_value_string) 
-      tokens = yaml_value_string.split
-      if (tokens.size > 2)
-        @latitude    = tokens[0]
-        @longitude   = tokens[1]
-        @note        = ''
-        count        = 0
-        tokens.each { |tok|
-          count = count + 1
-          if (count > 2)
-            @note << tok
-            @note << ' '
-          end
-        } 
-      end
-    end
-      
-    public
-  
-    def has_coordinates?
-      return false if @latitude == nil
-      return false if @latitude.size < 1
-      return false if @longitude == nil
-      return false if @longitude .size < 1
-      return true
-    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 << " poi.#{@number.to_s.ljust(12)}"  if @number
-      s << " #{@note}" if @note
-      s      
-    end
-  
-    def to_csv
-      return "#{@latitude}#{csv_delim}#{@longitude}#{csv_delim}#{@altitude}"
-    end
-    
-    def latitude_as_float
-      @latitude ? @latitude.to_f : invalid_latitude
-    end
-  
-    def longitude_as_float
-      @longitude ? @longitude.to_f : invalid_longitude
-    end
-  
-    def altitude_as_float
-      @altitude ? @altitude.to_f : invalid_altitude
-    end
-
-    def heartbeat_as_float
-      @heartbeat? @heartbeat.to_f : invalid_heartbeat
-    end
-        
-    def degrees_diff(another_point)      
-      if (another_point)
-        puts "this:  #{to_s}" if false
-        puts "other: #{another_point.to_s}"  if false
-        puts "lats:  #{latitude_as_float}  #{another_point.latitude_as_float}"  if false
-        puts "lngs:  #{longitude_as_float}  #{another_point.longitude_as_float}"  if false
-        lat_diff = latitude_as_float  - another_point.latitude_as_float
-        lng_diff = longitude_as_float - another_point.longitude_as_float
-        diff = lat_diff.abs + lng_diff.abs
-        puts "diff: #{diff} #{lat_diff} #{lng_diff}"  if false
-        diff
-      else
-        360
-      end
-    end 
-    
-    def proximity(another_point, uom)
-      if (another_point)
-        arg1  = latitude_as_float
-        arg2  = another_point.latitude_as_float
-        arg3  = latitude_as_float
-        arg4  = another_point.latitude_as_float
-        theta = longitude_as_float - another_point.longitude_as_float  
-        res1  = Math.sin(deg2rad(arg1))
-        res2  = Math.sin(deg2rad(arg2))
-        res3  = Math.cos(deg2rad(arg3))
-        res4  = Math.cos(deg2rad(arg4))
-        res5  = Math.cos(deg2rad(theta.to_f))
-        dist  = ((res1 * res2) + (res3 * res4 * res5)).to_f
-        
-        if (!dist.nan?)
-          dist = Math.acos(dist.to_f)
-          if (!dist.nan?)    
-            dist = rad2deg(dist)
-            if (!dist.nan?)
-              dist = dist * 60 * 1.1515;
-              if (!dist.nan?)
-                if uom == "km"
-                   dist = dist * 1.609344;
-                end 
-                if uom == "n"
-                   dist = dist * 0.8684;
-                end  
-              end
-            end
-          end
-          return dist.to_f
-        else
-          return 0
-        end
-      else
-        return 0
-      end
-    end  
-  
-    def deg2rad(degrees)
-      (((0 + degrees) * Math::PI) / 180)
-    end
-  
-    def rad2deg(radians)
-      (((0 + radians) * 180) / Math::PI)
-    end
-  end
-
-end # end of module