fit_doctor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e671e26d71c72c773db9def073622d3f543f71e61b3081d2ee4dd60932e30043
+  data.tar.gz: 3c87d3926558355ee92d8a0103c57d4d388624190bb0a1787b68098ed0bacbff
+SHA512:
+  metadata.gz: '08373c8ff41002ba445d7acaf8571eb24495b989ed752cb48d6b23f4479ec254f16cb1b1f8004d4a3c7e9f8ba907a67cf1cf24b8d02af5f4bbc4e4d251dce864'
+  data.tar.gz: 11782fda2ee55559126654f27c8c9fb048ffe88ae5c316f79d862d39ee063f9a3a55aabbed6ee6dbee6b8989eb44010c8ecf71657c2fb83e21f1cd93da13d539

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 copilot-swe-agent[bot]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# Fit Doctor
+
+A Ruby gem for reading Garmin FIT files with a `gpx-doctor`-style interface.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "fit_doctor"
+```
+
+Or install directly:
+
+```bash
+gem install fit_doctor
+```
+
+## Configuration
+
+```ruby
+FitDoctor.configure do |config|
+  config.decode_scaled_values = true   # default true
+  config.convert_timestamps   = true   # default true
+  config.convert_coordinates  = true   # default true
+  config.symbolize_enums      = true   # default true
+end
+
+FitDoctor.configuration.convert_timestamps # => true
+FitDoctor.reset_configuration!
+```
+
+## Parsing
+
+### From a file
+
+```ruby
+result = FitDoctor::Parser.parse("path/to/activity.fit")
+```
+
+### Example `.fit` files in this repository
+
+You can use the bundled fixture files for local testing:
+
+- `spec/fixtures/example_running.fit`
+- `spec/fixtures/example_cycling.fit`
+
+### From binary data
+
+```ruby
+binary = File.binread("path/to/activity.fit")
+result = FitDoctor::Parser.parse_data(binary)
+```
+
+### Parse raw values (no conversion)
+
+```ruby
+result = FitDoctor::Parser.parse("path/to/activity.fit", params: { raw_values: true })
+```
+
+## Result interface
+
+```ruby
+result.file_id       # => first :file_id message or nil
+result.records       # => array of :record messages
+result.points        # => alias for records
+result.sessions      # => array of :session messages
+result.laps          # => array of :lap messages
+result.events        # => array of :event messages
+result.activities    # => array of :activity messages
+result.workouts      # => array of :workout messages
+result.courses       # => array of :course messages
+result.course_points # => array of :course_point messages
+result.monitoring    # => array of :monitoring messages
+result.message_types # => all parsed message types
+result.by_type(:device_info)
+```
+
+Each message is an object with named attributes and metadata:
+
+```ruby
+record = result.records.first
+record.timestamp
+record.position_lat
+record.speed
+record.fields                  # hash of all decoded fields
+record.name                    # :record
+record.global_message_number   # 20
+record.local_message_type      # local definition number
+```
+
+## Supported decoding behavior
+
+- FIT header parsing and validation (`.FIT` magic, optional header/data CRC checks)
+- Definition and data message decoding (including compressed timestamp headers)
+- Scale/offset conversions for common fields (speed, distance, altitude, times)
+- Semicircle-to-degree coordinate conversion
+- FIT epoch timestamp conversion (`1989-12-31`)
+- Enum decoding for common profile values
+- Developer field decoding when `field_description` metadata is present
+
+The parser keeps unknown message/field data so FIT files with additional message types are still readable.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+## License
+
+MIT

data/lib/avo/concerns/events/verification.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Avo
+  module Concerns
+    module Events
+      Verification = ::Constans::Events::Verification unless const_defined?(:Verification, false)
+    end
+  end
+end

data/lib/constans/events/verification.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Constans
+  module Events
+    class Verification
+    end
+  end
+end

data/lib/fit_doctor/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FitDoctor
+  class Configuration
+    attr_accessor :decode_scaled_values,
+                  :convert_timestamps,
+                  :convert_coordinates,
+                  :symbolize_enums
+
+    def initialize
+      @decode_scaled_values = true
+      @convert_timestamps = true
+      @convert_coordinates = true
+      @symbolize_enums = true
+    end
+  end
+end

data/lib/fit_doctor/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FitDoctor
+  class Error < StandardError; end
+  class InvalidFitError < Error; end
+end

data/lib/fit_doctor/models/message.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module FitDoctor
+  module Models
+    class Message < OpenStruct
+      attr_reader :name, :global_message_number, :local_message_type
+
+      def initialize(name:, global_message_number:, local_message_type:, fields:)
+        @name = name
+        @global_message_number = global_message_number
+        @local_message_type = local_message_type
+        super(fields)
+      end
+
+      def fields
+        to_h
+      end
+    end
+  end
+end

data/lib/fit_doctor/parser.rb

@@ -0,0 +1,601 @@
+# frozen_string_literal: true
+
+module FitDoctor
+  class Parser
+    FIT_MAGIC = ".FIT"
+    MIN_HEADER_SIZE = 12
+
+    CRC_TABLE = [
+      0x0000, 0xCC01, 0xD801, 0x1400,
+      0xF001, 0x3C00, 0x2800, 0xE401,
+      0xA001, 0x6C00, 0x7800, 0xB401,
+      0x5000, 0x9C01, 0x8801, 0x4400
+    ].freeze
+
+    BASE_TYPES = {
+      0 => { size: 1, kind: :uint8, invalid: 0xFF },
+      1 => { size: 1, kind: :sint8, invalid: 0x7F },
+      2 => { size: 1, kind: :uint8, invalid: 0xFF },
+      3 => { size: 2, kind: :sint16, invalid: 0x7FFF },
+      4 => { size: 2, kind: :uint16, invalid: 0xFFFF },
+      5 => { size: 4, kind: :sint32, invalid: 0x7FFFFFFF },
+      6 => { size: 4, kind: :uint32, invalid: 0xFFFFFFFF },
+      7 => { size: 1, kind: :string, invalid: 0x00 },
+      8 => { size: 4, kind: :float32 },
+      9 => { size: 8, kind: :float64 },
+      10 => { size: 1, kind: :uint8, invalid: 0x00 },
+      11 => { size: 2, kind: :uint16, invalid: 0x0000 },
+      12 => { size: 4, kind: :uint32, invalid: 0x00000000 },
+      13 => { size: 1, kind: :byte, invalid: 0xFF },
+      14 => { size: 8, kind: :sint64, invalid: 0x7FFFFFFFFFFFFFFF },
+      15 => { size: 8, kind: :uint64, invalid: 0xFFFFFFFFFFFFFFFF },
+      16 => { size: 8, kind: :uint64, invalid: 0x0000000000000000 }
+    }.freeze
+
+    Result = Struct.new(:messages, :messages_by_type, keyword_init: true) do
+      def by_type(type)
+        messages_by_type.fetch(type.to_sym, [])
+      end
+
+      def message_types
+        messages_by_type.keys
+      end
+
+      def file_id
+        by_type(:file_id).first
+      end
+
+      def sessions
+        by_type(:session)
+      end
+
+      def laps
+        by_type(:lap)
+      end
+
+      def records
+        by_type(:record)
+      end
+
+      def points
+        records
+      end
+
+      def events
+        by_type(:event)
+      end
+
+      def activities
+        by_type(:activity)
+      end
+
+      def workouts
+        by_type(:workout)
+      end
+
+      def courses
+        by_type(:course)
+      end
+
+      def course_points
+        by_type(:course_point)
+      end
+
+      def monitoring
+        by_type(:monitoring)
+      end
+    end
+
+    DefinitionMessage = Struct.new(
+      :global_message_number,
+      :little_endian,
+      :fields,
+      :developer_fields,
+      :profile,
+      keyword_init: true
+    )
+
+    DefinitionField = Struct.new(:number, :size, :base_type, keyword_init: true)
+
+    DeveloperDefinitionField = Struct.new(
+      :number,
+      :size,
+      :developer_data_index,
+      keyword_init: true
+    )
+
+    class << self
+      def parse(file_path, params: {})
+        parse_data(File.binread(file_path), params: params)
+      end
+
+      def parse_data(binary_data, params: {})
+        new(binary_data, params: params).parse
+      end
+    end
+
+    def initialize(binary_data, params: {})
+      @binary_data = binary_data
+      @params = params
+      @definitions = {}
+      @last_timestamps = {}
+      @developer_field_descriptions = {}
+    end
+
+    def parse
+      header = parse_header
+      validate_header_crc!(header)
+      validate_file_crc!(header)
+
+      data_section = read_exact(@binary_data, header[:header_size], header[:data_size], "FIT data section")
+      messages = parse_records(data_section)
+      by_type = Hash.new { |hash, key| hash[key] = [] }
+      messages.each { |message| by_type[message.name] << message }
+
+      Result.new(messages: messages, messages_by_type: by_type)
+    end
+
+    private
+
+    def parse_header
+      raise InvalidFitError, "FIT file is too short" if @binary_data.bytesize < MIN_HEADER_SIZE
+
+      header_size = @binary_data.getbyte(0)
+      raise InvalidFitError, "Invalid FIT header size" if header_size.nil? || header_size < MIN_HEADER_SIZE
+      raise InvalidFitError, "FIT header is truncated" if header_size > @binary_data.bytesize
+
+      data_type = read_exact(@binary_data, 8, 4, "FIT header data type")
+      raise InvalidFitError, "Invalid FIT header magic" unless data_type == FIT_MAGIC
+
+      protocol_version = @binary_data.getbyte(1)
+      profile_version = unpack_uint16(read_exact(@binary_data, 2, 2, "FIT profile version"), true)
+      data_size = unpack_uint32(read_exact(@binary_data, 4, 4, "FIT data size"), true)
+
+      expected_min_size = header_size + data_size
+      raise InvalidFitError, "FIT data section is truncated" if expected_min_size > @binary_data.bytesize
+
+      header_crc = nil
+      if header_size > MIN_HEADER_SIZE
+        header_crc = unpack_uint16(read_exact(@binary_data, header_size - 2, 2, "FIT header CRC"), true)
+      end
+
+      {
+        header_size: header_size,
+        protocol_version: protocol_version,
+        profile_version: profile_version,
+        data_size: data_size,
+        header_crc: header_crc
+      }
+    end
+
+    def validate_header_crc!(header)
+      return unless header[:header_crc]
+
+      crc_payload = read_exact(@binary_data, 0, header[:header_size] - 2, "FIT header CRC payload")
+      calculated = crc16(crc_payload)
+      return if calculated == header[:header_crc]
+
+      raise InvalidFitError, "FIT header CRC mismatch"
+    end
+
+    def validate_file_crc!(header)
+      data_start = header[:header_size]
+      data_end = data_start + header[:data_size]
+      return if @binary_data.bytesize < data_end + 2
+
+      expected_crc = unpack_uint16(read_exact(@binary_data, data_end, 2, "FIT file CRC"), true)
+
+      crc_data_only = crc16(read_exact(@binary_data, data_start, header[:data_size], "FIT data section"))
+      return if expected_crc == crc_data_only
+
+      crc_header_and_data = crc16(read_exact(@binary_data, 0, data_end, "FIT header and data"))
+      return if expected_crc == crc_header_and_data
+
+      raise InvalidFitError, "FIT file CRC mismatch"
+    end
+
+    def parse_records(data_section)
+      messages = []
+      offset = 0
+
+      while offset < data_section.bytesize
+        record_header = data_section.getbyte(offset)
+        raise InvalidFitError, "Invalid FIT record header" if record_header.nil?
+
+        offset += 1
+
+        if compressed_timestamp_header?(record_header)
+          local_message_type = (record_header >> 5) & 0x03
+          timestamp_offset = record_header & 0x1F
+          definition = fetch_definition(local_message_type)
+          fields, consumed, raw_timestamp = parse_data_message_fields(data_section, offset, definition)
+          offset += consumed
+
+          raw_timestamp ||= expand_compressed_timestamp(local_message_type, timestamp_offset)
+          fields[:timestamp] = convert_timestamp(raw_timestamp) unless fields.key?(:timestamp)
+          @last_timestamps[local_message_type] = raw_timestamp
+
+          message = build_message(definition, local_message_type, fields)
+          track_developer_field_description(message)
+          messages << message
+          next
+        end
+
+        local_message_type = record_header & 0x0F
+        if (record_header & 0x40) != 0
+          definition, consumed = parse_definition_message(data_section, offset, developer_data: (record_header & 0x20) != 0)
+          offset += consumed
+          @definitions[local_message_type] = definition
+          next
+        end
+
+        definition = fetch_definition(local_message_type)
+        fields, consumed, raw_timestamp = parse_data_message_fields(data_section, offset, definition)
+        offset += consumed
+        @last_timestamps[local_message_type] = raw_timestamp if raw_timestamp
+
+        message = build_message(definition, local_message_type, fields)
+        track_developer_field_description(message)
+        messages << message
+      end
+
+      messages
+    end
+
+    def parse_definition_message(data_section, offset, developer_data:)
+      start_offset = offset
+      read_exact(data_section, offset, 5, "FIT definition message")
+
+      architecture = data_section.getbyte(offset + 1)
+      little_endian = architecture == 0
+      global_message_number = unpack_uint16(read_exact(data_section, offset + 2, 2, "FIT global message number"), little_endian)
+      number_of_fields = data_section.getbyte(offset + 4)
+
+      offset += 5
+      fields = []
+      number_of_fields.times do
+        field_blob = read_exact(data_section, offset, 3, "FIT field definition")
+        fields << DefinitionField.new(
+          number: field_blob.getbyte(0),
+          size: field_blob.getbyte(1),
+          base_type: field_blob.getbyte(2)
+        )
+        offset += 3
+      end
+
+      developer_fields = []
+      if developer_data
+        number_of_developer_fields = data_section.getbyte(offset)
+        raise InvalidFitError, "Invalid FIT developer field definition" if number_of_developer_fields.nil?
+
+        offset += 1
+        number_of_developer_fields.times do
+          field_blob = read_exact(data_section, offset, 3, "FIT developer field definition")
+          developer_fields << DeveloperDefinitionField.new(
+            number: field_blob.getbyte(0),
+            size: field_blob.getbyte(1),
+            developer_data_index: field_blob.getbyte(2)
+          )
+          offset += 3
+        end
+      end
+
+      definition = DefinitionMessage.new(
+        global_message_number: global_message_number,
+        little_endian: little_endian,
+        fields: fields,
+        developer_fields: developer_fields,
+        profile: Profile.message_profile(global_message_number)
+      )
+
+      [definition, offset - start_offset]
+    end
+
+    def parse_data_message_fields(data_section, offset, definition)
+      start_offset = offset
+      fields = {}
+      raw_timestamp = nil
+
+      definition.fields.each do |field_definition|
+        value_blob = read_exact(data_section, offset, field_definition.size, "FIT field value")
+        offset += field_definition.size
+
+        base_type_id = base_type_id(field_definition.base_type)
+        raw_value = decode_base_value(value_blob, base_type_id, definition.little_endian)
+
+        field_profile = definition.profile[:fields][field_definition.number]
+        field_name = field_profile&.fetch(:name, nil) || :"field_#{field_definition.number}"
+
+        raw_timestamp = raw_value if field_name == :timestamp && raw_value
+        value = apply_field_conversion(raw_value, field_profile)
+        fields[field_name] = value unless value.nil?
+      end
+
+      definition.developer_fields.each do |field_definition|
+        value_blob = read_exact(data_section, offset, field_definition.size, "FIT developer field value")
+        offset += field_definition.size
+
+        descriptor = @developer_field_descriptions[[field_definition.developer_data_index, field_definition.number]]
+        base_type = descriptor&.dig(:fit_base_type_id)
+
+        raw_value = if base_type
+                      decode_base_value(value_blob, base_type_id(base_type), definition.little_endian)
+                    elsif field_definition.size == 1
+                      value_blob.getbyte(0)
+                    else
+                      value_blob.bytes
+                    end
+
+        field_name = developer_field_name(field_definition, descriptor)
+        value = apply_field_conversion(raw_value, descriptor)
+        fields[field_name] = value unless value.nil?
+      end
+
+      [fields, offset - start_offset, raw_timestamp]
+    end
+
+    def build_message(definition, local_message_type, fields)
+      Models::Message.new(
+        name: definition.profile[:name],
+        global_message_number: definition.global_message_number,
+        local_message_type: local_message_type,
+        fields: fields
+      )
+    end
+
+    def fetch_definition(local_message_type)
+      definition = @definitions[local_message_type]
+      return definition if definition
+
+      raise InvalidFitError, "Missing FIT definition for local message type #{local_message_type}"
+    end
+
+    def track_developer_field_description(message)
+      return unless message.name == :field_description
+
+      developer_data_index = message.developer_data_index
+      field_definition_number = message.field_definition_number
+      fit_base_type_id = message.fit_base_type_id
+
+      return if developer_data_index.nil? || field_definition_number.nil? || fit_base_type_id.nil?
+
+      @developer_field_descriptions[[developer_data_index, field_definition_number]] = {
+        field_name: message.field_name,
+        fit_base_type_id: fit_base_type_id,
+        units: message.units
+      }
+    end
+
+    def developer_field_name(field_definition, descriptor)
+      normalized = normalize_field_name(descriptor&.dig(:field_name))
+      return normalized if normalized
+
+      :"developer_#{field_definition.developer_data_index}_field_#{field_definition.number}"
+    end
+
+    def normalize_field_name(value)
+      return nil if value.nil?
+
+      candidate = value.to_s.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/\A_|_\z/, "")
+      return nil if candidate.empty?
+
+      candidate.to_sym
+    end
+
+    def compressed_timestamp_header?(header)
+      (header & 0x80) != 0
+    end
+
+    def expand_compressed_timestamp(local_message_type, offset)
+      base = @last_timestamps[local_message_type]
+      return offset unless base
+
+      expanded = (base & 0xFFFFFFE0) + offset
+      expanded += 0x20 if expanded < base
+      expanded
+    end
+
+    def apply_field_conversion(value, field_profile)
+      return value if value.nil?
+      return value if raw_values?
+
+      converted = value
+
+      if convert_timestamps? && field_profile && %i[date_time local_date_time].include?(field_profile[:type])
+        converted = convert_timestamp(converted)
+      end
+
+      if convert_coordinates? && field_profile && field_profile[:type] == :semicircles
+        converted = convert_semicircles(converted)
+      end
+
+      if decode_scaled_values? && field_profile && (field_profile[:scale] || field_profile[:offset])
+        converted = convert_scaled_value(converted, field_profile)
+      end
+
+      if symbolize_enums? && field_profile && field_profile[:enum]
+        converted = convert_enum_value(converted, field_profile[:enum])
+      end
+
+      converted
+    end
+
+    def convert_timestamp(value)
+      convert_container(value) do |item|
+        next item unless item.is_a?(Numeric)
+
+        Profile::FIT_EPOCH + item
+      end
+    end
+
+    def convert_semicircles(value)
+      convert_container(value) do |item|
+        next item unless item.is_a?(Numeric)
+
+        item.to_f * Profile::SEMICIRCLE_TO_DEGREES
+      end
+    end
+
+    def convert_scaled_value(value, field_profile)
+      convert_container(value) do |item|
+        next item unless item.is_a?(Numeric)
+
+        converted = item.to_f
+        converted /= field_profile[:scale] if field_profile[:scale]
+        converted -= field_profile[:offset] if field_profile[:offset]
+        converted
+      end
+    end
+
+    def convert_enum_value(value, enum_type)
+      mapping = Profile.enum_mapping(enum_type)
+      return value unless mapping
+
+      convert_container(value) { |item| mapping.fetch(item, item) }
+    end
+
+    def convert_container(value)
+      if value.is_a?(Array)
+        value.map { |item| yield(item) }
+      else
+        yield(value)
+      end
+    end
+
+    def raw_values?
+      @params[:raw_values] == true
+    end
+
+    def decode_scaled_values?
+      return false if raw_values?
+
+      param_or_config(:decode_scaled_values)
+    end
+
+    def convert_timestamps?
+      return false if raw_values?
+
+      param_or_config(:convert_timestamps)
+    end
+
+    def convert_coordinates?
+      return false if raw_values?
+
+      param_or_config(:convert_coordinates)
+    end
+
+    def symbolize_enums?
+      return false if raw_values?
+
+      param_or_config(:symbolize_enums)
+    end
+
+    def param_or_config(key)
+      return @params[key] unless @params[key].nil?
+
+      FitDoctor.configuration.public_send(key)
+    end
+
+    def read_exact(data, offset, size, label)
+      chunk = data.byteslice(offset, size)
+      if chunk.nil? || chunk.bytesize != size
+        raise InvalidFitError, "Unexpected end of FIT file while reading #{label}"
+      end
+
+      chunk
+    end
+
+    def base_type_id(value)
+      value & 0x1F
+    end
+
+    def decode_base_value(blob, base_type_id_value, little_endian)
+      definition = BASE_TYPES[base_type_id_value]
+      return blob.bytes if definition.nil?
+
+      kind = definition[:kind]
+      element_size = definition[:size]
+
+      if kind == :string
+        text = blob.delete("\0").strip
+        return text.empty? ? nil : text
+      end
+
+      if kind == :byte
+        return blob.bytes if blob.bytesize > 1
+
+        value = blob.getbyte(0)
+        return nil if value == definition[:invalid]
+
+        return value
+      end
+
+      if blob.bytesize == element_size
+        decode_scalar(blob, kind, definition[:invalid], little_endian)
+      elsif (blob.bytesize % element_size).zero?
+        values = blob.bytes.each_slice(element_size).map do |slice|
+          decode_scalar(slice.pack("C*"), kind, definition[:invalid], little_endian)
+        end
+        values.all?(&:nil?) ? nil : values
+      else
+        blob.bytes
+      end
+    end
+
+    def decode_scalar(blob, kind, invalid_value, little_endian)
+      if %i[float32 float64].include?(kind) && blob.bytes.all?(0xFF)
+        return nil
+      end
+
+      unpack_directive = case kind
+                         when :sint8 then "c"
+                         when :uint8 then "C"
+                         when :sint16 then little_endian ? "s<" : "s>"
+                         when :uint16 then little_endian ? "S<" : "S>"
+                         when :sint32 then little_endian ? "l<" : "l>"
+                         when :uint32 then little_endian ? "L<" : "L>"
+                         when :sint64 then little_endian ? "q<" : "q>"
+                         when :uint64 then little_endian ? "Q<" : "Q>"
+                         when :float32 then little_endian ? "e" : "g"
+                         when :float64 then little_endian ? "E" : "G"
+                         else
+                           nil
+                         end
+
+      return blob.bytes if unpack_directive.nil?
+
+      value = blob.unpack1(unpack_directive)
+      return nil if !invalid_value.nil? && value == invalid_value
+
+      value
+    end
+
+    def unpack_uint16(blob, little_endian)
+      blob.unpack1(little_endian ? "S<" : "S>")
+    end
+
+    def unpack_uint32(blob, little_endian)
+      blob.unpack1(little_endian ? "L<" : "L>")
+    end
+
+    def crc16(data)
+      crc = 0
+
+      data.each_byte do |byte|
+        crc = crc_update(crc, byte)
+      end
+
+      crc
+    end
+
+    def crc_update(crc, byte)
+      tmp = CRC_TABLE[crc & 0x0F]
+      crc = (crc >> 4) & 0x0FFF
+      crc ^= tmp ^ CRC_TABLE[byte & 0x0F]
+
+      tmp = CRC_TABLE[crc & 0x0F]
+      crc = (crc >> 4) & 0x0FFF
+      crc ^ tmp ^ CRC_TABLE[(byte >> 4) & 0x0F]
+    end
+  end
+end

data/lib/fit_doctor/profile.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+module FitDoctor
+  module Profile
+    FIT_EPOCH = Time.utc(1989, 12, 31).freeze
+    SEMICIRCLE_TO_DEGREES = 180.0 / (2**31)
+
+    ENUMS = {
+      file: {
+        1 => :device,
+        2 => :settings,
+        3 => :sport,
+        4 => :activity,
+        5 => :workout,
+        6 => :course,
+        7 => :schedules,
+        9 => :weight,
+        10 => :totals,
+        11 => :goals,
+        14 => :blood_pressure,
+        15 => :monitoring_a,
+        20 => :activity_summary,
+        28 => :monitoring_daily,
+        32 => :monitoring_b
+      },
+      gender: {
+        0 => :female,
+        1 => :male
+      },
+      sport: {
+        0 => :generic,
+        1 => :running,
+        2 => :cycling,
+        3 => :transition,
+        4 => :fitness_equipment,
+        5 => :swimming,
+        6 => :basketball,
+        7 => :soccer,
+        8 => :tennis,
+        9 => :american_football,
+        10 => :training,
+        11 => :walking,
+        15 => :rowing,
+        16 => :mountaineering,
+        17 => :hiking,
+        18 => :multisport,
+        19 => :paddling
+      },
+      sub_sport: {
+        0 => :generic,
+        1 => :treadmill,
+        2 => :street,
+        3 => :trail,
+        4 => :track,
+        5 => :spin,
+        6 => :indoor_cycling,
+        17 => :lap_swimming,
+        18 => :open_water,
+        19 => :flexibility,
+        20 => :strength_training,
+        25 => :indoor_rowing,
+        28 => :high_intensity_interval_training
+      },
+      event: {
+        0 => :timer,
+        3 => :workout,
+        8 => :session,
+        9 => :lap,
+        10 => :course_point,
+        21 => :activity,
+        26 => :length
+      },
+      event_type: {
+        0 => :start,
+        1 => :stop,
+        2 => :consecutive_deprecated,
+        3 => :marker,
+        4 => :stop_all,
+        5 => :begin_deprecated,
+        6 => :end_deprecated,
+        7 => :end_all,
+        8 => :stop_disable,
+        9 => :stop_disable_all
+      },
+      activity: {
+        0 => :manual,
+        1 => :auto_multi_sport
+      },
+      battery_status: {
+        1 => :new,
+        2 => :good,
+        3 => :ok,
+        4 => :low,
+        5 => :critical
+      },
+      course_point: {
+        0 => :generic,
+        1 => :summit,
+        2 => :valley,
+        3 => :water,
+        4 => :food,
+        5 => :danger,
+        6 => :left,
+        7 => :right,
+        8 => :straight,
+        23 => :u_turn,
+        24 => :segment_start,
+        25 => :segment_end
+      },
+      manufacturer: {
+        1 => :garmin,
+        13 => :dynastream,
+        89 => :zwift,
+        255 => :development
+      }
+    }.freeze
+
+    MESSAGE_PROFILES = {
+      0 => {
+        name: :file_id,
+        fields: {
+          0 => { name: :type, enum: :file },
+          1 => { name: :manufacturer, enum: :manufacturer },
+          2 => { name: :product },
+          3 => { name: :serial_number },
+          4 => { name: :time_created, type: :date_time },
+          5 => { name: :number }
+        }
+      },
+      2 => {
+        name: :device_settings,
+        fields: {
+          0 => { name: :active_time_zone },
+          1 => { name: :utc_offset },
+          2 => { name: :time_offset }
+        }
+      },
+      3 => {
+        name: :user_profile,
+        fields: {
+          1 => { name: :friendly_name },
+          2 => { name: :gender, enum: :gender },
+          3 => { name: :age },
+          4 => { name: :height, scale: 100 },
+          5 => { name: :weight, scale: 10 }
+        }
+      },
+      12 => {
+        name: :sport,
+        fields: {
+          0 => { name: :sport, enum: :sport },
+          1 => { name: :sub_sport, enum: :sub_sport },
+          3 => { name: :name }
+        }
+      },
+      18 => {
+        name: :session,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          2 => { name: :start_time, type: :date_time },
+          5 => { name: :sport, enum: :sport },
+          6 => { name: :sub_sport, enum: :sub_sport },
+          7 => { name: :total_elapsed_time, scale: 1000 },
+          8 => { name: :total_timer_time, scale: 1000 },
+          9 => { name: :total_distance, scale: 100 },
+          11 => { name: :total_calories },
+          13 => { name: :avg_speed, scale: 1000 },
+          14 => { name: :max_speed, scale: 1000 },
+          15 => { name: :avg_heart_rate },
+          16 => { name: :max_heart_rate },
+          17 => { name: :avg_cadence },
+          18 => { name: :max_cadence },
+          19 => { name: :avg_power },
+          20 => { name: :max_power },
+          21 => { name: :total_ascent },
+          22 => { name: :total_descent },
+          48 => { name: :avg_temperature },
+          49 => { name: :max_temperature }
+        }
+      },
+      19 => {
+        name: :lap,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          2 => { name: :start_time, type: :date_time },
+          7 => { name: :total_elapsed_time, scale: 1000 },
+          8 => { name: :total_timer_time, scale: 1000 },
+          9 => { name: :total_distance, scale: 100 },
+          11 => { name: :total_calories },
+          13 => { name: :avg_speed, scale: 1000 },
+          14 => { name: :max_speed, scale: 1000 },
+          15 => { name: :avg_heart_rate },
+          16 => { name: :max_heart_rate },
+          17 => { name: :avg_cadence },
+          18 => { name: :max_cadence },
+          19 => { name: :avg_power },
+          20 => { name: :max_power },
+          21 => { name: :total_ascent },
+          22 => { name: :total_descent },
+          24 => { name: :lap_trigger }
+        }
+      },
+      20 => {
+        name: :record,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          0 => { name: :position_lat, type: :semicircles },
+          1 => { name: :position_long, type: :semicircles },
+          2 => { name: :altitude, scale: 5, offset: 500 },
+          3 => { name: :heart_rate },
+          4 => { name: :cadence },
+          5 => { name: :distance, scale: 100 },
+          6 => { name: :speed, scale: 1000 },
+          7 => { name: :power },
+          13 => { name: :temperature },
+          29 => { name: :enhanced_speed, scale: 1000 },
+          30 => { name: :enhanced_altitude, scale: 5, offset: 500 }
+        }
+      },
+      21 => {
+        name: :event,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          0 => { name: :event, enum: :event },
+          1 => { name: :event_type, enum: :event_type },
+          2 => { name: :data16 },
+          3 => { name: :data },
+          4 => { name: :event_group }
+        }
+      },
+      23 => {
+        name: :device_info,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          0 => { name: :device_index },
+          1 => { name: :device_type },
+          2 => { name: :manufacturer, enum: :manufacturer },
+          3 => { name: :serial_number },
+          4 => { name: :product },
+          5 => { name: :software_version, scale: 100 },
+          10 => { name: :battery_status, enum: :battery_status },
+          11 => { name: :battery_voltage, scale: 256 }
+        }
+      },
+      26 => {
+        name: :workout,
+        fields: {
+          4 => { name: :sport, enum: :sport },
+          5 => { name: :sub_sport, enum: :sub_sport },
+          6 => { name: :capabilities },
+          8 => { name: :num_valid_steps },
+          11 => { name: :wkt_name }
+        }
+      },
+      31 => {
+        name: :course,
+        fields: {
+          4 => { name: :sport, enum: :sport },
+          5 => { name: :name },
+          6 => { name: :capabilities }
+        }
+      },
+      32 => {
+        name: :course_point,
+        fields: {
+          1 => { name: :timestamp, type: :date_time },
+          2 => { name: :position_lat, type: :semicircles },
+          3 => { name: :position_long, type: :semicircles },
+          4 => { name: :distance, scale: 100 },
+          5 => { name: :type, enum: :course_point },
+          6 => { name: :name }
+        }
+      },
+      34 => {
+        name: :activity,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          0 => { name: :total_timer_time, scale: 1000 },
+          1 => { name: :num_sessions },
+          2 => { name: :type, enum: :activity },
+          3 => { name: :event, enum: :event },
+          4 => { name: :event_type, enum: :event_type },
+          5 => { name: :local_timestamp, type: :local_date_time },
+          6 => { name: :event_group },
+          7 => { name: :total_elapsed_time, scale: 1000 }
+        }
+      },
+      49 => {
+        name: :file_creator,
+        fields: {
+          0 => { name: :software_version },
+          1 => { name: :hardware_version }
+        }
+      },
+      55 => {
+        name: :monitoring,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          3 => { name: :activity_type },
+          4 => { name: :activity_subtype },
+          5 => { name: :activity_level },
+          24 => { name: :distance, scale: 100 },
+          25 => { name: :calories },
+          26 => { name: :active_time }
+        }
+      },
+      72 => {
+        name: :training_file,
+        fields: {
+          0 => { name: :timestamp, type: :date_time },
+          1 => { name: :type, enum: :file },
+          2 => { name: :manufacturer, enum: :manufacturer },
+          3 => { name: :product },
+          4 => { name: :serial_number },
+          5 => { name: :time_created, type: :date_time }
+        }
+      },
+      103 => {
+        name: :monitoring_info,
+        fields: {
+          253 => { name: :timestamp, type: :date_time },
+          0 => { name: :local_timestamp, type: :local_date_time },
+          1 => { name: :activity_type },
+          3 => { name: :cycles_to_distance, scale: 5000 },
+          4 => { name: :cycles_to_calories, scale: 5000 }
+        }
+      },
+      132 => {
+        name: :hr_zone,
+        fields: {
+          1 => { name: :high_bpm },
+          2 => { name: :name }
+        }
+      },
+      206 => {
+        name: :field_description,
+        fields: {
+          0 => { name: :developer_data_index },
+          1 => { name: :field_definition_number },
+          2 => { name: :fit_base_type_id },
+          3 => { name: :field_name },
+          8 => { name: :native_field_num },
+          14 => { name: :units }
+        }
+      },
+      207 => {
+        name: :developer_data_id,
+        fields: {
+          0 => { name: :developer_id },
+          1 => { name: :application_id },
+          2 => { name: :manufacturer_id, enum: :manufacturer },
+          3 => { name: :developer_data_index },
+          4 => { name: :application_version }
+        }
+      }
+    }.freeze
+
+    def self.message_profile(global_message_number)
+      MESSAGE_PROFILES[global_message_number] || { name: :"message_#{global_message_number}", fields: {} }
+    end
+
+    def self.enum_mapping(type)
+      ENUMS[type]
+    end
+  end
+end

data/lib/fit_doctor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FitDoctor
+  VERSION = "0.1.0"
+end

data/lib/fit_doctor.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "fit_doctor/version"
+require_relative "fit_doctor/errors"
+require_relative "fit_doctor/configuration"
+require_relative "fit_doctor/models/message"
+require_relative "fit_doctor/profile"
+require_relative "fit_doctor/parser"
+require_relative "constans/events/verification"
+require_relative "avo/concerns/events/verification"
+
+module FitDoctor
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: fit_doctor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Poltrax
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: FIT Doctor parses Garmin FIT binary files and exposes typed message collections
+  with automatic unit conversions.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/avo/concerns/events/verification.rb
+- lib/constans/events/verification.rb
+- lib/fit_doctor.rb
+- lib/fit_doctor/configuration.rb
+- lib/fit_doctor/errors.rb
+- lib/fit_doctor/models/message.rb
+- lib/fit_doctor/parser.rb
+- lib/fit_doctor/profile.rb
+- lib/fit_doctor/version.rb
+homepage: https://github.com/Poltrax-live/fit-doctor
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Parse FIT files into Ruby objects
+test_files: []