gpx 0.8.3 → 1.1.1

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)..], 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

data/lib/gpx/track.rb

@@ -1,25 +1,5 @@
-#--
-# 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
   # In GPX, a single Track can hold multiple Segments, each of which hold
   # multiple points (in this library, those points are instances of
@@ -34,28 +14,45 @@ module GPX
     # Initialize a track from a XML::Node, or, if no :element option is
     # passed, initialize a blank Track object.
     def initialize(opts = {})
+      super()
       @gpx_file = opts[:gpx_file]
       @segments = []
       @points = []
       reset_meta_data
-      if(opts[:element])
-        trk_element = opts[:element]
-        @name = (trk_element.at("name").inner_text rescue "")
-        @comment = (trk_element.at('cmt').inner_text rescue '')
-        @description = (trk_element.at('desc').inner_text rescue '')
-        trk_element.search("trkseg").each do |seg_element|
-          seg = Segment.new(:element => seg_element, :track => self, :gpx_file => @gpx_file)
-          update_meta_data(seg)
-          @segments << seg
-        end
+
+      return unless opts[:element]
+
+      trk_element = opts[:element]
+      @name = (
+      begin
+        trk_element.at('name').inner_text
+      rescue StandardError
+        ''
+      end)
+      @comment = (
+      begin
+        trk_element.at('cmt').inner_text
+      rescue StandardError
+        ''
+      end)
+      @description = (
+      begin
+        trk_element.at('desc').inner_text
+      rescue StandardError
+        ''
+      end)
+      trk_element.search('trkseg').each do |seg_element|
+        seg = Segment.new(element: seg_element, track: self, gpx_file: @gpx_file)
+        append_segment(seg)
       end
     end
 
     # Append a segment to this track, updating its meta data along the way.
     def append_segment(seg)
+      return if seg.points.empty?
+
       update_meta_data(seg)
       @segments << seg
-      @points.concat(seg.points) unless seg.nil?
     end
 
     # Returns true if the given time occurs within any of the segments of this track.
@@ -63,7 +60,7 @@ module GPX
       segments.each do |seg|
         return true if seg.contains_time?(time)
       end
-      return false
+      false
     end
 
     # Finds the closest point (to "time") within this track.  Useful for
@@ -82,7 +79,7 @@ module GPX
         seg.crop(area)
         update_meta_data(seg) unless seg.empty?
       end
-      segments.delete_if { |seg| seg.empty? }
+      segments.delete_if(&:empty?)
     end
 
     # Deletes all points within a given area and updates the meta data.
@@ -92,13 +89,13 @@ module GPX
         seg.delete_area(area)
         update_meta_data(seg) unless seg.empty?
       end
-      segments.delete_if { |seg| seg.empty? }
+      segments.delete_if(&:empty?)
     end
 
     # Returns true if this track has no points in it.  This should return
     # true even when the track has empty segments.
     def empty?
-      (points.nil? or points.size.zero?)
+      (points.nil? || points.empty?)
     end
 
     # Prints out a friendly summary of this track (sans points).  Useful for
@@ -115,7 +112,7 @@ module GPX
       result << "\tMoving duration: #{moving_duration} km\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
 
@@ -125,12 +122,12 @@ module GPX
         @distance += seg.distance
       end
     end
- 
+
     protected
 
     def update_meta_data(seg)
-      @lowest_point   = seg.lowest_point if(@lowest_point.nil? or seg.lowest_point.elevation < @lowest_point.elevation)
-      @highest_point  = seg.highest_point if(@highest_point.nil? or seg.highest_point.elevation > @highest_point.elevation)
+      @lowest_point = seg.lowest_point if @lowest_point.nil? || (seg.lowest_point.elevation < @lowest_point.elevation)
+      @highest_point = seg.highest_point if @highest_point.nil? || (seg.highest_point.elevation > @highest_point.elevation)
       @bounds.add(seg.bounds)
       @distance += seg.distance
       @moving_duration += seg.duration
@@ -145,6 +142,5 @@ module GPX
       @moving_duration = 0.0
       @points = []
     end
-
   end
 end

data/lib/gpx/track_point.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GPX
+  # Basically the same as a point, the TrackPoint class is supposed to
+  # represent the points that are children of Segment elements.  So, the only
+  # real difference is that TrackPoints hold a reference to their parent
+  # Segments.
+  class TrackPoint < Point
+    RADIUS = 6371 # earth's mean radius in km
+
+    attr_accessor :segment
+
+    def initialize(opts = {})
+      super(opts)
+      @segment = opts[:segment]
+    end
+
+    # Units are in km
+    def haversine_distance_from(p2)
+      d_lat = p2.latr - latr
+      d_lon = p2.lonr - lonr
+      a = Math.sin(d_lat / 2) * Math.sin(d_lat / 2) + Math.cos(latr) * Math.cos(p2.latr) * Math.sin(d_lon / 2) * Math.sin(d_lon / 2)
+      c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+      RADIUS * c
+    end
+
+    # Units are in km
+    def law_of_cosines_distance_from(p2)
+      Math.acos(Math.sin(latr) * Math.sin(p2.latr) + Math.cos(latr) * Math.cos(p2.latr) * Math.cos(p2.lonr - lonr)) * RADIUS
+    end
+  end
+end

data/lib/gpx/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GPX
-  VERSION = "0.8.3"
+  VERSION = "1.1.1"
 end

data/lib/gpx/waypoint.rb

@@ -1,56 +1,32 @@
-#--
-# 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 supports the concept of a waypoint.  Beware that this class has
   # not seen much use yet, since WalkingBoss does not use waypoints right now.
   class Waypoint < Point
-
-    SUB_ELEMENTS = %w{ele magvar geoidheight name cmt desc src link sym type fix sat hdop vdop pdop ageofdgpsdata dgpsid extensions}
+    SUB_ELEMENTS = %w[ele magvar geoidheight name cmt desc src link sym type fix sat hdop vdop pdop ageofdgpsdata dgpsid extensions].freeze
 
     attr_reader :gpx_file
+
     SUB_ELEMENTS.each { |sub_el| attr_accessor sub_el.to_sym }
 
     # Not implemented
-    def crop(area)
-    end
+    def crop(area); end
 
     # Not implemented
-    def delete_area(area)
-    end
+    def delete_area(area); end
 
     # Initializes a waypoint from a XML::Node.
     def initialize(opts = {})
-      if(opts[:element] and opts[:gpx_file])
+      if opts[:element] && opts[:gpx_file]
         wpt_elem = opts[:element]
         @gpx_file = opts[:gpx_file]
-        super(:element => wpt_elem, :gpx_file => @gpx_file)
+        super(element: wpt_elem, gpx_file: @gpx_file)
         instantiate_with_text_elements(wpt_elem, SUB_ELEMENTS)
       else
         opts.each do |key, value|
           assignment_method = "#{key}="
-          if self.respond_to?(assignment_method)
-            self.send(assignment_method, value)
-          end
+          send(assignment_method, value) if respond_to?(assignment_method)
         end
       end
     end
@@ -65,7 +41,7 @@ module GPX
       result << "\tElevation: #{elevation}\n "
       result << "\tTime: #{time}\n"
       SUB_ELEMENTS.each do |sub_element_attribute|
-        val = self.send(sub_element_attribute)
+        val = send(sub_element_attribute)
         result << "\t#{sub_element_attribute}: #{val}\n" unless val.nil?
       end
       result