fit_parser 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfe16c1aae89815b69c6e91a5fdc5da00755a8a3
-  data.tar.gz: 37f28492ce843593331c48abd109359e80b290a0
+  metadata.gz: 26a162b17897f536d316acc8e36dad49d36a3a72
+  data.tar.gz: 597240fbd8ee2fef1a95e1165e9a1fcb95f1948d
 SHA512:
-  metadata.gz: 8e6191854d0c785710063ca83ec4d4fda9fc0f2e39a4dde31a85595f2678037ef4a3d8fcfebcb175f97074207cff27ab86a521be9ee827847b138fb29200dcb9
-  data.tar.gz: 07caf2f96cde4c0f98386267cd4199f0c7c6a661794db9e51e7e76838f19bdf01753f8b31c26ea5e4e10b35e46e20c26678e054baed82a948920c14ab3afd395
+  metadata.gz: 67a8ee06d504f0a96a7a3a3b1619692b287192830fdeb252c701dad9f7eb7dfb8dc1084ab36d7ef640ce2955110c099a6f29e16699c9734f9b8a77d2b729f829
+  data.tar.gz: 7c4795cb5492141343f2f6c50dc3b866b6a3101bfc6b05a56ec5cc6403adaf5befaf0bb14644c2d0df4ca52172094893f7f2ba3f963b0bb9bde68073a39d61de

data/lib/fit_parser/file/data.rb

@@ -1,8 +1,7 @@
 module FitParser
   class File
     class Data < BinData::Record
-
-      class_attribute :global_message_number, :instance_writer => false
+      class_attribute :global_message_number, instance_writer: false
 
       def self.generate(definition)
         msg_num = definition.global_message_number.snapshot
@@ -20,15 +19,15 @@ module FitParser
           RUBY
 
           definition.fields.each do |field|
-            code = ""
+            code = ''
 
             # in case the field size is a multiple of the field length, we must build an array
-            if (field.type != "string" and field.size > field.length)
+            if field.type != 'string' && field.size > field.length
               code << "array :#{field.raw_name}, :type => :#{field.type}, :initial_length => #{field.size/field.length}\n"
             else
               # string are not null terminated when they have exactly the lenght of the field
               code << "#{field.type} :#{field.raw_name}"
-              if field.type == "string"
+              if field.type == 'string'
                 code << ", :read_length => #{field.size}, :trim_padding => true"
               end
               code << "\n"
@@ -52,48 +51,46 @@ module FitParser
               end
             RUBY
 
-            class_eval code , __FILE__, __LINE__ + 1
+            class_eval code, __FILE__, __LINE__ + 1
           end
-      
+
           private
-			      # return the dynamic value if relevant
-            # otherwise, it returns value (scaled if necessary)
-            def get_value raw_value, raw_type, raw_scale, dyn_data
-              val = get_dyn_value(dyn_data, raw_value)
-              return val unless val.nil?
-              if raw_scale
-                if raw_value.is_a? Enumerable
-                  raw_value.map { |elt| elt / raw_scale }
-                else
-                  raw_value / raw_scale
-                end
+
+          # return the dynamic value if relevant
+          # otherwise, it returns value (scaled if necessary)
+          def get_value(raw_value, raw_type, raw_scale, dyn_data)
+            val = get_dyn_value(dyn_data, raw_value)
+            return val unless val.nil?
+            if raw_scale
+              if raw_value.is_a? Enumerable
+                raw_value.map { |elt| elt / raw_scale }
               else
-                get_real_value raw_type, raw_value
+                raw_value / raw_scale
               end
+            else
+              get_real_value raw_type, raw_value
             end
+          end
 
-            # return the value based on real type
-            def get_real_value( real_type, raw_value)
-              type = Type.get_type(real_type.to_sym)
-              # TODO: manage case where an array is returned
-              type ? type.value(raw_value) : raw_value
-            end
+          # return the value based on real type
+          def get_real_value(real_type, raw_value)
+            type = Type.get_type(real_type.to_sym)
+            # TODO: manage case where an array is returned
+            type ? type.value(raw_value) : raw_value
+          end
 
-            def get_dyn_value dyn_data, raw_value
-              return nil if dyn_data.nil?
-              dyn_data.each do |key, dyn|
-                # make sure method exist before calling send (all fields are not always defined)
-                if( self.respond_to?("raw_#{dyn[:ref_field_name]}") &&
-                    dyn[:ref_field_values].include?(self.send("raw_#{dyn[:ref_field_name]}")))
-                  return get_real_value(dyn[:type], raw_value)
-                end
+          def get_dyn_value(dyn_data, raw_value)
+            return nil if dyn_data.nil?
+            dyn_data.each do |key, dyn|
+              # make sure method exist before calling send (all fields are not always defined)
+              if respond_to?("raw_#{dyn[:ref_field_name]}") && dyn[:ref_field_values].include?(send("raw_#{dyn[:ref_field_name]}"))
+                return get_real_value(dyn[:type], raw_value)
               end
-              nil
             end
-
+            nil
+          end
         end
       end
-
     end
   end
 end

data/lib/fit_parser/file/definition.rb

@@ -1,7 +1,6 @@
 module FitParser
   class File
     class Definition < BinData::Record
-
       class Field < BinData::Record
         hide :reserved_bits
 
@@ -14,7 +13,7 @@ module FitParser
         def data
           @data ||= Definitions.get_field(parent.parent.global_message_number.snapshot,
                                           field_definition_number.snapshot) ||
-                      { :name => "field_#{field_definition_number.snapshot}", :scale => nil }
+                      { name: "field_#{field_definition_number.snapshot}", scale: nil }
         end
 
         def dyn_data
@@ -58,13 +57,13 @@ module FitParser
             # some cases found where string has the max field length
             # and is therefore not null terminated
             @length = 1
-            "string"
+            'string'
           when 8
             @length = 4
-            "float"
+            'float'
           when 9
             @length = 8
-            "double"
+            'double'
           when 10 # uint8z
             build_int_type 8, false
           when 11 # uint16z
@@ -74,7 +73,7 @@ module FitParser
           when 13 # array of bytes
             build_int_type 8, false
           else
-            raise "Can't map base_type_number #{base_type_number} to a data type"
+            fail "Can't map base_type_number #{base_type_number} to a data type"
           end
         end
 
@@ -82,7 +81,7 @@ module FitParser
         def size
           field_size
         end
-        
+
         # return the length in byte of the given type
         def length
           @length
@@ -92,19 +91,19 @@ module FitParser
 
         def build_int_type(length, signed)
           # @length is in byte not in bits, so divide by 8
-          @length = length/8
+          @length = length / 8
           (signed ? '' : 'u') << 'int' << length.to_s
         end
       end
 
-      skip :length => 1
+      skip length: 1
       bit8 :architecture
-      choice :global_message_number, :selection => :architecture do
+      choice :global_message_number, selection: :architecture do
         uint16le 0
         uint16be 1
       end
       bit8 :field_count
-      array :fields, :type => Field, :initial_length => :field_count
+      array :fields, type: Field, initial_length: :field_count
 
       def endianness
         architecture.snapshot == 0 ? :little : :big
@@ -113,8 +112,6 @@ module FitParser
       def record_type
         :definition
       end
-
     end
   end
 end
-