fit-parser 0.0.1

data/lib/fit/version.rb

@@ -0,0 +1,3 @@
+module Fit
+  VERSION = '0.0.1'
+end

data/spec/file/data_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Fit::File::Data do
+  describe ".generate" do
+    context 'standard definition' do
+      let(:definition) do
+        Fit::File::Definition.read example_file('record/message/definition')
+      end
+
+      subject { described_class.generate(definition) }
+
+      its(:ancestors) { should include(BinData::Record) }
+      its("new.record_type") { should eq(:file_id) }
+    end
+
+    context 'definition with multiple time the same field' do
+      before :all do
+        @fields = Fit::File::Definitions.class_variable_get :@@fields
+        @dyn_fields = Fit::File::Definitions.class_variable_get :@@dyn_fields
+        # force a fake definition for scaling of arrays
+        Fit::File::Definitions.add_field 2, 2, "field_array", :type => 6, :scale => 10, :offset => 0
+      end
+
+      after :all do
+        Fit::File::Definitions.class_variable_set :@@fields, @fields
+        Fit::File::Definitions.class_variable_set :@@dyn_fields, @dyn_fields
+      end
+
+      before :each do
+        def_file = example_file('record/message/definition_field_array.fit')
+        data_file = example_file('record/message/data_field_array.fit')
+        definition = described_class.generate(Fit::File::Definition.read def_file)
+        @result = definition.read( data_file )
+      end
+
+      it "reads the entire record" do
+        # read first the record definition
+        expect(@result.raw_field_array).to be == [ 123456789, 987654321 ]
+        expect(@result.raw_field_4).to be == [ 1, 3 ]
+        expect(@result.raw_field_8).to be == 1539
+        expect(@result.raw_active_time_zone).to be == 0
+      end
+    
+      it "does not apply the scale equal to 1 for integer" do
+        expect(@result.raw_active_time_zone).to be == 0
+        expect(@result.active_time_zone.to_s).to be_eql '0'
+      end
+      
+      it "does not apply the scale equal to 1 for arrays" do
+        expect(@result.raw_field_4).to be == [ 1, 3 ]
+        expect(@result.field_4.to_s).to be_eql '[1, 3]'
+      end
+
+      it "does apply scale on each element of an array" do
+        expect(@result.raw_field_array).to be == [ 123456789, 987654321 ]
+        expect(@result.field_array.to_s).to be_eql '[12345678.9, 98765432.1]'
+      end
+    end
+
+    context 'definition with dynamic fields' do
+      before :each do
+        def_file = example_file('record/message/definition_dynamic_fields.fit')
+        data_file = example_file('record/message/data_dynamic_fields.fit')
+        definition = described_class.generate(Fit::File::Definition.read def_file)
+        @result = definition.read( data_file )
+      end
+
+      it 'uses dynamic field value' do
+        expect(@result.raw_product).to be == 1499
+        expect(@result.product).to be == 'swim'
+      end
+    end
+
+    context 'definition with non basic types' do
+      before :each do
+        def_file = example_file('record/message/definition_dynamic_fields.fit')
+        data_file = example_file('record/message/data_dynamic_fields.fit')
+        definition = described_class.generate(Fit::File::Definition.read def_file)
+        @result = definition.read( data_file )
+      end
+
+      it 'returns the real value' do
+        expect(@result.raw_type).to be == 1
+        expect(@result.type).to be == 'device'
+      end
+    end
+
+    context 'definition with bit field types' do
+      before :each do
+        def_file = example_file('record/message/definition_file_capabilities.fit')
+        @definition = described_class.generate(Fit::File::Definition.read def_file)
+      end
+
+      context 'when only 1 bit set' do
+        it 'returns the single value' do
+          res = @definition.read( example_file('record/message/data_file_capabilities_activities.fit') )
+          expect(res.raw_flags).to eq(2)
+          expect(res.flags).to eq('read')
+        end
+      end
+
+      context 'when several bits set' do
+        it 'returns the compound value' do
+          res = @definition.read( example_file('record/message/data_file_capabilities_settings.fit') )
+          expect(res.raw_flags).to eq(6)
+          expect(res.flags).to eq('read/write')
+        end
+      end
+    end
+  end
+end

data/spec/file/definition_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Fit::File::Definition do
+  context "given a sample definition message" do
+    describe ".read" do
+      subject do
+        described_class.read example_file('record/message/definition')
+      end
+
+      its(:architecture) { should == 0 }
+      its(:global_message_number) { should == 0 }
+      its(:field_count) { should == 6 }
+      it { expect(subject.fields.size).to eq(subject.field_count) }
+
+      its(:record_type) { should == :definition }
+      it 'returns the real type for fields' do
+        expect(subject.fields[0].real_type).to be == :uint32z
+        expect(subject.fields[1].real_type).to be == :date_time
+        expect(subject.fields[2].real_type).to be == :manufacturer
+        expect(subject.fields[3].real_type).to be == :uint16 # product
+        expect(subject.fields[4].real_type).to be == :uint16 # number
+        expect(subject.fields[5].real_type).to be == :file
+      end
+    end
+  end
+end

data/spec/file/definitions_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+# we use undefined numbers for field otherwise we interfere
+# with already defined fields in definitions.rb and test are
+# not really independant of the code
+describe Fit::File::Definitions do
+  describe ".add_field" do
+    before :all do
+      @fields = described_class.class_variable_get :@@fields
+      @dyn_fields = described_class.class_variable_get :@@dyn_fields
+    end
+
+    after :all do
+      Fit::File::Definitions.class_variable_set(:@@fields, @fields)
+      Fit::File::Definitions.class_variable_set(:@@dyn_fields, @dyn_fields)
+    end
+
+    context "without additional options" do
+      before :each do
+        Fit::File::Definitions.class_variable_set(:@@fields, Hash.new { |h,k| h[k]={} })
+        Fit::File::Definitions.class_variable_set(:@@dyn_fields, Hash.new { |h,k| h[k]={} })
+        described_class.add_field(999, 999, 'rspec_test')
+      end
+
+      it "adds field data" do
+        expect(described_class.get_field(999,999)).to be_a(Hash)
+        expect(described_class.get_field(999,999)).to eql({ :name => 'rspec_test'})
+      end
+
+      it 'raised an error for dynamic field data' do
+        expect { described_class.add_field(999, 999, 'rspec_test_dyn') }.to raise_error
+      end
+    end
+
+    context "with additional options" do
+      before :each do
+        Fit::File::Definitions.class_variable_set(:@@fields, Hash.new { |h,k| h[k]={} })
+        Fit::File::Definitions.class_variable_set(:@@dyn_fields, Hash.new { |h,k| h[k]={} })
+
+        described_class.add_field(999, 999, 'rspec_test', :scale => 100, :units => 'm')
+        described_class.add_field(999, 999, 'rspec_test_dyn', :type => 4, :scale => 10, :offset => 10, :ref_field_name => nil, :ref_field_values => nil)
+      end
+
+      it "adds field data" do
+        expect(described_class.get_field(999, 999)).to be_a(Hash)
+        expect(described_class.get_field(999, 999)).to eql({ :name => 'rspec_test', :scale => 100, :units => 'm'})
+      end
+      
+      it 'adds dynamic field data' do
+        expect(described_class.get_dynamic_fields(999, 999)).to be_a(Hash)
+        expect(described_class.get_dynamic_fields(999, 999)).to eql({ :rspec_test_dyn => {:type => 4, :scale => 10, :offset => 10, :ref_field_name => nil, :ref_field_values => nil} })
+      end
+    end
+  end
+
+  describe ".get_field" do
+    it "returns nil if no field exists" do
+      expect(described_class.get_field(100,100)).to be_nil
+    end
+  end
+
+  describe '.get_dynamic_field' do
+    it 'returns nil if no dynamic field exists' do
+      described_class.add_field(100, 100, 'rspec')
+      expect(described_class.get_dynamic_fields(100, 100)).to be_nil
+    end
+  end
+
+  describe ".add_name" do
+    it "adds a name" do
+      described_class.add_name(20, 'record')
+      expect(described_class.get_name(20)).to eql('record')
+    end
+  end
+
+  describe ".get_name" do
+    it "returns nil if no name exists" do
+      expect(described_class.get_name(100)).to be_nil
+    end
+  end
+end

data/spec/file/header_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Fit::File::Header do
+  context "given a sample FIT header" do
+    subject do
+      described_class.read example_file('file/header')
+    end
+
+    its(:header_size) { should == 12 }
+    its(:protocol_version) { should == 16 }
+    its(:profile_version) { should == 64 }
+    its(:data_size) { should == 36069 }
+    its(:data_type) { should == ".FIT" }
+  end
+
+  context "given a sample header file of 14 bytes length" do
+    subject do
+      described_class.read example_file('file/header_14b.fit')
+    end
+
+    its(:header_size) { should == 14 }
+    its(:protocol_version) { should == 16 }
+    its(:profile_version) { should == 411 }
+    its(:data_size) { should == 325 }
+    its(:data_type) { should == ".FIT" }
+    its(:crc) { should == 17101 }
+  end
+end

data/spec/file/record_header_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Fit::File::RecordHeader do
+  context "given a sample normal header" do
+    subject do
+      described_class.read example_file('record/normal_header')
+    end
+
+    its(:header_type) { should == 0 }
+    its(:message_type) { should == 1 }
+    its(:local_message_type) { should == 0 }
+
+    it { is_expected.to be_normal }
+    it { is_expected.not_to be_a_compressed_timestamp }
+  end
+
+  context "given a sample compressed timestamp header" do
+    # TODO
+  end
+end

data/spec/file/record_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Fit::File::Record do
+  before do
+    described_class.clear_definitions!
+    described_class.read(example_file('record/definition_record_2.fit'))
+  end
+
+  describe ".read" do
+    subject { described_class.read(file) }
+
+    context "given a sample definition record" do
+      let(:file) { example_file('record/definition_record') }
+
+      it { expect(subject.header).to be_a Fit::File::RecordHeader }
+      it { expect(subject.content).to be_a Fit::File::Definition }
+
+    end
+
+    context "given a sample data record" do
+      let(:file) { nil }
+    end
+  
+    context "given a sample data record with a string non null terminated" do
+
+      context 'string length is equal to field size' do
+      
+        let(:file) { example_file('record/data_record_2.fit') }
+
+        its(:header) { should be_a(Fit::File::RecordHeader) }
+        it { expect(subject.content.raw_version).to be == 250 }
+        it { expect(subject.content.raw_part_number).to be == '123-A1234-00' }
+      end
+
+    context 'string length is smaller than field size' do
+      
+        let(:file) { example_file('record/data_record_2bis.fit') }
+
+        its(:header) { should be_a(Fit::File::RecordHeader) }
+        it { expect(subject.content.raw_version).to be == 251 }
+        it { expect(subject.content.version).to be == 2.51 }
+        it { expect(subject.content.raw_part_number).to be == '123-A1234' }
+        it { expect(subject.content.part_number).to be == '123-A1234' }
+      end
+    end
+  end
+
+  describe ".clear_definitions" do
+    it "should clear the definitions class variable" do
+      described_class.read example_file('record/definition_record')
+      expect(described_class.definitions).to_not be_empty
+      described_class.clear_definitions!
+      expect(described_class.definitions).to be_empty
+    end
+  end
+end

data/spec/file/type_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Fit::File::Type do
+  before :all do
+    @types = Fit::File::Types.class_variable_get :@@types
+    Fit::File::Types.add_type(:int_type, :sint8)
+    Fit::File::Types.add_type(:int_type_with_val, :uint8, :values => {1 => 'one', 2 => 'two', 3 => 'three'})
+  end
+
+  after :all do
+    Fit::File::Types.class_variable_set(:@@types, @types)
+  end
+
+  describe '.get_type' do
+    context 'when valid name' do
+      it 'returns a type' do
+        expect(described_class.get_type(:int_type)).to be_a Fit::File::Type
+      end
+
+      it 'returns always the same instance' do
+        expect(described_class.get_type(:int_type)).to equal described_class.get_type(:int_type)
+      end
+    end
+    
+    context 'when invalid name' do
+      it 'returns nil' do
+        expect(described_class.get_type(:unknown_type)).to be_nil
+      end
+    end
+  end
+
+  describe '#value' do
+    context 'when type has values' do
+
+      let(:type) { described_class.get_type(:int_type_with_val) }
+
+      context 'known value requested' do
+        it 'returns the value' do
+          expect(type.value(2)).to eql 'two'
+        end
+      end
+      
+      context 'unknown value requested' do
+        it 'returns the input value' do
+          expect(type.value(999)).to eql 999
+        end
+      end
+
+      context 'when invalid value is requested' do
+        it 'returns nil' do
+          expect(type.value(255)).to be_nil
+          expect(type.value(0xFF)).to be_nil
+        end
+      end
+    end
+
+    context 'when type has date_time value' do
+      let(:type) { described_class.get_type(:date_time) }
+      it 'returns the date' do
+        expect(type.value(790509304)).to eq('2015-01-18 09:55:04 UTC')
+      end
+    end
+
+    context 'when type has message_index value' do
+      let(:type) { described_class.get_type(:message_index) }
+      
+      it 'returns the message_index' do
+        expect(type.value(10)).to eq(10)
+        expect(type.value(32778)).to eq(10)
+        expect(type.value(28682)).to eq(10)
+      end 
+
+    end
+
+    context 'when type has file_flags value' do
+      let(:type) { described_class.get_type(:file_flags) }
+      it 'returns the file_flags' do
+        expect(type.value(10)).to eq('read/erase')
+        expect(type.value(0x0A)).to eq('read/erase')
+      end
+    end
+
+    context 'when type has bool value' do
+      let(:type) { described_class.get_type(:bool) }
+      it 'returns the boolean value' do
+        expect(type.value(0)).to eq(false)
+        expect(type.value(1)).to eq(true)
+        expect(type.value(255)).to be_nil
+      end
+    end
+
+    context 'when type has no value' do
+      it 'returns nil' do
+        type = described_class.get_type(:int_type)
+        expect(type.value(1)).to eql 1
+      end
+    end
+  end
+end

data/spec/file/types_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Fit::File::Types do
+  before :all do
+    @types = described_class.class_variable_get :@@types
+  end
+
+  after :all do
+    Fit::File::Types.class_variable_set(:@@types, @types)
+  end
+
+  describe '.add_type' do
+    before :each do
+      Fit::File::Types.class_variable_set(:@@types, Hash.new { |h,k| h[k]={} })
+    end
+
+    context 'for enum type' do
+      it 'add enum data' do
+        val = {:values => { 1 => 'val1', 2=> 'val2', 3 => 'val3'}}
+        described_class.add_type(:test_enum, :enum, val)
+        expect(described_class.get_type_definition(:test_enum)).to eql val.merge({:basic_type => :enum})
+      end
+    end
+  end
+
+  describe '.get_type_definition' do
+    it 'returns nil when type does not exist' do
+      expect(described_class.get_type_definition(:rspec_unknown)).to be_nil
+    end
+  end
+  
+  describe '.date_time_value' do
+    context 'wen value below min' do
+      it 'returns system time in second' do
+        expect(described_class.date_time_value(9999, {268435456 => 'min'}, {:utc => true})).to eql '9999'
+        expect(described_class.date_time_value(9999, {268435456 => 'min'}, {:utc => false})).to eql '9999'
+      end
+    end
+
+    context 'when value is above min' do
+      context 'with UTC mode' do
+        it 'returns exact date UTC' do
+          expect(described_class.date_time_value(790509304, {268435456 => 'min'}, {:utc => true})).to eql '2015-01-18 09:55:04 UTC'
+        end
+      end
+      
+      context 'with local mode' do
+        it 'returns exact date in locale time zone' do
+          # TODO: manage answer based on current system local
+          expect(described_class.date_time_value(790509304, {268435456 => 'min'}, {:utc => false})).not_to match(/UTC$/)
+        end
+      end
+
+    end
+  end
+
+  describe '.message_index_value' do
+    let(:values) { {32768 => 'selected', 28672 => 'reserved', 4095 => 'mask' } }
+
+    context 'when value is not reserved or selected' do
+      it 'returns the message index' do
+        expect(described_class.message_index_value(10, values)).to eq(10)
+      end
+    end
+
+    context 'when value is reserved' do
+      it 'returns real message index' do
+        expect(described_class.message_index_value(28682, values)).to eq(10)
+      end
+    end
+
+    context 'when value is selected' do
+      it 'returns real message index' do
+        expect(described_class.message_index_value(32778, values)).to eq(10)
+      end
+    end
+
+  end
+
+  describe '.bitfield_value' do
+    let(:values) { {0x02 => 'read', 0x04 => 'write', 0x08 => 'erase'} }
+
+    context 'when value is a single bit' do
+      it 'returns the single value' do
+        expect(described_class.bitfield_value(2, values)).to eq('read')
+        expect(described_class.bitfield_value(4, values)).to eq('write')
+        expect(described_class.bitfield_value(8, values)).to eq('erase')
+      end
+    end
+
+    context 'when value is several bits' do
+      it 'returns the values separated by a slash' do
+        expect(described_class.bitfield_value(6, values)).to eq('read/write')
+        expect(described_class.bitfield_value(12, values)).to eq('write/erase')
+      end
+    end
+  end
+
+end
+