rubyfit 0.0.2 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (19) hide show
  1. checksums.yaml +7 -0
  2. data/ext/rubyfit/fit.c +96 -25
  3. data/ext/rubyfit/fit.h +127 -44
  4. data/ext/rubyfit/fit_config.h +7 -7
  5. data/ext/rubyfit/fit_convert.c +66 -13
  6. data/ext/rubyfit/fit_convert.h +28 -23
  7. data/ext/rubyfit/fit_crc.c +30 -6
  8. data/ext/rubyfit/fit_crc.h +12 -5
  9. data/ext/rubyfit/fit_example.c +899 -0
  10. data/ext/rubyfit/fit_example.h +3299 -0
  11. data/ext/rubyfit/fit_ram.c +203 -0
  12. data/ext/rubyfit/fit_ram.h +39 -0
  13. data/ext/rubyfit/rubyfit.c +25 -36
  14. data/lib/rubyfit/version.rb +1 -1
  15. metadata +14 -16
  16. data/ext/rubyfit/fit_product.c +0 -21
  17. data/ext/rubyfit/fit_product.h +0 -21
  18. data/ext/rubyfit/fit_sdk.c +0 -618
  19. data/ext/rubyfit/fit_sdk.h +0 -2083
data/ext/rubyfit/fit_ram.c ADDED
@@ -0,0 +1,203 @@
1
+ ////////////////////////////////////////////////////////////////////////////////
2
+ // The following FIT Protocol software provided may be used with FIT protocol
3
+ // devices only and remains the copyrighted property of Dynastream Innovations Inc.
4
+ // The software is being provided on an "as-is" basis and as an accommodation,
5
+ // and therefore all warranties, representations, or guarantees of any kind
6
+ // (whether express, implied or statutory) including, without limitation,
7
+ // warranties of merchantability, non-infringement, or fitness for a particular
8
+ // purpose, are specifically disclaimed.
9
+ //
10
+ // Copyright 2013 Dynastream Innovations Inc.
11
+ ////////////////////////////////////////////////////////////////////////////////
12
+ // ****WARNING**** This file is auto-generated! Do NOT edit this file.
13
+ // Profile Version = 8.10Release
14
+ // Tag = $Name: AKW8_100 $
15
+ // Product = EXAMPLE
16
+ // Alignment = 4 bytes, padding disabled.
17
+ ////////////////////////////////////////////////////////////////////////////////
18
+
19
+
20
+ #include <string.h>
21
+
22
+ #include "fit_ram.h"
23
+ #include "fit_crc.h"
24
+ #include "fit_convert.h"
25
+
26
+ #if defined(FIT_RAM_INCLUDE)
27
+
28
+ ///////////////////////////////////////////////////////////////////////////////
29
+ // Private Variables
30
+ ///////////////////////////////////////////////////////////////////////////////
31
+
32
+ static FIT_UINT32 read_crc_offset;
33
+ static FIT_UINT16 read_crc;
34
+
35
+
36
+ ///////////////////////////////////////////////////////////////////////////////
37
+ // Public Functions
38
+ ///////////////////////////////////////////////////////////////////////////////
39
+
40
+ FIT_RAM_FILE FitRAM_LookupFile(FIT_FILE file)
41
+ {
42
+ FIT_RAM_FILE ram_file;
43
+
44
+ for (ram_file = (FIT_RAM_FILE)0; ram_file < FIT_RAM_FILES; ram_file++)
45
+ {
46
+ if (file == fit_ram_files[ram_file]->file_def->type)
47
+ return ram_file;
48
+ }
49
+
50
+ return FIT_RAM_FILES;
51
+ }
52
+
53
+ FIT_UINT32 FitRAM_GetFileSize(FIT_RAM_FILE file)
54
+ {
55
+ if (file >= FIT_RAM_FILES)
56
+ return 0;
57
+
58
+ return FIT_FILE_HDR_SIZE + fit_ram_files[file]->file_def->data_size + sizeof(FIT_UINT16);
59
+ }
60
+
61
+ void FitRAM_FileReadBytes(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT32 file_offset, void *data, FIT_UINT32 data_size)
62
+ {
63
+ FIT_BYTE *data_ptr = (FIT_BYTE *) data;
64
+ const FIT_RAM_FILE_DATA *file_data = fit_ram_files[file]->data;
65
+ FIT_UINT16 data_index = 0;
66
+ FIT_UINT32 offset = file_offset;
67
+ FIT_UINT32 size;
68
+ FIT_UINT8 read_crc_size = 0;
69
+
70
+ if ((file_offset + data_size) > (FIT_FILE_HDR_SIZE + fit_ram_files[file]->file_def->data_size))
71
+ {
72
+ read_crc_size = (FIT_UINT8)((file_offset + data_size) - (FIT_FILE_HDR_SIZE + fit_ram_files[file]->file_def->data_size)); // Don't include file crc in copy.
73
+ data_size -= read_crc_size;
74
+
75
+ if (read_crc_size > 2)
76
+ read_crc_size = 2;
77
+ }
78
+
79
+ if (data_size > 0)
80
+ {
81
+ do
82
+ {
83
+ while ((data_index < fit_ram_files[file]->data_count) && ((file_data->file_offset + file_data->size) <= offset))
84
+ {
85
+ file_data++;
86
+ data_index++;
87
+ }
88
+
89
+ if ((data_index >= fit_ram_files[file]->data_count) || (file_data->file_offset >= (file_offset + data_size)))
90
+ {
91
+ size = file_offset + data_size - offset;
92
+ memcpy(&data_ptr[offset - file_offset], &fit_ram_files[file]->file[offset], size);
93
+ offset += size;
94
+ break; // Done.
95
+ }
96
+
97
+ if (offset < file_data->file_offset)
98
+ {
99
+ size = file_data->file_offset - offset;
100
+
101
+ if ((offset + size) > (file_offset + data_size))
102
+ size = file_offset + data_size - offset;
103
+
104
+ memcpy(&data_ptr[offset - file_offset], &fit_ram_files[file]->file[offset], size);
105
+ offset += size;
106
+ }
107
+
108
+ size = offset + file_data->size;
109
+
110
+ if (size > (file_offset + data_size))
111
+ size = file_offset + data_size;
112
+
113
+ size -= offset;
114
+ memcpy(&data_ptr[offset - file_offset], &((FIT_BYTE *)file_data->data)[offset - file_data->file_offset], size);
115
+ offset += size;
116
+ } while (offset < (file_offset + data_size));
117
+
118
+ if (file_offset == 0)
119
+ {
120
+ read_crc = 0;
121
+ read_crc_offset = 0;
122
+ }
123
+
124
+ if (file_offset > read_crc_offset)
125
+ read_crc_offset = file_offset; // Non-contiguous read. CRC will be invalid.
126
+
127
+ if ((file_offset + data_size) > read_crc_offset)
128
+ read_crc = FitCRC_Update16(read_crc, &data_ptr[read_crc_offset - file_offset], (FIT_UINT8)(file_offset + data_size - read_crc_offset));
129
+
130
+ read_crc_offset = file_offset + data_size;
131
+ }
132
+
133
+ if (read_crc_size > 0)
134
+ {
135
+ data_ptr[offset - file_offset] = (FIT_BYTE)read_crc;
136
+ offset++;
137
+
138
+ if (read_crc_size == 1)
139
+ return;
140
+
141
+ data_ptr[offset - file_offset] = (FIT_BYTE)(read_crc >> 8);
142
+ }
143
+ }
144
+
145
+ void FitRAM_FileWriteBytes(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT32 file_offset, const void *data, FIT_UINT32 data_size)
146
+ {
147
+ const FIT_RAM_FILE_DATA *file_data;
148
+ FIT_UINT16 data_index;
149
+ FIT_BYTE *src;
150
+ FIT_BYTE *dest;
151
+ FIT_UINT32 size;
152
+
153
+ for (data_index = 0; data_index < fit_ram_files[file]->data_count; data_index++)
154
+ {
155
+ file_data = &fit_ram_files[file]->data[data_index];
156
+
157
+ if (file_data->file_offset >= (file_offset + data_size))
158
+ return; // Data start is after end of write so we are done.
159
+
160
+ if (file_offset >= (file_data->file_offset + file_data->size))
161
+ continue; // Data end is after write so continue to next data element.
162
+
163
+ src = (FIT_BYTE *) data;
164
+ dest = (FIT_BYTE *) file_data->data;
165
+ size = data_size;
166
+
167
+ if (file_offset < file_data->file_offset)
168
+ {
169
+ size -= file_data->file_offset - file_offset;
170
+ src += file_data->file_offset - file_offset;
171
+ }
172
+ else
173
+ {
174
+ dest += file_offset - file_data->file_offset;
175
+ }
176
+
177
+ if (size > file_data->size)
178
+ size = file_data->size;
179
+
180
+ memcpy(dest, src, size);
181
+ }
182
+ }
183
+
184
+ void FitRAM_FileWriteMesg(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT16 mesg_num, const void *mesg_data, FIT_BOOL restore_fields)
185
+ {
186
+ FIT_UINT32 offset;
187
+ FIT_UINT8 size;
188
+ FIT_BYTE old_mesg[FIT_MESG_SIZE];
189
+
190
+ offset = Fit_GetFileMesgOffset(fit_ram_files[file]->file_def, mesg_num, 0);
191
+ size = Fit_GetMesgSize(mesg_num);
192
+
193
+ if (restore_fields)
194
+ {
195
+ FitRAM_FileReadBytes(file, file_index, offset, old_mesg, size);
196
+ FitConvert_RestoreFields(old_mesg);
197
+ }
198
+
199
+ FitRAM_FileWriteBytes(file, file_index, offset, mesg_data, size);
200
+ }
201
+
202
+ #endif // defined(FIT_RAM_INCLUDE)
203
+
data/ext/rubyfit/fit_ram.h ADDED
@@ -0,0 +1,39 @@
1
+ ////////////////////////////////////////////////////////////////////////////////
2
+ // The following FIT Protocol software provided may be used with FIT protocol
3
+ // devices only and remains the copyrighted property of Dynastream Innovations Inc.
4
+ // The software is being provided on an "as-is" basis and as an accommodation,
5
+ // and therefore all warranties, representations, or guarantees of any kind
6
+ // (whether express, implied or statutory) including, without limitation,
7
+ // warranties of merchantability, non-infringement, or fitness for a particular
8
+ // purpose, are specifically disclaimed.
9
+ //
10
+ // Copyright 2013 Dynastream Innovations Inc.
11
+ ////////////////////////////////////////////////////////////////////////////////
12
+ // ****WARNING**** This file is auto-generated! Do NOT edit this file.
13
+ // Profile Version = 8.10Release
14
+ // Tag = $Name: AKW8_100 $
15
+ // Product = EXAMPLE
16
+ // Alignment = 4 bytes, padding disabled.
17
+ ////////////////////////////////////////////////////////////////////////////////
18
+
19
+
20
+ #if !defined(FIT_RAM_H)
21
+ #define FIT_RAM_H
22
+
23
+ #include "fit_example.h"
24
+
25
+ #if defined(FIT_RAM_INCLUDE)
26
+
27
+ ///////////////////////////////////////////////////////////////////////////////
28
+ // Public Function Prototypes
29
+ ///////////////////////////////////////////////////////////////////////////////
30
+
31
+ FIT_RAM_FILE FitRAM_LookupFile(FIT_FILE file);
32
+ FIT_UINT32 FitRAM_GetFileSize(FIT_RAM_FILE file);
33
+ void FitRAM_FileReadBytes(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT32 file_offset, void *data, FIT_UINT32 data_size);
34
+ void FitRAM_FileWriteBytes(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT32 file_offset, const void *data, FIT_UINT32 data_size);
35
+ void FitRAM_FileWriteMesg(FIT_RAM_FILE file, FIT_UINT16 file_index, FIT_UINT16 mesg_num, const void *mesg_data, FIT_BOOL restore_fields);
36
+
37
+ #endif // defined(FIT_RAM_INCLUDE)
38
+
39
+ #endif // !defined(FIT_RAM_H)
data/ext/rubyfit/rubyfit.c CHANGED
@@ -32,11 +32,13 @@ VALUE cFitHandlerUserProfileFun;
32
32
  VALUE cFitHandlerEventFun;
33
33
  VALUE cFitHandlerWeightScaleInfoFun;
34
34
  static ID HANDLER_ATTR;
35
- //garmin/dynastream, in their infinite wisdom, decided to pinch pennies on bits
36
- //by tinkering with well established time offsets. This is the magic number of
37
- //seconds needed to add to their number to get the true number of seconds since
38
- //the epoch. For those math challenged, this is 20 years of seconds.
39
- const GARMIN_SUCKS_OFFSET = 631065600;
35
+ /*
36
+ * garmin/dynastream, decided to pinch pennies on bits by tinkering with well
37
+ * established time offsets. This is the magic number of seconds needed to add
38
+ * to their number to get the true number of seconds since the epoch.
39
+ * This is 20 years of seconds.
40
+ */
41
+ const long GARMIN_TIME_OFFSET = 631065600;
40
42
 
41
43
 
42
44
  void pass_message(char *msg) {
@@ -68,15 +70,15 @@ static VALUE init(VALUE self, VALUE handler) {
68
70
  return Qnil;
69
71
  }
70
72
 
71
- static pass_activity(const FIT_ACTIVITY_MESG *mesg) {
73
+ static void pass_activity(const FIT_ACTIVITY_MESG *mesg) {
72
74
  VALUE rh = rb_hash_new();
73
75
 
74
76
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
75
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
77
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
76
78
  if(mesg->total_timer_time != FIT_UINT32_INVALID)
77
79
  rb_hash_aset(rh, rb_str_new2("total_timer_time"), rb_float_new(mesg->total_timer_time / 1000.0));
78
80
  if(mesg->local_timestamp != FIT_DATE_TIME_INVALID)
79
- rb_hash_aset(rh, rb_str_new2("local_timestamp"), rb_float_new(mesg->local_timestamp + GARMIN_SUCKS_OFFSET));
81
+ rb_hash_aset(rh, rb_str_new2("local_timestamp"), rb_float_new(mesg->local_timestamp + GARMIN_TIME_OFFSET));
80
82
  if(mesg->num_sessions != FIT_UINT16_INVALID)
81
83
  rb_hash_aset(rh, rb_str_new2("num_sessions"), UINT2NUM(mesg->num_sessions));
82
84
  if(mesg->type != FIT_ENUM_INVALID)
@@ -91,11 +93,11 @@ static pass_activity(const FIT_ACTIVITY_MESG *mesg) {
91
93
  rb_funcall(cFitHandler, cFitHandlerActivityFun, 1, rh);
92
94
  }
93
95
 
94
- static pass_record(const FIT_RECORD_MESG *mesg) {
96
+ static void pass_record(const FIT_RECORD_MESG *mesg) {
95
97
  VALUE rh = rb_hash_new();
96
98
 
97
99
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
98
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
100
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
99
101
  if(mesg->position_lat != FIT_SINT32_INVALID)
100
102
  rb_hash_aset(rh, rb_str_new2("position_lat"), fit_pos_to_rb(mesg->position_lat));
101
103
  if(mesg->position_long != FIT_SINT32_INVALID)
@@ -126,13 +128,13 @@ static pass_record(const FIT_RECORD_MESG *mesg) {
126
128
  rb_funcall(cFitHandler, cFitHandlerRecordFun, 1, rh);
127
129
  }
128
130
 
129
- static pass_lap(const FIT_LAP_MESG *mesg) {
131
+ static void pass_lap(const FIT_LAP_MESG *mesg) {
130
132
  VALUE rh = rb_hash_new();
131
133
 
132
134
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
133
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
135
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
134
136
  if(mesg->start_time != FIT_DATE_TIME_INVALID)
135
- rb_hash_aset(rh, rb_str_new2("start_time"), UINT2NUM(mesg->start_time + GARMIN_SUCKS_OFFSET));
137
+ rb_hash_aset(rh, rb_str_new2("start_time"), UINT2NUM(mesg->start_time + GARMIN_TIME_OFFSET));
136
138
  if(mesg->start_position_lat != FIT_SINT32_INVALID)
137
139
  rb_hash_aset(rh, rb_str_new2("start_position_lat"), fit_pos_to_rb(mesg->start_position_lat));
138
140
  if(mesg->start_position_long != FIT_SINT32_INVALID)
@@ -149,14 +151,6 @@ static pass_lap(const FIT_LAP_MESG *mesg) {
149
151
  rb_hash_aset(rh, rb_str_new2("total_distance"), rb_float_new(mesg->total_distance / 100.0));
150
152
  if(mesg->total_cycles != FIT_UINT32_INVALID)
151
153
  rb_hash_aset(rh, rb_str_new2("total_cycles"), UINT2NUM(mesg->total_cycles));
152
- if(mesg->nec_lat != FIT_SINT32_INVALID)
153
- rb_hash_aset(rh, rb_str_new2("nec_lat"), fit_pos_to_rb(mesg->nec_lat));
154
- if(mesg->nec_long != FIT_SINT32_INVALID)
155
- rb_hash_aset(rh, rb_str_new2("nec_long"), fit_pos_to_rb(mesg->nec_long));
156
- if(mesg->swc_lat != FIT_SINT32_INVALID)
157
- rb_hash_aset(rh, rb_str_new2("swc_lat"), fit_pos_to_rb(mesg->swc_lat));
158
- if(mesg->swc_long != FIT_SINT32_INVALID)
159
- rb_hash_aset(rh, rb_str_new2("swc_long"), fit_pos_to_rb(mesg->swc_long));
160
154
  if(mesg->message_index != FIT_UINT16_INVALID)
161
155
  rb_hash_aset(rh, rb_str_new2("message_index"), UINT2NUM(mesg->message_index));
162
156
  if(mesg->total_calories != FIT_UINT16_INVALID)
@@ -199,13 +193,13 @@ static pass_lap(const FIT_LAP_MESG *mesg) {
199
193
  rb_funcall(cFitHandler, cFitHandlerLapFun, 1, rh);
200
194
  }
201
195
 
202
- static pass_session(const FIT_SESSION_MESG *mesg) {
196
+ static void pass_session(const FIT_SESSION_MESG *mesg) {
203
197
  VALUE rh = rb_hash_new();
204
198
 
205
199
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
206
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
200
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
207
201
  if(mesg->start_time != FIT_DATE_TIME_INVALID)
208
- rb_hash_aset(rh, rb_str_new2("start_time"), UINT2NUM(mesg->start_time + GARMIN_SUCKS_OFFSET));
202
+ rb_hash_aset(rh, rb_str_new2("start_time"), UINT2NUM(mesg->start_time + GARMIN_TIME_OFFSET));
209
203
  if(mesg->start_position_lat != FIT_SINT32_INVALID)
210
204
  rb_hash_aset(rh, rb_str_new2("start_position_lat"), fit_pos_to_rb(mesg->start_position_lat));
211
205
  if(mesg->start_position_long != FIT_SINT32_INVALID)
@@ -272,7 +266,7 @@ static pass_session(const FIT_SESSION_MESG *mesg) {
272
266
  rb_funcall(cFitHandler, cFitHandlerSessionFun, 1, rh);
273
267
  }
274
268
 
275
- static pass_user_profile(const FIT_USER_PROFILE_MESG *mesg) {
269
+ static void pass_user_profile(const FIT_USER_PROFILE_MESG *mesg) {
276
270
  VALUE rh = rb_hash_new();
277
271
 
278
272
  if(mesg->friendly_name != FIT_STRING_INVALID)
@@ -317,11 +311,11 @@ static pass_user_profile(const FIT_USER_PROFILE_MESG *mesg) {
317
311
  rb_funcall(cFitHandler, cFitHandlerUserProfileFun, 1, rh);
318
312
  }
319
313
 
320
- static pass_event(const FIT_EVENT_MESG *mesg) {
314
+ static void pass_event(const FIT_EVENT_MESG *mesg) {
321
315
  VALUE rh = rb_hash_new();
322
316
 
323
317
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
324
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
318
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
325
319
  if(mesg->data != FIT_UINT32_INVALID)
326
320
  rb_hash_aset(rh, rb_str_new2("data"), UINT2NUM(mesg->data));
327
321
  if(mesg->data16 != FIT_UINT16_INVALID)
@@ -336,11 +330,11 @@ static pass_event(const FIT_EVENT_MESG *mesg) {
336
330
  rb_funcall(cFitHandler, cFitHandlerEventFun, 1, rh);
337
331
  }
338
332
 
339
- static pass_device_info(const FIT_DEVICE_INFO_MESG *mesg) {
333
+ static void pass_device_info(const FIT_DEVICE_INFO_MESG *mesg) {
340
334
  VALUE rh = rb_hash_new();
341
335
 
342
336
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
343
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
337
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
344
338
  if(mesg->serial_number != FIT_UINT32Z_INVALID)
345
339
  rb_hash_aset(rh, rb_str_new2("serial_number"), UINT2NUM(mesg->serial_number));
346
340
  if(mesg->manufacturer != FIT_MANUFACTURER_INVALID)
@@ -363,11 +357,11 @@ static pass_device_info(const FIT_DEVICE_INFO_MESG *mesg) {
363
357
  rb_funcall(cFitHandler, cFitHandlerDeviceInfoFun, 1, rh);
364
358
  }
365
359
 
366
- static pass_weight_scale_info(const FIT_WEIGHT_SCALE_MESG *mesg) {
360
+ static void pass_weight_scale_info(const FIT_WEIGHT_SCALE_MESG *mesg) {
367
361
  VALUE rh = rb_hash_new();
368
362
 
369
363
  if(mesg->timestamp != FIT_DATE_TIME_INVALID)
370
- rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_SUCKS_OFFSET));
364
+ rb_hash_aset(rh, rb_str_new2("timestamp"), UINT2NUM(mesg->timestamp + GARMIN_TIME_OFFSET));
371
365
  if(mesg->weight != FIT_WEIGHT_INVALID)
372
366
  rb_hash_aset(rh, rb_str_new2("weight"), rb_float_new(mesg->weight / 100.0));
373
367
  if(mesg->percent_fat != FIT_UINT16_INVALID)
@@ -403,7 +397,6 @@ static VALUE parse(VALUE self, VALUE original_str) {
403
397
  FIT_UINT8 buf[8];
404
398
  FIT_CONVERT_RETURN convert_return = FIT_CONVERT_CONTINUE;
405
399
  FIT_UINT32 buf_size;
406
- FIT_UINT32 mesg_index = 0;
407
400
  #if defined(FIT_CONVERT_MULTI_THREAD)
408
401
  FIT_CONVERT_STATE state;
409
402
  #endif
@@ -444,13 +437,10 @@ static VALUE parse(VALUE self, VALUE original_str) {
444
437
  FIT_UINT16 mesg_num = FitConvert_GetMessageNumber();
445
438
  #endif
446
439
 
447
- //sprintf(err_msg, "Mesg %d (%d) - ", mesg_index++, mesg_num);
448
440
  //pass_message(err_msg);
449
441
 
450
442
  switch(mesg_num) {
451
443
  case FIT_MESG_NUM_FILE_ID: {
452
- const FIT_FILE_ID_MESG *id = (FIT_FILE_ID_MESG *) mesg;
453
- //sprintf(err_msg, "File ID: type=%u, number=%u\n", id->type, id->number);
454
444
  //pass_message(err_msg);
455
445
  break;
456
446
  }
@@ -578,7 +568,6 @@ static VALUE parse(VALUE self, VALUE original_str) {
578
568
  void Init_rubyfit() {
579
569
  mRubyFit = rb_define_module("RubyFit");
580
570
  cFitParser = rb_define_class_under(mRubyFit, "FitParser", rb_cObject);
581
- //cFitParser = rb_define_class("FitParser", rb_cObject);
582
571
 
583
572
  //instance methods
584
573
  rb_define_method(cFitParser, "initialize", init, 1);
data/lib/rubyfit/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module Rubyfit
2
- VERSION = "0.0.2"
2
+ VERSION = "0.0.3"
3
3
  end
metadata CHANGED
@@ -1,15 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: rubyfit
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.0.2
5
- prerelease:
4
+ version: 0.0.3
6
5
  platform: ruby
7
6
  authors:
8
7
  - Cullen King
9
8
  autorequire:
10
9
  bindir: bin
11
10
  cert_chain: []
12
- date: 2012-02-23 00:00:00.000000000 Z
11
+ date: 2013-10-02 00:00:00.000000000 Z
13
12
  dependencies: []
14
13
  description: FIT files are binary, and as a result, are a pain to parse. This is
15
14
  a wrapper around the FIT SDK, which makes creating a stream based parser simple.
@@ -22,42 +21,41 @@ extra_rdoc_files: []
22
21
  files:
23
22
  - lib/rubyfit/version.rb
24
23
  - lib/rubyfit.rb
25
- - ext/rubyfit/fit_convert.c
26
- - ext/rubyfit/rubyfit.c
27
24
  - ext/rubyfit/fit.c
25
+ - ext/rubyfit/fit_convert.c
28
26
  - ext/rubyfit/fit_crc.c
29
- - ext/rubyfit/fit_sdk.c
30
- - ext/rubyfit/fit_product.c
27
+ - ext/rubyfit/fit_example.c
28
+ - ext/rubyfit/fit_ram.c
29
+ - ext/rubyfit/rubyfit.c
31
30
  - ext/rubyfit/fit.h
31
+ - ext/rubyfit/fit_config.h
32
32
  - ext/rubyfit/fit_convert.h
33
33
  - ext/rubyfit/fit_crc.h
34
- - ext/rubyfit/fit_config.h
35
- - ext/rubyfit/fit_sdk.h
36
- - ext/rubyfit/fit_product.h
34
+ - ext/rubyfit/fit_example.h
35
+ - ext/rubyfit/fit_ram.h
37
36
  - ext/rubyfit/extconf.rb
38
37
  homepage: http://cullenking.com
39
38
  licenses: []
39
+ metadata: {}
40
40
  post_install_message:
41
41
  rdoc_options: []
42
42
  require_paths:
43
43
  - lib
44
44
  - ext
45
45
  required_ruby_version: !ruby/object:Gem::Requirement
46
- none: false
47
46
  requirements:
48
- - - ! '>='
47
+ - - '>='
49
48
  - !ruby/object:Gem::Version
50
49
  version: '0'
51
50
  required_rubygems_version: !ruby/object:Gem::Requirement
52
- none: false
53
51
  requirements:
54
- - - ! '>='
52
+ - - '>='
55
53
  - !ruby/object:Gem::Version
56
54
  version: '0'
57
55
  requirements: []
58
56
  rubyforge_project: rubyfit
59
- rubygems_version: 1.8.10
57
+ rubygems_version: 2.0.5
60
58
  signing_key:
61
- specification_version: 3
59
+ specification_version: 4
62
60
  summary: A stream based parser for FIT files.
63
61
  test_files: []