postrunner 0.0.11 → 0.1.0

data/lib/postrunner/Percentiles.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Percentiles.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2015 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+module PostRunner
+
+  # This class can be used to partition sets according to a given percentile.
+  class Percentiles
+
+    # Create a Percentiles object for the given data set.
+    # @param set [Array] It must be an Array of tuples (2 element Array). The
+    #        first element is the actual value, the second does not matter for
+    #        the computation. It is usually a reference to the context of the
+    #        value.
+    def initialize(set)
+      @set = set.sort { |e1, e2| e1[0] <=> e2[0] }
+    end
+
+    # @return [Array] Return the tuples that are within the given percentile.
+    # @param x [Float] Percentage value
+    def tp_x(x)
+      split_idx = (x / 100.0 * @set.size).to_i
+      @set[0..split_idx]
+    end
+
+    # @return [Array] Return the tuples that are not within the given
+    #         percentile.
+    # @param x [Float] Percentage value
+    def not_tp_x(x)
+      split_idx = (x / 100.0 * @set.size).to_i
+      @set[split_idx..-1]
+    end
+
+  end
+
+end
+

data/lib/postrunner/PersonalRecords.rb

@@ -1,28 +1,22 @@
 #!/usr/bin/env ruby -w
 # encoding: UTF-8
 #
-# = PersonalRecords.rb -- PostRunner - Manage the data from your Garmin sport devices.
+# = FitFileStore.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2014, 2015 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 2014, 2015, 2016 by Chris Schlaeger <cs@taskjuggler.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
 # published by the Free Software Foundation.
 #
 
-require 'fileutils'
-require 'yaml'
-
-require 'fit4ruby'
-require 'postrunner/BackedUpFile'
 require 'postrunner/RecordListPageView'
-require 'postrunner/ActivityLink'
 
 module PostRunner
 
   # The PersonalRecords class stores the various records. Records are grouped
   # by specific year or all-time records.
-  class PersonalRecords
+  class PersonalRecords < PEROBS::Object
 
     include Fit4Ruby::Converters
 
@@ -78,13 +72,11 @@ module PostRunner
       }
     }
 
-    # The Record class stores a single speed or longest distance record. It
-    # also stores a reference to the Activity that contains the record.
-    class Record
+    po_attr :sport_records
 
-      include Fit4Ruby::Converters
+    class ActivityResult
 
-      attr_accessor :activity, :sport, :distance, :duration, :start_time
+      attr_reader :activity, :sport, :distance, :duration, :start_time
 
       def initialize(activity, sport, distance, duration, start_time)
         @activity = activity
@@ -94,32 +86,56 @@ module PostRunner
         @start_time = start_time
       end
 
+    end
+
+    # The Record class stores a single speed or longest distance record. It
+    # also stores a reference to the Activity that contains the record.
+    class Record < PEROBS::Object
+
+      include Fit4Ruby::Converters
+
+      po_attr :activity, :sport, :distance, :duration, :start_time
+
+      def initialize(p, result)
+        super(p)
+
+        self.activity = result.activity
+        self.sport = result.sport
+        self.distance = result.distance
+        self.duration = result.duration
+        self.start_time = result.start_time
+      end
+
       def to_table_row(t)
         t.row((@duration.nil? ?
                [ 'Longest Distance', '%.3f km' % (@distance / 1000.0), '-' ] :
                [ PersonalRecords::SpeedRecordDistances[@sport][@distance],
                  secsToHMS(@duration),
                  speedToPace(@distance / @duration) ]) +
-        [ @activity.db.ref_by_fit_file(@activity.fit_file),
-          ActivityLink.new(@activity, false),
-          @start_time.strftime("%Y-%m-%d") ])
+              [ @store['file_store'].ref_by_activity(@activity),
+                ActivityLink.new(@activity, false),
+                @start_time.strftime("%Y-%m-%d") ])
       end
 
     end
 
-    class RecordSet
+    class RecordSet < PEROBS::Object
 
       include Fit4Ruby::Converters
 
-      attr_reader :year
+      po_attr :sport, :year, :distance_record, :speed_records
 
-      def initialize(sport, year)
-        @sport = sport
-        @year = year
-        @distance_record = nil
-        @speed_records = {}
-        PersonalRecords::SpeedRecordDistances[@sport].each_key do |dist|
-          @speed_records[dist] = nil
+      def initialize(p, sport, year)
+        super(p)
+
+        self.sport = sport
+        self.year = year
+        self.distance_record = nil
+        self.speed_records = @store.new(PEROBS::Hash)
+        if sport
+          PersonalRecords::SpeedRecordDistances[sport].each_key do |dist|
+            @speed_records[dist.to_s] = nil
+          end
         end
       end
 
@@ -131,9 +147,9 @@ module PostRunner
             Log.fatal "Unknown record distance #{result.distance}"
           end
 
-          old_record = @speed_records[result.distance]
+          old_record = @speed_records[result.distance.to_s]
           if old_record.nil? || old_record.duration > result.duration
-            @speed_records[result.distance] = result
+            @speed_records[result.distance.to_s] = @store.new(Record, result)
             Log.info "New #{@year ? @year.to_s : 'all-time'} " +
                      "#{result.sport} speed record for " +
                      "#{PersonalRecords::SpeedRecordDistances[@sport][
@@ -145,7 +161,8 @@ module PostRunner
           # We have a potential distance record.
           if @distance_record.nil? ||
              @distance_record.distance < result.distance
-            @distance_record = result
+            self.distance_record = @store.new(Record, result)
+            raise RuntimeError if @distance_record.is_a?(String)
             Log.info "New #{@year ? @year.to_s : 'all-time'} " +
                      "#{result.sport} distance record: #{result.distance} m"
             return true
@@ -156,14 +173,20 @@ module PostRunner
       end
 
       def delete_activity(activity)
+        record_deleted = false
         if @distance_record && @distance_record.activity == activity
-          @distance_record = nil
+          self.distance_record = nil
+          record_deleted = true
         end
         PersonalRecords::SpeedRecordDistances[@sport].each_key do |dist|
+          dist = dist.to_s
           if @speed_records[dist] && @speed_records[dist].activity == activity
             @speed_records[dist] = nil
+            record_deleted = true
           end
         end
+
+        record_deleted
       end
 
       # Return true if no Record is stored in this RecordSet object.
@@ -210,33 +233,33 @@ module PostRunner
         ])
         t.body
 
-        records = @speed_records.values.delete_if { |r| r.nil? }
+        records = @speed_records.values.delete_if { |r| r.nil? }.
+                  sort { |r1, r2| r1.distance <=> r2.distance }
         records << @distance_record if @distance_record
 
-        records.sort { |r1, r2| r1.distance <=> r2.distance }.each do |r|
-          r.to_table_row(t)
-        end
+        records.each { |r| r.to_table_row(t) }
 
         t
       end
 
-
     end
 
-    class SportRecords
+    class SportRecords < PEROBS::Object
 
-      attr_reader :sport, :all_time, :yearly
+      po_attr :sport, :all_time, :yearly
 
-      def initialize(sport)
-        @sport = sport
-        @all_time = RecordSet.new(@sport, nil)
-        @yearly = {}
+      def initialize(p, sport)
+        super(p)
+
+        self.sport = sport
+        self.all_time = @store.new(RecordSet, sport, nil)
+        self.yearly = @store.new(PEROBS::Hash)
       end
 
       def register_result(result)
-        year = result.start_time.year
+        year = result.start_time.year.to_s
         unless @yearly[year]
-          @yearly[year] = RecordSet.new(@sport, year)
+          @yearly[year] = @store.new(RecordSet, @sport, year)
         end
 
         new_at = @all_time.register_result(result)
@@ -246,9 +269,12 @@ module PostRunner
       end
 
       def delete_activity(activity)
+        record_deleted = false
         ([ @all_time ] + @yearly.values).each do |r|
-          r.delete_activity(activity)
+          record_deleted = true if r.delete_activity(activity)
         end
+
+        record_deleted
       end
 
       # Return true if no record is stored in this SportRecords object.
@@ -285,8 +311,9 @@ module PostRunner
         doc.div {
           doc.h3('All-time records')
           @all_time.to_html(doc)
-          @yearly.values.sort{ |r1, r2| r2.year <=> r1.year }.each do |record|
-            puts record.year
+          @yearly.values.sort do |r1, r2|
+            r2.year.to_i <=> r1.year.to_i
+          end.each do |record|
             unless record.empty?
               doc.h3("Records of #{record.year}")
               record.to_html(doc)
@@ -297,47 +324,161 @@ module PostRunner
 
     end
 
-    def initialize(activities)
-      @activities = activities
-      @db_dir = activities.db_dir
-      @records_file = File.join(@db_dir, 'records.yml')
+    def initialize(p)
+      super(p)
+
+      self.sport_records = @store.new(PEROBS::Hash)
       delete_all_records
+    end
+
+    def scan_activity_for_records(activity, report_update_requested = false)
+      # If we have the @norecord flag set, we ignore this Activity for the
+      # record collection.
+      return if activity.norecord
+
+      activity.load_fit_file
+
+      distance_record = 0.0
+      distance_record_sport = nil
+      # Array with popular distances (in meters) in ascending order.
+      record_distances = nil
+      # Speed records for popular distances (seconds hashed by distance in
+      # meters)
+      speed_records = {}
+
+      segment_start_time = activity.fit_activity.sessions[0].start_time
+      segment_start_distance = 0.0
+
+      sport = nil
+      last_timestamp = nil
+      last_distance = nil
+
+      activity.fit_activity.records.each do |record|
+        if record.distance.nil?
+          # All records must have a valid distance mark or the activity does
+          # not qualify for a personal record.
+          Log.warn "Found a record without a valid distance"
+          return
+        end
+        if record.timestamp.nil?
+          Log.warn "Found a record without a valid timestamp"
+          return
+        end
+
+        unless sport
+          # If the Activity has sport set to 'multisport' or 'all' we pick up
+          # the sport from the FIT records. Otherwise, we just use whatever
+          # sport the Activity provides.
+          if activity.sport == 'multisport' || activity.sport == 'all'
+            sport = record.activity_type
+          else
+            sport = activity.sport
+          end
+          return unless SpeedRecordDistances.include?(sport)
+
+          record_distances = SpeedRecordDistances[sport].
+            keys.sort
+        end
+
+        segment_start_distance = record.distance unless segment_start_distance
+        segment_start_time = record.timestamp unless segment_start_time
+
+        # Total distance covered in this segment so far
+        segment_distance = record.distance - segment_start_distance
+        # Check if we have reached the next popular distance.
+        if record_distances.first &&
+           segment_distance >= record_distances.first
+          segment_duration = record.timestamp - segment_start_time
+          # The distance may be somewhat larger than a popular distance. We
+          # normalize the time to the norm distance.
+          norm_duration = segment_duration / segment_distance *
+            record_distances.first
+          # Save the time for this distance.
+          speed_records[record_distances.first] = {
+            :time => norm_duration, :sport => sport
+          }
+          # Switch to the next popular distance.
+          record_distances.shift
+        end
 
-      load_records
+        # We've reached the end of a segment if the sport type changes, we
+        # detect a pause of more than 30 seconds or when we've reached the
+        # last record.
+        if (record.activity_type && sport && record.activity_type != sport) ||
+           (last_timestamp && (record.timestamp - last_timestamp) > 30) ||
+           record.equal?(activity.fit_activity.records.last)
+
+          # Check for a total distance record
+          if segment_distance > distance_record
+            distance_record = segment_distance
+            distance_record_sport = sport
+          end
+
+          # Prepare for the next segment in this Activity
+          segment_start_distance = nil
+          segment_start_time = nil
+          sport = nil
+        end
+
+        last_timestamp = record.timestamp
+        last_distance = record.distance
+      end
+
+      # Store the found records
+      start_time = activity.fit_activity.sessions[0].timestamp
+      update_reports = false
+      if distance_record_sport
+        if register_result(activity, distance_record_sport, distance_record,
+                           nil, start_time)
+          update_reports = true
+        end
+      end
+      speed_records.each do |dist, info|
+        if register_result(activity, info[:sport], dist, info[:time],
+                           start_time)
+          update_reports = true
+        end
+      end
+
+      generate_html_reports if update_reports && report_update_requested
     end
 
     def register_result(activity, sport, distance, duration, start_time)
       unless @sport_records.include?(sport)
         Log.info "Ignoring records for activity type '#{sport}' in " +
-                 "#{activity.fit_file}"
+                 "#{activity.fit_file_name}"
         return false
       end
 
-      result = Record.new(activity, sport, distance, duration, start_time)
+      result = ActivityResult.new(activity, sport, distance, duration,
+                                  start_time)
       @sport_records[sport].register_result(result)
     end
 
     def delete_all_records
-      @sport_records = {}
+      @sport_records.clear
       SpeedRecordDistances.keys.each do |sport|
-        @sport_records[sport] = SportRecords.new(sport)
+        @sport_records[sport] = @store.new(SportRecords, sport)
       end
     end
 
     def delete_activity(activity)
-      @sport_records.each_value { |r| r.delete_activity(activity) }
-    end
+      record_deleted = false
+      @sport_records.each_value do |r|
+        record_deleted = true if r.delete_activity(activity)
+      end
 
-    def sync
-      save_records
+      record_deleted
+    end
 
+    def generate_html_reports
       non_empty_records = @sport_records.select { |s, r| !r.empty? }
       max = non_empty_records.length
       i = 0
       non_empty_records.each do |sport, record|
-        output_file = File.join(@activities.cfg[:html_dir],
+        output_file = File.join(@store['config']['html_dir'],
                                 "records-#{i}.html")
-        RecordListPageView.new(@activities, record, max, i).
+        RecordListPageView.new(@store['file_store'], record, max, i).
                                write(output_file)
         i += 1
       end
@@ -362,8 +503,7 @@ module PostRunner
     def activity_records(activity)
       records = []
       each do |record|
-      #  puts record.activity
-        if record.activity.equal?(activity) && !records.include?(record)
+        if record.activity.equal?(activity)
           records << record
         end
       end
@@ -371,57 +511,6 @@ module PostRunner
       records
     end
 
-    private
-
-    def load_records
-      begin
-        if File.exists?(@records_file)
-          @sport_records = YAML.load_file(@records_file)
-        else
-          Log.info "No records file found at '#{@records_file}'"
-        end
-      rescue IOError
-        Log.fatal "Cannot load records file '#{@records_file}': #{$!}"
-      end
-
-      unless @sport_records.is_a?(Hash)
-        Log.fatal "The personal records file '#{@records_file}' is corrupted"
-      end
-      fit_file_names_to_activity_refs
-    end
-
-    def save_records
-      activity_refs_to_fit_file_names
-      begin
-        BackedUpFile.open(@records_file, 'w') do |f|
-          f.write(@sport_records.to_yaml)
-        end
-      rescue IOError
-        Log.fatal "Cannot write records file '#{@records_file}': #{$!}"
-      end
-      fit_file_names_to_activity_refs
-    end
-
-    # Convert FIT file names in all Record objects into Activity references.
-    def fit_file_names_to_activity_refs
-      each do |record|
-        # Record objects can be referenced multiple times.
-        if record.activity.is_a?(String)
-          record.activity = @activities.activity_by_fit_file(record.activity)
-        end
-      end
-    end
-
-    # Convert Activity references in all Record objects into FIT file names.
-    def activity_refs_to_fit_file_names
-      each do |record|
-        # Record objects can be referenced multiple times.
-        unless record.activity.is_a?(String)
-          record.activity = record.activity.fit_file
-        end
-      end
-    end
-
   end
 
 end