gpx 0.9.0 → 1.1.0

data/lib/gpx/magellan_track_log.rb

@@ -1,30 +1,10 @@
-#--
-# Copyright (c) 2006  Doug Fales
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
+# frozen_string_literal: true
+
 module GPX
   # This class will parse the lat/lon and time data from a Magellan track log,
   # which is a NMEA formatted CSV list of points.
   class MagellanTrackLog
-    #PMGNTRK
+    # PMGNTRK
     # This message is to be used to transmit Track information (basically a list of previous position fixes)
     # which is often displayed on the plotter or map screen of the unit.  The first field in this message
     # is the Latitude, followed by N or S.  The next field is the Longitude followed by E or W.  The next
@@ -35,98 +15,86 @@ module GPX
     # of the fix.  Note that this field is (and its preceding comma) is only produced by the unit when the
     # command PMGNCMD,TRACK,2 is given.  It is not present when a simple command of PMGNCMD,TRACK is issued.
 
-    #NOTE: The Latitude and Longitude Fields are shown as having two decimal
+    # NOTE: The Latitude and Longitude Fields are shown as having two decimal
     # places. As many additional decimal places may be added as long as the total
     # length of the message does not exceed 82 bytes.
 
     # $PMGNTRK,llll.ll,a,yyyyy.yy,a,xxxxx,a,hhmmss.ss,A,c----c,ddmmyy*hh<CR><LF>
     require 'csv'
 
-    LAT       = 1
-    LAT_HEMI  = 2
-    LON       = 3
-    LON_HEMI  = 4
-    ELE       = 5
+    LAT = 1
+    LAT_HEMI = 2
+    LON = 3
+    LON_HEMI = 4
+    ELE = 5
     ELE_UNITS = 6
-    TIME      = 7
+    TIME = 7
     INVALID_FLAG = 8
-    DATE      = 10
+    DATE = 10
 
     FEET_TO_METERS = 0.3048
 
     class << self
-
       # Takes the name of a magellan file, converts the contents to GPX, and
       # writes the result to gpx_filename.
       def convert_to_gpx(magellan_filename, gpx_filename)
-
         segment = Segment.new
 
-        CSV.open(magellan_filename, "r").each do |row|
-          next if(row.size < 10 or row[INVALID_FLAG] == 'V')
+        CSV.open(magellan_filename, 'r').each do |row|
+          next if (row.size < 10) || (row[INVALID_FLAG] == 'V')
 
-          lat_deg  = row[LAT][0..1]
-          lat_min  = row[LAT][2...-1]
+          lat_deg = row[LAT][0..1]
+          lat_min = row[LAT][2...-1]
           lat_hemi = row[LAT_HEMI]
 
           lat = lat_deg.to_f + (lat_min.to_f / 60.0)
-          lat = (-lat) if(lat_hemi == 'S')
+          lat = -lat if lat_hemi == 'S'
 
-          lon_deg      = row[LON][0..2]
-          lon_min  = row[LON][3..-1]
+          lon_deg = row[LON][0..2]
+          lon_min = row[LON][3..-1]
           lon_hemi = row[LON_HEMI]
 
           lon = lon_deg.to_f + (lon_min.to_f / 60.0)
-          lon = (-lon) if(lon_hemi == 'W')
-
+          lon = -lon if lon_hemi == 'W'
 
           ele = row[ELE]
           ele_units = row[ELE_UNITS]
           ele = ele.to_f
-          if(ele_units == 'F')
-            ele *= FEET_TO_METERS
-          end
+          ele *= FEET_TO_METERS if ele_units == 'F'
 
-          hrs  = row[TIME][0..1].to_i
+          hrs = row[TIME][0..1].to_i
           mins = row[TIME][2..3].to_i
           secs = row[TIME][4..5].to_i
-          day  = row[DATE][0..1].to_i
-          mon  = row[DATE][2..3].to_i
-          yr   = 2000 + row[DATE][4..5].to_i
+          day = row[DATE][0..1].to_i
+          mon = row[DATE][2..3].to_i
+          yr = 2000 + row[DATE][4..5].to_i
 
           time = Time.gm(yr, mon, day, hrs, mins, secs)
 
-          #must create point
-          pt = TrackPoint.new(:lat => lat, :lon => lon, :time => time, :elevation => ele)
+          # must create point
+          pt = TrackPoint.new(lat: lat, lon: lon, time: time, elevation: ele)
           segment.append_point(pt)
-
         end
 
         trk = Track.new
         trk.append_segment(segment)
-        gpx_file = GPXFile.new(:tracks => [trk])
+        gpx_file = GPXFile.new(tracks: [trk])
         gpx_file.write(gpx_filename)
-
       end
 
       # Tests to see if the given file is a magellan NMEA track log.
-      def is_magellan_file?(filename)
+      def magellan_file?(filename)
         i = 0
-        File.open(filename, "r") do |f|
+        File.open(filename, 'r') do |f|
           f.each do |line|
-            i +=  1
-            if line =~ /^\$PMGNTRK/
-              return true
-            elsif line =~ /<\?xml/
-              return false
-            elsif(i > 10)
-              return false
-            end
+            i += 1
+            return true if line =~ /^\$PMGNTRK/
+            return false if line =~ /<\?xml/
+            return false if i > 10
           end
         end
-        return false
+        false
       end
     end
-
   end
 end

data/lib/gpx/point.rb

@@ -1,46 +1,35 @@
-#--
-# Copyright (c) 2006  Doug Fales
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
+# frozen_string_literal: true
+
 module GPX
   # The base class for all points.  Trackpoint and Waypoint both descend from this base class.
   class Point < Base
-    D_TO_R = Math::PI/180.0;
-    attr_accessor :lat, :lon, :time, :elevation, :gpx_file, :speed, :extensions
+    D_TO_R = Math::PI / 180.0
+    attr_accessor :time, :elevation, :gpx_file, :speed, :extensions
+    attr_reader :lat, :lon
 
     # 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 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 } )
+    def initialize(opts = { lat: 0.0, lon: 0.0, elevation: 0.0, time: Time.now })
+      super()
       @gpx_file = opts[:gpx_file]
-      if (opts[:element])
+      if opts[:element]
         elem = opts[:element]
-        @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.at("time").inner_text) rescue nil)
-        @elevation = elem.at("ele").inner_text.to_f unless elem.at("ele").nil?
-        @speed = elem.at("speed").inner_text.to_f unless elem.at("speed").nil?
-        @extensions = elem.at("extensions") unless elem.at("extensions").nil?
+        @lat = elem['lat'].to_f
+        @lon = elem['lon'].to_f
+        @latr = (D_TO_R * @lat)
+        @lonr = (D_TO_R * @lon)
+        # '-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
+        @time = (
+        begin
+          Time.xmlschema(elem.at('time').inner_text)
+        rescue StandardError
+          nil
+        end)
+        @elevation = elem.at('ele').inner_text.to_f unless elem.at('ele').nil?
+        @speed = elem.at('speed').inner_text.to_f unless elem.at('speed').nil?
+        @extensions = elem.at('extensions') unless elem.at('extensions').nil?
       else
         @lat = opts[:lat]
         @lon = opts[:lon]
@@ -49,10 +38,8 @@ module GPX
         @speed = opts[:speed]
         @extensions = opts[:extensions]
       end
-
     end
 
-
     # Returns the latitude and longitude (in that order), separated by the
     # given delimeter.  This is useful for passing a point into another API
     # (i.e. the Google Maps javascript API).

data/lib/gpx/route.rb

@@ -1,58 +1,37 @@
-#--
-# Copyright (c) 2006  Doug Fales
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
+# frozen_string_literal: true
+
 module GPX
   # A Route in GPX is very similar to a Track, but it is created by a user
   # from a series of Waypoints, whereas a Track is created by the GPS device
   # automatically logging your progress at regular intervals.
   class Route < Base
-
     attr_accessor :points, :name, :gpx_file
 
     # Initialize a Route from a XML::Node.
     def initialize(opts = {})
-      if(opts[:gpx_file] and opts[:element])
+      super()
+      if opts[:gpx_file] && opts[:element]
         rte_element = opts[:element]
         @gpx_file = opts[:gpx_file]
-        @name = rte_element.at("name").inner_text
+        @name = rte_element.at('name')&.inner_text
         @points = []
-        rte_element.search("rtept").each do |point|
-          @points << Point.new(:element => point, :gpx_file => @gpx_file)
+        rte_element.search('rtept').each do |point|
+          @points << Point.new(element: point, gpx_file: @gpx_file)
         end
       else
-        @points = (opts[:points] or [])
+        @points = (opts[:points] || [])
         @name = (opts[:name])
       end
-
     end
 
     # Delete points outside of a given area.
     def crop(area)
-      points.delete_if{ |pt| not area.contains? pt }
+      points.delete_if { |pt| !area.contains? pt }
     end
 
     # Delete points within the given area.
     def delete_area(area)
-      points.delete_if{ |pt| area.contains? pt }
+      points.delete_if { |pt| area.contains? pt }
     end
   end
 end

data/lib/gpx/segment.rb

@@ -1,38 +1,18 @@
-#--
-# Copyright (c) 2006  Doug Fales
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
+# frozen_string_literal: true
+
 module GPX
   # A segment is the basic container in a GPX file.  A Segment contains points
   # (in this lib, they're called TrackPoints).  A Track contains Segments.  An
   # instance of Segment knows its highest point, lowest point, earliest and
   # latest points, distance, and bounds.
   class Segment < Base
-
     attr_reader :earliest_point, :latest_point, :bounds, :highest_point, :lowest_point, :distance, :duration
     attr_accessor :points, :track
 
     # 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 = {})
+      super()
       @gpx_file = opts[:gpx_file]
       @track = opts[:track]
       @points = []
@@ -43,15 +23,13 @@ module GPX
       @distance = 0.0
       @duration = 0.0
       @bounds = Bounds.new
-      if(opts[:element])
-        segment_element = opts[:element]
-        last_pt = nil
-        if segment_element.is_a?(Nokogiri::XML::Node)
-          segment_element.search("trkpt").each do |trkpt|
-            pt = TrackPoint.new(:element => trkpt, :segment => self, :gpx_file => @gpx_file)
-            append_point(pt)
-          end
-        end
+
+      segment_element = opts[:element]
+      return unless segment_element.is_a?(Nokogiri::XML::Node)
+
+      segment_element.search('trkpt').each do |trkpt|
+        pt = TrackPoint.new(element: trkpt, segment: self, gpx_file: @gpx_file)
+        append_point(pt)
       end
     end
 
@@ -59,8 +37,8 @@ module GPX
     def append_point(pt)
       last_pt = @points[-1]
       if pt.time
-        @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)
+        @earliest_point = pt if @earliest_point.nil? || (@earliest_point.time && pt.time < @earliest_point.time)
+        @latest_point = pt if @latest_point.nil? || (@latest_point.time && pt.time > @latest_point.time)
       else
         # when no time information in data, we consider the points are ordered
         @earliest_point = @points[0]
@@ -68,8 +46,8 @@ module GPX
       end
 
       if pt.elevation
-        @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)
+        @lowest_point = pt if @lowest_point.nil? || (pt.elevation < @lowest_point.elevation)
+        @highest_point = pt if @highest_point.nil? || (pt.elevation > @highest_point.elevation)
       end
       @bounds.min_lat = pt.lat if pt.lat < @bounds.min_lat
       @bounds.min_lon = pt.lon if pt.lon < @bounds.min_lon
@@ -77,14 +55,16 @@ module GPX
       @bounds.max_lon = pt.lon if pt.lon > @bounds.max_lon
       if last_pt
         @distance += haversine_distance(last_pt, pt)
-        @duration += pt.time - last_pt.time if pt.time and last_pt.time
+        @duration += pt.time - last_pt.time if pt.time && last_pt.time
       end
       @points << pt
     end
 
     # Returns true if the given time is within this Segment.
     def contains_time?(time)
-      (time >= @earliest_point.time and time <= @latest_point.time) rescue false
+      ((time >= @earliest_point.time) && (time <= @latest_point.time))
+    rescue StandardError
+      false
     end
 
     # Finds the closest point in time to the passed-in time argument.  Useful
@@ -97,12 +77,12 @@ module GPX
     # Deletes all points within this Segment that lie outside of the given
     # area (which should be a Bounds object).
     def crop(area)
-      delete_if { |pt| not area.contains?(pt) }
+      delete_if { |pt| !area.contains?(pt) }
     end
 
     # Deletes all points in this Segment that lie within the given area.
     def delete_area(area)
-      delete_if{ |pt| area.contains?(pt) }
+      delete_if { |pt| area.contains?(pt) }
     end
 
     # A handy method that deletes points based on a block that is passed in.
@@ -114,18 +94,18 @@ module GPX
       keep_points = []
       last_pt = nil
       points.each do |pt|
-        unless yield(pt)
-          keep_points << pt
-          update_meta_data(pt, last_pt)
-          last_pt = pt
-        end
+        next if yield(pt)
+
+        keep_points << pt
+        update_meta_data(pt, last_pt)
+        last_pt = pt
       end
       @points = keep_points
     end
 
     # Returns true if this Segment has no points.
     def empty?
-      (points.nil? or (points.size == 0))
+      (points.nil? || points.empty?)
     end
 
     # Prints out a nice summary of this Segment.
@@ -133,31 +113,31 @@ module GPX
       result = "Track Segment\n"
       result << "\tSize: #{points.size} points\n"
       result << "\tDistance: #{distance} km\n"
-      result << "\tEarliest Point: #{earliest_point.time.to_s} \n"
-      result << "\tLatest Point: #{latest_point.time.to_s} \n"
+      result << "\tEarliest Point: #{earliest_point.time} \n"
+      result << "\tLatest Point: #{latest_point.time} \n"
       result << "\tLowest Point: #{lowest_point.elevation} \n"
       result << "\tHighest Point: #{highest_point.elevation}\n "
-      result << "\tBounds: #{bounds.to_s}"
+      result << "\tBounds: #{bounds}"
       result
     end
 
     def find_point_by_time_or_offset(indicator)
       if indicator.nil?
-        return nil
+        nil
       elsif indicator.is_a?(Integer)
-        return closest_point(@earliest_point.time + indicator)
-      elsif(indicator.is_a?(Time))
-        return closest_point(indicator)
+        closest_point(@earliest_point.time + indicator)
+      elsif indicator.is_a?(Time)
+        closest_point(indicator)
       else
-        raise Exception, "find_end_point_by_time_or_offset requires an argument of type Time or Integer"
+        raise ArgumentError, 'find_end_point_by_time_or_offset requires an argument of type Time or Integer'
       end
     end
-  
+
     # smooths the location data in the segment (by recalculating the location as an average of 20 neighbouring points.  Useful for removing noise from GPS traces.
-    def smooth_location_by_average(opts={})
+    def smooth_location_by_average(opts = {})
       seconds_either_side = opts[:averaging_window] || 20
 
-      #calculate the first and last points to which the smoothing should be applied
+      # calculate the first and last points to which the smoothing should be applied
       earliest = (find_point_by_time_or_offset(opts[:start]) || @earliest_point).time
       latest = (find_point_by_time_or_offset(opts[:end]) || @latest_point).time
 
@@ -165,18 +145,18 @@ module GPX
 
       @points.each do |point|
         if point.time > latest || point.time < earliest
-          tmp_points.push point #add the point unaltered
-          next 
+          tmp_points.push point # add the point unaltered
+          next
         end
         lat_av = 0.to_f
         lon_av = 0.to_f
         alt_av = 0.to_f
         n = 0
-        # k ranges from the time of the current point +/- 20s 
-        (-1*seconds_either_side..seconds_either_side).each do |k|
+        # k ranges from the time of the current point +/- 20s
+        (-1 * seconds_either_side..seconds_either_side).each do |k|
           # find the point nearest to the time offset indicated by k
           contributing_point = closest_point(point.time + k)
-          #sum up the contributions to the average
+          # sum up the contributions to the average
           lat_av += contributing_point.lat
           lon_av += contributing_point.lon
           alt_av += contributing_point.elevation
@@ -184,37 +164,36 @@ module GPX
         end
         # calculate the averages
         tmp_point = point.clone
-        tmp_point.lon = ((lon_av) / n).round(7)
-        tmp_point.elevation = ((alt_av) / n).round(2)
-        tmp_point.lat = ((lat_av) / n).round(7)
+        tmp_point.lon = (lon_av / n).round(7)
+        tmp_point.elevation = (alt_av / n).round(2)
+        tmp_point.lat = (lat_av / n).round(7)
         tmp_points.push tmp_point
       end
-      last_pt = nil
       @points.clear
       reset_meta_data
-      #now commit the averages back and recalculate the distances
+      # now commit the averages back and recalculate the distances
       tmp_points.each do |point|
         append_point(point)
       end
     end
 
     protected
+
     def find_closest(pts, time)
       return pts.first if pts.size == 1
-      midpoint = pts.size/2
+
+      midpoint = pts.size / 2
       if pts.size == 2
         diff_1 = pts[0].time - time
         diff_2 = pts[1].time - time
         return (diff_1 < diff_2 ? pts[0] : pts[1])
       end
-      if time >= pts[midpoint].time and time <= pts[midpoint+1].time
-
-        return pts[midpoint]
-
-      elsif(time <= pts[midpoint].time)
-        return find_closest(pts[0..midpoint], time)
+      if (time >= pts[midpoint].time) && (time <= pts[midpoint + 1].time)
+        pts[midpoint]
+      elsif time <= pts[midpoint].time
+        find_closest(pts[0..midpoint], time)
       else
-        return find_closest(pts[(midpoint+1)..-1], time)
+        find_closest(pts[(midpoint + 1)..-1], time)
       end
     end
 
@@ -224,11 +203,6 @@ module GPX
       p1.haversine_distance_from(p2)
     end
 
-    # Calculate the plain Pythagorean difference between two points.  Not currently used.
-    def pythagorean_distance(p1, p2)
-      p1.pythagorean_distance_from(p2)
-    end
-
     # Calculates the distance between two points using the Law of Cosines formula.  Not currently used.
     def law_of_cosines_distance(p1, p2)
       p1.law_of_cosines_distance_from(p2)
@@ -246,8 +220,8 @@ module GPX
 
     def update_meta_data(pt, last_pt)
       if pt.time
-        @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)
+        @earliest_point = pt if @earliest_point.nil? || (pt.time < @earliest_point.time)
+        @latest_point = pt if @latest_point.nil? || (pt.time > @latest_point.time)
       else
         # when no time information in data, we consider the points are ordered
         @earliest_point = @points[0]
@@ -255,16 +229,15 @@ module GPX
       end
 
       if pt.elevation
-        @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)
+        @lowest_point = pt if @lowest_point.nil? || (pt.elevation < @lowest_point.elevation)
+        @highest_point = pt if @highest_point.nil? || (pt.elevation > @highest_point.elevation)
       end
       @bounds.add(pt)
-      if last_pt
-        @distance += haversine_distance(last_pt, pt)
-        @duration += pt.time - last_pt.time if pt.time and last_pt.time
-      end
-    end
 
-  end
+      return unless last_pt
 
+      @distance += haversine_distance(last_pt, pt)
+      @duration += pt.time - last_pt.time if pt.time && last_pt.time
+    end
+  end
 end