rueda 0.1.0

data/lib/rueda/cli.rb

@@ -0,0 +1,191 @@
+require "date"
+require "json"
+require "optparse"
+
+module Rueda
+  class CLI
+    FORMATS = %w[table json ndjson csv].freeze
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_DAYS = 30
+    DATE = /\A\d{4}-\d{2}-\d{2}\z/
+    ID = /\A[1-9]\d*\z/
+    BANNER = <<~TEXT.freeze
+      Usage: rueda COMMAND [options]
+
+      Commands:
+        auth check    Check the key and request a new token
+        activities    List activities (--since, --until, --type, --limit)
+        activity ID   Show one activity, or download its original file (--fit, -o, --force)
+        version       Print the version
+
+      Options:
+    TEXT
+
+    def initialize(stdout: $stdout, stderr: $stderr, env: ENV)
+      @stdout = stdout
+      @stderr = stderr
+      @env = env
+      @options = {timeout: DEFAULT_TIMEOUT, quiet: false, types: []}
+    end
+
+    def run(argv)
+      dispatch(command(argv))
+    rescue => e
+      error = as_rueda_error(e)
+      report(error)
+      exit(error.exit_status)
+    end
+
+    private
+
+    def command(argv)
+      args = parser.parse(argv)
+      @options[:command] || args
+    end
+
+    def parser
+      @parser ||= OptionParser.new(BANNER) do
+        it.require_exact = true
+        it.on("--format FORMAT", FORMATS) { @options[:format] = it }
+        it.on("--api-key-file PATH") { @options[:api_key_file] = it }
+        it.on("--timeout SECONDS", Float) { @options[:timeout] = it }
+        it.on("--raw") { @options[:raw] = true }
+        it.on("--quiet") { @options[:quiet] = true }
+        it.on("--since DATE") { @options[:since] = date(it) }
+        it.on("--until DATE") { @options[:until] = date(it) }
+        it.on("--type TYPE") { @options[:types] << it }
+        it.on("--limit N", Integer) { @options[:limit] = positive(it) }
+        it.on("--fit") { @options[:fit] = true }
+        it.on("-o", "--output FILE") { @options[:output] = it }
+        it.on("--force") { @options[:force] = true }
+        it.on("-h", "--help") { @options[:command] = ["help"] }
+        it.on("--version") { @options[:command] = ["version"] }
+      end
+    end
+
+    def dispatch(args)
+      case args
+      in ["auth", "check"] then auth_check
+      in ["activities"] then list_activities
+      in ["activity", ID => id] then @options[:fit] ? download_fit(Integer(id)) : show_activity(Integer(id))
+      in ["activity", *] then raise UsageError, "Usage: rueda activity ID, where ID is a Garmin activity ID."
+      in ["version"] then @stdout.puts(VERSION)
+      in ["help"] then @stdout.puts(parser.help)
+      else raise UsageError, "Unknown command. Run `rueda --help`."
+      end
+    end
+
+    def auth_check
+      expires_at = authenticator.fresh_token.expires_at
+      if table?
+        @stdout.puts("Token OK, valid until #{expires_at.localtime.strftime("%Y-%m-%d %H:%M %Z")}.")
+      else
+        @stdout.puts(JSON.generate(token_expires_at: expires_at.iso8601))
+      end
+    end
+
+    def list_activities
+      to = @options[:until] || Date.today
+      from = @options[:since] || (to - DEFAULT_DAYS)
+      raise UsageError, "--since must not be after --until." if from > to
+      check_raw_format
+
+      activities = Activities.new(client:, authenticator:)
+        .list(from:, to:, types: @options[:types], limit: @options[:limit], raw: raw?)
+      query = {since: from.iso8601, until: to.iso8601, type: @options[:types]}
+      emit(Output.activities(activities, format:, query:, raw: raw?))
+    end
+
+    def show_activity(id)
+      check_raw_format
+      activity = Activities.new(client:, authenticator:).find(id, raw: raw?)
+      emit(Output.activity(activity, format:, raw: raw?))
+    end
+
+    def download_fit(id)
+      path = @options[:output] || "activity-#{id}.zip"
+      raise UsageError, "Refusing to write a ZIP to a terminal. Redirect stdout or pass -o FILE." if path == "-" && @stdout.tty?
+
+      zip = Activities.new(client:, authenticator:).fit_file(id)
+      if path == "-"
+        @stdout.binmode.write(zip)
+      else
+        Output::SavedFile.write(path, zip, force: @options.fetch(:force, false))
+        info("saved #{path}")
+      end
+    end
+
+    def check_raw_format
+      raise UsageError, "--raw works only with --format json or ndjson." if raw? && !Output::RAW_FORMATS.include?(format)
+    end
+
+    def authenticator
+      @authenticator ||= Auth::Authenticator.new(
+        api_key:,
+        client:,
+        cache: Auth::TokenCache.new(path: config_path("token.json"), warn: method(:warn))
+      )
+    end
+
+    def client
+      @client ||= Garmin::Client.new(timeout: @options[:timeout])
+    end
+
+    def api_key
+      Auth::ApiKey.new(file: @options[:api_key_file], env: @env, default_path: config_path("api_key"),
+        warn: method(:warn)).value
+    end
+
+    def config_path(name)
+      File.join(@env["HOME"] || Dir.home, ".config", "rueda", name)
+    end
+
+    def date(text)
+      raise UsageError, "Dates must be YYYY-MM-DD." unless text.match?(DATE)
+
+      Date.iso8601(text)
+    rescue Date::Error
+      raise UsageError, "Dates must be YYYY-MM-DD."
+    end
+
+    def positive(number)
+      raise UsageError, "--limit must be a positive integer." unless number.positive?
+
+      number
+    end
+
+    def format
+      @options[:format] || ((@stdout.tty? && !raw?) ? "table" : "json")
+    end
+
+    def table? = format == "table"
+
+    def raw? = @options.fetch(:raw, false)
+
+    def emit(text)
+      @stdout.puts(text) unless text.empty?
+    end
+
+    def warn(message) = info("warning: #{message}")
+
+    def info(message)
+      @stderr.puts("rueda: #{message}") unless @options[:quiet]
+    end
+
+    def as_rueda_error(error)
+      case error
+      when Error then error
+      when OptionParser::ParseError then UsageError.new("#{error.reason}: #{error.args.first.to_s.split("=", 2).first}")
+      else Error.new("Unexpected error (#{error.class}).")
+      end
+    end
+
+    def report(error)
+      if table?
+        @stderr.puts("rueda: #{error.message}")
+      else
+        @stderr.puts(JSON.generate(error: {code: error.code, message: error.message}))
+      end
+    end
+  end
+end

data/lib/rueda/errors.rb

@@ -0,0 +1,50 @@
+module Rueda
+  class Error < StandardError
+    CODE = "unexpected"
+    EXIT_STATUS = 1
+
+    def code = self.class::CODE
+
+    def exit_status = self.class::EXIT_STATUS
+  end
+
+  class UsageError < Error
+    CODE = "usage"
+    EXIT_STATUS = 2
+  end
+
+  class NoApiKey < Error
+    CODE = "no_api_key"
+    EXIT_STATUS = 3
+  end
+
+  class AuthFailed < Error
+    CODE = "auth_failed"
+    EXIT_STATUS = 4
+  end
+
+  class NotFound < Error
+    CODE = "not_found"
+    EXIT_STATUS = 5
+  end
+
+  class RateLimited < Error
+    CODE = "rate_limited"
+    EXIT_STATUS = 6
+  end
+
+  class NetworkError < Error
+    CODE = "network"
+    EXIT_STATUS = 7
+  end
+
+  class BadResponse < Error
+    CODE = "bad_response"
+    EXIT_STATUS = 8
+  end
+
+  class GarminError < Error
+    CODE = "garmin_error"
+    EXIT_STATUS = 9
+  end
+end

data/lib/rueda/garmin/client.rb

@@ -0,0 +1,107 @@
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+require_relative "../errors"
+require_relative "../auth/token"
+
+module Rueda
+  module Garmin
+    class Client
+      HOST = URI("https://personal.connectapi.garmin.com")
+      TOKEN_PATH = "/personalapitoken-service/personal-api/personal-api-key/token".freeze
+      ACTIVITIES_PATH = "/activitylist-service/activities/search/activities".freeze
+      DETAIL_PATH = "/activity-service/activity/%d".freeze
+      FILE_PATH = "/download-service/files/activity/%d".freeze
+      PAGE_SIZE = 99
+      STATUS_ERRORS = {"401" => AuthFailed, "403" => AuthFailed, "404" => NotFound, "429" => RateLimited}.freeze
+      NETWORK_ERRORS = [Timeout::Error, SocketError, SystemCallError, OpenSSL::SSL::SSLError, IOError,
+        Net::ProtocolError].freeze
+
+      def initialize(timeout:)
+        @timeout = timeout
+      end
+
+      def token(api_key)
+        Auth::Token.new(post(TOKEN_PATH, authorization: "ApiKey #{api_key}").body.to_s.strip)
+      end
+
+      def each_activity(token, from:, to:, &)
+        return enum_for(__method__, token, from:, to:) unless block_given?
+
+        start = 0
+        loop do
+          page = activities_page(token, start:, from:, to:)
+          break if page.empty?
+
+          page.each(&)
+          start += page.size
+        end
+      end
+
+      def activity(token, id)
+        detail = parse(get(format(DETAIL_PATH, id), authorization: bearer(token)))
+        raise BadResponse, "The activity is not an object." unless detail.is_a?(Hash)
+
+        detail
+      end
+
+      def activity_file(token, id)
+        zip = get(format(FILE_PATH, id), authorization: bearer(token)).body.to_s
+        raise BadResponse, "The activity file is not a ZIP." unless zip.start_with?("PK")
+
+        zip
+      end
+
+      private
+
+      def bearer(token) = "Bearer #{token}"
+
+      def activities_page(token, start:, from:, to:)
+        query = URI.encode_www_form(start:, limit: PAGE_SIZE, startDate: from.iso8601, endDate: to.iso8601)
+        page = parse(get("#{ACTIVITIES_PATH}?#{query}", authorization: bearer(token)))
+        raise BadResponse, "The activity list is not a list." unless page.is_a?(Array)
+
+        page
+      end
+
+      def post(path, authorization:) = send_request(Net::HTTP::Post, path, authorization:)
+
+      def get(path, authorization:) = send_request(Net::HTTP::Get, path, authorization:)
+
+      def send_request(method, path, authorization:)
+        request = method.new(path)
+        request["Authorization"] = authorization
+        check(perform(request))
+      end
+
+      def perform(request)
+        http.request(request)
+      rescue Net::HTTPBadResponse
+        raise BadResponse, "Garmin sent a malformed HTTP response."
+      rescue *NETWORK_ERRORS => e
+        raise NetworkError, "Could not reach Garmin (#{e.class})."
+      end
+
+      def http
+        Net::HTTP.new(HOST.host, HOST.port).tap do
+          it.use_ssl = true
+          it.open_timeout = @timeout
+          it.read_timeout = @timeout
+        end
+      end
+
+      def check(response)
+        return response if response.is_a?(Net::HTTPSuccess)
+
+        raise STATUS_ERRORS.fetch(response.code, GarminError), "Garmin returned HTTP #{response.code}."
+      end
+
+      def parse(response)
+        JSON.parse(response.body.to_s)
+      rescue JSON::ParserError
+        raise BadResponse, "Garmin's response is not JSON."
+      end
+    end
+  end
+end

data/lib/rueda/model/activity.rb

@@ -0,0 +1,24 @@
+module Rueda
+  module Model
+    Activity = Data.define(
+      :garmin_id,
+      :name,
+      :type,
+      :started_at,
+      :local_date,
+      :distance_km,
+      :moving_time_s,
+      :elapsed_time_s,
+      :avg_speed_kmh,
+      :max_speed_kmh,
+      :elevation_gain_m,
+      :elevation_loss_m,
+      :avg_hr_bpm,
+      :max_hr_bpm,
+      :avg_power_w,
+      :calories,
+      :avg_cadence_rpm,
+      :max_cadence_rpm
+    )
+  end
+end

data/lib/rueda/normalize/activity.rb

@@ -0,0 +1,139 @@
+require "date"
+require "time"
+require_relative "../errors"
+require_relative "../model/activity"
+
+module Rueda
+  module Normalize
+    class Activity
+      TYPE_KEY = %w[activityType typeKey].freeze
+      START_TIME = /\A(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})/
+      MPS_TO_KMH = 3.6
+      FIELDS = {
+        distance: "distance",
+        moving: "movingDuration",
+        elapsed: "elapsedDuration",
+        max_speed: "maxSpeed",
+        elevation_gain: "elevationGain",
+        elevation_loss: "elevationLoss",
+        avg_hr: "averageHR",
+        max_hr: "maxHR",
+        avg_power: "avgPower",
+        calories: "calories",
+        avg_cadence: "averageBikingCadenceInRevPerMinute",
+        max_cadence: "maxBikingCadenceInRevPerMinute"
+      }.freeze
+
+      def self.call(raw) = new(raw).call
+
+      def self.type(raw) = new(raw).type
+
+      def initialize(raw)
+        raise BadResponse, "An activity is not an object." unless raw.is_a?(Hash)
+
+        @raw = raw
+      end
+
+      def call
+        Model::Activity.new(
+          garmin_id:, name:, type:, started_at:, local_date:, distance_km:, moving_time_s:, elapsed_time_s:,
+          avg_speed_kmh:, max_speed_kmh:, elevation_gain_m:, elevation_loss_m:, avg_hr_bpm:, max_hr_bpm:,
+          avg_power_w:, calories:, avg_cadence_rpm:, max_cadence_rpm:
+        )
+      rescue TypeError, ArgumentError
+        raise BadResponse, "An activity has fields of an unexpected type."
+      end
+
+      def type
+        required(@raw, *self.class::TYPE_KEY)
+      rescue TypeError
+        raise BadResponse, "An activity has an activity type of an unexpected type."
+      end
+
+      private
+
+      def summary = @raw
+
+      def garmin_id = Integer(required(@raw, "activityId"))
+
+      def name = @raw["activityName"]
+
+      def started_at
+        date, time = start("startTimeGMT")
+        Time.strptime("#{date} #{time} +00:00", "%Y-%m-%d %H:%M:%S %z").utc.iso8601
+      end
+
+      def local_date
+        date, = start("startTimeLocal")
+        Date.iso8601(date).iso8601
+      end
+
+      def distance_km = decimal(measure(:distance)&./(1000))
+
+      def moving_time_s = whole(measure(:moving))
+
+      def elapsed_time_s = whole(measure(:elapsed))
+
+      def avg_speed_kmh
+        meters = measure(:distance)
+        seconds = measure(:moving) || measure(:elapsed)
+        return if meters.nil? || seconds.nil? || seconds.zero?
+
+        decimal(meters / seconds * MPS_TO_KMH)
+      end
+
+      def max_speed_kmh = decimal(measure(:max_speed)&.*(MPS_TO_KMH))
+
+      def elevation_gain_m = whole(measure(:elevation_gain))
+
+      def elevation_loss_m = whole(measure(:elevation_loss))
+
+      def avg_hr_bpm = whole(measure(:avg_hr))
+
+      def max_hr_bpm = whole(measure(:max_hr))
+
+      def avg_power_w = whole(measure(:avg_power))
+
+      def calories = whole(measure(:calories))
+
+      def avg_cadence_rpm = whole(measure(:avg_cadence))
+
+      def max_cadence_rpm = whole(measure(:max_cadence))
+
+      def start(field)
+        match = START_TIME.match(required(summary, field))
+        raise BadResponse, "An activity has a malformed #{field}." unless match
+
+        match.captures
+      end
+
+      def measure(name) = summary[self.class::FIELDS.fetch(name)]
+
+      def required(source, *keys)
+        source.dig(*keys) || raise(BadResponse, "An activity has no #{keys.join(".")}.")
+      end
+
+      def whole(number) = number&.round
+
+      def decimal(number) = number&.round(1)
+    end
+
+    class ActivityDetail < Activity
+      TYPE_KEY = %w[activityTypeDTO typeKey].freeze
+      FIELDS = Activity::FIELDS.merge(
+        avg_power: "averagePower",
+        avg_cadence: "averageBikeCadence",
+        max_cadence: "maxBikeCadence"
+      ).freeze
+
+      private
+
+      def summary
+        detail_summary = @raw["summaryDTO"]
+        raise BadResponse, "An activity has no summaryDTO." unless detail_summary.is_a?(Hash)
+
+        detail_summary
+      end
+    end
+  end
+end

data/lib/rueda/output/csv.rb

@@ -0,0 +1,15 @@
+require "csv"
+require_relative "../model/activity"
+
+module Rueda
+  module Output
+    module Csv
+      def self.activities(activities)
+        CSV.generate do |csv|
+          csv << Model::Activity.members
+          activities.each { csv << it.deconstruct }
+        end
+      end
+    end
+  end
+end

data/lib/rueda/output/json.rb

@@ -0,0 +1,22 @@
+require "json"
+
+module Rueda
+  module Output
+    module Json
+      SCHEMA_VERSION = 1
+
+      def self.activities(activities, query:)
+        JSON.generate(
+          schema_version: SCHEMA_VERSION,
+          query:,
+          count: activities.size,
+          activities: activities.map(&:to_h)
+        )
+      end
+
+      def self.activity(activity)
+        JSON.generate(schema_version: SCHEMA_VERSION, activity: activity.to_h)
+      end
+    end
+  end
+end

data/lib/rueda/output/ndjson.rb

@@ -0,0 +1,11 @@
+require "json"
+
+module Rueda
+  module Output
+    module Ndjson
+      def self.activities(activities)
+        activities.map { JSON.generate(it.to_h) }.join("\n")
+      end
+    end
+  end
+end

data/lib/rueda/output/saved_file.rb

@@ -0,0 +1,17 @@
+require_relative "../errors"
+
+module Rueda
+  module Output
+    module SavedFile
+      NEW_FILE = File::WRONLY | File::CREAT | File::EXCL | File::BINARY
+
+      def self.write(path, bytes, force:)
+        File.open(path, force ? "wb" : NEW_FILE) { it.write(bytes) }
+      rescue Errno::EEXIST
+        raise UsageError, "#{path} already exists. Use --force to overwrite it."
+      rescue SystemCallError => e
+        raise Error, "Could not write #{path} (#{e.class})."
+      end
+    end
+  end
+end

data/lib/rueda/output/table.rb

@@ -0,0 +1,57 @@
+module Rueda
+  module Output
+    class Table
+      MISSING = "—".freeze
+      COLUMNS = {
+        "DATE" => :local_date,
+        "TYPE" => :type,
+        "NAME" => :name,
+        "KM" => :distance_km,
+        "MOVING" => :moving_time_s,
+        "KM/H" => :avg_speed_kmh,
+        "ELEV" => :elevation_gain_m,
+        "HR" => :avg_hr_bpm,
+        "CAD" => :avg_cadence_rpm
+      }.freeze
+
+      def self.activities(activities) = new(activities).to_s
+
+      def initialize(activities)
+        @rows = [COLUMNS.keys] + activities.map { row(it) }
+      end
+
+      def to_s
+        @rows.map { line(it) }.join("\n")
+      end
+
+      private
+
+      def row(activity)
+        COLUMNS.values.map { cell(activity, it) }
+      end
+
+      def cell(activity, field)
+        value = activity.public_send(field)
+        return MISSING if value.nil?
+
+        (field == :moving_time_s) ? duration(value) : printable(value.to_s)
+      end
+
+      def printable(text)
+        text.gsub(/[[:cntrl:]]/, "")
+      end
+
+      def duration(seconds)
+        format("%d:%02d:%02d", seconds / 3600, seconds % 3600 / 60, seconds % 60)
+      end
+
+      def line(cells)
+        cells.zip(widths).map { |cell, width| cell.ljust(width) }.join("  ").rstrip
+      end
+
+      def widths
+        @widths ||= @rows.transpose.map { |column| column.map(&:length).max }
+      end
+    end
+  end
+end

data/lib/rueda/output.rb

@@ -0,0 +1,30 @@
+require "json"
+require_relative "output/csv"
+require_relative "output/json"
+require_relative "output/ndjson"
+require_relative "output/saved_file"
+require_relative "output/table"
+
+module Rueda
+  module Output
+    RAW_FORMATS = %w[json ndjson].freeze
+
+    def self.activities(activities, format:, query:, raw:)
+      case [format, raw]
+      in ["json", false] then Json.activities(activities, query:)
+      in ["json", true] then JSON.generate(activities)
+      in ["ndjson", _] then Ndjson.activities(activities)
+      in ["csv", false] then Csv.activities(activities)
+      in ["table", false] then Table.activities(activities)
+      end
+    end
+
+    def self.activity(activity, format:, raw:)
+      case [format, raw]
+      in ["json", false] then Json.activity(activity)
+      in ["json" | "ndjson", true] then JSON.generate(activity)
+      else activities([activity], format:, query: nil, raw:)
+      end
+    end
+  end
+end

data/lib/rueda/version.rb

@@ -0,0 +1,3 @@
+module Rueda
+  VERSION = "0.1.0".freeze
+end

data/lib/rueda.rb

@@ -0,0 +1,13 @@
+require_relative "rueda/version"
+require_relative "rueda/errors"
+require_relative "rueda/auth/secret_file"
+require_relative "rueda/auth/token"
+require_relative "rueda/auth/api_key"
+require_relative "rueda/auth/token_cache"
+require_relative "rueda/auth/authenticator"
+require_relative "rueda/garmin/client"
+require_relative "rueda/model/activity"
+require_relative "rueda/normalize/activity"
+require_relative "rueda/output"
+require_relative "rueda/activities"
+require_relative "rueda/cli"