git-fit 0.7.9 → 0.8.0

data/lib/git_fit/sync/garmin_base_di.rb

@@ -1,5 +1,7 @@
-require_relative "garmin_base"
-require "open3"
+# frozen_string_literal: true
+
+require_relative 'garmin_base'
+require 'open3'
 
 module GitFit
   module Sync
@@ -31,16 +33,16 @@ module GitFit
           end
         end
 
-        puts "Garmin: no valid DI token found"
-        puts "  First time: ./scripts/garmin_auth_local.sh"
-        puts "  Refresh:    ./scripts/garmin_auth_local.sh --sync"
+        puts 'Garmin: no valid DI token found'
+        puts '  First time: ./scripts/garmin_auth_local.sh'
+        puts '  Refresh:    ./scripts/garmin_auth_local.sh --sync'
         false
       end
 
       def before_call
-        if @config["auth_seed"].to_s.empty? && !File.exist?(token_path)
-          puts "Garmin: auth_seed not configured and no cached token"
-          puts "  Run: ./scripts/garmin_auth_local.sh"
+        if @config['auth_seed'].to_s.empty? && !File.exist?(token_path)
+          puts 'Garmin: auth_seed not configured and no cached token'
+          puts '  Run: ./scripts/garmin_auth_local.sh'
           return false
         end
         @start_time = Time.now
@@ -48,7 +50,7 @@ module GitFit
       end
 
       def reauth_hint
-        "Re-auth: ./scripts/garmin_auth_local.sh --sync"
+        'Re-auth: ./scripts/garmin_auth_local.sh --sync'
       end
 
       private
@@ -64,30 +66,30 @@ module GitFit
         data = JSON.parse(File.read(path))
         @access_token = data
         true
-      rescue => e
+      rescue StandardError => e
         puts "Failed to load Garmin tokens: #{e.message}"
         false
       end
 
       def save_tokens
-        return unless @access_token&.dig("access_token")
+        return unless @access_token&.dig('access_token')
 
         path = token_path
         FileUtils.mkdir_p(File.dirname(path))
         File.write(path, JSON.pretty_generate(@access_token))
-      rescue => e
+      rescue StandardError => e
         puts "Failed to save Garmin tokens: #{e.message}"
       end
 
       def remove_stale_tokens
         path = token_path
         File.delete(path) if File.exist?(path)
-      rescue => e
+      rescue StandardError => e
         puts "Warning: failed to remove stale tokens: #{e.message}"
       end
 
       def load_auth_seed
-        seed = @config["auth_seed"]
+        seed = @config['auth_seed']
         return false unless seed && !seed.empty?
 
         decoded = JSON.parse(Base64.strict_decode64(seed))
@@ -95,49 +97,49 @@ module GitFit
         save_tokens
         true
       rescue JSON::ParserError
-        puts "Garmin: auth_seed decode failed — invalid Base64 or JSON"
-        puts "  Fix: ./scripts/garmin_auth_local.sh --sync"
+        puts 'Garmin: auth_seed decode failed — invalid Base64 or JSON'
+        puts '  Fix: ./scripts/garmin_auth_local.sh --sync'
         false
-      rescue => e
+      rescue StandardError => e
         puts "Garmin: auth_seed error: #{e.message}"
         false
       end
 
       def refresh_token
-        return false unless @access_token&.dig("refresh_token")
+        return false unless @access_token&.dig('refresh_token')
 
-        client_id = @access_token["di_client_id"] || DI_CLIENT_IDS.first
+        client_id = @access_token['di_client_id'] || DI_CLIENT_IDS.first
         basic = Base64.strict_encode64("#{client_id}:")
 
         uri = URI("#{auth_base}/di-oauth2-service/oauth/token")
         req = Net::HTTP::Post.new(uri)
-        req["Authorization"] = "Basic #{basic}"
-        req["Content-Type"] = "application/x-www-form-urlencoded"
-        req["Cache-Control"] = "no-cache"
-        req["User-Agent"] = "GCM-Android-5.23"
+        req['Authorization'] = "Basic #{basic}"
+        req['Content-Type'] = 'application/x-www-form-urlencoded'
+        req['Cache-Control'] = 'no-cache'
+        req['User-Agent'] = 'GCM-Android-5.23'
         req.body = URI.encode_www_form(
-          grant_type: "refresh_token",
+          grant_type: 'refresh_token',
           client_id: client_id,
-          refresh_token: @access_token["refresh_token"]
+          refresh_token: @access_token['refresh_token']
         )
 
         resp = retry_on_429 { send_http(uri, req) }
         unless resp.code.to_i == 200
           msg = "DI refresh error: #{resp.code}"
           if resp.code.to_i == 400
-            msg += " — refresh_token expired across rotation"
-            msg += ", re-run: scripts/garmin_auth_local.sh"
+            msg += ' — refresh_token expired across rotation'
+            msg += ', re-run: scripts/garmin_auth_local.sh'
           elsif resp.code.to_i == 401
-            msg += " — DI client_id rotated by Garmin"
-            msg += ", re-run: scripts/garmin_auth_local.sh"
+            msg += ' — DI client_id rotated by Garmin'
+            msg += ', re-run: scripts/garmin_auth_local.sh'
           end
           raise AuthError, msg
         end
 
         result = JSON.parse(resp.body)
-        result["expires_at"] = Time.now.to_i + (result["expires_in"] || 64800).to_i
-        if result["refresh_token_expires_in"]
-          result["refresh_token_expires_at"] = Time.now.to_i + result["refresh_token_expires_in"].to_i
+        result['expires_at'] = Time.now.to_i + (result['expires_in'] || 64800).to_i
+        if result['refresh_token_expires_in']
+          result['refresh_token_expires_at'] = Time.now.to_i + result['refresh_token_expires_in'].to_i
         end
         @access_token = result
         save_tokens
@@ -153,31 +155,31 @@ module GitFit
       # historical. In scripts/garmin_auth_local.sh, Playwright runs first (cookies
       # persist 365d → no repeat MFA), curl_cffi is the fallback.
       def strategy_a_login
-        script = File.expand_path("../../../scripts/garmin_auth.py", __dir__)
+        script = File.expand_path('../../../scripts/garmin_auth.py', __dir__)
         return nil unless File.exist?(script)
 
         stdout, stderr, status = Open3.capture3(
-          {"SYNC__GARMIN__EMAIL" => @email, "SYNC__GARMIN__PASSWORD" => @password, "SYNC__GARMIN__DOMAIN" => @domain},
-          "python3", script
+          {'SYNC__GARMIN__EMAIL' => @email, 'SYNC__GARMIN__PASSWORD' => @password, 'SYNC__GARMIN__DOMAIN' => @domain},
+          'python3', script
         )
         warn stderr unless stderr.empty?
         JSON.parse(stdout) if status.success?
-      rescue => e
+      rescue StandardError => e
         puts "Strategy A (curl_cffi) failed: #{e.message}"
         nil
       end
 
       def strategy_b_login
-        script = File.expand_path("../../../scripts/garmin_auth_playwright.py", __dir__)
+        script = File.expand_path('../../../scripts/garmin_auth_playwright.py', __dir__)
         return nil unless File.exist?(script)
 
         stdout, stderr, status = Open3.capture3(
-          {"SYNC__GARMIN__EMAIL" => @email, "SYNC__GARMIN__PASSWORD" => @password, "SYNC__GARMIN__DOMAIN" => @domain},
-          "python3", script
+          {'SYNC__GARMIN__EMAIL' => @email, 'SYNC__GARMIN__PASSWORD' => @password, 'SYNC__GARMIN__DOMAIN' => @domain},
+          'python3', script
         )
         warn stderr unless stderr.empty?
         JSON.parse(stdout) if status.success?
-      rescue => e
+      rescue StandardError => e
         puts "Strategy B (Playwright) failed: #{e.message}"
         nil
       end

data/lib/git_fit/sync/garmin_cn.rb

@@ -1,4 +1,6 @@
-require_relative "garmin_base"
+# frozen_string_literal: true
+
+require_relative 'garmin_base'
 
 module GitFit
   module Sync
@@ -8,20 +10,20 @@ module GitFit
 
       def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
         super
-        @domain = "garmin.cn"
-        @ssl_verify = config.key?("ssl_verify") ? config["ssl_verify"] : false
+        @domain = 'garmin.cn'
+        @ssl_verify = config.key?('ssl_verify') ? config['ssl_verify'] : false
       end
 
       def raw_dir
-        File.join("data", "raw", "garmin_cn")
+        File.join('data', 'raw', 'garmin_cn')
       end
 
       def std_dir
-        File.join("data", "std", "garmin_cn")
+        File.join('data', 'std', 'garmin_cn')
       end
 
       def source_prefix
-        "garmin_cn"
+        'garmin_cn'
       end
     end
   end

data/lib/git_fit/sync/igpsport.rb

@@ -1,28 +1,30 @@
-require_relative "base"
-require "faraday"
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'faraday'
 
 module GitFit
   module Sync
     class IGPSPORT < Base
-      BASE_URL = "https://prod.zh.igpsport.com/service"
+      BASE_URL = 'https://prod.zh.igpsport.com/service'
       LOGIN_URL = "#{BASE_URL}/auth/account/login"
       QUERY_URL = "#{BASE_URL}/web-gateway/web-analyze/activity/queryMyActivity"
       DOWNLOAD_URL = "#{BASE_URL}/web-gateway/web-analyze/activity/getDownloadUrl"
 
       EXERCISE_MAP = {
-        0 => "ride", 1 => "run", 2 => "hike", 3 => "walk",
-        4 => "swim", 5 => "ski", 6 => "workout"
+        0 => 'ride', 1 => 'run', 2 => 'hike', 3 => 'walk',
+        4 => 'swim', 5 => 'ski', 6 => 'workout'
       }.freeze
 
-      RAW_EXT = "fit"
+      RAW_EXT = 'fit'
 
       register_adapter
       register_config :phone, :password
 
       def initialize(...)
         super
-        @phone = @config["phone"]
-        @password = @config["password"]
+        @phone = @config['phone']
+        @password = @config['password']
       end
 
       def before_call
@@ -42,9 +44,9 @@ module GitFit
           acts = fetch_page(page)
           break if acts.nil? || acts.empty?
           acts.each do |act|
-            ride_id = act["rideId"].to_s
+            ride_id = act['rideId'].to_s
             next if existing.include?(ride_id) && raw_file_exists?(ride_id)
-            type = map_sport(act["exerciseType"])
+            type = map_sport(act['exerciseType'])
             next if skip_type?(type)
             ids << { id: ride_id, type: type, summary: act }
           end
@@ -61,14 +63,14 @@ module GitFit
 
       def login
         resp = Faraday.post(LOGIN_URL,
-          JSON.generate({ appId: "igpsport-web", username: @phone, password: @password }),
-          { "Content-Type" => "application/json" }
+          JSON.generate({ appId: 'igpsport-web', username: @phone, password: @password }),
+          { 'Content-Type' => 'application/json' }
         )
         return false unless resp.status == 200
         data = JSON.parse(resp.body)
-        @token = data.dig("data", "access_token")
+        @token = data.dig('data', 'access_token')
         return false unless @token
-        @auth_headers = { "Authorization" => "Bearer #{@token}" }
+        @auth_headers = { 'Authorization' => "Bearer #{@token}" }
         true
       end
 
@@ -88,16 +90,16 @@ module GitFit
         wgs_points = FIT::Decoder.decode(fit_path)
         return false if wgs_points.empty?
 
-        first_ts = wgs_points.first["timestamp"]
+        first_ts = wgs_points.first['timestamp']
         if first_ts
-          fit_epoch = Time.new(1989, 12, 31, 0, 0, 0, "+00:00").to_i
+          fit_epoch = Time.new(1989, 12, 31, 0, 0, 0, '+00:00').to_i
           t = Time.at(fit_epoch + first_ts)
           @fit_start_utc = t.utc
-          @fit_start_local = t.getlocal("+08:00")
+          @fit_start_local = t.getlocal('+08:00')
         end
 
         write_standardized_json(wgs_points, ride_id)
-        polyline = Geo::Polyline.encode(wgs_points.map { |pt| [pt["positionLat"], pt["positionLong"]] })
+        polyline = Geo::Polyline.encode(wgs_points.map { |pt| [pt['positionLat'], pt['positionLong']] })
         sensor_summary = compute_sensor_summary(wgs_points)
 
         attrs = build_attrs(act, ride_id, polyline, sensor_summary)
@@ -110,7 +112,7 @@ module GitFit
       def get_download_url(ride_id)
         resp = Faraday.get("#{DOWNLOAD_URL}/#{ride_id}", {}, @auth_headers)
         return nil unless resp.status == 200
-        JSON.parse(resp.body)["data"]
+        JSON.parse(resp.body)['data']
       end
 
       def download_fit(url, ride_id)
@@ -128,7 +130,7 @@ module GitFit
         wgs_points = FIT::Decoder.decode(fit_path)
         return nil if wgs_points.empty?
 
-        Geo::Polyline.encode(wgs_points.map { |pt| [pt["positionLat"], pt["positionLong"]] })
+        Geo::Polyline.encode(wgs_points.map { |pt| [pt['positionLat'], pt['positionLong']] })
       end
 
       def write_standardized_json(wgs_points, ride_id)
@@ -146,30 +148,30 @@ module GitFit
           @auth_headers
         )
         return nil unless resp.status == 200
-        JSON.parse(resp.body).dig("data", "rows")
+        JSON.parse(resp.body).dig('data', 'rows')
       end
 
       def build_attrs(act, ride_id, polyline = nil, sensor = {})
-        type = map_sport(act["exerciseType"])
-        start_t = @fit_start_utc || parse_date(act["startTime"])
+        type = map_sport(act['exerciseType'])
+        start_t = @fit_start_utc || parse_date(act['startTime'])
         start_t_local = @fit_start_local || start_t
-        distance = act["rideDistance"].to_f
-        moving_time = (act["totalMovingTime"] || act["recordTime"]).to_i
-        avg_speed = act["avgSpeed"].to_f
+        distance = act['rideDistance'].to_f
+        moving_time = (act['totalMovingTime'] || act['recordTime']).to_i
+        avg_speed = act['avgSpeed'].to_f
 
         {
           run_id: "igpsport_#{ride_id}",
-          name: act["title"] || "iGPSPORT Activity",
+          name: act['title'] || 'iGPSPORT Activity',
           distance: distance,
           moving_time: moving_time > 0 ? moving_time : nil,
           elapsed_time: moving_time > 0 ? moving_time : nil,
           sport_category: type,
-          sport_type: EXERCISE_MAP[act["exerciseType"]] || "ride",
+          sport_type: EXERCISE_MAP[act['exerciseType']] || 'ride',
           start_date: start_t.iso8601,
           start_date_local: start_t_local.iso8601,
           location_country: nil,
-          average_heartrate: act["avgHrm"]&.to_f&.nonzero?,
-          max_heartrate: act["maxHrm"]&.to_f&.nonzero?,
+          average_heartrate: act['avgHrm']&.to_f&.nonzero?,
+          max_heartrate: act['maxHrm']&.to_f&.nonzero?,
           average_cadence: sensor[:average_cadence],
           max_cadence: sensor[:max_cadence],
           average_power: sensor[:average_power],
@@ -177,18 +179,18 @@ module GitFit
           calories: sensor[:calories],
           average_temperature: sensor[:average_temperature],
           average_speed: avg_speed > 0 ? avg_speed : nil,
-          elevation_gain: act["totalAscent"].to_f.nonzero?,
+          elevation_gain: act['totalAscent'].to_f.nonzero?,
           summary_polyline: polyline,
-          source: "igpsport"
+          source: 'igpsport',
         }
       end
 
       def compute_sensor_summary(records)
         return {} if records.empty?
 
-        cad = records.map { |r| r["cadence"] }.compact
-        pow = records.map { |r| r["power"] }.compact
-        tmp = records.map { |r| r["temperature"] }.compact
+        cad = records.map { |r| r['cadence'] }.compact
+        pow = records.map { |r| r['power'] }.compact
+        tmp = records.map { |r| r['temperature'] }.compact
 
         {
           average_cadence: cad.any? ? (cad.sum.to_f / cad.size).round(1) : nil,
@@ -196,25 +198,25 @@ module GitFit
           average_power: pow.any? ? (pow.sum.to_f / pow.size).round(1) : nil,
           max_power: pow.max,
           average_temperature: tmp.any? ? (tmp.sum.to_f / tmp.size).round(1) : nil,
-          calories: nil
+          calories: nil,
         }
       end
 
       def map_sport(exercise_type)
-        EXERCISE_MAP[exercise_type] || "other"
+        EXERCISE_MAP[exercise_type] || 'other'
       end
 
       def parse_date(str)
         return nil unless str
-        normalized = str.to_s.tr(".", "-")
+        normalized = str.to_s.tr('.', '-')
         Time.parse(normalized)
-      rescue
+      rescue StandardError
         nil
       end
 
       def existing_run_ids
-        @db[:activities].where(source: "igpsport").select_map(:run_id)
-          .map { |id| id.sub("igpsport_", "") }
+        @db[:activities].where(source: 'igpsport').select_map(:run_id)
+          .map { |id| id.sub('igpsport_', '') }
       end
 
       def raw_path(platform_id)