joule 1.0.0 → 1.0.1

data/lib/joule/exception/unsupported_file_type_exception.rb

@@ -0,0 +1,7 @@
+class UnsupportedFileTypeException < Exception
+  
+  def initialize
+    message = "Unsupported file type.  Valid file types include SRM (.srm), PowerTap (.csv), iBike (.csv), and Garmin (.tcx)."
+  end
+  
+end

data/lib/joule/hashable.rb

@@ -0,0 +1,9 @@
+module Joule
+  module Hashable
+    def to_hash
+      hash = Hash.new
+      instance_variables.each { |v| hash[ v[1..-1].to_sym ] = instance_variable_get v  }
+      hash
+    end
+  end
+end

data/lib/joule/ibike/parser.rb

@@ -15,50 +15,50 @@ module Joule
       LONGITUDE = 13
       TIMESTAMP = 14
 
-      def parse_header()
+      def parse_properties()
         records = FasterCSV.parse(@data)
         header = records.shift
 
-        @properties = Joule::IBike::Properties.new
-        @properties.version=header[1]
-        @properties.units=header[2]
+        @workout.properties = Joule::IBike::Properties.new
+        @workout.properties.version=header[1]
+        @workout.properties.units=header[2]
         header = records.shift
-        @properties.date_time = Time.mktime(header[0].to_i, header[1].to_i, header[2].to_i, header[3].to_i, header[4].to_i, header[5].to_i)
+        @workout.properties.date_time = Time.mktime(header[0].to_i, header[1].to_i, header[2].to_i, header[3].to_i, header[4].to_i, header[5].to_i)
         records.shift
         header = records.shift
-        @properties.total_weight = header[0]
-        @properties.energy = header[1]
-        @properties.record_interval = header[4].to_i
-        @properties.starting_elevation = header[5]
-        @properties.total_climbing = header[6]
-        @properties.wheel_size = header[7]
-        @properties.temperature = header[8]
-        @properties.starting_pressure = header[9]
-        @properties.wind_scaling = header[10]
-        @properties.riding_tilt = header[11]
-        @properties.calibration_weight = header[12]
-        @properties.cm = header[13]
-        @properties.cda = header[14]
-        @properties.crr = header[15]
+        @workout.properties.total_weight = header[0]
+        @workout.properties.energy = header[1]
+        @workout.properties.record_interval = header[4].to_i
+        @workout.properties.starting_elevation = header[5]
+        @workout.properties.total_climbing = header[6]
+        @workout.properties.wheel_size = header[7]
+        @workout.properties.temperature = header[8]
+        @workout.properties.starting_pressure = header[9]
+        @workout.properties.wind_scaling = header[10]
+        @workout.properties.riding_tilt = header[11]
+        @workout.properties.calibration_weight = header[12]
+        @workout.properties.cm = header[13]
+        @workout.properties.cda = header[14]
+        @workout.properties.crr = header[15]
       end
 
       def parse_data_points()
         records = FasterCSV.parse(@data).slice(5..-1)
         records.each_with_index { |record, index|
           data_point  = DataPoint.new
-          data_point.time  = index * @properties.record_interval
+          data_point.time  = index * @workout.properties.record_interval
           data_point.speed = convert_speed(record[SPEED].to_f)
           data_point.power = record[POWER].to_f
           data_point.distance = convert_distance(record[DISTANCE].to_f)
           data_point.cadence = record[CADENCE].to_i
           data_point.heartrate = record[HEARTRATE].to_i
-          @data_points << data_point 
+          @workout.data_points << data_point 
         }
       end
 
       def parse_markers
         records = FasterCSV.parse(@data).slice(5..-1)
-        @markers << create_workout_marker(records)
+        @workout.markers << create_workout_marker(records)
       end
 
     end

data/lib/joule/marker.rb

@@ -1,53 +1,53 @@
-class Marker
-  attr_accessor :active
-  attr_accessor :average_cadence
-  attr_accessor :average_heartrate
-  attr_accessor :average_power
-  attr_accessor :average_power_to_weight
-  attr_accessor :average_speed
-  attr_accessor :comment
-  attr_accessor :duration_seconds
-  attr_accessor :distance
-  attr_accessor :end
-  attr_accessor :energy
-  attr_accessor :intensity_factor
-  attr_accessor :maximum_cadence
-  attr_accessor :maximum_heartrate
-  attr_accessor :maximum_power
-  attr_accessor :maximum_power_to_weight
-  attr_accessor :maximum_speed 
-  attr_accessor :normalized_power 
-  attr_accessor :start
-  attr_accessor :start_time
-  attr_accessor :training_stress_score 
-  
-  
-  def initialize(options = {})
-    @active = true
-    @average_cadence = 0
-    @average_heartrate = 0
-    @average_power = 0.0
-    @average_power_to_weight = 0.0
-    @average_speed = 0.0
-    @comment = ""
-    @duration_seconds = 0
-    @distance = 0.0
-    @end = options[:end]
-    @energy = 0
-    @intensity_factor = 0
-    @maximum_cadence = 0
-    @maximum_heartrate = 0
-    @maximum_power = 0.0
-    @maximum_power_to_weight = 0.0
-    @maximum_speed = 0.0
-    @normalized_power = 0
-    @start = options[:start]
-    @training_stress_score = 0.0
-    
-  end
-  
-  def start_time_in_seconds
-    (@start_time.hour * 3600) + (@start_time.min * 60) + @start_time.sec
-  end
+module Joule
+  class Marker
+    include Joule::Hashable
+
+    attr_accessor :active
+    attr_accessor :average_cadence
+    attr_accessor :average_heartrate
+    attr_accessor :average_power
+    attr_accessor :average_power_to_weight
+    attr_accessor :average_speed
+    attr_accessor :comment
+    attr_accessor :duration_seconds
+    attr_accessor :distance
+    attr_accessor :end
+    attr_accessor :energy
+    attr_accessor :intensity_factor
+    attr_accessor :maximum_cadence
+    attr_accessor :maximum_heartrate
+    attr_accessor :maximum_power
+    attr_accessor :maximum_power_to_weight
+    attr_accessor :maximum_speed 
+    attr_accessor :normalized_power 
+    attr_accessor :start
+    attr_accessor :training_stress_score 
+
+
+    def initialize(options = {})
+      @active = true
+      @average_cadence = 0
+      @average_heartrate = 0
+      @average_power = 0.0
+      @average_power_to_weight = 0.0
+      @average_speed = 0.0
+      @comment = ""
+      @duration_seconds = 0
+      @distance = 0.0
+      options[:end] ? @end = options[:end] : @end = 0
+      @energy = 0
+      @intensity_factor = 0
+      @maximum_cadence = 0
+      @maximum_heartrate = 0
+      @maximum_power = 0.0
+      @maximum_power_to_weight = 0.0
+      @maximum_speed = 0.0
+      @normalized_power = 0
+      options[:start] ? @start = options[:start] : @start = 0 
+      @training_stress_score = 0.0
+    end
+
+  end  
 end
 
+

data/lib/joule/peak_power.rb

@@ -0,0 +1,13 @@
+module Joule
+  class PeakPower
+    include Joule::Hashable
+    attr_accessor :duration, :value, :start
+    
+    def initialize(duration) 
+      @duration = duration
+      @value = 0
+      @start = 0 
+    end
+    
+  end
+end

data/lib/joule/powertap/parser.rb

@@ -10,16 +10,17 @@ module Joule
       HEARTRATE = 6
       MARKER = 7
 
-      def parse_header()
+      def parse_properties()
         header = FasterCSV.parse(@data).shift
         records = FasterCSV.parse(@data) 
-        @properties = Joule::PowerTap::Properties.new
-        @properties.speed_units = header[SPEED].to_s.downcase
-        @properties.power_units = header[POWER].to_s.downcase
-        @properties.distance_units = header[DISTANCE].to_s.downcase
+        @workout.properties = Joule::PowerTap::Properties.new
+        @workout.properties.speed_units = header[SPEED].to_s.downcase
+        @workout.properties.power_units = header[POWER].to_s.downcase
+        @workout.properties.distance_units = header[DISTANCE].to_s.downcase
         calculate_record_interval(records)
       end
-
+      
+      private
       def parse_data_points()
         records = FasterCSV.parse(@data) 
         records.shift
@@ -34,14 +35,14 @@ module Joule
           data_point.cadence = record[CADENCE].to_i
           data_point.heartrate = (record[HEARTRATE].to_i < 0) && 0 || record[HEARTRATE].to_i
 
-          @data_points << data_point
+          @workout.data_points << data_point
         }  
       end
 
       def parse_markers
         records = FasterCSV.parse(@data) 
         records.shift
-        @markers << create_workout_marker(records)
+        @workout.markers << create_workout_marker(records)
 
         current_marker_index = 0
 
@@ -57,23 +58,23 @@ module Joule
       end
 
       def create_marker(start)
-        if(@markers.size.eql?(1))
-          @markers << Marker.new(:start => 0)
+        if(@workout.markers.size.eql?(1))
+          @workout.markers << Marker.new(:start => 0)
         end  
         set_previous_marker_end(start - 1)
-        @markers << Marker.new(:start => start)
+        @workout.markers << Marker.new(:start => start)
       end
 
       def set_previous_marker_end(value)
-        if(@markers.size > 1)
-          @markers.last.end = value
+        if(@workout.markers.size > 1)
+          @workout.markers.last.end = value
         end
       end
 
       def calculate_record_interval(records)
         times = Array.new
         records[1..30].each_slice(2) {|s| times << ((s[1][MINUTES].to_f - s[0][MINUTES].to_f)  * 60) }
-        @properties.record_interval = times.average.round
+        @workout.properties.record_interval = times.average.round
       end
 
     end

data/lib/joule/srm.rb

@@ -1,2 +1,8 @@
 require 'joule/srm/parser'
-require 'joule/srm/properties'
+require 'joule/srm/properties'
+
+module Joule
+  module SRM
+    FILE_EXTENSION = "srm"
+  end
+end

data/lib/joule/srm/parser.rb

@@ -2,65 +2,44 @@ require 'kconv'
 
 module Joule
   module SRM
-    class Parser
-       include Joule::Calculator::MarkerCalculator
-       include Joule::Calculator::PeakPowerCalculator
-
-       SRM = '.srm'
+    class Parser < Joule::Base::Parser
        HEADER_SIZE=86
        MARKER_SIZE=270
        BLOCK_SIZE=6
 
-       attr_reader :properties, :markers, :data_points, :peak_powers
-
-       def initialize(data)
-         @data = data  
-         @data_points = Array.new
-         @markers = Array.new
-         @peak_powers = Array.new
-       end
-
-       def parse(options = {})
-         parse_header
+       def parse_workout()
          parse_markers
          parse_blocks
          parse_data_points
          parse_data_point_times
-
-         if(options[:calculate_marker_values])
-           calculate_marker_values()
-         end
-
-         if(options[:calculate_peak_power_values])
-           calculate_peak_power_values(:durations => options[:durations], :total_duration => @markers.first.duration_seconds)
-         end
        end
-
-       def parse_header()
+       
+       def parse_properties()
          str = @data.slice(0, HEADER_SIZE)
-         @properties = Joule::SRM::Properties.new
-         @properties.ident=str.slice(0,4)
-         @properties.srm_date = str.slice(4,2).unpack('S')[0]
-         @properties.wheel_size = str.slice(6,2).unpack('S')[0]
-         @properties.record_interval_numerator = str.slice(8,1).unpack('C')[0]
-         @properties.record_interval_denominator = str.slice(9,1).unpack('C')[0]
-         @properties.block_count = str.slice(10,2).unpack('S')[0]
-         @properties.marker_count = str.slice(12,2).unpack('S')[0]
-         @properties.comment = str.slice(16,70).toutf8.strip
+         @workout.properties = Joule::SRM::Properties.new
+         @workout.properties.ident=str.slice(0,4)
+         @workout.properties.srm_date = str.slice(4,2).unpack('S')[0]
+         @workout.properties.wheel_size = str.slice(6,2).unpack('S')[0]
+         @workout.properties.record_interval_numerator = str.slice(8,1).unpack('C')[0]
+         @workout.properties.record_interval_denominator = str.slice(9,1).unpack('C')[0]
+         @workout.properties.block_count = str.slice(10,2).unpack('S')[0]
+         @workout.properties.marker_count = str.slice(12,2).unpack('S')[0]
+         @workout.properties.comment = str.slice(16,70).toutf8.strip
 
          str=@data.slice(HEADER_SIZE + 
-           (MARKER_SIZE * (@properties.marker_count + 1 )) + 
-           (BLOCK_SIZE * @properties.block_count) , 6)
+           (MARKER_SIZE * (@workout.properties.marker_count + 1 )) + 
+           (BLOCK_SIZE * @workout.properties.block_count) , 6)
 
-         @properties.zero_offset = str.slice(0,2).unpack('S')[0]
-         @properties.slope = str.slice(2,2).unpack('S')[0]
-         @properties.record_count = str.slice(4,2).unpack('S')[0]   
+         @workout.properties.zero_offset = str.slice(0,2).unpack('S')[0]
+         @workout.properties.slope = str.slice(2,2).unpack('S')[0]
+         @workout.properties.record_count = str.slice(4,2).unpack('S')[0]   
        end
 
+       private
        def parse_markers
          marker_offset = HEADER_SIZE
 
-         (@properties.marker_count + 1).times { |i|
+         (@workout.properties.marker_count + 1).times { |i|
            str = @data.slice(marker_offset + (i * MARKER_SIZE), MARKER_SIZE)
 
            marker = Marker.new
@@ -68,16 +47,16 @@ module Joule
            marker.active = str.slice(255)
            marker.start = str.slice(256,2).unpack('S')[0] - 1
            marker.end = str.slice(258,2).unpack('S')[0] - 1
-           @markers << marker        
+           @workout.markers << marker        
          }
 
        end
 
        def parse_blocks
-         block_offset = HEADER_SIZE + (MARKER_SIZE * (@properties.marker_count + 1 ))
+         block_offset = HEADER_SIZE + (MARKER_SIZE * (@workout.properties.marker_count + 1 ))
 
          @blocks = Array.new
-         @properties.block_count.times {|i|
+         @workout.properties.block_count.times {|i|
            str=@data.slice(block_offset + (i * BLOCK_SIZE), BLOCK_SIZE)
 
            block = Hash.new
@@ -89,26 +68,26 @@ module Joule
 
        def parse_data_points()
          count = 0
-         start = HEADER_SIZE + (MARKER_SIZE * (@properties.marker_count + 1 )) + (BLOCK_SIZE * @properties.block_count) + 7
-         total_distance = 0
+         start = HEADER_SIZE + (MARKER_SIZE * (@workout.properties.marker_count + 1 )) + (BLOCK_SIZE * @workout.properties.block_count) + 7
+         total_distance = 0.0
 
-         while count < @properties.record_count
+         while count < @workout.properties.record_count
            record=@data.slice(start + (count * 5), 5)
            byte1=record.slice(0)
            byte2=record.slice(1)
            byte3=record.slice(2)
            data_point = DataPoint.new
 
-           data_point.time = count * @properties.record_interval
+           data_point.time = count * @workout.properties.record_interval
            data_point.power = ( (byte2 & 0x0F) | (byte3 << 4) ).to_f
            data_point.speed = ( ( ( (byte2 & 0xF0) << 3) | (byte1 & 0x7F) ) * 32 ) #stored in mm/s
            data_point.cadence = record.slice(3)
            data_point.heartrate = record.slice(4)
 
-           total_distance = total_distance + (data_point.speed * @properties.record_interval) 
+           total_distance = total_distance + (data_point.speed * @workout.properties.record_interval) 
            data_point.distance = total_distance #in mm
 
-           @data_points << data_point
+           @workout.data_points << data_point
            count=count + 1
          end
        end
@@ -118,33 +97,15 @@ module Joule
          @blocks.each { |block|
           relative_count = 0
            while relative_count < block[:count]
-             @data_points[count].time_of_day =  block[:time]/100 + (@properties.record_interval*relative_count)
-             @data_points[count].time_with_pauses = block[:time]/100 - @blocks[0][:time]/100 + (@properties.record_interval*(relative_count + 1))
+             @workout.data_points[count].time_of_day =  block[:time]/100 + (@workout.properties.record_interval*relative_count)
+             @workout.data_points[count].time_with_pauses = block[:time]/100 - @blocks[0][:time]/100 + (@workout.properties.record_interval*(relative_count + 1))
 
              relative_count=relative_count+1
              count=count+1
            end
          }
 
-         @properties.date_time = data_points.first.time_of_day.to_i
-       end
-
-       def calculate_marker_values
-         @markers.each_with_index { |marker, i|
-           calculate_marker_averages marker      
-           calculate_marker_maximums marker
-           calculate_marker_training_metrics marker
-
-           if i.eql?(0)
-             marker.distance = @data_points.last.distance
-           else
-             marker.distance = @data_points[marker.end + 1].distance - @data_points[marker.start].distance
-           end
-
-           marker.duration_seconds = (marker.end - marker.start + 1) * @properties.record_interval
-           marker.energy = (marker.average_power.round * marker.duration_seconds)/1000
-
-         }
+         @workout.properties.date_time = @workout.data_points.first.time_of_day.to_i
        end
 
      end