gpx 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aa764ea01fcc4255a69ff9bad6d1c159fc8ae8a1b29c0e54d05b9fe2b0e0bc9
-  data.tar.gz: 699edd3b9dec8cc83ac136c90b81f428a60ed8359aa01445ef3aead1a343c0d1
+  metadata.gz: f206f4729605d96cdaf65fe3fe52237c14f61eb1ae69558eb826c6f831e4076b
+  data.tar.gz: b05a8fd9d66446f57640474b3dad428b5eab24617b2e0cb3b19e655d079ea0d6
 SHA512:
-  metadata.gz: 43dc778d82e3b044ef872c219a60a703a6e4e53845817e783c464b36b37b60647eb5c390e2b16df1f1bb51b5359d2eae5a05e39fdb352ee3e2eaec179e007b9e
-  data.tar.gz: a6aa72c84b2ff150569506a27889835b818057a549a72d44ad163e81ef5000dd936ca91b8da7faf3a44150ec66bdbe6bb1630291dbeeca5c3416f676130c368a
+  metadata.gz: 28c8c86253452eb56383790c43189de24929482781b5d94ac9416ab93be596fbbe5259e0226a18bbb7e44070503d6b721671bff2b239a5512a935fcb21dbc19f
+  data.tar.gz: be64658d5bf4cf3d7653b2457f286401971d3a7a272766002d78296341eedd2c4ad237dc5ac38d38debe7dd7288275185b6ac27bef99460d250c2e62bd3d9c5b

data/.github/workflows/ruby.yml

@@ -0,0 +1,36 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1']
+
+    steps:
+    - uses: actions/checkout@v2
+    - 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@f0971f0dd45a5cbb3f119f7db77cc58057c53530
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.2
+  TargetRubyVersion: 2.5
 
 Style/Alias:
   Enabled: false
@@ -152,7 +152,7 @@ Metrics/ParameterLists:
 Metrics/PerceivedComplexity:
   Enabled: false
 
-Naming/UncommunicativeMethodParamName:
+Naming/MethodParameterName:
   Enabled: false
 
 Naming/VariableNumber:
@@ -160,6 +160,3 @@ Naming/VariableNumber:
 
 Style/DateTime:
   Enabled: false
-
-Performance/Caller:
-  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.0.2

data/.travis.yml

@@ -1,7 +1,8 @@
 language: ruby
 rvm:
-  - 2.2
-  - 2.3
-  - 2.4
   - 2.5
-script: "bundle exec rake ci:build"
+  - 2.6
+  - 2.7
+  - 3.0
+#  - 3.1 # Not supported by Travis yet as of 2021-12-29
+script: "bundle exec rake"

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.1.0] - 202
+  * Specify UTF-8 encoding for XML encoding (#35 via @sh1nduu)
+  * Added GeoJSON conversion (#38 via @tyrauber and @niborg)
+  * Support Ruby 3 (#43 via @LocoDelAssembly)
+  * Fix nil-to-Time comparison (#46 via @frodrigo)
+  * Fix bug when <rte> GPX file does not specify <name> tag (#41 via @niborg)
+  * Drop Ruby 2.5 and 2.6 from CI (#50 via @niborg)
 ## [1.0.0] - 2018-03-06
 
   * Fix duplication of points on appending segment to track (#20 via @niborg)

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in seryz.gemspec

data/README.md

@@ -10,15 +10,19 @@ 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, and writing 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).
+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,
+and it also calculates some meta-data about the tracks and points in a file (such as distance, duration, average speed, etc).
 
 ## Requirements
 
 As of `1.0.0`, `gpx` requires at least Ruby 2.2 to run.
 
+## Installation
+Add to your gemfile:
+```
+gem 'gpx'
+```
 ## Examples
 
 Reading a GPX file, and cropping its contents to a given area:
@@ -37,6 +41,17 @@ if GPX::MagellanTrackLog::is_magellan_file?(filename)
 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')
+
+# Converting from a string
+data = JSON.generate(my_geojson_hash)
+gpx_file = GPX::GeoJSON.convert_to_gpx(geojson_data: data)
+```
+
 Exporting an ActiveRecord to GPXFile (as Waypoints)
 ```ruby
 #

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rdoc/task'
@@ -32,3 +34,8 @@ Rake::RDocTask.new('doc') do |rdoc|
   rdoc.rdoc_files.include('README')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+desc 'open an irb session preloaded with this gem'
+task :console do
+  sh 'irb -r pp -r ./lib/gpx.rb'
+end

data/bin/gpx_distance

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require File.expand_path('../lib/gpx', __dir__)
 
 filename = ARGV[0]

data/bin/gpx_smooth

@@ -1,12 +1,15 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require File.expand_path('../lib/gpx', __dir__)
 require 'optparse'
 
 def str_to_int_or_time(str)
-  if str =~ /\A\d{10}\Z/
+  case str
+  when /\A\d{10}\Z/
     Time.at(str.to_i)
-  elsif str =~ /\A\d+\Z/
+  when /\A\d+\Z/
     str.to_i
   else
     DateTime.strptime(str, '%Y%m%d-%H:%M:%S').to_time

data/gpx.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -11,12 +12,11 @@ Gem::Specification.new do |s|
   s.summary = 'A basic API for reading and writing GPX files.'
   s.description = 'A basic API for reading and writing GPX files.'
 
-  s.required_ruby_version = '~>2.2'
+  s.required_ruby_version = '>= 2.5', '< 4'
 
   s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
-  s.has_rdoc = true
 
   s.homepage = 'http://www.github.com/dougfales/gpx'
   s.add_dependency 'nokogiri', '~>1.7'

data/lib/gpx/bounds.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GPX
   class Bounds < Base
     attr_accessor :min_lat, :max_lat, :max_lon, :min_lon
@@ -5,6 +7,7 @@ module GPX
     # Creates a new bounds object with the passed-in min and max longitudes
     # and latitudes.
     def initialize(opts = { min_lat: 90.0, max_lat: -90.0, min_lon: 180.0, max_lon: -180.0 })
+      super()
       @min_lat = opts[:min_lat].to_f
       @max_lat = opts[:max_lat].to_f
       @min_lon = opts[:min_lon].to_f

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,3 +1,5 @@
+# frozen_string_literal: true
+
 module GPX
   # A common base class which provides a useful initializer method to many
   # class in the GPX library.

data/lib/gpx/gpx_file.rb

@@ -1,9 +1,11 @@
+# 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
 
-    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
@@ -23,6 +25,7 @@ module GPX
     #         gpx_file = GPXFile.new(:tracks => [some_track])
     #
     def initialize(opts = {})
+      super()
       @duration = 0
       @attributes = {}
       @namespace_defs = []
@@ -43,7 +46,8 @@ module GPX
         @namespace_defs = gpx_element.namespace_definitions
         @version = gpx_element['version']
         reset_meta_data
-        bounds_element = (begin
+        bounds_element = (
+        begin
           @xml.at('metadata/bounds')
         rescue StandardError
           nil
@@ -58,20 +62,20 @@ module GPX
         end
 
         @time = begin
-                  Time.parse(@xml.at('metadata/time').inner_text)
-                rescue StandardError
-                  nil
-                end
+          Time.parse(@xml.at('metadata/time').inner_text)
+        rescue StandardError
+          nil
+        end
         @name = begin
-                  @xml.at('metadata/name').inner_text
-                rescue StandardError
-                  nil
-                end
+          @xml.at('metadata/name').inner_text
+        rescue StandardError
+          nil
+        end
         @description = begin
-                         @xml.at('metadata/desc').inner_text
-                       rescue StandardError
-                         nil
-                       end
+          @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)
@@ -87,7 +91,7 @@ module GPX
       else
         reset_meta_data
         opts.each { |attr_name, value| instance_variable_set("@#{attr_name}", value) }
-        unless @tracks.nil? || @tracks.size.zero?
+        unless @tracks.nil? || @tracks.empty?
           @tracks.each { |trk| update_meta_data(trk) }
           calculate_duration
         end
@@ -103,7 +107,8 @@ module GPX
         result = el[name]
         break unless result.nil?
       end
-      (begin
+      (
+      begin
         result.to_f
       rescue StandardError
         nil
@@ -189,6 +194,8 @@ 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
@@ -215,6 +222,7 @@ module GPX
       doc = generate_xml_doc
       doc.to_xml
     end
+    # rubocop:enable Style/OptionalBooleanParameter
 
     def inspect
       "<#{self.class.name}:...>"
@@ -234,13 +242,13 @@ module GPX
       # $stderr.puts @namespace_defs.inspect
       gpx_header = {}
       @attributes.each do |k, v|
-        k = v.namespace.prefix + ':' + k if v.namespace
+        k = "#{v.namespace.prefix}:#{k}" if v.namespace
         gpx_header[k] = v.value
       end
 
       @namespace_defs.each do |nsd|
         tag = 'xmlns'
-        tag += ':' + nsd.prefix if nsd.prefix
+        tag += ":#{nsd.prefix}" if nsd.prefix
         gpx_header[tag] = nsd.href
       end
       gpx_header
@@ -260,7 +268,7 @@ module GPX
       # $stderr.puts gpx_header.keys.inspect
 
       # rubocop:disable Metrics/BlockLength
-      doc = Nokogiri::XML::Builder.new do |xml|
+      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'
@@ -285,19 +293,17 @@ module GPX
             end
           end
 
-          unless tracks.nil?
-            tracks.each do |t|
-              xml.trk do
-                xml.name t.name
-
-                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
+          tracks&.each do |t|
+            xml.trk do
+              xml.name t.name
+
+              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
@@ -305,27 +311,23 @@ module GPX
             end
           end
 
-          unless waypoints.nil?
-            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
+          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
 
-          unless routes.nil?
-            routes.each do |r|
-              xml.rte do
-                xml.name r.name
+          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
+              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
             end
@@ -333,17 +335,17 @@ module GPX
         end
       end
       # rubocop:enable Metrics/BlockLength
-
-      doc
     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? || @tracks.size.zero? || @tracks[0].segments.nil? || @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 StandardError
       @duration = 0

data/lib/gpx/magellan_track_log.rb

@@ -1,3 +1,5 @@
+# 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.

data/lib/gpx/point.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GPX
   # The base class for all points.  Trackpoint and Waypoint both descend from this base class.
   class Point < Base
@@ -10,6 +12,7 @@ module GPX
     # 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 })
+      super()
       @gpx_file = opts[:gpx_file]
       if opts[:element]
         elem = opts[:element]
@@ -18,7 +21,8 @@ module GPX
         @latr = (D_TO_R * @lat)
         @lonr = (D_TO_R * @lon)
         # '-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
-        @time = (begin
+        @time = (
+        begin
           Time.xmlschema(elem.at('time').inner_text)
         rescue StandardError
           nil