git-fit 0.1.1 → 0.4.1

data/lib/git_fit/parser/base.rb

@@ -0,0 +1,128 @@
+require "time"
+
+module GitFit
+  module Parser
+    class Base
+      def initialize(source: nil)
+        @source_name = source
+      end
+
+      def call(_input)
+        raise NotImplementedError
+      end
+
+      private
+
+      def haversine(p1, p2)
+        lat1 = deg_to_rad(p1[0])
+        lat2 = deg_to_rad(p2[0])
+        dlat = deg_to_rad(p2[0] - p1[0])
+        dlon = deg_to_rad(p2[1] - p1[1])
+        a = Math.sin(dlat / 2) ** 2 +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2) ** 2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        6371000.0 * c
+      end
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def total_distance(points)
+        return 0.0 if points.length < 2
+        (1...points.length).sum { |i| haversine(points[i - 1], points[i]) }
+      end
+
+      def elevation_gain(points)
+        return 0.0 if points.length < 2
+        (1...points.length).sum do |i|
+          elev1 = points[i - 1][2] || 0.0
+          elev2 = points[i][2] || 0.0
+          gain = elev2 - elev1
+          gain > 0 ? gain : 0.0
+        end
+      end
+
+      def moving_time_from_points(points, threshold_s: 30)
+        return 0 if points.length < 2
+        total = 0
+        (1...points.length).each do |i|
+          t1 = points[i - 1][3]
+          t2 = points[i][3]
+          next unless t1 && t2
+          diff = (t2 - t1).abs
+          total += diff if diff <= threshold_s
+        end
+        total.round
+      end
+
+      def elapsed_time_from_points(points)
+        return 0 if points.length < 2
+        times = points.map { |p| p[3] }.compact
+        return 0 if times.length < 2
+        ((times.last - times.first).abs).round
+      end
+
+      def build_run_id(source_prefix, value)
+        "#{source_prefix}_#{value}"
+      end
+
+      def default_sport
+        "other"
+      end
+
+      def simplify_polyline(points, max_points: 500)
+        return GitFit::Geo::Polyline.encode(points) if points.length <= max_points
+        step = (points.length.to_f / max_points).ceil
+        sampled = (0...points.length).step(step).map { |i| points[i] }
+        sampled << points.last if sampled.last != points.last
+        GitFit::Geo::Polyline.encode(sampled)
+      end
+
+      def normalize_sport_type(type)
+        return default_sport if type.nil? || type.empty?
+        mapping = {
+          "running" => "run", "run" => "run",
+          "cycling" => "ride", "biking" => "ride", "ride" => "ride",
+          "hiking" => "hike", "hike" => "hike",
+          "walking" => "walk", "walk" => "walk",
+          "swimming" => "swim", "swim" => "swim",
+          "skiing" => "ski", "ski" => "ski",
+          "workout" => "workout", "other" => "other"
+        }
+        mapping[type.downcase.strip] || default_sport
+      end
+
+      def build_activity_attrs(data)
+        {
+          run_id: data[:run_id],
+          name: data[:name],
+          distance: data[:distance]&.round(2),
+          moving_time: data[:moving_time]&.round,
+          elapsed_time: data[:elapsed_time]&.round,
+          sport_category: data[:sport_category] || default_sport,
+          sport_type: data[:sport_type],
+          start_date: format_time(data[:start_date]),
+          start_date_local: format_time_local(data[:start_date_local]),
+          location_country: data[:location_country],
+          summary_polyline: data[:summary_polyline],
+          average_heartrate: data[:average_heartrate]&.round(1),
+          average_speed: data[:distance] && data[:moving_time].to_f.positive? ? (data[:distance].to_f / data[:moving_time]).round(2) : data[:average_speed],
+          elevation_gain: data[:elevation_gain]&.round(1),
+          source: @source_name || data[:source]
+        }
+      end
+
+      def format_time(t)
+        return nil unless t
+        t.respond_to?(:iso8601) ? t.getutc.iso8601 : t.to_s
+      end
+
+      def format_time_local(t)
+        return nil unless t
+        t.respond_to?(:iso8601) ? t.iso8601 : t.to_s
+      end
+    end
+  end
+end

data/lib/git_fit/parser/fit.rb

@@ -0,0 +1,69 @@
+require "json"
+require "securerandom"
+require "time"
+
+module GitFit
+  module Parser
+    class FIT < Base
+      FIT_EPOCH = Time.utc(1989, 12, 31).freeze
+
+      def call(input)
+        path = input.is_a?(String) ? input : nil
+        return [] unless path && File.exist?(path)
+
+        records = GitFit::FIT::Decoder.decode(path)
+        return [] if records.empty?
+
+        points = records.filter_map { |r| record_to_point(r) }
+        return [] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        start_date = times.min
+        end_date = times.max
+
+        sport_type = GitFit::FIT::Decoder.sport(path)
+
+        [build_activity_attrs({
+          run_id: build_run_id("fit", SecureRandom.hex(8)),
+          name: nil,
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: normalize_sport_type(sport_type),
+          sport_type: sport_type,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
+          average_heartrate: average_heartrate(points),
+          elevation_gain: elevation_gain(points),
+          source: "fit"
+        })]
+      end
+
+      private
+
+      def record_to_point(rec)
+        lat = rec["positionLat"]
+        lon = rec["positionLong"]
+        return nil unless lat && lon
+        ts = rec["timestamp"]
+        time = ts.is_a?(Numeric) ? FIT_EPOCH + ts : parse_time(ts)
+        [lat, lon, rec["altitude"], time, rec["heartRate"]]
+      end
+
+      def average_heartrate(points)
+        hrs = points.map { |p| p[4] }.compact
+        return nil if hrs.empty?
+        hrs.sum / hrs.size
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str.to_s)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser/gpx.rb

@@ -0,0 +1,80 @@
+require "time"
+require "nokogiri"
+
+module GitFit
+  module Parser
+    class GPX < Base
+      NS = { gpx: "http://www.topografix.com/GPX/1/1" }.freeze
+
+      def call(input)
+        doc = input.is_a?(String) ? Nokogiri::XML(input) : input
+        doc.remove_namespaces!
+        tracks = doc.xpath("//trk")
+        return [] if tracks.empty?
+        tracks.filter_map { |trk| parse_track(trk) }
+      end
+
+      private
+
+      def parse_track(trk)
+        name = trk.at_xpath("name")&.text
+        segments = trk.xpath("trkseg")
+        return nil if segments.empty?
+        points = segments.flat_map { |seg| parse_segment(seg) }
+        return nil if points.empty?
+        times = points.map { |p| p[3] }.compact
+        start_date = times.min
+        end_date = times.max
+        data = {
+          run_id: build_run_id("gpx", start_date&.strftime("%Y%m%dT%H%M%S") || SecureRandom.hex(4)),
+          name: name,
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: default_sport,
+          sport_type: nil,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
+          average_heartrate: average_heartrate(points),
+          elevation_gain: elevation_gain(points),
+          source: "gpx"
+        }
+        build_activity_attrs(data)
+      end
+
+      def parse_segment(seg)
+        seg.xpath("trkpt").filter_map do |pt|
+          lat = pt["lat"]&.to_f
+          lon = pt["lon"]&.to_f
+          next unless lat && lon
+          elev = pt.at_xpath("ele")&.text&.to_f
+          time = parse_time(pt.at_xpath("time")&.text)
+          hr = parse_heartrate(pt)
+          [lat, lon, elev, time, hr]
+        end
+      end
+
+      def parse_heartrate(pt)
+        ext = pt.at_xpath("extensions")
+        return nil unless ext
+        hr = ext.at_xpath(".//hr")
+        hr&.text&.to_f
+      end
+
+      def average_heartrate(points)
+        hrs = points.map { |p| p[4] }.compact
+        return nil if hrs.empty?
+        hrs.sum / hrs.size
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser/tcx.rb

@@ -0,0 +1,89 @@
+require "time"
+require "nokogiri"
+
+module GitFit
+  module Parser
+    class TCX < Base
+      NS = { tcx: "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" }.freeze
+
+      def call(input)
+        doc = input.is_a?(String) ? Nokogiri::XML(input) : input
+        activities = doc.xpath("//tcx:Activities/tcx:Activity", NS)
+        return [] if activities.empty?
+        activities.filter_map { |act| parse_activity(act) }
+      end
+
+      private
+
+      def parse_activity(act)
+        sport = act["Sport"]
+        laps = act.xpath("tcx:Lap", NS)
+        return nil if laps.empty?
+        lap_data = laps.map { |lap| parse_lap(lap) }.compact
+        return nil if lap_data.empty?
+        total_distance = lap_data.sum { |ld| ld[:distance] || 0.0 }
+        total_moving_time = lap_data.sum { |ld| ld[:moving_time] || 0 }
+        total_elapsed_time = lap_data.sum { |ld| ld[:elapsed_time] || 0 }
+        elevation_gain = lap_data.sum { |ld| ld[:elevation_gain] || 0.0 }
+        avg_hr = lap_data.map { |ld| ld[:avg_hr] }.compact
+        all_points = lap_data.flat_map { |ld| ld[:points] }
+        times = all_points.map { |p| p[3] }.compact
+        start_date = times.min
+        data = {
+          run_id: build_run_id("tcx", start_date&.strftime("%Y%m%dT%H%M%S") || SecureRandom.hex(4)),
+          name: act.at_xpath("tcx:Notes", NS)&.text,
+          distance: total_distance,
+          moving_time: total_moving_time,
+          elapsed_time: total_elapsed_time,
+          sport_category: normalize_sport_type(sport),
+          sport_type: sport,
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: simplify_polyline(all_points.map { |p| [p[0], p[1]] }),
+          average_heartrate: avg_hr.empty? ? nil : (avg_hr.sum / avg_hr.size).round(1),
+          elevation_gain: elevation_gain,
+          source: "tcx"
+        }
+        build_activity_attrs(data)
+      end
+
+      def parse_lap(lap)
+        points = parse_track(lap)
+        return nil if points.empty?
+        distance = lap.at_xpath("tcx:DistanceMeters", NS)&.text&.to_f
+        total_time = lap.at_xpath("tcx:TotalTimeSeconds", NS)&.text&.to_f
+        avg_hr_node = lap.at_xpath("tcx:AverageHeartRateBpm/tcx:Value", NS)
+        avg_hr = avg_hr_node&.text&.to_f
+        elev_gain = points.length >= 2 ? elevation_gain(points) : 0.0
+        moving_time = moving_time_from_points(points, threshold_s: 30)
+        { distance: distance, elapsed_time: total_time&.round,
+          moving_time: moving_time > 0 ? moving_time : (total_time&.round || 0),
+          avg_hr: avg_hr, elevation_gain: elev_gain, points: points }
+      end
+
+      def parse_track(lap)
+        track = lap.at_xpath("tcx:Track", NS)
+        return [] unless track
+        track.xpath("tcx:Trackpoint", NS).filter_map do |tp|
+          pos = tp.at_xpath("tcx:Position", NS)
+          next unless pos
+          lat = pos.at_xpath("tcx:LatitudeDegrees", NS)&.text&.to_f
+          lon = pos.at_xpath("tcx:LongitudeDegrees", NS)&.text&.to_f
+          next unless lat && lon
+          elev = tp.at_xpath("tcx:AltitudeMeters", NS)&.text&.to_f
+          time = parse_time(tp.at_xpath("tcx:Time", NS)&.text)
+          hr = tp.at_xpath("tcx:HeartRateBpm/tcx:Value", NS)&.text&.to_f
+          [lat, lon, elev, time, hr]
+        end
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/parser.rb

@@ -0,0 +1,9 @@
+module GitFit
+  module Parser
+  end
+end
+
+require_relative "parser/base"
+require_relative "parser/gpx"
+require_relative "parser/tcx"
+require_relative "parser/fit"

data/lib/git_fit/privacy/polyline_filter.rb

@@ -0,0 +1,79 @@
+module GitFit
+  module Privacy
+    class PolylineFilter
+      def initialize(config: {})
+        @start_end_range = (config["start_end_range"] || 200).to_f / 1000.0
+        @ignore_polyline = decode_polyline(config["polyline"]) if config["polyline"]
+        @ignore_range = (config["range"] || 0).to_f / 1000.0
+        @before_saving = config["before_saving"] || false
+      end
+
+      def before_saving?
+        @before_saving
+      end
+
+      def filter(polyline_str)
+        return nil if polyline_str.nil? || polyline_str.empty?
+        points = decode_polyline(polyline_str)
+        return polyline_str if points.nil? || points.empty?
+        points = filter_start_end(points)
+        points = filter_range(points)
+        return nil if points.empty?
+        encode_polyline(points)
+      end
+
+      private
+
+      def filter_start_end(points)
+        return points if @start_end_range <= 0
+        start_idx = 0
+        dist = 0.0
+        (1...points.length).each do |i|
+          dist += haversine(points[i], points[i - 1])
+          start_idx = i
+          break if dist > @start_end_range
+        end
+        end_idx = points.length - 1
+        dist = 0.0
+        (points.length - 2).downto(0) do |i|
+          dist += haversine(points[i], points[i + 1])
+          end_idx = i
+          break if dist > @start_end_range
+        end
+        return [] if start_idx >= end_idx
+        points[start_idx..end_idx]
+      end
+
+      def filter_range(points)
+        return points if @ignore_polyline.nil? || @ignore_range <= 0
+        points.reject do |point|
+          @ignore_polyline.any? { |ip| haversine(point, ip) < @ignore_range }
+        end
+      end
+
+      def haversine(p1, p2)
+        lat1 = deg_to_rad(p1[0])
+        lat2 = deg_to_rad(p2[0])
+        dlat = deg_to_rad(p2[0] - p1[0])
+        dlon = deg_to_rad(p2[1] - p1[1])
+        a = Math.sin(dlat / 2) ** 2 +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2) ** 2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        6371.0 * c
+      end
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def decode_polyline(str)
+        GitFit::Geo::Polyline.decode(str)
+      end
+
+      def encode_polyline(points)
+        GitFit::Geo::Polyline.encode(points)
+      end
+    end
+  end
+end

data/lib/git_fit/source/base.rb

@@ -0,0 +1,155 @@
+require "date"
+
+module GitFit
+  module Source
+    class Base
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        @config = config
+        @db = db
+        @activity_filter = activity_filter
+        @privacy = privacy
+        @time_budget = time_budget
+        @start_time = nil
+        @progress_reported = false
+      end
+
+      attr_reader :progress_reported
+
+      def call
+        return 0 unless before_call
+        return 0 unless respond_to?(:authenticate) ? authenticate : true
+        ids = pending_ids
+        return 0 if ids.nil? || ids.empty?
+        total = ids.size
+        count = 0
+        ids.filter_map do |p|
+          r = process_one(p)
+          count += 1
+          report_progress(count, total, build_progress_info(r)) if r
+          r
+        end.size
+      end
+
+      def before_call
+        @start_time = Time.now
+        true
+      end
+
+      def pending_ids
+        raise NotImplementedError
+      end
+
+      def process_one(pending)
+        raise NotImplementedError
+      end
+
+      def build_progress_info(attrs)
+        parts = []
+        sd = attrs["start_date"] || attrs[:start_date]
+        if sd
+          d = Date.parse(sd.to_s) rescue nil
+          if d
+            date_str = d.year == Date.today.year ? d.strftime("%m-%d") : d.strftime("%Y-%m-%d")
+            parts << date_str
+          end
+        end
+        type = attrs["sport_category"] || attrs[:sport_category]
+        parts << type if type
+        dist = attrs["distance"] || attrs[:distance]
+        if dist && dist.to_f > 0
+          parts << "#{format('%.1f', dist.to_f / 1000)}km"
+        end
+        source = attrs["source"] || attrs[:source] || source_label
+        name = attrs["name"] || attrs[:name]
+        display_name = name.to_s.strip
+        display_name = "#{source} Activity" if display_name.empty?
+        chars = display_name.chars
+        display_name = chars.first(30).join + "…" if chars.size > 30
+        parts << display_name
+        parts.join(" | ") unless parts.empty?
+      end
+
+      protected
+
+      def time_expired?
+        return false unless @time_budget.is_a?(Numeric) && @time_budget > 0 && @start_time
+        (Time.now - @start_time) > @time_budget
+      end
+
+      def raw_dir
+        src = self.class.name.split("::").last.downcase
+        File.join("data", "raw", src)
+      end
+
+      def raw_path(platform_id)
+        raise NotImplementedError
+      end
+
+      def raw_file_exists?(platform_id)
+        File.exist?(raw_path(platform_id))
+      end
+
+      def std_dir
+        src = self.class.name.split("::").last.downcase
+        File.join("data", "std", src)
+      end
+
+      def std_path(platform_id, ext = "json")
+        File.join(std_dir, "#{platform_id}.#{ext}")
+      end
+
+      def report_progress(count, total = nil, info = nil)
+        return unless show_progress?(count, total)
+        @progress_reported = true
+        line = "#{source_label}: #{count}"
+        line += "/#{total}" if total
+        line += " #{info}" if info
+        line += " "
+        print "\r#{line}"
+        $stdout.flush
+      end
+
+      def show_progress?(count, total)
+        return true if count == 1
+        return true if total && (total - count) <= 50
+        step = progress_step(total)
+        step <= 1 || count % step == 0
+      end
+
+      def progress_step(total)
+        return 1 unless total && total > 0
+        [1, (1.5 * (total ** 0.4)).to_i].max
+      end
+
+      def source_label
+        name = self.class.name
+        name ? name.split("::").last : "Source"
+      end
+
+      def upsert_activity(attrs)
+        attrs = attrs.transform_keys(&:to_s)
+        now = Time.now.utc
+
+        if @privacy && !@privacy.before_saving?
+          attrs["summary_polyline"] = @privacy.filter(attrs["summary_polyline"])
+        end
+
+        existing = @db[:activities].where(run_id: attrs["run_id"]).first
+        if existing
+          attrs.delete("created_at")
+          attrs["updated_at"] = now
+          @db[:activities].where(run_id: attrs["run_id"]).update(attrs)
+        else
+          attrs["created_at"] ||= now
+          attrs["updated_at"] ||= now
+          @db[:activities].insert(attrs)
+        end
+      end
+
+      def skip_type?(sport_type)
+        return false unless @activity_filter
+        !@activity_filter.include?(sport_type.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/git_fit/source/tally.rb

@@ -0,0 +1,55 @@
+module GitFit
+  module Source
+    class Tally
+      DIGITS = %w[零 一 二 三 四 五 六 七 八 九 十]
+
+      def initialize(count = 0)
+        @count = count
+      end
+
+      def add(n = 1)
+        @count += n
+      end
+
+      def to_s
+        return @count.to_s if @count > 9999
+        chinese_numeral
+      rescue StandardError
+        @count.to_s
+      end
+
+      private
+
+      def chinese_numeral
+        n = @count
+        return DIGITS[0] if n == 0
+        return DIGITS[n] if n <= 10
+
+        result = ""
+        thousands = n / 1000
+        n %= 1000
+        result += DIGITS[thousands] + "千" if thousands > 0
+
+        hundreds = n / 100
+        n %= 100
+        if hundreds > 0
+          result += DIGITS[hundreds] + "百"
+        elsif thousands > 0 && n > 0
+          result += "零"
+        end
+
+        tens = n / 10
+        ones = n % 10
+        if tens > 0
+          join_ten = tens > 1 || !result.empty?
+          result += (join_ten ? DIGITS[tens] : "") + "十"
+        elsif !result.empty? && tens == 0 && ones > 0 && !result.end_with?("零")
+          result += "零"
+        end
+
+        result += DIGITS[ones] if ones > 0
+        result
+      end
+    end
+  end
+end

data/lib/git_fit/source.rb

@@ -0,0 +1,7 @@
+module GitFit
+  module Source
+  end
+end
+
+require_relative "source/tally"
+require_relative "source/base"