gpx 0.9.0 → 1.1.0

data/lib/gpx/geo_json.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GPX
+  # Class to parse GeoJSON LineStrings, MultiLineStrings, Points,
+  # and MultiPoint geometric objects to GPX format. For the full
+  # specification of GeoJSON, see:
+  #   http://geojson.org/geojson-spec.html
+  # Note that GeoJSON coordinates are specified in lon/lat format,
+  # instead of the more traditional lat/lon format.
+  #
+  class GeoJSON
+    class << self
+      FEATURE = 'Feature'
+      LINESTRING = 'LineString'
+      MULTILINESTRING = 'MultiLineString'
+      POINT = 'Point'
+      MULTIPOINT = 'MultiPoint'
+
+      # Conversion can be initiated by either specifying a file,
+      # file name, or by passing in GeoJSON data as a string.
+      # Examples:
+      #   GPX::GeoJSON.convert_to_gpx(geojson_file: 'mygeojsonfile.json')
+      # or
+      #   file = File.new('mygeojsonfile.json', 'r')
+      #   GPX::GeoJSON.convert_to_gpx(geojson_file: file)
+      # or
+      #   data = JSON.generate(my_geojson_hash)
+      #   GPX::GeoJSON.convert_to_gpx(geojson_data: data)
+      #
+      # Returns a GPX::GPX_File object populated with the converted data.
+      #
+      def convert_to_gpx(opts = {})
+        geojson = geojson_data_from(opts)
+        gpx_file = GPX::GPXFile.new
+        add_tracks_to(gpx_file, geojson)
+        add_waypoints_to(gpx_file, geojson)
+        gpx_file
+      end
+
+      private
+
+      def geojson_data_from(opts)
+        if opts[:geojson_file]
+          parse_geojson_data_from_file(opts[:geojson_file])
+        elsif opts[:geojson_data]
+          parse_geojson_data(opts[:geojson_data])
+        else
+          raise ArgumentError,
+                'Must pass value for \':geojson_file\' ' \
+                'or \':geojson_data\' to convert_to_gpx'
+        end
+      end
+
+      def parse_geojson_data_from_file(filename)
+        parse_geojson_data(IO.read(filename))
+      end
+
+      def parse_geojson_data(data)
+        JSON.parse(data)
+      end
+
+      def add_tracks_to(gpx_file, geojson)
+        tracks = [line_strings_to_track(geojson)] +
+                 multi_line_strings_to_tracks(geojson)
+        tracks.compact!
+        gpx_file.tracks += tracks
+        gpx_file.tracks.each { |t| gpx_file.update_meta_data(t) }
+      end
+
+      def add_waypoints_to(gpx_file, geojson)
+        gpx_file.waypoints +=
+          points_to_waypoints(geojson, gpx_file) +
+          multi_points_to_waypoints(geojson, gpx_file)
+      end
+
+      # Converts GeoJSON 'LineString' features.
+      # Current strategy is to convert each LineString into a
+      # Track Segment, returning a Track for all LineStrings.
+      #
+      def line_strings_to_track(geojson)
+        line_strings = line_strings_in(geojson)
+        return nil unless line_strings.any?
+
+        track = GPX::Track.new
+        line_strings.each do |ls|
+          coords = ls['geometry']['coordinates']
+          track.append_segment(coords_to_segment(coords))
+        end
+        track
+      end
+
+      # Converts GeoJSON 'MultiLineString' features.
+      # Current strategy is to convert each MultiLineString
+      # into a Track, with each set of LineString coordinates
+      # within a MultiLineString a Track Segment.
+      #
+      def multi_line_strings_to_tracks(geojson)
+        tracks = []
+        multi_line_strings_in(geojson).each do |mls|
+          track = GPX::Track.new
+          mls['geometry']['coordinates'].each do |coords|
+            seg = coords_to_segment(coords)
+            seg.track = track
+            track.append_segment(seg)
+          end
+          tracks << track
+        end
+        tracks
+      end
+
+      # Converts GeoJSON 'Point' features.
+      # Current strategy is to convert each Point
+      # feature into a GPX waypoint.
+      #
+      def points_to_waypoints(geojson, gpx_file)
+        points_in(geojson).reduce([]) do |acc, pt|
+          coords = pt['geometry']['coordinates']
+          acc << point_to_waypoint(coords, gpx_file)
+        end
+      end
+
+      # Converts GeoJSON 'MultiPoint' features.
+      # Current strategy is to convert each coordinate
+      # point in a MultiPoint to a GPX waypoint.
+      #
+      # NOTE: It is debatable that a MultiPoint feature
+      # might translate best into a GPX route, which is
+      # described as
+      #   "an ordered list of waypoints representing a
+      #    series of turn points leading to a destination."
+      # See http://www.topografix.com/gpx/1/1/#type_rteType
+      #
+      def multi_points_to_waypoints(geojson, gpx_file)
+        multi_points_in(geojson).reduce([]) do |acc, mpt|
+          mpt['geometry']['coordinates'].each do |coords|
+            acc << point_to_waypoint(coords, gpx_file)
+          end
+        end
+      end
+
+      # Given an array of [lng, lat, ele] coordinates,
+      # return a GPX track segment.
+      #
+      def coords_to_segment(coords)
+        seg = GPX::Segment.new
+        coords.each do |pt|
+          seg.append_point(point_to_track_point(pt, seg))
+        end
+        seg
+      end
+
+      # Given a GeoJSON coordinate point, return
+      # a GPX::Waypoint
+      def point_to_waypoint(point, gpx_file)
+        GPX::Waypoint.new(gpx_file: gpx_file,
+                          lon: point[0],
+                          lat: point[1],
+                          elevation: point[2])
+      end
+
+      # Given a GeoJSON coorindate point, and
+      # GPX segment, return a GPX::TrackPoint.
+      #
+      def point_to_track_point(point, seg)
+        GPX::TrackPoint.new(segment: seg,
+                            lon: point[0],
+                            lat: point[1],
+                            elevation: point[2])
+      end
+
+      # Returns all features in the passed geojson
+      # that match the type.
+      #
+      def features_for(geojson, type)
+        geojson['features'].find_all do |f|
+          f['type'] == FEATURE && f['geometry']['type'] == type
+        end
+      end
+
+      def points_in(geojson)
+        features_for(geojson, POINT)
+      end
+
+      def multi_points_in(geojson)
+        features_for(geojson, MULTIPOINT)
+      end
+
+      def line_strings_in(geojson)
+        features_for(geojson, LINESTRING)
+      end
+
+      def multi_line_strings_in(geojson)
+        features_for(geojson, MULTILINESTRING)
+      end
+    end
+  end
+end

data/lib/gpx/gpx.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
   # A common base class which provides a useful initializer method to many
   # class in the GPX library.
@@ -33,14 +13,12 @@ module GPX
     # attributes to this method.
     def instantiate_with_text_elements(parent, text_elements)
       text_elements.each do |el|
-        child_xpath = "#{el}"
+        child_xpath = el.to_s
         unless parent.at(child_xpath).nil?
           val = parent.at(child_xpath).inner_text
-          self.send("#{el}=", val)
+          send("#{el}=", val)
         end
       end
-
     end
-
   end
 end

data/lib/gpx/gpx_file.rb

@@ -1,30 +1,11 @@
-#--
-# 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
   class GPXFile < Base
-    attr_accessor :tracks, :routes, :waypoints, :bounds, :lowest_point, :highest_point, :duration, :ns, :time, :name, :version, :creator, :description, :moving_duration
+    attr_accessor :tracks,
+                  :routes, :waypoints, :bounds, :lowest_point, :highest_point, :duration, :ns, :time, :name, :version, :creator, :description, :moving_duration
 
-    DEFAULT_CREATOR = "GPX RubyGem #{GPX::VERSION} -- http://dougfales.github.io/gpx/".freeze
+    DEFAULT_CREATOR = "GPX RubyGem #{GPX::VERSION} -- http://dougfales.github.io/gpx/"
 
     # This initializer can be used to create a new GPXFile from an existing
     # file or to create a new GPXFile instance with no data (so that you can
@@ -44,10 +25,14 @@ module GPX
     #         gpx_file = GPXFile.new(:tracks => [some_track])
     #
     def initialize(opts = {})
+      super()
       @duration = 0
       @attributes = {}
       @namespace_defs = []
-      if(opts[:gpx_file] or opts[:gpx_data])
+      @tracks = []
+      @time = nil
+
+      if opts[:gpx_file] || opts[:gpx_data]
         if opts[:gpx_file]
           gpx_file = opts[:gpx_file]
           gpx_file = File.open(gpx_file) unless gpx_file.is_a?(File)
@@ -59,41 +44,54 @@ module GPX
         gpx_element = @xml.at('gpx')
         @attributes = gpx_element.attributes
         @namespace_defs = gpx_element.namespace_definitions
-        #$stderr.puts gpx_element.attributes.sort.inspect
-        #$stderr.puts @xmlns.inspect
-        #$stderr.puts @xsi.inspect
         @version = gpx_element['version']
         reset_meta_data
-        bounds_element = (@xml.at("metadata/bounds") rescue nil)
+        bounds_element = (
+        begin
+          @xml.at('metadata/bounds')
+        rescue StandardError
+          nil
+        end)
         if bounds_element
-          @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})
+          @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
 
-        @time = Time.parse(@xml.at("metadata/time").inner_text) rescue nil
-        @name = @xml.at("metadata/name").inner_text rescue nil
-        @description = @xml.at('metadata/desc').inner_text rescue nil
-        @tracks = []
-        @xml.search("trk").each do |trk|
-          trk = Track.new(:element => trk, :gpx_file => self)
+        @time = begin
+          Time.parse(@xml.at('metadata/time').inner_text)
+        rescue StandardError
+          nil
+        end
+        @name = begin
+          @xml.at('metadata/name').inner_text
+        rescue StandardError
+          nil
+        end
+        @description = begin
+          @xml.at('metadata/desc').inner_text
+        rescue StandardError
+          nil
+        end
+        @xml.search('trk').each do |trk|
+          trk = Track.new(element: trk, gpx_file: self)
           update_meta_data(trk, get_bounds)
           @tracks << trk
         end
         @waypoints = []
-        @xml.search("wpt").each { |wpt| @waypoints << Waypoint.new(:element => wpt, :gpx_file => self) }
+        @xml.search('wpt').each { |wpt| @waypoints << Waypoint.new(element: wpt, gpx_file: self) }
         @routes = []
-        @xml.search("rte").each { |rte| @routes << Route.new(:element => rte, :gpx_file => self) }
-        @tracks.delete_if { |t| t.empty? }
+        @xml.search('rte').each { |rte| @routes << Route.new(element: rte, gpx_file: self) }
+        @tracks.delete_if(&:empty?)
 
         calculate_duration
       else
         reset_meta_data
-        opts.each { |attr_name, value| instance_variable_set("@#{attr_name.to_s}", value) }
-        unless(@tracks.nil? or @tracks.size.zero?)
+        opts.each { |attr_name, value| instance_variable_set("@#{attr_name}", value) }
+        unless @tracks.nil? || @tracks.empty?
           @tracks.each { |trk| update_meta_data(trk) }
           calculate_duration
         end
@@ -109,19 +107,24 @@ module GPX
         result = el[name]
         break unless result.nil?
       end
-      return (result.to_f rescue nil)
+      (
+      begin
+        result.to_f
+      rescue StandardError
+        nil
+      end)
     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' })
+    def distance(opts = { units: 'kilometers' })
       case opts[:units]
       when /kilometers/i
-        return @distance
+        @distance
       when /meters/i
-        return (@distance * 1000)
+        (@distance * 1000)
       when /miles/i
-        return (@distance * 0.62)
+        (@distance * 0.62)
       end
     end
 
@@ -129,14 +132,14 @@ module GPX
     # GPXFile.  The calculation is based on the total distance divided by the
     # sum of duration of all segments of all tracks
     # (not taking into accounting pause time).
-    def average_speed(opts = { :units => 'kilometers' })
+    def average_speed(opts = { units: 'kilometers' })
       case opts[:units]
       when /kilometers/i
-        return distance / (moving_duration/3600.0)
+        distance / (moving_duration / 3600.0)
       when /meters/i
-        return (distance * 1000) /  (moving_duration/3600.0)
+        (distance * 1000) / (moving_duration / 3600.0)
       when /miles/i
-        return (distance * 0.62) / (moving_duration/3600.0)
+        (distance * 0.62) / (moving_duration / 3600.0)
       end
     end
 
@@ -176,7 +179,7 @@ module GPX
           keep_tracks << trk
         end
       end
-      @tracks =  keep_tracks
+      @tracks = keep_tracks
       routes.each { |rte| rte.delete_area(area) }
       waypoints.each { |wpt| wpt.delete_area(area) }
     end
@@ -191,13 +194,15 @@ module GPX
       @moving_duration = 0.0
     end
 
+    # rubocop:disable Style/OptionalBooleanParameter
+
     # Updates the meta data for this GPX file.  Meta data includes the
     # bounds, the high and low points, and the distance.  This is useful when
     # you modify the GPX data (i.e. by adding or deleting points) and you
     # want the meta data to accurately reflect the new data.
     def update_meta_data(trk, get_bounds = true)
-      @lowest_point   = trk.lowest_point if(@lowest_point.nil? or (!trk.lowest_point.nil? and trk.lowest_point.elevation < @lowest_point.elevation))
-      @highest_point  = trk.highest_point if(@highest_point.nil? or (!trk.highest_point.nil? and trk.highest_point.elevation > @highest_point.elevation))
+      @lowest_point = trk.lowest_point if @lowest_point.nil? || (!trk.lowest_point.nil? && (trk.lowest_point.elevation < @lowest_point.elevation))
+      @highest_point = trk.highest_point if @highest_point.nil? || (!trk.highest_point.nil? && (trk.highest_point.elevation > @highest_point.elevation))
       @bounds.add(trk.bounds) if get_bounds
       @distance += trk.distance
       @moving_duration += trk.moving_duration
@@ -206,17 +211,18 @@ module GPX
     # Serialize the current GPXFile to a gpx file named <filename>.
     # If the file does not exist, it is created.  If it does exist, it is overwritten.
     def write(filename, update_time = true)
-      @time = Time.now if(@time.nil? or update_time)
+      @time = Time.now if @time.nil? || update_time
       @name ||= File.basename(filename)
       doc = generate_xml_doc
       File.open(filename, 'w+') { |f| f.write(doc.to_xml) }
     end
 
     def to_s(update_time = true)
-      @time = Time.now if(@time.nil? or update_time)
+      @time = Time.now if @time.nil? || update_time
       doc = generate_xml_doc
       doc.to_xml
     end
+    # rubocop:enable Style/OptionalBooleanParameter
 
     def inspect
       "<#{self.class.name}:...>"
@@ -231,117 +237,117 @@ module GPX
     end
 
     private
+
     def attributes_and_nsdefs_as_gpx_attributes
-      #$stderr.puts @namespace_defs.inspect
+      # $stderr.puts @namespace_defs.inspect
       gpx_header = {}
-      @attributes.each do |k,v|
-        k = v.namespace.prefix + ':' + k if v.namespace
+      @attributes.each do |k, v|
+        k = "#{v.namespace.prefix}:#{k}" if v.namespace
         gpx_header[k] = v.value
-      end 
+      end
 
       @namespace_defs.each do |nsd|
         tag = 'xmlns'
-        if nsd.prefix
-          tag += ':' + nsd.prefix
-        end
+        tag += ":#{nsd.prefix}" if nsd.prefix
         gpx_header[tag] = nsd.href
       end
-      return gpx_header
+      gpx_header
     end
- 
+
     def generate_xml_doc
       @version ||= '1.1'
-      version_dir = version.gsub('.','/')
+      version_dir = version.tr('.', '/')
 
       gpx_header = attributes_and_nsdefs_as_gpx_attributes
-      
-      gpx_header['version'] = @version.to_s if !gpx_header['version']
-      gpx_header['creator'] = DEFAULT_CREATOR if !gpx_header['creator']
-      gpx_header['xsi:schemaLocation'] = "http://www.topografix.com/GPX/#{version_dir} http://www.topografix.com/GPX/#{version_dir}/gpx.xsd" if !gpx_header['xsi:schemaLocation']
-      gpx_header['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance" if !gpx_header['xsi'] and !gpx_header['xmlns:xsi']
-      
-      #$stderr.puts gpx_header.keys.inspect
-
-      doc = Nokogiri::XML::Builder.new do |xml|
-        xml.gpx(gpx_header) \
-        {
-            # version 1.0 of the schema doesn't support the metadata element, so push them straight to the root 'gpx' element
-            if (@version == '1.0') then
+
+      gpx_header['version'] = @version.to_s unless gpx_header['version']
+      gpx_header['creator'] = DEFAULT_CREATOR unless gpx_header['creator']
+      gpx_header['xsi:schemaLocation'] = "http://www.topografix.com/GPX/#{version_dir} http://www.topografix.com/GPX/#{version_dir}/gpx.xsd" unless gpx_header['xsi:schemaLocation']
+      gpx_header['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance' if !gpx_header['xsi'] && !gpx_header['xmlns:xsi']
+
+      # $stderr.puts gpx_header.keys.inspect
+
+      # rubocop:disable Metrics/BlockLength
+      Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.gpx(gpx_header) do
+          # version 1.0 of the schema doesn't support the metadata element, so push them straight to the root 'gpx' element
+          if @version == '1.0'
+            xml.name @name
+            xml.time @time.xmlschema
+            xml.bound(
+              minlat: bounds.min_lat,
+              minlon: bounds.min_lon,
+              maxlat: bounds.max_lat,
+              maxlon: bounds.max_lon
+            )
+          else
+            xml.metadata do
               xml.name @name
               xml.time @time.xmlschema
               xml.bound(
                 minlat: bounds.min_lat,
                 minlon: bounds.min_lon,
                 maxlat: bounds.max_lat,
-                maxlon: bounds.max_lon,
+                maxlon: bounds.max_lon
               )
-            else
-              xml.metadata {
-                xml.name @name
-                xml.time @time.xmlschema
-                xml.bound(
-                  minlat: bounds.min_lat,
-                  minlon: bounds.min_lon,
-                  maxlat: bounds.max_lat,
-                  maxlon: bounds.max_lon,
-                )
-              }
             end
+          end
+
+          tracks&.each do |t|
+            xml.trk do
+              xml.name t.name
 
-            tracks.each do |t|
-              xml.trk {
-                xml.name t.name
-
-                t.segments.each do |seg|
-                  xml.trkseg {
-                    seg.points.each do |p|
-                      xml.trkpt(lat: p.lat, lon: p.lon) {
-                        xml.time p.time.xmlschema unless p.time.nil?
-                        xml.ele p.elevation unless p.elevation.nil?
-                        xml << p.extensions.to_xml unless p.extensions.nil?
-                      }
+              t.segments.each do |seg|
+                xml.trkseg do
+                  seg.points.each do |p|
+                    xml.trkpt(lat: p.lat, lon: p.lon) do
+                      xml.time p.time.xmlschema unless p.time.nil?
+                      xml.ele p.elevation unless p.elevation.nil?
+                      xml << p.extensions.to_xml unless p.extensions.nil?
                     end
-                  }
+                  end
                 end
-              }
-            end unless tracks.nil?
-
-            waypoints.each do |w|
-              xml.wpt(lat: w.lat, lon: w.lon) {
-                xml.time w.time.xmlschema unless w.time.nil?
-                Waypoint::SUB_ELEMENTS.each do |sub_elem|
-                  xml.send(sub_elem, w.send(sub_elem)) if w.respond_to?(sub_elem) && !w.send(sub_elem).nil?
-                end
-              }
-            end unless waypoints.nil?
-
-            routes.each do |r|
-              xml.rte {
-                xml.name r.name
-
-                r.points.each do |p|
-                  xml.rtept(lat: p.lat, lon: p.lon) {
-                    xml.time p.time.xmlschema unless p.time.nil?
-                    xml.ele p.elevation unless p.elevation.nil?
-                  }
+              end
+            end
+          end
+
+          waypoints&.each do |w|
+            xml.wpt(lat: w.lat, lon: w.lon) do
+              xml.time w.time.xmlschema unless w.time.nil?
+              Waypoint::SUB_ELEMENTS.each do |sub_elem|
+                xml.send(sub_elem, w.send(sub_elem)) if w.respond_to?(sub_elem) && !w.send(sub_elem).nil?
+              end
+            end
+          end
+
+          routes&.each do |r|
+            xml.rte do
+              xml.name r.name
+
+              r.points.each do |p|
+                xml.rtept(lat: p.lat, lon: p.lon) do
+                  xml.time p.time.xmlschema unless p.time.nil?
+                  xml.ele p.elevation unless p.elevation.nil?
                 end
-              }
-            end unless routes.nil?
-          }
+              end
+            end
+          end
+        end
       end
-
-      return doc
+      # rubocop:enable Metrics/BlockLength
     end
 
     # Calculates and sets the duration attribute by subtracting the time on
     # the very first point from the time on the very last point.
     def calculate_duration
       @duration = 0
-      if(@tracks.nil? or @tracks.size.zero? or @tracks[0].segments.nil? or @tracks[0].segments.size.zero?)
+      if @tracks.nil? || @tracks.empty? || @tracks[0].segments.nil? || @tracks[0].segments.empty?
         return @duration
+
       end
+
       @duration = (@tracks[-1].segments[-1].points[-1].time - @tracks.first.segments.first.points.first.time)
-    rescue
+    rescue StandardError
       @duration = 0
     end
   end