git-fit 0.10.4 → 0.10.5

data/lib/git_fit/dedup/matcher.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module GitFit
+  module Dedup
+    class Matcher
+      WEIGHTS = { time: 0.35, distance: 0.35, duration: 0.15, category: 0.15 }.freeze
+      TRAJECTORY_WEIGHTS = {
+        dtw_similarity: 0.30,
+        overlap_score: 0.25,
+        hausdorff_score: 0.25,
+        distance_match: 0.20,
+      }.freeze
+
+      def self.effective_duration(act)
+        [act[:moving_time].to_f, act[:elapsed_time].to_f].max
+      end
+
+      def self.external_id_match(a, b)
+        a_eid = a[:external_id]
+        b_eid = b[:external_id]
+        return nil if a_eid.nil? || b_eid.nil?
+        return nil if a_eid.empty? || b_eid.empty?
+
+        a_normalized = a_eid.sub(%r{^strava://activities/}, '')
+        b_normalized = b_eid.sub(%r{^strava://activities/}, '')
+
+        { confidence: 1.0, flag: 'derived', source: 'external_id' } if a_normalized == b_normalized
+      end
+
+      def self.match(a, b)
+        exact = external_id_match(a, b)
+        return exact[:confidence] if exact
+
+        t_diff = time_diff_abs(a[:start_date], b[:start_date])
+        max_diff = [300, (a[:elapsed_time] || 0).to_i, (b[:elapsed_time] || 0).to_i].max
+        return 0.0 if t_diff > max_diff
+
+        t_score = 1.0 - t_diff / max_diff.to_f
+        d_score = distance_score(a[:distance].to_f, b[:distance].to_f)
+        return 0.0 unless d_score
+
+        dur_score = duration_score(effective_duration(a), effective_duration(b))
+        cat_score = a[:sport_category] == b[:sport_category] ? 1.0 : -0.67
+
+        result = t_score * WEIGHTS[:time] +
+                 d_score * WEIGHTS[:distance] +
+                 dur_score * WEIGHTS[:duration] +
+                 cat_score * WEIGHTS[:category]
+        result.round(4)
+      end
+
+      def self.time_diff_abs(t1, t2)
+        t1 = t1.to_s
+        t2 = t2.to_s
+        return 9999 if t1.empty? || t2.empty?
+        (Time.parse(t1) - Time.parse(t2)).abs
+      rescue StandardError
+        9999
+      end
+
+      def self.distance_score(d1, d2)
+        max = [d1, d2].max
+        return nil if max <= 0
+        diff = (d1 - d2).abs
+        return nil if diff > max * 0.15
+        1.0 - diff / (max * 0.15)
+      end
+
+      def self.duration_score(d1, d2)
+        max = [d1, d2].max
+        return 0.0 if max <= 0
+        diff = (d1 - d2).abs
+        return 0.0 if diff > max * 0.15
+        1.0 - diff / (max * 0.15)
+      end
+
+      def self.trajectory_score(scores)
+        return 0.0 if scores.nil? || scores.empty?
+        weighted = TRAJECTORY_WEIGHTS.sum do |metric, weight|
+          score = scores[metric]
+          next 0.0 unless score.is_a?(Numeric) && score >= 0.0 && score <= 1.0
+          score * weight
+        end
+        weighted.round(4)
+      end
+    end
+  end
+end

data/lib/git_fit/dedup/service.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require_relative 'matcher'
+require_relative 'trajectory'
+require_relative 'group_consolidator'
+require_relative 'log_writer'
+
+module GitFit
+  module Dedup
+    class Service
+      def initialize(db, incremental: false, log_path: nil, verbose: false)
+        @db = db
+        @trajectory = Trajectory.new(db)
+        @incremental = incremental
+        @log_path = log_path
+        @verbose = verbose
+        @updates = {}
+        @matched_pairs = []
+      end
+
+      def run
+        activities = activities_scope.all
+        return 0 if activities.size < 2
+        puts "DedupService: scanning #{activities.size} activities" if @verbose
+
+        start_time = Time.now.utc
+        matched = 0
+
+        activities.each_with_index do |a, i|
+          a_start = parse_time(a[:start_date])
+          next unless a_start
+          a_range = activity_range(a)
+
+          (i + 1...activities.size).each do |j|
+            b = activities[j]
+            b_start = parse_time(b[:start_date])
+            next unless b_start
+            break if b_start > (a_range[:end] + 86400)
+
+            score = Matcher.match(a, b)
+            next unless score && score >= 0.15
+
+            flag = classify_flag(a, b, score)
+            next unless flag
+
+            append_info(a[:run_id], b[:source], b[:run_id], score, flag)
+            append_info(b[:run_id], a[:source], a[:run_id], score, flag)
+            @matched_pairs << { a: a, b: b, score: score, flag: flag }
+            matched += 1
+          end
+        end
+
+        flush_updates
+
+        consolidate_groups if matched > 0
+
+        elapsed = Time.now.utc - start_time
+
+        if @log_path
+          log_stats = {
+            scanned: activities.size,
+            compared: @matched_pairs.size,
+            matched: matched,
+            by_flag: @matched_pairs.group_by { |mp| mp[:flag] }.transform_values(&:size),
+          }
+          LogWriter.new(@log_path).write(
+            stats: log_stats,
+            matches: @matched_pairs.map.with_index do |mp, idx|
+              {
+                id: idx + 1,
+                a: { run_id: mp[:a][:run_id], source: mp[:a][:source] },
+                b: { run_id: mp[:b][:run_id], source: mp[:b][:source] },
+                confidence: mp[:score],
+                flag: mp[:flag],
+              }
+            end,
+            elapsed: elapsed,
+          )
+        end
+
+        puts "DedupService: #{matched} matches in #{elapsed.round(1)}s" if @verbose
+        matched
+      end
+
+      private
+
+      def activities_scope
+        base = @db[:activities].where(Sequel.lit('distance > 100')).order(:start_date)
+        return base unless @incremental
+        base.where(Sequel.lit('run_id NOT IN (SELECT run_id FROM dedup_group_members)'))
+      end
+
+      def parse_time(val)
+        return nil unless val
+        t = Time.parse(val.to_s)
+        t.utc? ? t : t.utc
+      rescue StandardError
+        nil
+      end
+
+      def activity_range(activity)
+        duration = [activity[:elapsed_time].to_i, activity[:moving_time].to_i].max
+        duration = 3600 if duration <= 0
+        start_t = parse_time(activity[:start_date])
+        { start: start_t, end: start_t + duration }
+      end
+
+      def classify_flag(a, b, score)
+        if score >= 0.85
+          'derived'
+        elsif score >= 0.15
+          traj_a = @trajectory.points(a[:run_id])
+          traj_b = @trajectory.points(b[:run_id])
+
+          if traj_a.nil? || traj_b.nil? || traj_a.size < 2 || traj_b.size < 2
+            'similar'
+          else
+            containment = @trajectory.containment_relation(traj_a, traj_b)
+            case containment
+            when :equivalent then 'duplicate'
+            when :contained_a, :contained_b then 'contained'
+            when :partial then 'partial'
+            when :cross then 'cross'
+            else 'similar'
+            end
+          end
+        end
+      end
+
+      def append_info(run_id, source, matched_run_id, score, flag)
+        return unless flag
+
+        entry = { 'source' => source, 'run_id' => matched_run_id,
+                  'confidence' => score, 'flag' => flag }
+        @updates[run_id] ||= []
+        existing = @updates[run_id].find { |e| e['run_id'] == matched_run_id }
+        if existing
+          existing.merge!(entry)
+        else
+          @updates[run_id] << entry
+        end
+      end
+
+      def flush_updates
+        @updates.each do |run_id, entries|
+          existing_json = @db[:activities].where(run_id: run_id).get(:duplicate_info)
+          existing = begin
+            existing_json ? JSON.parse(existing_json) : []
+          rescue JSON::ParserError
+            []
+          end
+          merged = merge_entries(existing, entries)
+          new_json = merged.empty? ? nil : JSON.generate(merged)
+          @db[:activities].where(run_id: run_id).update(duplicate_info: new_json)
+        end
+      end
+
+      def merge_entries(existing, new_entries)
+        by_run_id = {}
+        existing.each { |e| by_run_id[e['run_id']] = e }
+        new_entries.each { |e| by_run_id[e['run_id']] = e }
+        by_run_id.values
+      end
+
+      def consolidate_groups
+        return if @matched_pairs.empty?
+
+        consolidator = GroupConsolidator.new
+        groups = consolidator.consolidate(@matched_pairs)
+
+        groups.each do |group_id, run_ids|
+          members = @db[:activities].where(run_id: run_ids).all
+          write_dedup_group(group_id, members)
+        end
+      end
+
+      def write_dedup_group(group_id, members)
+        now = Time.now.utc
+        @db[:dedup_groups].insert_conflict(target: :group_id).insert(
+          group_id: group_id, created_at: now, updated_at: now,
+        )
+
+        best = Hash.new { |h, k| h[k] = { confidence: 0.0, flag: nil } }
+        @matched_pairs.each do |mp|
+          [mp[:a], mp[:b]].each do |act|
+            if mp[:score] > best[act[:run_id]][:confidence]
+              best[act[:run_id]] = { confidence: mp[:score], flag: mp[:flag] }
+            end
+          end
+        end
+
+        members.each do |m|
+          entry = best[m[:run_id]]
+          @db[:dedup_group_members].insert_conflict(target: [:group_id, :run_id]).insert(
+            group_id: group_id,
+            run_id: m[:run_id],
+            source: m[:source],
+            flag: entry[:flag],
+            confidence: entry[:confidence],
+          )
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/dedup/trajectory.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitFit
+  module Dedup
+    class Trajectory
+      SAMPLE_RATE = 10  # take every Nth point
+      PROXIMITY_M = 50  # points within 50m count as same
+      DP_EPSILON = 0.0001           # ~10m in lat/lng degrees
+      CONTAINED_THRESHOLD = 0.7     # 70% overlap → equivalent/contained
+      PARTIAL_THRESHOLD = 0.3       # 30% → partial boundary
+      MAX_EXPECTED_COST = 1000.0    # DTW normalization denominator
+      PLACEHOLDER_POLYLINE = 'gqqrFurkeU??'
+
+      def initialize(db)
+        @db = db
+        @cache = {}
+      end
+
+      def duplicate?(run_id_a, run_id_b)
+        pts_a = cached_points(run_id_a)
+        pts_b = cached_points(run_id_b)
+        return nil unless pts_a && pts_b && pts_a.size >= 2 && pts_b.size >= 2
+
+        shorter = pts_a.size <= pts_b.size ? pts_a : pts_b
+        longer = pts_a.size > pts_b.size ? pts_a : pts_b
+
+        sampled = shorter.each_slice(SAMPLE_RATE).map(&:first)
+        matches = sampled.count { |pt| near(pt, longer) }
+        ratio = matches.to_f / sampled.size
+        ratio >= 0.3
+      end
+
+      def points(run_id)
+        cached_points(run_id)
+      end
+
+      def douglas_peucker(points, epsilon = DP_EPSILON)
+        return points if points.size <= 2
+
+        coords = points.map { |p| point_coordinates(p) }.compact
+        return points if coords.size <= 2
+
+        stack = [[0, coords.size - 1]]
+        keep = Set.new([0, coords.size - 1])
+
+        while stack.any?
+          start_idx, end_idx = stack.pop
+          dmax = 0.0
+          idx = start_idx
+
+          ((start_idx + 1)...end_idx).each do |i|
+            d = perpendicular_distance(coords[i], coords[start_idx], coords[end_idx])
+            if d > dmax
+              dmax = d
+              idx = i
+            end
+          end
+
+          next unless dmax > epsilon
+          keep.add(idx)
+          stack.push([start_idx, idx])
+          stack.push([idx, end_idx])
+        end
+
+        coords.select.with_index { |_, i| keep.include?(i) }
+      end
+
+      def dtw_similarity(traj_a, traj_b)
+        return nil if traj_a.nil? || traj_b.nil? || traj_a.size < 2 || traj_b.size < 2
+
+        a = traj_a.map { |p| point_coordinates(p) }.compact
+        b = traj_b.map { |p| point_coordinates(p) }.compact
+        return nil if a.size < 2 || b.size < 2
+
+        n = a.size
+        m = b.size
+        dtw = Array.new(n + 1) { Array.new(m + 1, Float::INFINITY) }
+        dtw[0][0] = 0
+
+        (1..n).each do |i|
+          (1..m).each do |j|
+            cost = haversine(a[i - 1][0], a[i - 1][1], b[j - 1][0], b[j - 1][1])
+            dtw[i][j] = cost + [dtw[i - 1][j], dtw[i][j - 1], dtw[i - 1][j - 1]].min
+          end
+        end
+
+        avg_cost = dtw[n][m] / [n, m].max
+        [1.0 - avg_cost / MAX_EXPECTED_COST, 0.0].max
+      end
+
+      def hausdorff_distance(traj_a, traj_b)
+        return nil if traj_a.nil? || traj_b.nil? || traj_a.size < 2 || traj_b.size < 2
+
+        a_coords = traj_a.map { |p| point_coordinates(p) }.compact
+        b_coords = traj_b.map { |p| point_coordinates(p) }.compact
+        return nil if a_coords.size < 2 || b_coords.size < 2
+
+        max_min_a = a_coords.map { |p| min_distance_to_set(p, b_coords) }.max || 0.0
+        max_min_b = b_coords.map { |p| min_distance_to_set(p, a_coords) }.max || 0.0
+        [max_min_a, max_min_b].max
+      end
+
+      def normalized_hausdorff_score(traj_a, traj_b)
+        dist = hausdorff_distance(traj_a, traj_b)
+        return nil if dist.nil?
+        [1.0 - dist / 2000.0, 0.0].max
+      end
+
+      def overlap_score(traj_a, traj_b, _radius = PROXIMITY_M)
+        return nil if traj_a.nil? || traj_b.nil? || traj_a.size < 2 || traj_b.size < 2
+
+        sampled_a = traj_a.each_slice(SAMPLE_RATE).map(&:first)
+        sampled_b = traj_b.each_slice(SAMPLE_RATE).map(&:first)
+        return nil if sampled_a.empty? || sampled_b.empty?
+
+        a_in_b = sampled_a.count { |p| near(p, sampled_b) }
+        b_in_a = sampled_b.count { |p| near(p, sampled_a) }
+
+        ratio_a = a_in_b.to_f / sampled_a.size
+        ratio_b = b_in_a.to_f / sampled_b.size
+        (ratio_a + ratio_b) / 2.0
+      end
+
+      def containment_relation(traj_a, traj_b, _radius = PROXIMITY_M, threshold = CONTAINED_THRESHOLD)
+        return nil if traj_a.nil? || traj_b.nil? || traj_a.size < 2 || traj_b.size < 2
+
+        sampled_a = traj_a.each_slice(SAMPLE_RATE).map(&:first)
+        sampled_b = traj_b.each_slice(SAMPLE_RATE).map(&:first)
+        return nil if sampled_a.empty? || sampled_b.empty?
+
+        a_in_b = sampled_a.count { |p| near(p, sampled_b) } / sampled_a.size.to_f
+        b_in_a = sampled_b.count { |p| near(p, sampled_a) } / sampled_b.size.to_f
+
+        if a_in_b >= threshold && b_in_a >= threshold
+          :equivalent
+        elsif a_in_b >= threshold
+          :contained_a
+        elsif b_in_a >= threshold
+          :contained_b
+        elsif a_in_b > PARTIAL_THRESHOLD || b_in_a > PARTIAL_THRESHOLD
+          :partial
+        elsif a_in_b > 0 || b_in_a > 0
+          :cross
+        else
+          :disjoint
+        end
+      end
+
+      private
+
+      def cached_points(run_id)
+        @cache[run_id] ||= load_points(run_id)
+      end
+
+      def load_points(run_id)
+        points = load_std_points(run_id)
+        return points if points
+
+        polyline = load_db_polyline(run_id)
+        return nil unless polyline
+
+        coords = Geo::Polyline.decode(polyline)
+        return nil if coords.nil? || coords.empty?
+
+        coords.map { |lat, lng| { 'latitude' => lat, 'longitude' => lng } }
+      end
+
+      def load_std_points(run_id)
+        source = source_from_run_id(run_id)
+        return nil unless source
+
+        std_dir = File.join('data', 'std', source)
+        id = run_id.sub("#{source}_", '')
+        path = Dir.glob(File.join(std_dir, "#{id}.*")).first
+        return nil unless path && File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        return data if data.is_a?(Array) && data.first.is_a?(Hash)
+
+        nil
+      rescue Errno::ENOENT, JSON::ParserError
+        nil
+      end
+
+      def load_db_polyline(run_id)
+        polyline = @db[:activities].where(run_id: run_id).get(:summary_polyline)
+        return nil if polyline.nil? || polyline.empty?
+        return nil if polyline == PLACEHOLDER_POLYLINE
+        polyline
+      end
+
+      def source_from_run_id(run_id)
+        %w[garmin_cn garmin strava keep igpsport xoss xingzhe].each do |s|
+          return s if run_id.start_with?("#{s}_")
+        end
+        nil
+      end
+
+      def near(pt, candidates)
+        lat = pt['latitude'] || pt['positionLat'] || pt[:latitude] || pt[:positionLat]
+        lng = pt['longitude'] || pt['positionLong'] || pt[:longitude] || pt[:positionLong]
+        return false unless lat && lng
+
+        candidates.any? do |c|
+          clat = c['latitude'] || c['positionLat'] || c[:latitude] || c[:positionLat]
+          clng = c['longitude'] || c['positionLong'] || c[:longitude] || c[:positionLong]
+          next false unless clat && clng
+
+          haversine(lat, lng, clat, clng) <= PROXIMITY_M
+        end
+      end
+
+      def haversine(lat1, lon1, lat2, lon2)
+        r = 6_371_000
+        dlat = (lat2 - lat1) * Math::PI / 180
+        dlon = (lon2 - lon1) * Math::PI / 180
+        a = Math.sin(dlat / 2)**2 +
+            Math.cos(lat1 * Math::PI / 180) *
+            Math.cos(lat2 * Math::PI / 180) *
+            Math.sin(dlon / 2)**2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        r * c
+      end
+
+      def point_coordinates(pt)
+        lat = pt['latitude'] || pt['positionLat'] || pt[:latitude] || pt[:positionLat]
+        lng = pt['longitude'] || pt['positionLong'] || pt[:longitude] || pt[:positionLong]
+        [lat, lng] if lat && lng
+      end
+
+      def perpendicular_distance(pt, a, b)
+        lat1 = a[0] * Math::PI / 180
+        lon1 = a[1] * Math::PI / 180
+        lat2 = b[0] * Math::PI / 180
+        lon2 = b[1] * Math::PI / 180
+        lat3 = pt[0] * Math::PI / 180
+        lon3 = pt[1] * Math::PI / 180
+
+        d13 = Math.acos(Math.sin(lat1) * Math.sin(lat3) + Math.cos(lat1) * Math.cos(lat3) * Math.cos(lon3 - lon1))
+        theta12 = Math.atan2(Math.sin(lon2 - lon1) * Math.cos(lat2),
+                             Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1))
+        theta13 = Math.atan2(Math.sin(lon3 - lon1) * Math.cos(lat3),
+                             Math.cos(lat1) * Math.sin(lat3) - Math.sin(lat1) * Math.cos(lat3) * Math.cos(lon3 - lon1))
+        cross = Math.asin(Math.sin(d13) * Math.sin(theta13 - theta12))
+        (cross.abs * 6371000.0)
+      end
+
+      def min_distance_to_set(pt, candidates)
+        candidates.map { |c| haversine(pt[0], pt[1], c[0], c[1]) }.min
+      end
+    end
+  end
+end

data/lib/git_fit/export/gpx.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'time'
+
+module GitFit
+  module Export
+    class GPX
+      CATEGORY_MAP = {
+        'run' => 'running', 'ride' => 'cycling', 'walk' => 'walking',
+        'hike' => 'hiking', 'swim' => 'swimming', 'ski' => 'skiing',
+        'workout' => 'other', 'other' => 'other'
+      }.freeze
+
+      def initialize(db:, output:, activity_filter: nil)
+        @db = db
+        @output = output
+        @activity_filter = activity_filter
+      end
+
+      def call
+        FileUtils.mkdir_p(@output)
+        activities = load_activities
+        return 0 if activities.empty?
+
+        activities.each { |a| write_gpx(a) }
+        activities.size
+      end
+
+      private
+
+      def load_activities
+        ds = @db[:activities]
+             .where(Sequel.lit('summary_polyline IS NOT NULL AND summary_polyline != ?', ''))
+             .order(Sequel.desc(:start_date))
+        ds = ds.where(sport_category: @activity_filter) if @activity_filter
+        ds.all
+      end
+
+      def write_gpx(activity)
+        points = l2_points(activity) || polyline_points(activity)
+        return unless points && points.size >= 2
+
+        safe_id = activity[:run_id].to_s.gsub(/[^a-zA-Z0-9_-]/, '_')
+        name = esc(activity[:name] || 'Activity')
+        type = CATEGORY_MAP[activity[:sport_category]] || 'other'
+        start_t = parse_time(activity[:start_date])
+
+        xml = +%(<?xml version="1.0" encoding="UTF-8"?>\n)
+        xml << %(<gpx version="1.1" creator="GitFit"\n)
+        xml << %(  xmlns="http://www.topografix.com/GPX/1/1"\n)
+        xml << %(  xmlns:gpxtpx="http://www.garmin.com/xmlschemas/TrackPointExtension/v1">\n)
+        xml << %(<metadata>\n  <name>#{name}</name>\n  <time>#{start_t}</time>\n</metadata>\n)
+        xml << %(<trk>\n  <name>#{name}</name>\n  <type>#{type}</type>\n  <trkseg>\n)
+
+        points.each do |pt|
+          s = +%(  <trkpt lat="#{fmt(pt[:lat])}" lon="#{fmt(pt[:lon])}">\n)
+          s << %(    <ele>#{fmt(pt[:ele])}</ele>\n) if pt[:ele]
+          s << %(    <time>#{pt[:time]}</time>\n) if pt[:time]
+          if pt[:hr] || pt[:cad] || pt[:watts] || pt[:temp]
+            s << %(    <extensions>\n)
+            s << %(      <gpxtpx:TrackPointExtension>\n)
+            s << %(        <gpxtpx:hr>#{pt[:hr].to_i}</gpxtpx:hr>\n) if pt[:hr]
+            s << %(        <gpxtpx:cad>#{pt[:cad].to_i}</gpxtpx:cad>\n) if pt[:cad]
+            s << %(        <gpxtpx:watts>#{pt[:watts].to_i}</gpxtpx:watts>\n) if pt[:watts]
+            s << %(        <gpxtpx:temp>#{pt[:temp].to_i}</gpxtpx:temp>\n) if pt[:temp]
+            s << %(      </gpxtpx:TrackPointExtension>\n)
+            s << %(    </extensions>\n)
+          end
+          s << %(  </trkpt>\n)
+          xml << s
+        end
+
+        xml << %(</trkseg>\n</trk>\n</gpx>\n)
+        File.write(File.join(@output, "#{safe_id}.gpx"), xml)
+      end
+
+      def l2_points(activity)
+        return nil unless activity[:source]
+
+        path = File.join('data', 'std', activity[:source].to_s, "#{activity[:run_id]}.json")
+        return nil unless File.exist?(path)
+
+        records = ::JSON.parse(File.read(path))
+        return nil if records.empty?
+
+        pts = []
+        records.each do |r|
+          lat = r['positionLat'] || r['latitude']
+          lng = r['positionLong'] || r['longitude']
+          next unless lat && lng
+
+          ele = r['altitude']
+          time = parse_time(r['timestamp'])
+          hr = r['heartRate'] || r['heartrate'] || r['heart_rate']
+          pts << {
+            lat: lat, lon: lng, ele: ele, time: time,
+            hr: hr, cad: r['cadence'], watts: r['power'] || r['watts'],
+            temp: r['temperature']
+          }
+        end
+        pts.size >= 2 ? pts : nil
+      end
+
+      def polyline_points(activity)
+        pts = Geo::Polyline.decode(activity[:summary_polyline])
+        return nil if pts.size < 2
+        pts.map { |lat, lng| { lat: lat, lon: lng } }
+      end
+
+      def parse_time(value)
+        return nil unless value
+        Time.parse(value.to_s).utc.xmlschema
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def fmt(value)
+        case value
+        when Float then value.round(6).to_s
+        when nil then ''
+        else value.to_s
+        end
+      end
+
+      def esc(str)
+        str.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+           .gsub("'", '&apos;').gsub('"', '&quot;')
+      end
+    end
+  end
+end