gpx 0.1 → 0.2

data/README

@@ -33,7 +33,7 @@ work-in-progress than an attempt at full GPX compliance.  The track side of the
 library has seen much more use than the route/waypoint side, so if you're doing
 something with routes or waypoints, you may need to tweak some things.  
 
-Since this code uses REXML to read an entire GPX file into memory, it is not
+Since this code uses XML to read an entire GPX file into memory, it is not
 the fastest possible solution for working with GPX data, especially if you are
 working with tracks from several days or weeks.  
 

data/lib/gpx.rb

@@ -21,7 +21,8 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 $:.unshift(File.dirname(__FILE__))
-require 'rexml/document'
+require 'rubygems'
+require 'xml/libxml'
 require 'date'
 require 'time'
 require 'csv'

data/lib/gpx/bounds.rb

@@ -44,11 +44,11 @@ module GPX
       end
 
       def to_xml
-         bnd = REXML::Element.new('bounds')
-         bnd.attributes['min_lat'] = min_lat
-         bnd.attributes['min_lon'] = min_lon
-         bnd.attributes['max_lat'] = max_lat
-         bnd.attributes['max_lon'] = max_lon
+         bnd = XML::Node.new('bounds')
+         bnd['minlat'] = min_lat.to_s
+         bnd['minlon'] = min_lon.to_s
+         bnd['maxlat'] = max_lat.to_s
+         bnd['maxlon'] = max_lon.to_s
          bnd
       end
 

data/lib/gpx/gpx.rb

@@ -21,14 +21,14 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 module GPX
-   VERSION = "0.1"
+   VERSION = "0.2"
 
    # A common base class which provides a useful initializer method to many
    # class in the GPX library.
    class Base
-   include REXML
+   include XML
 
-      # This initializer can take a REXML::Element and scrape out any text
+      # This initializer can take an XML::Node and scrape out any text
       # elements with the names given in the "text_elements" array.  Each
       # element found underneath "parent" with a name in "text_elements" causes
       # an attribute to be initialized on the instance.  This means you don't
@@ -37,8 +37,8 @@ module GPX
       # attributes to this method.
       def instantiate_with_text_elements(parent, text_elements)
          text_elements.each do |el|
-            unless parent.elements[el].nil?
-               val = parent.elements[el].text
+            unless parent.find(el).empty?
+               val = parent.find(el).first.content
                code = <<-code
                   attr_accessor #{ el }
                   #{el}=#{val}

data/lib/gpx/gpx_file.rb

@@ -22,7 +22,7 @@
 #++
 module GPX
    class GPXFile < Base
-      attr_reader :tracks, :routes, :waypoints, :bounds, :lowest_point, :highest_point, :distance, :duration, :average_speed
+      attr_reader :tracks, :routes, :waypoints, :bounds, :lowest_point, :highest_point, :distance, :duration, :average_speed, :ns
 
 
       # This initializer can be used to create a new GPXFile from an existing
@@ -44,30 +44,41 @@ module GPX
          @duration = 0
          if(opts[:gpx_file])
             gpx_file = opts[:gpx_file]
-            case gpx_file
-            when String
-               gpx_file = File.open(gpx_file)
-            end
+            #case gpx_file
+            #when String
+            #   gpx_file = File.open(gpx_file)
+            #end
+            gpx_file = gpx_file.name if gpx_file.is_a?(File) 
             reset_meta_data
-            @xml = Document.new(gpx_file, :ignore_whitespace_nodes => :all)
-
-            bounds_element = (XPath.match(@xml, "/gpx/metadata/bounds").first rescue nil)
+            @xml = XML::Document.file(gpx_file)
+            
+            # set XML namespace for XML find
+            if @xml.root.namespace_node
+              @ns = 'gpx:' + @xml.root.namespace_node.href
+            else
+              @ns = 'gpx:http://www.topografix.com/GPX/1/1'  # default to GPX 1.1
+            end
+            
+            bounds_element = (@xml.find("//gpx:gpx/gpx:metadata/gpx:bounds", @ns).to_a.first rescue nil)
             if bounds_element
-               @bounds.min_lat = bounds_element.attributes["min_lat"].to_f
-               @bounds.min_lon = bounds_element.attributes["min_lon"].to_f
-               @bounds.max_lat = bounds_element.attributes["max_lat"].to_f
-               @bounds.max_lon = bounds_element.attributes["max_lon"].to_f
+               @bounds.min_lat = get_bounds_attr_value(bounds_element, %w{ min_lat minlat minLat })
+               @bounds.min_lon = get_bounds_attr_value(bounds_element, %w{ min_lon minlon minLon})
+               @bounds.max_lat = get_bounds_attr_value(bounds_element, %w{ max_lat maxlat maxLat})
+               @bounds.max_lon = get_bounds_attr_value(bounds_element, %w{ max_lon maxlon maxLon})
             else
                get_bounds = true
             end
-
-            @tracks = XPath.match(@xml, "/gpx/trk").collect do |trk| 
+            
+            @tracks = [] 
+            @xml.find("//gpx:gpx/gpx:trk", @ns).each do |trk| 
                trk = Track.new(:element => trk, :gpx_file => self) 
                update_meta_data(trk, get_bounds)
-               trk
+               @tracks << trk
             end
-            @waypoints = XPath.match(@xml, "/gpx/wpt").collect { |wpt| Waypoint.new(:element => wpt, :gpx_file => self) }
-            @routes =    XPath.match(@xml, "/gpx/rte").collect { |rte| Route.new(:element => rte, :gpx_file => self) }
+            @waypoints = [] 
+            @xml.find("//gpx:gpx/gpx:wpt", @ns).each { |wpt| @waypoints << Waypoint.new(:element => wpt, :gpx_file => self) }
+            @routes = []
+            @xml.find("//gpx:gpx/gpx:rte", @ns).each { |rte| @routes << Route.new(:element => rte, :gpx_file => self) }
 
             @tracks.delete_if { |t| t.empty? }
 
@@ -82,6 +93,15 @@ module GPX
          end
       end
 
+      def get_bounds_attr_value(el, possible_names)
+         result = nil
+         possible_names.each do |name|
+            result = el[name]
+            break unless result.nil?
+         end
+         return (result.to_f rescue nil)
+      end
+
       # Returns the distance, in kilometers, meters, or miles, of all of the
       # tracks and segments contained in this GPXFile.
       def distance(opts = { :units => 'kilometers' })
@@ -175,32 +195,32 @@ module GPX
       def write(filename)
 
          doc = Document.new
-         gpx_elem = Element.new('gpx')
-         doc.add(gpx_elem)
-         gpx_elem.attributes['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance" 
-         gpx_elem.attributes['xmlns'] = "http://www.topografix.com/GPX/1/1" 
-         gpx_elem.attributes['version'] = "1.1" 
-         gpx_elem.attributes['creator'] = "GPX RubyGem 0.1 Copyright 2006 Doug Fales -- http://walkingboss.com" 
-         gpx_elem.attributes['xsi:schemaLocation'] = "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd"
+         doc.root = Node.new('gpx')
+         gpx_elem = doc.root
+         gpx_elem['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance" 
+         gpx_elem['xmlns'] = "http://www.topografix.com/GPX/1/1" 
+         gpx_elem['version'] = "1.1" 
+         gpx_elem['creator'] = "GPX RubyGem 0.1 Copyright 2006 Doug Fales -- http://walkingboss.com" 
+         gpx_elem['xsi:schemaLocation'] = "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd"
 
-         meta_data_elem = Element.new('metadata')
-         name_elem = Element.new('name')
-         name_elem.text = File.basename(filename)
-         meta_data_elem.elements << name_elem
+         meta_data_elem = Node.new('metadata')
+         name_elem = Node.new('name')
+         name_elem << File.basename(filename)
+         meta_data_elem << name_elem
 
-         time_elem = Element.new('time')
-         time_elem.text = Time.now.xmlschema
-         meta_data_elem.elements << time_elem
+         time_elem = Node.new('time')
+         time_elem << Time.now.xmlschema
+         meta_data_elem << time_elem
 
-         meta_data_elem.elements << bounds.to_xml
+         meta_data_elem << bounds.to_xml
 
-         gpx_elem.elements << meta_data_elem
+         gpx_elem << meta_data_elem
 
-         tracks.each    { |t|   gpx_elem.add_element t.to_xml } unless tracks.nil?
-         waypoints.each { |w| gpx_elem.add_element w.to_xml } unless waypoints.nil?
-         routes.each    { |r| gpx_elem.add_element r.to_xml } unless routes.nil?
+         tracks.each    { |t| gpx_elem << t.to_xml } unless tracks.nil?
+         waypoints.each { |w| gpx_elem << w.to_xml } unless waypoints.nil?
+         routes.each    { |r| gpx_elem << r.to_xml } unless routes.nil?
 
-         File.open(filename, 'w') { |f| doc.write(f) }
+         doc.save(filename, true)
       end
 
       private 

data/lib/gpx/point.rb

@@ -29,16 +29,17 @@ module GPX
 
       # When you need to manipulate individual points, you can create a Point
       # object with a latitude, a longitude, an elevation, and a time.  In
-      # addition, you can pass a REXML element to this initializer, and the
+      # addition, you can pass an XML element to this initializer, and the
       # relevant info will be parsed out.
       def initialize(opts = {:lat => 0.0, :lon => 0.0, :elevation => 0.0, :time => Time.now } )
+         @gpx_file = opts[:gpx_file]
          if (opts[:element]) 
             elem = opts[:element]
-            @lat, @lon = elem.attributes["lat"].to_f, elem.attributes["lon"].to_f
+            @lat, @lon = elem["lat"].to_f, elem["lon"].to_f
             @latr, @lonr = (D_TO_R * @lat), (D_TO_R * @lon)
             #'-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
-            @time = (Time.xmlschema(elem.elements["time"].text) rescue nil)
-            @elevation = elem.elements["ele"].text.to_f if elem.elements["ele"]
+            @time = (Time.xmlschema(elem.find("gpx:time", @gpx_file.ns).first.content) rescue nil)
+            @elevation = elem.find("gpx:ele", @gpx_file.ns).first.content.to_f unless elem.find("gpx:ele", @gpx_file.ns).empty?
          else
             @lat = opts[:lat]
             @lon = opts[:lon]
@@ -85,17 +86,19 @@ module GPX
          @lon = longitude
       end
 
-      # Convert this point to a REXML::Element.
+      # Convert this point to a XML::Node.
       def to_xml(elem_name = 'trkpt')
-         pt = Element.new('trkpt')
-         pt.attributes['lat'] = lat
-         pt.attributes['lon'] = lon
-         time_elem = Element.new('time')
-         time_elem.text = time.xmlschema
-         pt.elements << time_elem
-         elev = Element.new('ele')
-         elev.text = elevation
-         pt.elements << elev
+         pt = Node.new('trkpt')
+         pt['lat'] = lat.to_s
+         pt['lon'] = lon.to_s
+         unless time.nil?
+            time_elem = Node.new('time')
+            time_elem << time.xmlschema
+            pt << time_elem
+         end
+         elev = Node.new('ele')
+         elev << elevation
+         pt <<  elev
          pt
       end
 

data/lib/gpx/route.rb

@@ -29,13 +29,13 @@ module GPX
 
       attr_reader :points, :name, :gpx_file
 
-      # Initialize a Route from a REXML::Element.
+      # Initialize a Route from a XML::Node.
       def initialize(opts = {})
          rte_element = opts[:element]
          @gpx_file = opts[:gpx_file]
-         @name = rte_element.elements["child::name"].text
+         @name = rte_element.find("child::gpx:name", @ns).first.content
          @points = []
-         XPath.each(rte_element, "child::rtept") do |point|
+         rte_element.find("child::gpx:rtept", @ns).each do |point|
             @points << Point.new(:element => point)
          end
 
@@ -51,13 +51,13 @@ module GPX
          points.delete_if{ |pt| area.contains? pt }
       end
 
-      # Convert this Route to a REXML::Element.
+      # Convert this Route to a XML::Node.
       def to_xml
-         rte = Element.new('rte')
-         name_elem = Element.new('name')
-         name_elem.text = name
-         rte.elements << name_elem
-         points.each { |rte_pt| rte.elements << rte_pt.to_xml('rtept') }
+         rte = Node.new('rte')
+         name_elem = Node.new('name')
+         name_elem <<  name
+         rte <<  name_elem
+         points.each { |rte_pt| rte <<  rte_pt.to_xml('rtept') }
          rte
       end
 

data/lib/gpx/segment.rb

@@ -31,9 +31,10 @@ module GPX
       attr_reader :earliest_point, :latest_point, :bounds, :highest_point, :lowest_point, :distance
       attr_accessor :points, :track 
 
-      # If a REXML::Element object is passed-in, this will initialize a new
+      # If a XML::Node object is passed-in, this will initialize a new
       # Segment based on its contents.  Otherwise, a blank Segment is created.
       def initialize(opts = {})
+         @gpx_file = opts[:gpx_file]
          @track = opts[:track]
          @points = []
          @earliest_point = nil
@@ -45,11 +46,13 @@ module GPX
          if(opts[:element])
             segment_element = opts[:element]
             last_pt = nil
-            unless segment_element.is_a?(Text)
-               XPath.each(segment_element, "child::trkpt") do |trkpt| 
-                  pt = TrackPoint.new(:element => trkpt, :segment => self)  
-                  @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
-                  @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+            if segment_element.is_a?(XML::Node)
+               segment_element.find("child::gpx:trkpt", @gpx_file.ns).each do |trkpt| 
+                  pt = TrackPoint.new(:element => trkpt, :segment => self, :gpx_file => @gpx_file)  
+                  unless pt.time.nil?
+                     @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
+                     @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+                  end
                   unless pt.elevation.nil?
                      @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
                      @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
@@ -85,7 +88,7 @@ module GPX
 
       # Returns true if the given time is within this Segment.
       def contains_time?(time)
-         (time >= @earliest_point.time and time <= @latest_point.time)
+         (time >= @earliest_point.time and time <= @latest_point.time) rescue false
       end
 
       # Finds the closest point in time to the passed-in time argument.  Useful
@@ -129,10 +132,10 @@ module GPX
          (points.nil? or (points.size == 0))
       end
 
-      # Converts this Segment to a REXML::Element object.
+      # Converts this Segment to a XML::Node object.
       def to_xml
-         seg = Element.new('trkseg')
-         points.each { |pt| seg.elements << pt.to_xml }
+         seg = Node.new('trkseg')
+         points.each { |pt| seg <<  pt.to_xml }
          seg
       end
 
@@ -202,8 +205,10 @@ module GPX
       end
 
       def update_meta_data(pt, last_pt)
-         @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
-         @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+         unless pt.time.nil?
+            @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
+            @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+         end
          unless pt.elevation.nil?
             @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
             @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)

data/lib/gpx/track.rb

@@ -32,7 +32,7 @@ module GPX
       attr_reader :points, :bounds, :lowest_point, :highest_point, :distance
       attr_accessor :segments, :name, :gpx_file
 
-      # Initialize a track from a REXML::Element, or, if no :element option is
+      # Initialize a track from a XML::Node, or, if no :element option is
       # passed, initialize a blank Track object.
       def initialize(opts = {})
          @gpx_file = opts[:gpx_file]
@@ -41,9 +41,9 @@ module GPX
          reset_meta_data
          if(opts[:element]) 
             trk_element = opts[:element]
-            @name = (trk_element.elements["child::name"].text rescue "")
-            XPath.each(trk_element, "child::trkseg") do |seg_element|
-               seg = Segment.new(:element => seg_element, :track => self)
+            @name = (trk_element.find("child::gpx:name", @gpx_file.ns).first.content rescue "")
+            trk_element.find("child::gpx:trkseg", @gpx_file.ns).each do |seg_element|
+               seg = Segment.new(:element => seg_element, :track => self, :gpx_file => @gpx_file)
                update_meta_data(seg)
                @segments << seg
                @points.concat(seg.points) unless seg.nil?
@@ -101,14 +101,14 @@ module GPX
          (points.nil? or points.size.zero?)
       end
 
-      # Creates a new REXML::Element from the contents of this instance.
+      # Creates a new XML::Node from the contents of this instance.
       def to_xml
-         trk= Element.new('trk')
-         name_elem = Element.new('name')
-         name_elem.text = name
-         trk.elements << name_elem
+         trk= Node.new('trk')
+         name_elem = Node.new('name')
+         name_elem <<  name
+         trk <<  name_elem
          segments.each do |seg|
-            trk.elements << seg.to_xml
+            trk <<  seg.to_xml
          end
          trk
       end

data/lib/gpx/waypoint.rb

@@ -39,7 +39,7 @@ module GPX
       def delete_area(area)
       end
 
-      # Initializes a waypoint from a REXML::Element.
+      # Initializes a waypoint from a XML::Node.
       def initialize(opts = {})
          wpt_elem = opts[:element]
          super(:element => wpt_elem)
@@ -47,25 +47,25 @@ module GPX
          @gpx_file = opts[:gpx_file]
       end
 
-      # Converts a waypoint to a REXML::Element.
+      # Converts a waypoint to a XML::Node.
       def to_xml
-         wpt = Element.new('wpt')
+         wpt = Node.new('wpt')
          wpt.attributes['lat'] = lat
          wpt.attributes['lon'] = lon
          if self.respond_to? :name
-            name_elem = Element.new('name')
-            name_elem.text = self.name 
-            wpt.elements << name_elem
+            name_elem = Node.new('name')
+            name_elem <<  self.name 
+            wpt <<  name_elem
          end
          if self.respond_to? :sym
-            sym_elem = Element.new('sym')
-            sym_elem.text = self.sym
-            wpt.elements << sym_elem
+            sym_elem = Node.new('sym')
+            sym_elem <<  self.sym
+            wpt <<  sym_elem
          end
          if self.respond_to? :ele
-            elev_elem = Element.new('ele')
-            elev_elem.text = self.ele
-            wpt.elements << elev_elem
+            elev_elem = Node.new('ele')
+            elev_elem <<  self.ele
+            wpt <<  elev_elem
          end
          wpt
       end

data/tests/gpx10_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/gpx'
+
+class TestGPX10 < Test::Unit::TestCase
+   GPX_FILE = File.join(File.dirname(__FILE__), "gpx_files/gpx10.gpx")
+
+   def test_read
+      # make sure we can read a GPX 1.0 file
+      @gpx_file = GPX::GPXFile.new(:gpx_file => GPX_FILE)
+   end
+
+end

data/tests/gpx_files/gpx10.gpx

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gpx version="1.0"
+creator="GPSBabel - http://www.gpsbabel.org"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xmlns="http://www.topografix.com/GPX/1/0"
+xsi:schemaLocation="http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd">
+	<trk>
+	  <name>ACTIVE LOG #74</name>
+	  <number>82</number>
+	<trkseg>
+	<trkpt lat="37.378388923" lon="-122.063654875">
+	  <ele>35.706055</ele>
+	<time>2007-11-23T23:49:43Z</time>
+	</trkpt>
+	</trkseg>
+</trk>
+</gpx>

data/tests/segment_test.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'yaml'
 require File.dirname(__FILE__) + '/../lib/gpx'
 
 class TestSegment < Test::Unit::TestCase

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: gpx
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2006-10-14 00:00:00 -06:00
+  version: "0.2"
+date: 2007-11-29 00:00:00 -07:00
 summary: A basic API for reading and writing GPX files.
 require_paths: 
 - lib
@@ -25,11 +25,11 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Doug Fales
 files: 
 - lib/gpx
-- lib/gpx.rb
 - lib/gpx/bounds.rb
 - lib/gpx/gpx.rb
 - lib/gpx/gpx_file.rb
@@ -40,18 +40,21 @@ files:
 - lib/gpx/track.rb
 - lib/gpx/trackpoint.rb
 - lib/gpx/waypoint.rb
+- lib/gpx.rb
+- tests/gpx10_test.rb
 - tests/gpx_files
-- tests/magellan_test.rb
-- tests/segment_test.rb
-- tests/track_file_test.rb
-- tests/track_test.rb
 - tests/gpx_files/arches.gpx
+- tests/gpx_files/gpx10.gpx
 - tests/gpx_files/magellan_track.log
 - tests/gpx_files/one_segment.gpx
 - tests/gpx_files/one_track.gpx
 - tests/gpx_files/routes.gpx
 - tests/gpx_files/tracks.gpx
 - tests/gpx_files/waypoints.gpx
+- tests/magellan_test.rb
+- tests/segment_test.rb
+- tests/track_file_test.rb
+- tests/track_test.rb
 - Rakefile
 - README
 test_files: []