postrunner 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c193dbf151045522cfe8f47b729d244eb87f957
-  data.tar.gz: fb92f5b286258cac2c17e96dae821d858face419
+  metadata.gz: dd23d401a204deb3a2bdb839097e78c7eafc9b17
+  data.tar.gz: a97ce94a450b07cb1744d6b65ee42f463144ae2a
 SHA512:
-  metadata.gz: 2a01b57478175e684b1253e30174e46ee5b3119dd8a2941a8cf6141255e7955c6628fff6a20167c3421feaee0ca7c857370ae8c05a4d7ae114fb6730df909953
-  data.tar.gz: b3f8c2ad6fa0effd9958a4102b6280e373c5bf11a3c90982bfdaaffaeb14d90f03fff37460963d51e6600cd9432f36b11338a86e3b5eb19536252fcd37e4c048
+  metadata.gz: beb4337b53ade2b2ff109f95f59a1d4bc3f21c1d1abc7f97101f046e45db78cf3d3bcc677a88b6ce1d14373a582397540ac8c0192a429d3056bf578e820e55ac
+  data.tar.gz: 32b1f9ef0128568d5d0e909c205477e955fcedca800f12d47406e499366eb4e26bdabae8b9811ce5d66a1197a7b9d0a28da919522be787ecd31fd7bb4b8ad6f3

data/lib/postrunner/ActivitiesDB.rb

@@ -3,7 +3,7 @@
 #
 # = ActivitiesDB.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 2014, 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
@@ -14,22 +14,24 @@ require 'fileutils'
 require 'yaml'
 
 require 'fit4ruby'
+require 'postrunner/BackedUpFile'
 require 'postrunner/Activity'
 require 'postrunner/PersonalRecords'
 require 'postrunner/ActivityListView'
+require 'postrunner/ViewButtons'
 
 module PostRunner
 
   class ActivitiesDB
 
-    attr_reader :db_dir, :cfg, :fit_dir, :html_dir, :activities
+    attr_reader :db_dir, :cfg, :fit_dir, :activities, :records, :views
 
     def initialize(db_dir, cfg)
       @db_dir = db_dir
       @cfg = cfg
       @fit_dir = File.join(@db_dir, 'fit')
-      @html_dir = File.join(@db_dir, 'html')
       @archive_file = File.join(@db_dir, 'archive.yml')
+      @auxilliary_dirs = %w( icons jquery flot openlayers )
 
       create_directories
       begin
@@ -38,7 +40,7 @@ module PostRunner
         else
           @activities = []
         end
-      rescue StandardError
+      rescue RuntimeError
         Log.fatal "Cannot load archive file '#{@archive_file}': #{$!}"
       end
 
@@ -58,10 +60,31 @@ module PostRunner
         sync_needed |= !a.fit_activity.nil?
       end
 
+      # Define which View objects the HTML output will contain off. This
+      # doesn't really belong in ActivitiesDB but for now it's the best place
+      # to put it.
+      @views = ViewButtons.new([
+        NavButtonDef.new('activities.png', 'index.html'),
+        NavButtonDef.new('record.png', "records-0.html")
+      ])
+
       @records = PersonalRecords.new(self)
       sync if sync_needed
     end
 
+    # Ensure that all necessary directories are present to store the output
+    # files. This method is idempotent and can be called even when directories
+    # exist already.
+    def create_directories
+      create_directory(@db_dir, 'data')
+      create_directory(@fit_dir, 'fit')
+      create_directory(@cfg[:html_dir], 'html')
+
+      @auxilliary_dirs.each do |dir|
+        create_auxdir(dir)
+      end
+    end
+
     # Add a new FIT file to the database.
     # @param fit_file [String] Name of the FIT file.
     # @return [TrueClass or FalseClass] True if the file could be added. False
@@ -84,6 +107,10 @@ module PostRunner
         Log.error $!
         return false
       end
+      unless fit_activity
+        Log.error "#{fit_file} does not contain any activity records"
+        return false
+      end
 
       begin
         FileUtils.cp(fit_file, @fit_dir)
@@ -97,7 +124,10 @@ module PostRunner
         a2.timestamp <=> a1.timestamp
       end
 
-      activity.register_records(@records)
+      activity.register_records
+
+      # Generate HTML file for this activity.
+      activity.generate_html_view
 
       # The HTML activity views contain links to their predecessors and
       # successors. After inserting a new activity, we need to re-generate
@@ -116,10 +146,11 @@ module PostRunner
     end
 
     def delete(activity)
-      pred = predecessor(activities)
-      succ = successor(activities)
+      pred = predecessor(activity)
+      succ = successor(activity)
 
       @activities.delete(activity)
+      @records.delete_activity(activity)
 
       # The HTML activity views contain links to their predecessors and
       # successors. After deleting an activity, we need to re-generate these
@@ -135,8 +166,19 @@ module PostRunner
       sync
     end
 
+    def set(activity, attribute, value)
+      activity.set(attribute, value)
+      sync
+    end
+
     def check
-      @activities.each { |a| a.check }
+      @records.delete_all_records
+      @activities.sort do |a1, a2|
+        a1.timestamp <=> a2.timestamp
+      end.each { |a| a.check }
+      @records.sync
+      # Ensure that HTML index is up-to-date.
+      ActivityListView.new(self).update_index_pages
     end
 
     def ref_by_fit_file(fit_file)
@@ -189,11 +231,12 @@ module PostRunner
       @activities[idx - 1]
     end
 
-    # Return the previous Activity before the provided activity. Note that
-    # this has a higher index. If none is found, return nil.
+    # Return the previous Activity before the provided activity.
+    # If none is found, return nil.
     def predecessor(activity)
       idx = @activities.index(activity)
-      return nil if idx.nil? || idx >= @activities.length - 2
+      return nil if idx.nil?
+      # Activities indexes are reversed. The predecessor has a higher index.
       @activities[idx + 1]
     end
 
@@ -231,8 +274,8 @@ module PostRunner
 
     # Show the activity list in a web browser.
     def show_list_in_browser
-      ActivityListView.new(self).update_html_index
-      show_in_browser(File.join(@html_dir, 'index.html'))
+      ActivityListView.new(self).update_index_pages
+      show_in_browser(File.join(@cfg[:html_dir], 'index.html'))
     end
 
     def list
@@ -243,6 +286,10 @@ module PostRunner
       puts @records.to_s
     end
 
+    def activity_records(activity)
+      @records.activity_records(activity)
+    end
+
     # Launch a web browser and show an HTML file.
     # @param html_file [String] file name of the HTML file to show
     def show_in_browser(html_file)
@@ -262,32 +309,39 @@ module PostRunner
       @activities.each { |a| a.generate_html_view }
       Log.info "All HTML report files have been re-generated."
       # (Re-)generate index files.
-      ActivityListView.new(self).update_html_index
+      ActivityListView.new(self).update_index_pages
       Log.info "HTML index files have been updated."
     end
 
+    # Take all necessary steps to convert user data to match an updated
+    # PostRunner version.
+    def handle_version_update
+      # An updated version may bring new auxilliary directories. We remove the
+      # old directories and create new copies.
+      Log.warn('Removing old HTML auxilliary directories')
+      @auxilliary_dirs.each do |dir|
+        auxdir = File.join(@cfg[:html_dir], dir)
+        FileUtils.rm_rf(auxdir)
+      end
+      create_directories
+
+      Log.warn('Updating HTML files...')
+      generate_all_html_reports
+    end
+
     private
 
     def sync
       begin
-        File.open(@archive_file, 'w') { |f| f.write(@activities.to_yaml) }
+        BackedUpFile.open(@archive_file, 'w') do |f|
+          f.write(@activities.to_yaml)
+        end
       rescue StandardError
         Log.fatal "Cannot write archive file '#{@archive_file}': #{$!}"
       end
 
       @records.sync
-      ActivityListView.new(self).update_html_index
-    end
-
-    def create_directories
-      create_directory(@db_dir, 'data')
-      create_directory(@fit_dir, 'fit')
-      create_directory(@html_dir, 'html')
-
-      create_symlink('icons')
-      create_symlink('jquery')
-      create_symlink('flot')
-      create_symlink('openlayers')
+      ActivityListView.new(self).update_index_pages
     end
 
     def create_directory(dir, name)
@@ -301,7 +355,7 @@ module PostRunner
       end
     end
 
-    def create_symlink(dir)
+    def create_auxdir(dir)
       # This file should be in lib/postrunner. The 'misc' directory should be
       # found in '../../misc'.
       misc_dir = File.realpath(File.join(File.dirname(__FILE__),
@@ -313,12 +367,13 @@ module PostRunner
       unless Dir.exists?(src_dir)
         Log.fatal "Cannot find '#{src_dir}': #{$!}"
       end
-      dst_dir = File.join(@html_dir, dir)
+      dst_dir = File.join(@cfg[:html_dir], dir)
       unless File.exists?(dst_dir)
         begin
-          FileUtils.ln_s(src_dir, dst_dir)
+          #FileUtils.ln_s(src_dir, dst_dir)
+          FileUtils.cp_r(src_dir, dst_dir)
         rescue IOError
-          Log.fatal "Cannot create symbolic link to '#{dst_dir}': #{$!}"
+          Log.fatal "Cannot create auxilliary directory '#{dst_dir}': #{$!}"
         end
       end
     end

data/lib/postrunner/Activity.rb

@@ -3,7 +3,7 @@
 #
 # = Activity.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 2014, 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
@@ -19,19 +19,73 @@ module PostRunner
 
   class Activity
 
-    attr_reader :db, :fit_file, :name, :fit_activity, :html_dir, :html_file
+    attr_reader :db, :fit_file, :name, :fit_activity
 
     # This is a list of variables that provide data from the fit file. To
     # speed up access to it, we cache the data in the activity database.
-    @@CachedActivityValues = %w( sport timestamp total_distance
-                            total_timer_time avg_speed )
+    @@CachedActivityValues = %w( sport sub_sport timestamp total_distance
+                                 total_timer_time avg_speed )
     # We also store some additional information in the archive index.
     @@CachedAttributes = @@CachedActivityValues + %w( fit_file name )
 
+    ActivityTypes = {
+      'generic' => 'Generic',
+      'running' => 'Running',
+      'cycling' => 'Cycling',
+      'transition' => 'Transition',
+      'fitness_equipment' => 'Fitness Equipment',
+      'swimming' => 'Swimming',
+      'basketball' => 'Basketball',
+      'soccer' => 'Soccer',
+      'tennis' => 'Tennis',
+      'american_football' => 'American Football',
+      'walking' => 'Walking',
+      'cross_country_skiing' => 'Cross Country Skiing',
+      'alpine_skiing' => 'Alpine Skiing',
+      'snowboarding' => 'Snowboarding',
+      'rowing' => 'Rowing',
+      'mountaineering' => 'Mountaneering',
+      'hiking' => 'Hiking',
+      'multisport' => 'Multisport',
+      'paddling' => 'Paddling',
+      'all' => 'All'
+    }
+    ActivitySubTypes = {
+      'generic' => 'Generic',
+      'treadmill' => 'Treadmill',
+      'street' => 'Street',
+      'trail' => 'Trail',
+      'track' => 'Track',
+      'spin' => 'Spin',
+      'indoor_cycling' => 'Indoor Cycling',
+      'road' => 'Road',
+      'mountain' => 'Mountain',
+      'downhill' => 'Downhill',
+      'recumbent' => 'Recumbent',
+      'cyclocross' => 'Cyclocross',
+      'hand_cycling' => 'Hand Cycling',
+      'track_cycling' => 'Track Cycling',
+      'indoor_rowing' => 'Indoor Rowing',
+      'elliptical' => 'Elliptical',
+      'stair_climbing' => 'Stair Climbing',
+      'lap_swimming' => 'Lap Swimming',
+      'open_water' => 'Open Water',
+      'flexibility_training' => 'Flexibility Training',
+      'strength_training' => 'Strength Training',
+      'warm_up' => 'Warm up',
+      'match' => 'Match',
+      'exercise' => 'Excersize',
+      'challenge' => 'Challenge',
+      'indoor_skiing' => 'Indoor Skiing',
+      'cardio_training' => 'Cardio Training',
+      'all' => 'All'
+    }
+
     def initialize(db, fit_file, fit_activity, name = nil)
       @fit_file = fit_file
       @fit_activity = fit_activity
       @name = name || fit_file
+      @unset_variables = []
       late_init(db)
 
       @@CachedActivityValues.each do |v|
@@ -39,8 +93,6 @@ module PostRunner
         instance_variable_set(v_str, fit_activity.send(v))
         self.class.send(:attr_reader, v.to_sym)
       end
-      # Generate HTML file for this activity.
-      generate_html_view
     end
 
     # YAML::load() does not call initialize(). We don't have all attributes
@@ -48,12 +100,21 @@ module PostRunner
     # after a YAML::load().
     def late_init(db)
       @db = db
-      @html_dir = File.join(@db.db_dir, 'html')
-      @html_file = File.join(@html_dir, "#{@fit_file[0..-5]}.html")
+      @html_file = File.join(@db.cfg[:html_dir], "#{@fit_file[0..-5]}.html")
+
+      @unset_variables.each do |name_without_at|
+        # The YAML file does not yet have the instance variable cached.
+        # Load the Activity data and extract the value to set the instance
+        # variable.
+        @fit_activity = load_fit_file unless @fit_activity
+        instance_variable_set('@' + name_without_at,
+                              @fit_activity.send(name_without_at))
+      end
     end
 
     def check
-      @fit_activity = load_fit_file
+      generate_html_view
+      register_records
       Log.info "FIT file #{@fit_file} is OK"
     end
 
@@ -65,26 +126,21 @@ module PostRunner
     # objects. The initialize() is NOT called during YAML::load(). Any
     # additional initialization work is done in late_init().
     def init_with(coder)
+      @unset_variables = []
       @@CachedAttributes.each do |name_without_at|
-        name_with_at = '@' + name_without_at
         # Create attr_readers for cached variables.
         self.class.send(:attr_reader, name_without_at.to_sym)
 
         if coder.map.include?(name_without_at)
           # The YAML file has a value for the instance variable. So just set
           # it.
-          instance_variable_set(name_with_at, coder[name_without_at])
+          instance_variable_set('@' + name_without_at, coder[name_without_at])
         else
           if @@CachedActivityValues.include?(name_without_at)
-            # The YAML file does not yet have the instance variable cached.
-            # Load the Activity data and extract the value to set the instance
-            # variable.
-            @fit_activity = load_fit_file unless @fit_activity
-            instance_variable_set(name_with_at,
-                                  @fit_activity.send(name_without_at))
+            @unset_variables << name_without_at
           else
             Log.fatal "Don't know how to initialize the instance variable " +
-                      "#{name_with_at}."
+                      "#{name_without_at}."
           end
         end
       end
@@ -111,7 +167,10 @@ module PostRunner
 
     def summary
       @fit_activity = load_fit_file unless @fit_activity
-      puts ActivitySummary.new(@fit_activity, name, @db.cfg[:unit_system]).to_s
+      puts ActivitySummary.new(@fit_activity, @db.cfg[:unit_system],
+                               { :name => @name,
+                                 :type => activity_type,
+                                 :sub_type => activity_sub_type }).to_s
     end
 
     def rename(name)
@@ -119,22 +178,149 @@ module PostRunner
       generate_html_view
     end
 
-    def register_records(db)
-      @fit_activity.personal_records.each do |r|
-        if r.longest_distance == 1
-          # In case longest_distance is 1 the distance is stored in the
-          # duration field in 10-th of meters.
-          db.register_result(r.duration * 10.0 , 0, r.start_time, @fit_file)
-        else
-          db.register_result(r.distance, r.duration, r.start_time, @fit_file)
+    def set(attribute, value)
+      case attribute
+      when 'name'
+        @name = value
+      when 'type'
+        @fit_activity = load_fit_file unless @fit_activity
+        unless ActivityTypes.values.include?(value)
+          Log.fatal "Unknown activity type '#{value}'. Must be one of " +
+                    ActivityTypes.values.join(', ')
+        end
+        @sport = ActivityTypes.invert[value]
+        # Since the activity changes the records from this Activity need to be
+        # removed and added again.
+        @db.records.delete_activity(self)
+        register_records
+      when 'subtype'
+        unless ActivitySubTypes.values.include?(value)
+          Log.fatal "Unknown activity subtype '#{value}'. Must be one of " +
+                    ActivitySubTypes.values.join(', ')
+        end
+        @sub_sport = ActivitySubTypes.invert[value]
+      else
+        Log.fatal "Unknown activity attribute '#{attribute}'. Must be one of " +
+                  'name, type or subtype'
+      end
+      generate_html_view
+    end
+
+    def register_records
+      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 = @fit_activity.sessions[0].start_time
+      segment_start_distance = 0.0
+
+      sport = nil
+      last_timestamp = nil
+      last_distance = nil
+
+      @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 @sport == 'multisport' || @sport == 'all'
+            sport = record.activity_type
+          else
+            sport = @sport
+          end
+          return unless PersonalRecords::SpeedRecordDistances.include?(sport)
+
+          record_distances = PersonalRecords::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
+
+        # 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?(@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 = @fit_activity.sessions[0].timestamp
+      if @distance_record_sport
+        @db.records.register_result(self, distance_record_sport,
+                                    distance_record, nil, start_time)
       end
+      speed_records.each do |dist, info|
+        @db.records.register_result(self, info[:sport], dist, info[:time],
+                                    start_time)
+      end
+    end
+
+    # Return true if this activity generated any personal records.
+    def has_records?
+      !@db.records.activity_records(self).empty?
     end
 
     def generate_html_view
       @fit_activity = load_fit_file unless @fit_activity
-      ActivityView.new(self, @db.cfg[:unit_system], @db.predecessor(self),
-                       @db.successor(self))
+      ActivityView.new(self, @db.cfg[:unit_system])
+    end
+
+    def activity_type
+      ActivityTypes[@sport] || 'Undefined'
+    end
+
+    def activity_sub_type
+      ActivitySubTypes[@sub_sport] || 'Undefined'
     end
 
     private
@@ -142,10 +328,16 @@ module PostRunner
     def load_fit_file(filter = nil)
       fit_file = File.join(@db.fit_dir, @fit_file)
       begin
-        return Fit4Ruby.read(fit_file, filter)
+        fit_activity = Fit4Ruby.read(fit_file, filter)
       rescue Fit4Ruby::Error
         Log.fatal $!
       end
+
+      unless fit_activity
+        Log.fatal "#{fit_file} does not contain any activity records"
+      end
+
+      fit_activity
     end
 
   end