gpx 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b894a8f06a91646472aa6311602be3da1c0d4767a7bc44867ba954ecf93d1909
-  data.tar.gz: 73b5b4e73fb783f3e10a007e2101f49db0e57f48e3675fea7b8255d1a21b84ad
+  metadata.gz: e058dd4105b07060879b8084b796f964ca48d9ca357a47fe698fa645df8b0599
+  data.tar.gz: 0525a329af4a8e6ab2e10a40de6de388a708fb806731b72e2a6686da1824b3dc
 SHA512:
-  metadata.gz: 279dff5711fc5808537e5e69d9be696dc9439b899021f5ab3a7532a8c68d5c099a40b63fefd89d7ebba1c64c250e599211f4a157028d4f00663b41a77cbf4ae6
-  data.tar.gz: b0c69fe2fa5014edb2e3628fc73b949b1d9fdaad5e73ab7546e7fd74d47c295be5722451cb8cd7cec5ebeb7ba85cc32e9ac38682d9b72b6e223f0b3295e594a1
+  metadata.gz: 463d441112bca4747ea4db699281ebcd42705706abb0f703c351aea732d5935ceffee3ba84c3484d1afaf84e9e116f6740b3973bd907ad6f6bcad71a9da05a59
+  data.tar.gz: ff34c0fdfbf7661af840b757ef4c2b8bcb55419131f76dd8a03a43ee73398f408ccdb47b3a7d273b2409dd65410dfeb0de4a6acd5928efd999cb2ee4dc650f2f

data/.github/workflows/ruby.yml

@@ -24,12 +24,12 @@ jobs:
         ruby-version: ['2.7', '3.0', '3.1', '3.2']
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Ruby
     # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
     # change this to (see https://github.com/ruby/setup-ruby#versioning):
     # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@v1.149.0
+      uses: ruby/setup-ruby@v1.159.0
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically

data/.rubocop.yml

@@ -65,6 +65,9 @@ Style/NegatedWhile:
   Enabled: false
   StyleGuide: http://relaxed.ruby.style/#stylenegatedwhile
 
+Style/OptionalBooleanParameter:
+  Enabled: false
+
 Style/ParallelAssignment:
   Enabled: false
   StyleGuide: http://relaxed.ruby.style/#styleparallelassignment

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [1.2.0] - 2024-07-26
+
+  * Adds ability to address various GeoJSON properties when performing GeoJSON to GPX conversion. (#53 via @niborg)
+  * Allow anything that responds to `read` for GPXFile input. (#55 via @hiroaki)
+
 ## [1.1.1] - 2023-05-19
 
   * updates CI, minimal Ruby version now 2.7, updates tooling like rubocop and GitHub actions
@@ -5,6 +10,7 @@
   * adds UPGRADING.md to document changes between versions
 
 ## [1.1.0] - 2023-05-18
+
   * Specify UTF-8 encoding for XML encoding (#35 via @sh1nduu)
   * Added GeoJSON conversion (#38 via @tyrauber and @niborg)
   * Support Ruby 3 (#43 via @LocoDelAssembly)

data/README.md

@@ -6,12 +6,12 @@
 ## What It Does
 
 This library reads GPX files and provides an API for reading and manipulating
-the data as objects.  For more info on the GPX format, see
+the data as objects. For more info on the GPX format, see
 http://www.topografix.com/gpx.asp.
 
 In addition to parsing GPX files, this library is capable of converting
 Magellan NMEA files to GPX, converting GeoJSON data to GPX, and writing
-new GPX files.  It can crop and delete rectangular areas within a file,
+new GPX files. It can crop and delete rectangular areas within a file,
 and it also calculates some meta-data about the tracks and points in a file (such as distance, duration, average speed, etc).
 
 ## Requirements
@@ -20,12 +20,23 @@ and it also calculates some meta-data about the tracks and points in a file (suc
 - As of `1.0.0`, `gpx` requires at least Ruby 2.2 to run.
 
 ## Installation
+
 Add to your gemfile:
+
 ```
 gem 'gpx'
 ```
+
 ## Examples
 
+Initialize a `GPXFile` object with either a file-like object or a string representation:
+
+```ruby
+gpx = GPX::GPXFile.new(:gpx_file => string_io) # Anything that responds to `read`
+gpx = GPX::GPXFile.new(:gpx_file => path_to_a_file)
+gpx = GPX::GPXFile.new(:gpx_data => some_string)
+```
+
 Reading a GPX file, and cropping its contents to a given area:
 
 ```ruby
@@ -36,6 +47,7 @@ gpx.write(filename)                              # Save it
 ```
 
 Converting a Magellan track log to GPX:
+
 ```ruby
 if GPX::MagellanTrackLog::is_magellan_file?(filename)
  GPX::MagellanTrackLog::convert_to_gpx(filename, "#{filename}.gpx")
@@ -44,6 +56,7 @@ end
 
 Converting GeoJSON data to GPX can be achieved by providing a
 file path, file, or the data in string format:
+
 ```ruby
 # Converting from a file name
 gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: 'mygeojsonfile.json')
@@ -51,9 +64,23 @@ gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: 'mygeojsonfile.json')
 # Converting from a string
 data = JSON.generate(my_geojson_hash)
 gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_data: data)
+
+# The above won't transfer anything but coordinate values. If you want to
+# transfer ad hoc "properties" information, you can specify an object that
+# responds to `call` to manipulate GPX data structures as follows:
+gpx_file = GPX::GeoJSON.convert_to_gpx(
+  geojson_data: data,
+  line_string_feature_to_segment: ->(ls, seg) { seg.distance = ls["properties"]["distance"] },
+  multi_line_string_feature_to_track: lambda { |mls, track|
+    track.name = mls["properties"]["name"]
+  },
+  point_feature_to_waypoint: ->(pt, wpt) { wpt.name = pt["properties"]["name"] }
+  multi_point_feature_to_waypoint: ->(mpt, wpt) { wpt.sym = mpt["properties"]["icon"] }
+)
 ```
 
 Exporting an ActiveRecord to GPXFile (as Waypoints)
+
 ```ruby
 #
 # Our active record in this example is called stop
@@ -98,12 +125,11 @@ Mime::Type.register "application/gpx+xml", :gpx
 
 You have a complete example on how to create a gpx file from scratch on `tests/output_text.rb`.
 
-
 ## Notes
 
 This library was written to bridge the gap between my Garmin Geko
-and my website, WalkingBoss.org (RIP).  For that reason, it has always been more of a
-work-in-progress than an attempt at full GPX compliance.  The track side of the
+and my website, WalkingBoss.org (RIP). For that reason, it has always been more of a
+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.
 
@@ -113,7 +139,7 @@ working with tracks from several days or weeks.
 
 Finally, it should be noted that none of the distance/speed calculation or
 crop/delete code has been tested under International Date Line-crossing
-conditions.  That particular part of the code will likely be unreliable if
+conditions. That particular part of the code will likely be unreliable if
 you're zig-zagging across 180 degrees longitude routinely.
 
 ## License

data/lib/gpx/bounds.rb

@@ -28,7 +28,7 @@ module GPX
 
     # Returns true if the pt is within these bounds.
     def contains?(pt)
-      ((pt.lat >= min_lat) && (pt.lat <= max_lat) && (pt.lon >= min_lon) && (pt.lon <= max_lon))
+      (pt.lat >= min_lat) && (pt.lat <= max_lat) && (pt.lon >= min_lon) && (pt.lon <= max_lon)
     end
 
     # Adds an item to itself, expanding its min/max lat/lon as needed to

data/lib/gpx/geo_json.rb

@@ -34,8 +34,8 @@ module GPX
       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)
+        add_tracks_to(gpx_file, geojson, opts)
+        add_waypoints_to(gpx_file, geojson, opts)
         gpx_file
       end
 
@@ -61,32 +61,35 @@ module GPX
         JSON.parse(data)
       end
 
-      def add_tracks_to(gpx_file, geojson)
-        tracks = [line_strings_to_track(geojson)] +
-                 multi_line_strings_to_tracks(geojson)
+      def add_tracks_to(gpx_file, geojson, opts)
+        tracks = [line_strings_to_track(geojson, opts)] +
+                 multi_line_strings_to_tracks(geojson, opts)
         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)
+      def add_waypoints_to(gpx_file, geojson, opts)
         gpx_file.waypoints +=
-          points_to_waypoints(geojson, gpx_file) +
-          multi_points_to_waypoints(geojson, gpx_file)
+          points_to_waypoints(geojson, gpx_file, opts) +
+          multi_points_to_waypoints(geojson, gpx_file, opts)
       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)
+      def line_strings_to_track(geojson, opts)
         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))
+          segment = coords_to_segment(coords)
+
+          opts[:line_string_feature_to_segment]&.call(ls, segment)
+          track.append_segment(segment)
         end
         track
       end
@@ -96,15 +99,18 @@ module GPX
       # into a Track, with each set of LineString coordinates
       # within a MultiLineString a Track Segment.
       #
-      def multi_line_strings_to_tracks(geojson)
+      def multi_line_strings_to_tracks(geojson, opts)
         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
+
+          opts[:multi_line_string_feature_to_track]&.call(mls, track)
           tracks << track
         end
         tracks
@@ -114,10 +120,14 @@ module GPX
       # Current strategy is to convert each Point
       # feature into a GPX waypoint.
       #
-      def points_to_waypoints(geojson, gpx_file)
+      def points_to_waypoints(geojson, gpx_file, opts)
         points_in(geojson).reduce([]) do |acc, pt|
           coords = pt['geometry']['coordinates']
-          acc << point_to_waypoint(coords, gpx_file)
+          waypoint = point_to_waypoint(coords, gpx_file)
+
+          opts[:point_feature_to_waypoint]&.call(pt, waypoint)
+
+          acc << waypoint
         end
       end
 
@@ -132,10 +142,14 @@ module GPX
       #    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|
+      def multi_points_to_waypoints(geojson, gpx_file, opts)
+        multi_points_in(geojson).each_with_object([]) do |mpt, acc|
           mpt['geometry']['coordinates'].each do |coords|
-            acc << point_to_waypoint(coords, gpx_file)
+            waypoint = point_to_waypoint(coords, gpx_file)
+
+            opts[:multi_point_feature_to_waypoint]&.call(mpt, waypoint)
+
+            acc << waypoint
           end
         end
       end

data/lib/gpx/gpx_file.rb

@@ -35,7 +35,7 @@ module GPX
       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)
+          gpx_file = File.open(gpx_file) unless gpx_file.respond_to?(:read)
           @xml = Nokogiri::XML(gpx_file)
         else
           @xml = Nokogiri::XML(opts[:gpx_data])
@@ -194,8 +194,6 @@ 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
@@ -222,7 +220,6 @@ module GPX
       doc = generate_xml_doc
       doc.to_xml
     end
-    # rubocop:enable Style/OptionalBooleanParameter
 
     def inspect
       "<#{self.class.name}:...>"

data/lib/gpx/route.rb

@@ -19,7 +19,7 @@ module GPX
           @points << Point.new(element: point, gpx_file: @gpx_file)
         end
       else
-        @points = (opts[:points] || [])
+        @points = opts[:points] || []
         @name = (opts[:name])
       end
     end

data/lib/gpx/segment.rb

@@ -62,7 +62,7 @@ module GPX
 
     # Returns true if the given time is within this Segment.
     def contains_time?(time)
-      ((time >= @earliest_point.time) && (time <= @latest_point.time))
+      (time >= @earliest_point.time) && (time <= @latest_point.time)
     rescue StandardError
       false
     end
@@ -105,7 +105,7 @@ module GPX
 
     # Returns true if this Segment has no points.
     def empty?
-      (points.nil? || points.empty?)
+      points.nil? || points.empty?
     end
 
     # Prints out a nice summary of this Segment.

data/lib/gpx/track.rb

@@ -95,7 +95,7 @@ module GPX
     # 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? || points.empty?)
+      points.nil? || points.empty?
     end
 
     # Prints out a friendly summary of this track (sans points).  Useful for

data/lib/gpx/version.rb

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

data/tests/geojson_files/line_string_data.json

@@ -24,8 +24,11 @@
                 [-118.41506, 34.06301, 80],
                 [-118.415, 34.06305, 80],
                 [-118.41494, 34.06309, 80]
-              ]
-          }
+            ]
+        },
+        "properties": {
+          "distance": 10
+        }
       }, {
         "type": "Feature",
         "geometry": {
@@ -49,6 +52,9 @@
               [-118.36894, 34.05818, 40],
               [-118.369, 34.05806, 40]
             ]
+        },
+        "properties": {
+          "distance": 100
         }
       }, {
           "type": "Feature",
@@ -78,6 +84,9 @@
             [-118.35046, 34.03779, 30],
             [-118.3505, 34.03768, 30]
           ]
+        },
+        "properties": {
+          "distance": 1000
         }
     }]
 }

data/tests/geojson_files/multi_line_string_data.json

@@ -69,6 +69,9 @@
             [-118.35046, 34.03779, 30],
             [-118.3505, 34.03768, 30]
           ]]
+        },
+        "properties": {
+          "name": "Foo"
         }
     }]
 }

data/tests/geojson_files/multi_point_data.json

@@ -9,6 +9,9 @@
                 [-118.4158, 34.06256, 80],
                 [-118.41575, 34.06259, 80]
             ]
+        },
+        "properties": {
+            "name": "Foo"
         }
     }]
 }

data/tests/geojson_files/point_data.json

@@ -5,18 +5,27 @@
         "geometry": {
             "type": "Point",
             "coordinates": [-118.41585, 34.06253, 80]
+        },
+        "properties": {
+            "name": "Foo"
         }
     }, {
         "type": "Feature",
         "geometry": {
             "type": "Point",
             "coordinates": [-118.36855, 34.05844, 40]
+        },
+        "properties": {
+            "name": "Bar"
         }
     }, {
         "type": "Feature",
         "geometry": {
             "type": "Point",
             "coordinates": [-118.35043, 34.0392, 30]
+        },
+        "properties": {
+            "name": "Baz"
         }
     }]
 }

data/tests/geojson_test.rb

@@ -54,6 +54,28 @@ class GeojsonTest < Minitest::Test
     assert_equal(58, pts_size)
   end
 
+  def test_line_string_functionality_with_lambda
+    file = File.join(File.dirname(__FILE__), 'geojson_files/line_string_data.json')
+    gpx_file = GPX::GeoJSON.convert_to_gpx(
+      geojson_file: file,
+      line_string_feature_to_segment: lambda { |line_string, segment|
+        segment.points << GPX::Point.new(
+          {
+            lat: line_string['geometry']['coordinates'][0][1],
+            lon: line_string['geometry']['coordinates'][0][0]
+          }
+        )
+      }
+    )
+
+    assert_equal(1, gpx_file.tracks.size)
+    assert_equal(3, gpx_file.tracks.first.segments.size)
+    pts_size = gpx_file.tracks.first.segments[0].points.size +
+               gpx_file.tracks.first.segments[1].points.size +
+               gpx_file.tracks.first.segments[2].points.size
+    assert_equal(61, pts_size)
+  end
+
   def test_multi_line_string_functionality
     file = File.join(File.dirname(__FILE__), 'geojson_files/multi_line_string_data.json')
     gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: file)
@@ -65,18 +87,59 @@ class GeojsonTest < Minitest::Test
     assert_equal(58, pts_size)
   end
 
+  def test_multi_line_string_functionality_with_lambda
+    file = File.join(File.dirname(__FILE__), 'geojson_files/multi_line_string_data.json')
+    gpx_file = GPX::GeoJSON.convert_to_gpx(
+      geojson_file: file,
+      multi_line_string_feature_to_track: lambda { |multi_line_string, segment|
+        segment.name = multi_line_string['properties']['name']
+      }
+    )
+    assert_equal(1, gpx_file.tracks.size)
+    assert_equal(3, gpx_file.tracks.first.segments.size)
+    pts_size = gpx_file.tracks.first.segments[0].points.size +
+               gpx_file.tracks.first.segments[1].points.size +
+               gpx_file.tracks.first.segments[2].points.size
+    assert_equal(58, pts_size)
+    assert_equal("Foo", gpx_file.tracks[0].name)
+  end
+
   def test_point_functionality
     file = File.join(File.dirname(__FILE__), 'geojson_files/point_data.json')
     gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: file)
     assert_equal(3, gpx_file.waypoints.size)
   end
 
+  def test_point_functionality_with_proc
+    file = File.join(File.dirname(__FILE__), 'geojson_files/point_data.json')
+    gpx_file = GPX::GeoJSON.convert_to_gpx(
+      geojson_file: file,
+      point_feature_to_waypoint: ->(point, waypoint) { waypoint.name = point['properties']['name'] }
+    )
+    assert_equal(3, gpx_file.waypoints.size)
+    assert_equal('Foo', gpx_file.waypoints[0].name)
+    assert_equal('Bar', gpx_file.waypoints[1].name)
+    assert_equal('Baz', gpx_file.waypoints[2].name)
+  end
+
   def test_multi_point_functionality
     file = File.join(File.dirname(__FILE__), 'geojson_files/multi_point_data.json')
     gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: file)
     assert_equal(3, gpx_file.waypoints.size)
   end
 
+  def test_multi_point_functionality_with_proc
+    file = File.join(File.dirname(__FILE__), 'geojson_files/multi_point_data.json')
+    gpx_file = GPX::GeoJSON.convert_to_gpx(
+      geojson_file: file,
+      multi_point_feature_to_waypoint: ->(multi_point, waypoint) { waypoint.name = multi_point['properties']['name'] }
+    )
+    assert_equal(3, gpx_file.waypoints.size)
+    assert_equal('Foo', gpx_file.waypoints[0].name)
+    assert_equal('Foo', gpx_file.waypoints[1].name)
+    assert_equal('Foo', gpx_file.waypoints[2].name)
+  end
+
   def test_combined_functionality
     file = File.join(File.dirname(__FILE__), 'geojson_files/combined_data.json')
     gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_file: file)

data/tests/gpx_file_test.rb

@@ -2,6 +2,7 @@
 
 require 'minitest/autorun'
 require 'gpx'
+require 'stringio'
 
 class GPXFileTest < Minitest::Test
   ONE_TRACK_FILE = File.join(File.dirname(__FILE__), 'gpx_files/one_track.gpx')
@@ -11,39 +12,12 @@ class GPXFileTest < Minitest::Test
 
   def test_load_data_from_string
     gpx_file = GPX::GPXFile.new(gpx_data: File.open(ONE_TRACK_FILE).read)
-    assert_equal(1, gpx_file.tracks.size)
-    assert_equal(8, gpx_file.tracks.first.segments.size)
-    assert_equal('ACTIVE LOG', gpx_file.tracks.first.name)
-    assert_equal('active_log.gpx', gpx_file.name)
-    assert_equal('2006-04-08T16:44:28Z', gpx_file.time.xmlschema)
-    assert_equal(38.681488, gpx_file.bounds.min_lat)
-    assert_equal(-109.606948, gpx_file.bounds.min_lon)
-    assert_equal(38.791759, gpx_file.bounds.max_lat)
-    assert_equal(-109.447045, gpx_file.bounds.max_lon)
-    assert_equal('description of my GPX file with special char like &, <, >', gpx_file.description)
-    assert_equal('description of my GPX file with special char like &, <, >', gpx_file.description)
-    assert_equal(3.0724966849262554, gpx_file.distance)
-    assert_equal(15_237.0, gpx_file.duration)
-    assert_equal(3036.0, gpx_file.moving_duration)
-    assert_equal(3.6432767014935834, gpx_file.average_speed)
+    shared_assertions_for_one_track_file(gpx_file)
   end
 
   def test_load_data_from_file
     gpx_file = GPX::GPXFile.new(gpx_file: ONE_TRACK_FILE)
-    assert_equal(1, gpx_file.tracks.size)
-    assert_equal(8, gpx_file.tracks.first.segments.size)
-    assert_equal('ACTIVE LOG', gpx_file.tracks.first.name)
-    assert_equal('active_log.gpx', gpx_file.name)
-    assert_equal('2006-04-08T16:44:28Z', gpx_file.time.xmlschema)
-    assert_equal(38.681488, gpx_file.bounds.min_lat)
-    assert_equal(-109.606948, gpx_file.bounds.min_lon)
-    assert_equal(38.791759, gpx_file.bounds.max_lat)
-    assert_equal(-109.447045, gpx_file.bounds.max_lon)
-    assert_equal('description of my GPX file with special char like &, <, >', gpx_file.description)
-    assert_equal(3.0724966849262554, gpx_file.distance)
-    assert_equal(15_237.0, gpx_file.duration)
-    assert_equal(3036.0, gpx_file.moving_duration)
-    assert_equal(3.6432767014935834, gpx_file.average_speed)
+    shared_assertions_for_one_track_file(gpx_file)
   end
 
   def test_big_file
@@ -74,4 +48,35 @@ class GPXFileTest < Minitest::Test
     assert_equal(21.0, gpx_file.moving_duration)
     assert_equal(6.674040636626879, gpx_file.average_speed)
   end
+
+  def test_load_data_from_stringio_assigned_gpx_file
+    str = File.open(ONE_TRACK_FILE).read
+    io = StringIO.new(str, 'r+')
+    gpx_file = GPX::GPXFile.new(gpx_file: io)
+    shared_assertions_for_one_track_file(gpx_file)
+  end
+
+  def test_load_data_from_stringio_assigned_gpx_data
+    str = File.open(ONE_TRACK_FILE).read
+    io = StringIO.new(str, 'r+')
+    gpx_file = GPX::GPXFile.new(gpx_data: io)
+    shared_assertions_for_one_track_file(gpx_file)
+  end
+
+  def shared_assertions_for_one_track_file(gpx_file)
+    assert_equal(1, gpx_file.tracks.size)
+    assert_equal(8, gpx_file.tracks.first.segments.size)
+    assert_equal('ACTIVE LOG', gpx_file.tracks.first.name)
+    assert_equal('active_log.gpx', gpx_file.name)
+    assert_equal('2006-04-08T16:44:28Z', gpx_file.time.xmlschema)
+    assert_equal(38.681488, gpx_file.bounds.min_lat)
+    assert_equal(-109.606948, gpx_file.bounds.min_lon)
+    assert_equal(38.791759, gpx_file.bounds.max_lat)
+    assert_equal(-109.447045, gpx_file.bounds.max_lon)
+    assert_equal('description of my GPX file with special char like &, <, >', gpx_file.description)
+    assert_equal(3.0724966849262554, gpx_file.distance)
+    assert_equal(15_237.0, gpx_file.duration)
+    assert_equal(3036.0, gpx_file.moving_duration)
+    assert_equal(3.6432767014935834, gpx_file.average_speed)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gpx
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Guillaume Dott
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2024-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri