rubyfit 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33df17859113bfabf926430108e48e832a16609d
-  data.tar.gz: 67bf9d1069e605c1bd4fe8402c442a3eb9d55531
+  metadata.gz: 250aefed2638033617a97b1789e967c90a26940a
+  data.tar.gz: 46b607c278b112a5dffa6519d54f0bb2c585b0fa
 SHA512:
-  metadata.gz: c79dd06cb89f79330f458b2a7aae56cbd9dd7dbd30a1bfc7054931c960623b66097226a8c6a729e75dda582c4928d652438eadc4c82f631fbde07636652739f7
-  data.tar.gz: 5ba13d8485c785f17f2e25a90e940b04eb54272e099eea0f1167615acf432813e5b7023eb702c04679b62b2d098ee6cbdf03271151ff00ec309a6467570e0469
+  metadata.gz: d7fbc3064d7e5f8af5947228731c0c2f3213ea196cf4d9f0b2045968216bd41864e04d17c8a646694c5e3ac3541b73fe95861b2574ffa8d84453b9765263e9ca
+  data.tar.gz: 848eaca18d3bb03a830405671fd1c43e51020bfd51f4a6a66378c225b31e8b29f9d13bf82919c9473bf6fc77bbe03f76cecd443935b19d3ab337ab89b75ec307

data/ext/rubyfit/rubyfit.c

@@ -18,6 +18,7 @@
 #include "math.h"
 
 #include "fit_convert.h"
+#include "fit_crc.h"
 
 VALUE mRubyFit;
 VALUE cFitParser;
@@ -540,6 +541,13 @@ static VALUE parse(VALUE self, VALUE original_str) {
 	return Qnil;
 }
 
+static VALUE update_crc(VALUE self, VALUE r_crc, VALUE r_data) {
+        FIT_UINT16 crc = NUM2USHORT(r_crc);
+        const char* data = StringValuePtr(r_data);
+        const FIT_UINT16 byte_count = RSTRING_LEN(r_data);
+        return UINT2NUM(FitCRC_Update16(crc, data, byte_count));
+}
+
 void Init_rubyfit() {
         mRubyFit = rb_define_module("RubyFit");
         cFitParser = rb_define_class_under(mRubyFit, "FitParser", rb_cObject);
@@ -551,4 +559,8 @@ void Init_rubyfit() {
 	//attributes
 	HANDLER_ATTR = rb_intern("@handler");
 	rb_define_attr(cFitParser, "handler", 1, 1);
+
+        // CRC helper
+        VALUE mCRC = rb_define_module_under(mRubyFit, "CRC");
+        rb_define_singleton_method(mCRC, "update_crc", update_crc, 2);
 }

data/lib/rubyfit.rb

@@ -1,2 +1,5 @@
 require "rubyfit/version"
 require 'rubyfit/rubyfit'
+
+require 'rubyfit/writer'
+require 'rubyfit/helpers'

data/lib/rubyfit/helpers.rb

@@ -0,0 +1,107 @@
+module RubyFit::Helpers
+  # Garmin timestamps start at 12:00:00 01-01-1989, 20 years after the unix epoch
+  GARMIN_TIME_OFFSET = 631065600 
+
+  DEGREES_TO_SEMICIRCLES = 2**31 / 180.0
+
+  # Converts a fixnum or bignum into a byte array, optionally
+  # truncating or right-filling with 0 to match a certain size
+  def num2bytes(num, byte_count, big_endian = true)
+    raise ArgumentError.new("num must be an integer") unless num.is_a?(Integer)
+    orig_num = num
+    # Convert negative numbers to two's complement (1-byte alignment)
+    if num < 0
+      num = num.abs
+
+      if num > 2 ** (byte_count * 8 - 1)
+        STDERR.puts("RubyFit WARNING: Integer underflow for #{orig_num} (#{orig_num.bit_length + 1} bits) when fitting in #{byte_count} bytes (#{byte_count * 8} bits)")
+      end
+
+      num = 2 ** (byte_count * 8) - num
+    end
+
+    hex = num.to_s(16)
+    # pack('H*') assumes the high nybble is first, which reverses nybbles in
+    # the most significant byte if it's only one hex char (<= 0xF). Prevent
+    # this by prepending a zero if the hex string is an odd length
+    hex = "0" + hex if hex.length.odd?
+    result = [hex]
+      .pack('H*')
+      .unpack("C*")
+
+    if result.size > byte_count
+      STDERR.puts("RubyFit WARNING: Truncating #{orig_num} (#{orig_num.bit_length} bits) to fit in #{byte_count} bytes (#{byte_count * 8} bits)")
+      result = result.last(byte_count)
+    elsif result.size < byte_count
+      pad_bytes = [0] * (byte_count - result.size)
+      result.unshift(*pad_bytes)
+    end
+
+    result.reverse! unless big_endian
+
+    result
+  end
+
+  def bytes2num(bytes, byte_count, unsigned = true, big_endian = true)
+    directive = {
+      1 => "C",
+      2 => "S",
+      4 => "L",
+      8 => "Q"
+    }[byte_count]
+    raise "Unsupported byte count: #{byte_count}" unless directive
+    directive << (big_endian ? ">" : "<") if byte_count > 1
+    directive.downcase! unless unsigned
+    bytes.pack("C*").unpack(directive).first
+  end
+
+  # Converts an ASCII string into a byte array, truncating or right-filling
+  # with 0 to match byte_count
+  def str2bytes(str, byte_count)
+    str
+      .unpack("C#{byte_count - 1}") # Convert to n-1 bytes
+      .map{|v| v || 0} + [0] # Convert nils to 0 and add null terminator
+  end
+
+  # Converts a byte array to a string. Omits the last character of the byte
+  # array from the result if it is 0
+  def bytes2str(bytes)
+    bytes = bytes[0...-1] if bytes.last == 0
+    bytes.pack("C*")
+  end
+
+  # Generates strings of hex bytes (for debugging)
+  def bytes2hex(bytes)
+    bytes
+      .map{|b| "0x#{b.to_s(16).ljust(2, "0")}"}
+      .each_slice(8)
+      .map{ |s| s.join(", ") }
+  end
+
+  def unix2fit_timestamp(timestamp)
+    timestamp - GARMIN_TIME_OFFSET
+  end
+
+  def fit2unix_timestamp(timestamp)
+    timestamp + GARMIN_TIME_OFFSET
+  end
+
+
+  def deg2semicircles(degrees)
+    (degrees * DEGREES_TO_SEMICIRCLES).truncate
+  end
+
+  def semicircles2deg(degrees)
+    result = degrees / DEGREES_TO_SEMICIRCLES
+    result -= 360.0 if result > 180.0
+    result += 360.0 if result < -180.0
+    result
+  end
+
+  def make_message_header(opts = {})
+    result = 0
+    result |= (1 << 6) if opts[:definition]
+    result |= (opts[:local_number] || 0) & 0xF
+    result
+  end
+end

data/lib/rubyfit/message_writer.rb

@@ -0,0 +1,176 @@
+require "rubyfit/type"
+require "rubyfit/helpers"
+
+class RubyFit::MessageWriter
+  extend RubyFit::Helpers
+
+  FIT_PROTOCOL_VERSION = 0x10 # major 1, minor 0
+  FIT_PROFILE_VERSION = 1 * 100 + 52 # major 1, minor 52
+
+  COURSE_POINT_TYPE = {
+    invalid: 255,
+    generic: 0,
+    summit: 1,
+    valley: 2,
+    water: 3,
+    food: 4,
+    danger: 5,
+    left: 6,
+    right: 7,
+    straight: 8,
+    first_aid: 9,
+    fourth_category: 10,
+    third_category: 11,
+    second_category: 12,
+    first_category: 13,
+    hors_category: 14,
+    sprint: 15,
+    left_fork: 16,
+    right_fork: 17,
+    middle_fork: 18,
+    slight_left: 19,
+    sharp_left: 20,
+    slight_right: 21,
+    sharp_right: 22,
+    u_turn: 23,
+    segment_start: 24,
+    segment_end: 25
+  }.freeze
+
+  MESSAGE_DEFINITIONS = {
+    file_id: {
+      id: 0,
+      fields: {
+        serial_number: { id: 3, type: RubyFit::Type.uint32z, required: true },
+        time_created: { id: 4, type: RubyFit::Type.timestamp, required: true },
+        manufacturer: { id: 1, type: RubyFit::Type.uint16 }, # See FIT_MANUFACTURER_*
+        product: { id: 2, type: RubyFit::Type.uint16 },
+        type: { id: 0, type: RubyFit::Type.enum, required: true }, # See FIT_FILE_*
+      }
+    },
+    course: {
+      id: 31,
+      fields: {
+        name: { id: 5, type: RubyFit::Type.string(16), required: true },
+      }
+    },
+    lap: {
+      id: 19,
+      fields: {
+        timestamp: { id: 253, type: RubyFit::Type.timestamp, required: true},
+        start_time: { id: 2, type: RubyFit::Type.timestamp, required: true},
+        start_y: { id: 3, type: RubyFit::Type.semicircles },
+        start_x: { id: 4, type: RubyFit::Type.semicircles },
+        end_y: { id: 5, type: RubyFit::Type.semicircles },
+        end_x: { id: 6, type: RubyFit::Type.semicircles },
+        total_distance: { id: 9, type: RubyFit::Type.centimeters },
+      },
+    },
+    course_point: {
+      id: 32,
+      fields: {
+        timestamp: { id: 1, type: RubyFit::Type.timestamp, required: true },
+        y: { id: 2, type: RubyFit::Type.semicircles, required: true },
+        x: { id: 3, type: RubyFit::Type.semicircles, required: true },
+        distance: { id: 4, type: RubyFit::Type.centimeters },
+        name: { id: 6, type: RubyFit::Type.string(16) },
+        message_index: { id: 254, type: RubyFit::Type.uint16 },
+        type: { id: 5, type: RubyFit::Type.enum, values: COURSE_POINT_TYPE, required: true }
+      },
+    },
+    record: {
+      id: 20,
+      fields: {
+        timestamp: { id: 253, type: RubyFit::Type.timestamp, required: true },
+        y: { id: 0, type: RubyFit::Type.semicircles, required: true },
+        x: { id: 1, type: RubyFit::Type.semicircles, required: true },
+        distance: { id: 5, type: RubyFit::Type.centimeters },
+        elevation: { id: 2, type: RubyFit::Type.altitude },
+      }
+    }
+  }
+
+  def self.definition_message(type, local_num)
+    pack_bytes do |bytes|
+      message_data = MESSAGE_DEFINITIONS[type]
+      bytes << header_byte(local_num, true)
+      bytes << 0x00 # Reserved uint8
+      bytes << 0x01 # Big endian
+      bytes.push(*num2bytes(message_data[:id], 2)) # Global message ID
+      bytes << message_data[:fields].size # Field count
+
+      message_data[:fields].each do |field, info|
+        type = info[:type]
+        bytes << info[:id]
+        bytes << type.byte_count
+        bytes << type.fit_id
+      end
+    end
+  end
+
+  def self.data_message(type, local_num, values)
+    pack_bytes do |bytes|
+      message_data = MESSAGE_DEFINITIONS[type]
+      bytes << header_byte(local_num, false)
+      message_data[:fields].each do |field, info|
+        field_type = info[:type]
+        value = values[field]
+        if info[:required] && value.nil?
+          raise ArgumentError.new("Missing required field '#{field}' in #{type} data message values")
+        end
+
+        if info[:values]
+          value = info[:values][value]
+          if value.nil?
+            raise ArgumentError.new("Invalid value for '#{field}' in #{type} data message values")
+          end
+        end
+
+        value_bytes = value ? field_type.val2bytes(value) : field_type.default_bytes
+        bytes.push(*value_bytes)
+      end
+    end
+  end
+
+  def self.definition_message_size(type)
+    message_data = MESSAGE_DEFINITIONS[type]
+    raise ArgumentError.new("Unknown message type '#{type}'") unless message_data
+    6 + message_data[:fields].count * 3
+  end
+
+  def self.data_message_size(type)
+    message_data = MESSAGE_DEFINITIONS[type]
+    raise ArgumentError.new("Unknown message type '#{type}'") unless message_data
+    1 + message_data[:fields].values.map{|info| info[:type].byte_count}.reduce(&:+)
+  end
+
+  def self.file_header(data_byte_count = 0) 
+    pack_bytes do |bytes|
+      bytes << 14 # Header size
+      bytes << FIT_PROTOCOL_VERSION # Protocol version
+      bytes.push(*num2bytes(FIT_PROFILE_VERSION, 2).reverse) # Profile version (little endian)
+      bytes.push(*num2bytes(data_byte_count, 4).reverse) # Data size (little endian)
+      bytes.push(*str2bytes(".FIT", 5).take(4)) # Data Type ASCII, no terminator
+      crc = 0 #RubyFit::CRC.update_crc(0, bytes2str(bytes))
+      bytes.push(*num2bytes(crc, 2).reverse) # Header CRC (little endian)
+    end
+  end
+
+  def self.crc(crc_value)
+    pack_bytes do |bytes|
+      bytes.push(*num2bytes(crc_value, 2, false)) # Little endian
+    end
+  end
+
+  # Internal
+  
+  def self.header_byte(local_number, definition)
+    local_number & 0xF | (definition ? 0x40 : 0x00)
+  end
+  
+  def self.pack_bytes
+    bytes = []
+    yield bytes
+    bytes.pack("C*")
+  end
+end

data/lib/rubyfit/type.rb

@@ -0,0 +1,155 @@
+require "rubyfit/helpers"
+
+class RubyFit::Type
+  attr_reader *%i(fit_id byte_count default_bytes)
+
+  def initialize(opts = {})
+    @val2bytes = opts[:val2bytes]
+    @bytes2val = opts[:bytes2val]
+    @rb2fit = opts[:rb2fit]
+    @fit2rb = opts[:fit2rb]
+    @default_bytes = opts[:default_bytes]
+    @byte_count = opts[:byte_count]
+    @fit_id = opts[:fit_id]
+  end
+
+  def val2bytes(val)
+    result = val
+    result = @rb2fit.call(result, self) if @rb2fit
+    result = @val2bytes.call(result, self)
+    result
+  end
+
+  def bytes2val(bytes)
+    result = bytes
+    result = @bytes2val.call(result, self)
+    result = @fit2rb.call(result, self) if @fit2rb
+    result
+  end
+
+  class << self
+    include RubyFit::Helpers
+
+    def integer(opts = {})
+      unsigned = opts.delete(:unsigned)
+      default = opts[:default]
+
+      # Default (invalid) value for integers is the maximum positive value
+      # given the bit length and whether the data is signed/unsigned
+      unless default
+        bit_count = opts[:byte_count] * 8
+        bit_count -= 1 unless unsigned
+        default = 2**bit_count - 1
+      end
+
+      new({
+        default_bytes: num2bytes(default, opts[:byte_count]),
+        val2bytes: ->(val, type) { num2bytes(val, type.byte_count) },
+        bytes2val: ->(bytes, type) { bytes2num(bytes, type.byte_count, unsigned) },
+      }.merge(opts))
+    end
+
+    # Base Types #
+    
+    def enum(opts = {})
+      uint8(fit_id: 0x00)
+    end
+
+    def string(byte_count, opts = {})
+      new({
+        fit_id: 0x07,
+        byte_count: byte_count,
+        default_bytes: [0x00] * byte_count,
+        val2bytes: ->(val, type) { str2bytes(val, type.byte_count) },
+        bytes2val: ->(bytes, type) { bytes2str(bytes) },
+      }.merge(opts))
+    end
+
+    def byte(byte_count, opts = {})
+      new({
+        fit_id: 0x0D,
+        default_bytes: [0xFF] * length,
+        val2bytes: ->(val) { val },
+        bytes2val: ->(bytes) { bytes },
+      }.merge(opts))
+    end
+
+    def sint8(opts = {})
+      integer({unsigned: false, byte_count: 1, fit_id: 0x01}.merge(opts))
+    end
+
+    def uint8(opts = {})
+      integer({unsigned: true, byte_count: 1, fit_id: 0x02}.merge(opts))
+    end
+
+    def sint16(opts = {})
+      integer({unsigned: false, byte_count: 2, fit_id: 0x83}.merge(opts))
+    end
+
+    def uint16(opts = {})
+      integer({unsigned: true, byte_count: 2, fit_id: 0x84}.merge(opts))
+    end
+
+    def sint32(opts = {})
+      integer({unsigned: false, byte_count: 4, fit_id: 0x85}.merge(opts))
+    end
+
+    def uint32(opts = {})
+      integer({unsigned: true, byte_count: 4, fit_id: 0x86}.merge(opts))
+    end
+
+    def sint64(opts = {})
+      integer({unsigned: false, byte_count: 8, fit_id: 0x8E}.merge(opts))
+    end
+
+    def uint64(opts = {})
+      integer({unsigned: true, byte_count: 8, fit_id: 0x8F}.merge(opts))
+    end
+
+    def uint8z(opts = {})
+      integer({unsigned: true, default: 0, byte_count: 1, fit_id: 0x0A}.merge(opts))
+    end
+
+    def uint16z(opts = {})
+      integer({unsigned: true, default: 0, byte_count: 2, fit_id: 0x8B}.merge(opts))
+    end
+
+    def uint32z(opts = {})
+      integer({unsigned: true, default: 0, byte_count: 4, fit_id: 0x8C}.merge(opts))
+    end
+
+    def uint64z(opts = {})
+      integer({unsigned: true, default: 0, byte_count: 8, fit_id: 0x90}.merge(opts))
+    end
+
+    # Derived types
+    
+    def timestamp
+      uint32({
+        rb2fit: ->(val, type) { unix2fit_timestamp(val) },
+        fit2rb: ->(val, type) { fit2unix_timestamp(val) }
+      })
+    end
+
+    def semicircles
+      sint32({
+        rb2fit: ->(val, type) { deg2semicircles(val) },
+        fit2rb: ->(val, type) { semicircles2deg(val) }
+      })
+    end
+
+    def centimeters
+      uint32({
+        rb2fit: ->(val, type) { (val * 100).truncate },
+        fit2rb: ->(val, type) { val / 100.0 }
+      })
+    end
+
+    def altitude
+      uint16({
+        rb2fit: ->(val, type) { (val + 500).truncate },
+        fit2rb: ->(val, type) { val - 500 }
+      })
+    end
+  end
+end

data/lib/rubyfit/version.rb

@@ -1,3 +1,3 @@
 module Rubyfit
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end

data/lib/rubyfit/writer.rb

@@ -0,0 +1,118 @@
+require "rubyfit/message_writer"
+
+class RubyFit::Writer
+  def write(stream, opts = {})
+    raise "Can't start write mode from #{@state}" if @state
+    @state = :write
+    @local_nums = []
+
+    @stream = stream
+
+    %i(start_time end_time course_point_count track_point_count name
+       total_distance time_created start_x start_y end_x end_y).each do |key|
+      raise ArgumentError.new("Missing required option #{key}") unless opts[key]
+    end
+
+    start_time = opts[:start_time].to_i
+    end_time = opts[:end_time].to_i
+    
+    @data_crc = 0
+
+    # Calculate data size to put in header
+    definition_sizes = %i(file_id course lap course_point record)
+      .map{|type| RubyFit::MessageWriter.definition_message_size(type) }
+      .reduce(&:+)
+
+    data_sizes = {
+      file_id: 1,
+      course: 1,
+      lap: 1,
+      course_point: opts[:course_point_count], 
+      record: opts[:track_point_count]
+    }
+      .map{|type, count| RubyFit::MessageWriter.data_message_size(type) * count }
+      .reduce(&:+)
+
+    data_size = definition_sizes + data_sizes
+    write_data(RubyFit::MessageWriter.file_header(data_size))
+
+    write_definition_message(:file_id)
+    write_data_message(:file_id, {
+      time_created: opts[:time_created],
+      type: 6, # Course file
+      manufacturer: 1, # Garmin
+      product: 0,
+      serial_number: 0,
+    })
+
+    write_definition_message(:course)
+    write_data_message(:course, { name: opts[:name] })
+
+    write_definition_message(:lap)
+    write_data_message(:lap, {
+      start_time: start_time,
+      timestamp: end_time,
+      start_x: opts[:start_x],
+      start_y: opts[:start_y],
+      end_x: opts[:end_x],
+      end_y: opts[:end_y],
+      total_distance: opts[:total_distance]
+    })
+
+    yield
+
+    write_data(RubyFit::MessageWriter.crc(@data_crc))
+    @state = nil
+  end
+
+  def course_points
+    raise "Can only start course points mode inside 'write' block" if @state != :write
+    @state = :course_points
+    write_definition_message(:course_point)
+    yield
+    @state = :write
+  end
+
+  def track_points
+    raise "Can only write track points inside 'write' block" if @state != :write
+    @state = :track_points
+    write_definition_message(:record)
+    yield
+    @state = :write
+  end
+
+  def course_point(values)
+    raise "Can only write course points inside 'course_points' block" if @state != :course_points
+    write_data_message(:course_point, values)
+  end
+
+  def track_point(values)
+    raise "Can only write track points inside 'track_points' block" if @state != :track_points
+    write_data_message(:record, values)
+  end
+
+  protected
+  
+  def write_definition_message(type)
+    write_data(RubyFit::MessageWriter.definition_message(type, local_num(type)))
+  end
+
+  def write_data_message(type, values)
+    write_data(RubyFit::MessageWriter.data_message(type, local_num(type), values))
+  end
+
+  def write_data(data)
+    @stream.write(data)
+    prev = @data_crc
+    @data_crc = RubyFit::CRC.update_crc(@data_crc, data)
+  end
+
+  def local_num(type)
+    result = @local_nums.index(type)
+    unless result
+      result = @local_nums.size
+      @local_nums << type
+    end
+    result
+  end
+end

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: rubyfit
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Cullen King
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-11 00:00:00.000000000 Z
-dependencies: []
+date: 2018-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.1
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: FIT files are binary, and as a result, are a pain to parse.  This is
   a wrapper around the FIT SDK, which makes creating a stream based parser simple.
 email:
@@ -34,7 +90,11 @@ files:
 - ext/rubyfit/fit_ram.h
 - ext/rubyfit/rubyfit.c
 - lib/rubyfit.rb
+- lib/rubyfit/helpers.rb
+- lib/rubyfit/message_writer.rb
+- lib/rubyfit/type.rb
 - lib/rubyfit/version.rb
+- lib/rubyfit/writer.rb
 homepage: http://cullenking.com
 licenses: []
 metadata: {}
@@ -55,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rubyfit
-rubygems_version: 2.6.6
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: A stream based parser for FIT files.