git-fit 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9551667addc842c5ddb8357d32b9d4eb040eedc236eeb3c940f59ea52f8be329
-  data.tar.gz: 3ede4c5df18fd6a3380b5aff8845bf2ac1ca7d1074c2507e647e05363bf745fb
+  metadata.gz: a3c36d045a4ed37a0eaad4f219367f1d514af31c26bcae72e76cbeec7bb5dbb0
+  data.tar.gz: ab845ce910206dae48a131315427bf06604bd02988b097eb462ae5805727ab97
 SHA512:
-  metadata.gz: 437969ed9c1dd8ec94de2449cbe8e71e8201bcfe2299fd3dcdcf44c8ae6b4901482b99fdd3459482395896a10c96c455a1acff8c69fd2e242c81e1befdb88941
-  data.tar.gz: 11ffe29a5aecb4c305f361c81ad3eef6f73394fc9abb00f75486d68a32caac3de565ef941236120622b63c61059b20486f790e32290ef016da93141266d20b5e
+  metadata.gz: 9822b621a741ce52c68c6510f6f73a1da52ae544c4371d05ffe430cacd1d882a914f4bd6959b98add49a13595b0ffc703b4258fd5dd5a6535ad887117d5e8be0
+  data.tar.gz: 139da861fd411de27553e13e03ec0b3c7d94e5019c64e3e6ba820415e49f87f43ed58490565c408801554f30c3b0a2fa03133e48c4d783ffa7276b54e9f67e22

data/lib/git-fit.rb

@@ -3,6 +3,8 @@ require "yaml"
 require "fileutils"
 
 module GitFit
+  SPORT_CATEGORIES = %w[run ride hike walk swim ski workout other].freeze
+
   @registered_configs = []
 
   class << self
@@ -11,12 +13,52 @@ module GitFit
     def register_config_source(prefix:, keys:, config_path:)
       @registered_configs << { prefix: prefix, keys: keys, config_path: config_path }
     end
+
+    def activity_to_hash(a)
+      return nil unless a
+
+      {
+        run_id: a[:run_id],
+        name: a[:name],
+        distance: a[:distance],
+        moving_time: format_time(a[:moving_time]),
+        type: a[:sport_category],
+        subtype: a[:sport_type],
+        start_date: a[:start_date],
+        start_date_local: a[:start_date_local],
+        location_country: a[:location_country],
+        summary_polyline: a[:summary_polyline],
+        average_heartrate: a[:average_heartrate],
+        average_speed: a[:average_speed],
+        elevation_gain: a[:elevation_gain]
+      }
+    end
+
+    def format_time(seconds)
+      return nil unless seconds
+      hours = seconds / 3600
+      minutes = (seconds % 3600) / 60
+      secs = seconds % 60
+      format("%d:%02d:%02d", hours, minutes, secs)
+    end
   end
 end
 
 require_relative "git_fit/version"
 require_relative "git_fit/config"
 require_relative "git_fit/config_template"
+require_relative "git_fit/sport_mapper"
+require_relative "git_fit/geo"
+require_relative "git_fit/fit"
+require_relative "git_fit/parser"
+require_relative "git_fit/source"
+require_relative "git_fit/timezone/resolver"
+require_relative "git_fit/privacy/polyline_filter"
 require_relative "git_fit/sync/base"
 require_relative "git_fit/sync/strava"
+require_relative "git_fit/db/connection"
+require_relative "git_fit/db/activity"
+require_relative "git_fit/export"
+require_relative "git_fit/db/cli"
+require_relative "git_fit/cli/export"
 require_relative "git_fit/cli"

data/lib/git_fit/cli/export.rb

@@ -0,0 +1,25 @@
+require "thor"
+
+module GitFit
+  class ExportCLI < Thor
+    desc "json", "Export activities to JSON"
+    option :output, type: :string, aliases: "-o", desc: "Output path"
+    option :activity, type: :array, desc: "Filter by sport type", aliases: "--act"
+    no_commands do
+      def git_fit_config
+        @git_fit_config ||= GitFit::Config.new(options[:config])
+      end
+    end
+
+    def json
+      config = git_fit_config
+      db = GitFit::DB::Connection.new(config.db_path).db
+      path = options[:output] || config.export_config.dig("json", "path") || "site/activities.json"
+      filter = options[:activity]&.map(&:strip)&.map(&:downcase)
+      count = Export::JSON.new(db: db, output: path, activity_filter: filter).call
+      say_status :done, "Exported #{count} activities to #{path}", :green
+    rescue => e
+      say_status :error, "JSON export failed: #{e.message}", :red
+    end
+  end
+end

data/lib/git_fit/cli.rb

@@ -10,11 +10,54 @@ module GitFit
       true
     end
 
+    desc "db SUBCOMMAND", "Database operations"
+    subcommand "db", DB::CLI
+
+    desc "export SUBCOMMAND", "Export activities to various formats"
+    subcommand "export", ExportCLI
+
     desc "version", "Show version"
     def version
       puts "git-fit v#{GitFit::VERSION}"
     end
 
+    desc "parse FILE", "Parse a GPX or TCX file"
+    option :save, type: :boolean, desc: "Save parsed activities to database", aliases: "-s"
+    def parse(file)
+      format = file.match?(/\.gpx$/i) ? :gpx : :tcx
+      content = File.read(file)
+      parser = format == :gpx ? GitFit::Parser::GPX.new(source: "file") : GitFit::Parser::TCX.new(source: "file")
+      activities = parser.call(content)
+
+      if activities.empty?
+        say_status :warn, "No activities found in #{file}", :yellow
+        return
+      end
+
+      activities.each do |act|
+        say_status :activity, act[:name] || "unnamed", :green
+        say "  #{act[:sport_category]}#{act[:sport_type] ? " (#{act[:sport_type]})" : ""}"
+        say "  #{act[:start_date]} | #{act[:distance]&.round(2)}m" if act[:distance]
+        say "  #{act[:moving_time]}s" if act[:moving_time]
+      end
+
+      if options[:save]
+        db = connect_db
+        now = Time.now.utc
+        activities.each do |act|
+          existing = db[:activities].where(run_id: act[:run_id]).first
+          if existing
+            db[:activities].where(run_id: act[:run_id]).update(act.merge(updated_at: now))
+          else
+            db[:activities].insert(act.merge(created_at: now, updated_at: now))
+          end
+        end
+        say_status :done, "Saved #{activities.size} activities", :green
+      end
+    rescue => e
+      say_status :error, "Parse failed: #{e.message}", :red
+    end
+
     desc "init", "Generate config.yml"
     option :output, type: :string, desc: "Output path", aliases: "-o"
     def init
@@ -49,6 +92,10 @@ module GitFit
         result
       end
 
+      def connect_db
+        GitFit::DB::Connection.new(git_fit_config.db_path).db
+      end
+
       def deep_dup(obj)
         case obj
         when Hash then obj.each_with_object({}) { |(k, v), h| h[k] = deep_dup(v) }

data/lib/git_fit/db/activity.rb

@@ -0,0 +1,15 @@
+# Deprecated: use GitFit.activity_to_hash / GitFit.format_time instead.
+# Kept for backward compatibility during migration.
+module GitFit
+  module DB
+    SPORT_CATEGORIES = GitFit::SPORT_CATEGORIES
+
+    def self.activity_to_hash(a)
+      GitFit.activity_to_hash(a)
+    end
+
+    def self.format_time(seconds)
+      GitFit.format_time(seconds)
+    end
+  end
+end

data/lib/git_fit/db/cli.rb

@@ -0,0 +1,16 @@
+require "thor"
+
+module GitFit
+  module DB
+    class CLI < Thor
+      desc "migrate", "Run database migrations"
+      def migrate
+        config = GitFit::Config.new
+        GitFit::DB::Connection.new(config.db_path)
+        say_status :done, "Migrations up to date", :green
+      rescue => e
+        say_status :error, "Migration failed: #{e.message}", :red
+      end
+    end
+  end
+end

data/lib/git_fit/db/connection.rb

@@ -0,0 +1,27 @@
+require "fileutils"
+require "sequel"
+
+module GitFit
+  module DB
+    class Connection
+      def initialize(db_path)
+        FileUtils.mkdir_p(File.dirname(db_path)) if db_path.include?("/")
+        @db = Sequel.sqlite(db_path)
+        @db.run("PRAGMA journal_mode=WAL")
+        @db.run("PRAGMA busy_timeout=5000")
+        run_migrations
+      end
+
+      def db
+        @db
+      end
+
+      private
+
+      def run_migrations
+        Sequel.extension :migration
+        Sequel::Migrator.run(@db, File.expand_path("../../../db/migrations", __dir__))
+      end
+    end
+  end
+end

data/lib/git_fit/export/defaults.rb

@@ -0,0 +1,29 @@
+module GitFit
+  module Export
+    module Defaults
+      SVG = {
+        background: "#222222", text: "#FFFFFF", track: "#4DD2FF",
+        track2: "#4DD2FF", special: "#FFFF00", special2: "#FFFF00",
+        empty_cell: "#444444", dim_past: "#555555", font: "Arial",
+      }.freeze
+
+      DASHBOARD = {
+        background: "#1a1a2e", surface: "#16213e", hover: "#0f3460",
+        active_row: "#1a3a6a", border: "#2a2a4a", text: "#e0e0e0",
+        text_secondary: "#888", text_dim: "#666", text_insight: "#aaa",
+        accent: "#4DD2FF", font: "-apple-system, BlinkMacSystemFont, sans-serif",
+      }.freeze
+
+      CATEGORIES = {
+        "run" => "#4DD2FF", "walk" => "#4ECDC4",
+        "ride" => "#FF6B6B", "hike" => "#FFD93D",
+      }.freeze
+
+      MAP = {
+        tiles_dark: "https://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}{r}.png",
+        tiles_light: "https://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{r}.png",
+        echarts_theme: "dark",
+      }.freeze
+    end
+  end
+end

data/lib/git_fit/export/json.rb

@@ -0,0 +1,112 @@
+require "json"
+
+module GitFit
+  module Export
+    class JSON
+      PLACEHOLDER_POLYLINE = "gqqrFurkeU??".freeze
+
+      def initialize(db:, output:, activity_filter: nil)
+        @db = db
+        @output = output
+        @activity_filter = activity_filter
+      end
+
+      def call
+        dataset = @db[:activities].order(Sequel.desc(:start_date))
+        dataset = dataset.where(sport_category: @activity_filter) if @activity_filter
+
+        activities = dataset.all
+
+        run_id_to_group = {}
+        @db[:dedup_group_members].each { |gm| run_id_to_group[gm[:run_id]] = gm[:group_id] }
+
+        group_members_cache = {}
+
+        formatted = activities.map do |a|
+          gid = run_id_to_group[a[:run_id]]
+          if gid
+            group_members_cache[gid] ||= @db[:dedup_group_members].where(group_id: gid).all
+            composite_activity(a, gid, group_members_cache[gid])
+          else
+            format_activity(a)
+          end
+        end
+
+        File.write(@output, ::JSON.pretty_generate(formatted))
+        formatted.size
+      end
+
+      private
+
+      def format_activity(a)
+        base = {
+          run_id: a[:run_id],
+          name: a[:name],
+          distance: a[:distance],
+          moving_time: a[:moving_time],
+          type: a[:sport_category],
+          sport_type: a[:sport_type],
+          start_date: a[:start_date],
+          start_date_local: a[:start_date_local],
+          location_country: a[:location_country],
+          summary_polyline: a[:source] == "keep" && a[:summary_polyline] == PLACEHOLDER_POLYLINE ?
+            nil : a[:summary_polyline],
+          average_heartrate: a[:average_heartrate] && a[:average_heartrate] != 0 ? a[:average_heartrate] : nil,
+          max_heartrate: a[:max_heartrate],
+          average_cadence: a[:average_cadence],
+          max_cadence: a[:max_cadence],
+          average_power: a[:average_power],
+          max_power: a[:max_power],
+          calories: a[:calories],
+          average_temperature: a[:average_temperature],
+          average_speed: a[:average_speed],
+          elevation_gain: a[:elevation_gain],
+          source: a[:source],
+        }
+        if a[:divisions]
+          base[:divisions] = ::JSON.parse(a[:divisions])
+        end
+        base
+      end
+
+      def composite_activity(activity, group_id, members)
+        run_ids = members.map { |m| m[:run_id] }
+        group_activities = @db[:activities].where(run_id: run_ids).all
+
+        composite = if defined?(GitFit::Dedup::FieldElector)
+          elector = GitFit::Dedup::FieldElector.new
+          result = {}
+          GitFit::Dedup::FieldElector::FIELD_ELECTION_RULES.each_key do |field|
+            values = group_activities.map { |a| a[field] }
+            sources = group_activities.map { |a| a[:source]&.to_sym }
+            result[field] = elector.elect(field, values, sources)
+          end
+          result
+        else
+          members.first&.slice(:run_id, :distance, :moving_time, :elapsed_time,
+            :average_heartrate, :max_heartrate, :elevation_gain,
+            :average_speed, :average_cadence, :max_cadence) || {}
+        end
+
+        composite[:run_id] = activity[:run_id]
+        composite[:source] = activity[:source]
+        composite[:sport_type] = activity[:sport_type]
+        composite[:start_date_local] = activity[:start_date_local]
+        composite[:location_country] = activity[:location_country]
+        composite[:sport_category] = activity[:sport_category]
+
+        if composite[:distance].to_f > 0 && composite[:moving_time].to_f > 0
+          composite[:average_speed] = composite[:distance] / composite[:moving_time]
+        end
+
+        composite[:type] = composite[:sport_category]
+        composite[:dedup_group] = group_id
+        composite[:member_sources] = members.map do |m|
+          { source: m[:source], run_id: m[:run_id], flag: m[:flag], confidence: m[:confidence] }
+        end
+
+        composite
+      end
+    end
+  end
+end

data/lib/git_fit/export.rb

@@ -0,0 +1,7 @@
+module GitFit
+  module Export
+  end
+end
+
+require_relative "export/defaults"
+require_relative "export/json"

data/lib/git_fit/fit/decoder.rb

@@ -0,0 +1,27 @@
+require "mini_racer"
+require "json"
+
+module GitFit
+  module FIT
+    class Decoder
+      JS_CODE = File.read(File.join(__dir__, "decoder.js")).freeze
+      CTX = MiniRacer::Context.new.tap { |c| c.eval(JS_CODE) }
+
+      def self.decode(path)
+        bytes = File.read(path, mode: "rb").bytes
+        json = CTX.eval("FitDecoder.decodeFit(#{bytes.inspect})")
+        records = JSON.parse(json)
+        records.each do |r|
+          r["positionLat"] *= 180 if r["positionLat"]
+          r["positionLong"] *= 180 if r["positionLong"]
+        end
+        records
+      end
+
+      def self.sport(path)
+        bytes = File.read(path, mode: "rb").bytes
+        CTX.eval("FitDecoder.fitSport(#{bytes.inspect})")
+      end
+    end
+  end
+end

data/lib/git_fit/fit.rb

@@ -0,0 +1 @@
+require_relative "fit/decoder"

data/lib/git_fit/geo/coord_transform.rb

@@ -0,0 +1,101 @@
+module GitFit
+  module Geo
+    # 3 coordinate systems: WGS84 (GPS native), GCJ-02 (China offset), BD-09 (Baidu).
+    module CoordTransform
+      A = 6378245.0
+      EE = 0.00669342162296594323
+
+      X_PI = Math::PI * 3000.0 / 180.0
+
+      module_function
+
+      def wgs84_to_gcj02(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        dlat, dlng = delta(lat, lng)
+        [lat + dlat, lng + dlng]
+      end
+
+      def gcj02_to_wgs84(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        dlat, dlng = delta(lat, lng)
+        [lat - dlat, lng - dlng]
+      end
+
+      def gcj02_to_wgs84_exact(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        init_lat = lat
+        init_lng = lng
+        5.times do
+          dlat, dlng = delta(init_lat, init_lng)
+          init_lat = lat - dlat
+          init_lng = lng - dlng
+        end
+        [init_lat, init_lng]
+      end
+
+      def gcj02_to_bd09(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        x = lng
+        y = lat
+        z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * X_PI)
+        theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * X_PI)
+        bd_lng = z * Math.cos(theta) + 0.0065
+        bd_lat = z * Math.sin(theta) + 0.006
+        [bd_lat, bd_lng]
+      end
+
+      def bd09_to_gcj02(lat, lng)
+        return [lat, lng] if out_of_china(lng, lat)
+        x = lng - 0.0065
+        y = lat - 0.006
+        z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * X_PI)
+        theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * X_PI)
+        gcj_lng = z * Math.cos(theta)
+        gcj_lat = z * Math.sin(theta)
+        [gcj_lat, gcj_lng]
+      end
+
+      def bd09_to_wgs84(lat, lng)
+        gcj_lat, gcj_lng = bd09_to_gcj02(lat, lng)
+        gcj02_to_wgs84_exact(gcj_lat, gcj_lng)
+      end
+
+      def wgs84_to_bd09(lat, lng)
+        gcj_lat, gcj_lng = wgs84_to_gcj02(lat, lng)
+        gcj02_to_bd09(gcj_lat, gcj_lng)
+      end
+
+      def out_of_china(lng, lat)
+        lng < 72.004 || lng > 137.8347 || lat < 0.8293 || lat > 55.8271
+      end
+
+      def delta(lat, lng)
+        dlat = transform_lat(lng - 105.0, lat - 35.0)
+        dlng = transform_lng(lng - 105.0, lat - 35.0)
+        radlat = lat / 180.0 * Math::PI
+        magic = Math.sin(radlat)
+        magic = 1 - EE * magic * magic
+        sqrt_magic = Math.sqrt(magic)
+        dlat = (dlat * 180.0) / ((A * (1 - EE)) / (magic * sqrt_magic) * Math::PI)
+        dlng = (dlng * 180.0) / (A / sqrt_magic * Math.cos(radlat) * Math::PI)
+        [dlat, dlng]
+      end
+
+      def transform_lat(x, y)
+        ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(x.abs)
+        ret += (20.0 * Math.sin(6.0 * x * Math::PI) + 20.0 * Math.sin(2.0 * x * Math::PI)) * 2.0 / 3.0
+        ret += (20.0 * Math.sin(y * Math::PI) + 40.0 * Math.sin(y / 3.0 * Math::PI)) * 2.0 / 3.0
+        ret += (160.0 * Math.sin(y / 12.0 * Math::PI) + 320.0 * Math.sin(y * Math::PI / 30.0)) * 2.0 / 3.0
+        ret
+      end
+
+      def transform_lng(x, y)
+        ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(x.abs)
+        ret += (20.0 * Math.sin(6.0 * x * Math::PI) + 20.0 * Math.sin(2.0 * x * Math::PI)) * 2.0 / 3.0
+        ret += (20.0 * Math.sin(x * Math::PI) + 40.0 * Math.sin(x / 3.0 * Math::PI)) * 2.0 / 3.0
+        ret += (150.0 * Math.sin(x / 12.0 * Math::PI) + 300.0 * Math.sin(x / 30.0 * Math::PI)) * 2.0 / 3.0
+        ret
+      end
+    end
+  end
+end

data/lib/git_fit/geo/polyline.rb

@@ -0,0 +1,78 @@
+module GitFit
+  module Geo
+    module Polyline
+      module_function
+
+      def decode(str)
+        return nil unless str && str.length > 0
+
+        points = []
+        index = 0
+        lat = 0
+        lng = 0
+
+        while index < str.length
+          shift = 0
+          result = 0
+          begin
+            byte = str[index].ord - 63
+            index += 1
+            result |= (byte & 0x1f) << shift
+            shift += 5
+          end while byte >= 0x20
+
+          dlat = (result & 1) != 0 ? ~(result >> 1) : (result >> 1)
+          lat += dlat
+
+          shift = 0
+          result = 0
+          begin
+            byte = str[index].ord - 63
+            index += 1
+            result |= (byte & 0x1f) << shift
+            shift += 5
+          end while byte >= 0x20
+
+          dlng = (result & 1) != 0 ? ~(result >> 1) : (result >> 1)
+          lng += dlng
+
+          points << [lat * 1e-5, lng * 1e-5]
+        end
+
+        points
+      end
+
+      def encode(points)
+        result = ""
+        plat = 0
+        plng = 0
+
+        points.each do |lat, lng|
+          dlat = ((lat * 1e5).round - plat)
+          dlng = ((lng * 1e5).round - plng)
+
+          plat += dlat
+          plng += dlng
+
+          result += encode_number(dlat)
+          result += encode_number(dlng)
+        end
+
+        result
+      end
+
+      def encode_number(num)
+        num = num < 0 ? ~(num << 1) : (num << 1)
+        result = ""
+
+        while num >= 0x20
+          result += ((0x20 | (num & 0x1f)) + 63).chr
+          num >>= 5
+        end
+
+        result += (num + 63).chr
+        result
+      end
+    end
+  end
+end

data/lib/git_fit/geo.rb

@@ -0,0 +1,7 @@
+module GitFit
+  module Geo
+  end
+end
+
+require_relative "geo/polyline"
+require_relative "geo/coord_transform"