Big refactoring to switch to PEROBS database.

12 files changed, 1136 insertions, 197 deletions

diff --git a/lib/postrunner/ActivitiesDB.rb b/lib/postrunner/ActivitiesDB.rb
index 608a0e4..c98af2d 100644
--- a/lib/postrunner/ActivitiesDB.rb
+++ b/lib/postrunner/ActivitiesDB.rb
@@ -3,7 +3,7 @@
 #
 # = ActivitiesDB.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
@@ -68,7 +68,6 @@ module PostRunner
         NavButtonDef.new('record.png', "records-0.html")
       ])
 
-      @records = PersonalRecords.new(self)
       sync if sync_needed
     end
 
@@ -140,7 +139,6 @@ module PostRunner
       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
@@ -167,16 +165,6 @@ module PostRunner
       sync
     end
 
-    def 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)
       i = 1
       @activities.each do |activity|
@@ -278,14 +266,6 @@ module PostRunner
       puts ActivityListView.new(self).to_s
     end
 
-    def show_records
-      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)
@@ -336,7 +316,6 @@ module PostRunner
         Log.fatal "Cannot write archive file '#{@archive_file}': #{$!}"
       end
 
-      @records.sync
       ActivityListView.new(self).update_index_pages
     end
 
diff --git a/lib/postrunner/ActivityLink.rb b/lib/postrunner/ActivityLink.rb
index 9c368b0..77898e6 100644
--- a/lib/postrunner/ActivityLink.rb
+++ b/lib/postrunner/ActivityLink.rb
@@ -30,7 +30,7 @@ module PostRunner
       doc.unique(:activitylink_style) { doc.style(style) }
 
       doc.a(@activity.name, { :class => 'activity_link',
-                              :href => @activity.fit_file[0..-5] + '.html' })
+                              :href => @activity.html_file_name(false) })
       if @show_record_icon && @activity.has_records?
         doc.img(nil, { :src => 'icons/record-small.png',
                        :style => 'vertical-align:middle' })
diff --git a/lib/postrunner/ActivityListView.rb b/lib/postrunner/ActivityListView.rb
index 8e38b93..11ae0b9 100644
--- a/lib/postrunner/ActivityListView.rb
+++ b/lib/postrunner/ActivityListView.rb
@@ -24,12 +24,12 @@ module PostRunner
 
     include Fit4Ruby::Converters
 
-    def initialize(db)
-      @db = db
-      @unit_system = @db.cfg[:unit_system]
+    def initialize(ffs)
+      @ffs = ffs
+      @unit_system = @ffs.store['config']['unit_system']
       @page_size = 20
       @page_no = -1
-      @last_page = (@db.activities.length - 1) / @page_size
+      @last_page = (@ffs.activities.length - 1) / @page_size
     end
 
     def update_index_pages
@@ -46,7 +46,7 @@ module PostRunner
     private
 
     def generate_html_index_page(page_index)
-      views = @db.views
+      views = @ffs.views
       views.current_page = 'index.html'
 
       pages = PagingButtons.new((0..@last_page).map do |i|
@@ -59,7 +59,8 @@ module PostRunner
       @view.doc.head { @view.doc.style(style) }
       body(@view.doc)
 
-      output_file = File.join(@db.cfg[:html_dir], pages.current_page)
+      output_file = File.join(@ffs.store['config']['html_dir'],
+                              pages.current_page)
       @view.write(output_file)
     end
 
@@ -85,9 +86,9 @@ module PostRunner
         { :halign => :right }
       ])
       t.body
-      activities = @page_no == -1 ? @db.activities :
-        @db.activities[(@page_no * @page_size)..
-                       ((@page_no + 1) * @page_size - 1)]
+      activities = @page_no == -1 ? @ffs.activities :
+        @ffs.activities[(@page_no * @page_size)..
+                        ((@page_no + 1) * @page_size - 1)]
       activities.each do |a|
         t.row([
           i += 1,
diff --git a/lib/postrunner/ActivityView.rb b/lib/postrunner/ActivityView.rb
index 9474089..4f2477e 100644
--- a/lib/postrunner/ActivityView.rb
+++ b/lib/postrunner/ActivityView.rb
@@ -27,26 +27,25 @@ module PostRunner
 
     def initialize(activity, unit_system)
       @activity = activity
-      db = @activity.db
+      ffs = @activity.store['file_store']
       @unit_system = unit_system
 
-      views = db.views
+      views = ffs.views
       views.current_page = nil
 
       # Sort activities in reverse order so the newest one is considered the
       # last report by the pagin buttons.
-      activities = db.activities.sort do |a1, a2|
+      activities = ffs.activities.sort do |a1, a2|
         a1.timestamp <=> a2.timestamp
       end
 
-      pages = PagingButtons.new(activities.map do |a|
-        "#{a.fit_file[0..-5]}.html"
-      end, false)
-      pages.current_page = "#{@activity.fit_file[0..-5]}.html"
+      pages = PagingButtons.new(
+        activities.map { |a| a.html_file_name(false) }, false)
+      pages.current_page = @activity.html_file_name(false)
 
       super("PostRunner Activity: #{@activity.name}", views, pages)
       generate_html(@doc)
-      write(File.join(db.cfg[:html_dir], pages.current_page))
+      write(@activity.html_file_name)
     end
 
     private
diff --git a/lib/postrunner/DirUtils.rb b/lib/postrunner/DirUtils.rb
new file mode 100644
index 0000000..a37af7a
--- /dev/null
+++ b/lib/postrunner/DirUtils.rb
@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = DirUtils.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# 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
+# published by the Free Software Foundation.
+#
+
+require 'fileutils'
+
+module PostRunner
+
+  module DirUtils
+
+    def create_directory(dir, name)
+      return if Dir.exists?(dir)
+
+      Log.info "Creating #{name} directory #{dir}"
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue StandardError
+        Log.fatal "Cannot create #{name} directory #{dir}: #{$!}"
+      end
+    end
+
+  end
+
+end
+
diff --git a/lib/postrunner/EventList.rb b/lib/postrunner/EventList.rb
index 06100ce..3ebb757 100644
--- a/lib/postrunner/EventList.rb
+++ b/lib/postrunner/EventList.rb
@@ -3,7 +3,7 @@
 #
 # = EventList.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2015 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 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
diff --git a/lib/postrunner/FFS_Activity.rb b/lib/postrunner/FFS_Activity.rb
new file mode 100644
index 0000000..309db1e
--- /dev/null
+++ b/lib/postrunner/FFS_Activity.rb
@@ -0,0 +1,308 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FFS_Activity.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 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 'fit4ruby'
+require 'perobs'
+
+require 'postrunner/ActivitySummary'
+require 'postrunner/DataSources'
+require 'postrunner/EventList'
+require 'postrunner/ActivityView'
+require 'postrunner/Schema'
+require 'postrunner/QueryResult'
+require 'postrunner/DirUtils'
+
+module PostRunner
+
+  # The FFS_Activity objects can store a reference to the FIT file data and
+  # caches some frequently used values. In some cases the cached values can be
+  # used to overwrite the data from the FIT file.
+  class FFS_Activity < PEROBS::Object
+
+    include DirUtils
+
+    @@Schemata = {
+      'long_date' => Schema.new('long_date', 'Date',
+                                { :func => 'timestamp',
+                                  :column_alignment => :left,
+                                  :format => 'date_with_weekday' }),
+      'sub_type' => Schema.new('sub_type', 'Subtype',
+                               { :func => 'activity_sub_type',
+                                 :column_alignment => :left }),
+      'type' => Schema.new('type', 'Type',
+                           { :func => 'activity_type',
+                             :column_alignment => :left })
+    }
+
+    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'
+    }
+
+    po_attr :device, :fit_file_name, :norecord, :name, :sport, :sub_sport,
+            :timestamp, :total_distance, :total_timer_time, :avg_speed
+    attr_reader :fit_activity
+
+    # Create a new FFS_Activity object.
+    # @param store [PEROBS::Store] The data base
+    # @param fit_file_name [String] The fully qualified file name of the FIT
+    #        file to add
+    # @param fit_entity [Fit4Ruby::FitEntity] The content of the loaded FIT
+    #        file
+    def initialize(store, device = nil, fit_file_name = nil, fit_entity = nil)
+      super(store)
+      init_attr(:device, device)
+      init_attr(:fit_file_name, fit_file_name ?
+                File.basename(fit_file_name) : nil)
+      init_attr(:name, fit_file_name ? File.basename(fit_file_name) : nil)
+      init_attr(:norecord, false)
+      if (@fit_activity = fit_entity)
+        init_attr(:timestamp, fit_entity.timestamp)
+        init_attr(:total_timer_time, fit_entity.total_timer_time)
+        init_attr(:sport, fit_entity.sport)
+        init_attr(:sub_sport, fit_entity.sub_sport)
+        init_attr(:total_distance, fit_entity.total_distance)
+        init_attr(:avg_speed, fit_entity.avg_speed)
+      end
+    end
+
+    def post_restore
+      raise RuntimeError unless @device.is_a?(PEROBS::ObjectBase)
+    end
+
+    # Store a copy of the given FIT file in the corresponding directory.
+    # @param fit_file_name [String] Fully qualified name of the FIT file.
+    def store_fit_file(fit_file_name)
+      # Get the right target directory for this particular FIT file.
+      dir = fit_file_dir(File.basename(fit_file_name))
+      # Create the necessary directories if they don't exist yet.
+      create_directory(dir, 'Device activity diretory')
+
+      # Copy the file into the target directory.
+      begin
+        FileUtils.cp(fit_file_name, dir)
+      rescue StandardError
+        Log.fatal "Cannot copy #{fit_file_name} into #{dir}: #{$!}"
+      end
+    end
+
+    # FFS_Activity objects are sorted by their timestamp values and then by
+    # their device long_uids.
+    def <=>(a)
+      @timestamp == a.timestamp ? a.device.long_uid <=> self.device.long_uid :
+        a.timestamp <=> @timestamp
+    end
+
+    def check
+      generate_html_report
+      Log.info "FIT file #{@fit_file_name} is OK"
+    end
+
+    def dump(filter)
+      load_fit_file(filter)
+    end
+
+    def dump(filter)
+      load_fit_file(filter)
+    end
+
+    def query(key)
+      unless @@Schemata.include?(key)
+        raise ArgumentError, "Unknown key '#{key}' requested in query"
+      end
+
+      schema = @@Schemata[key]
+
+      if schema.func
+        value = send(schema.func)
+      else
+        unless instance_variable_defined?(key)
+          raise ArgumentError, "Don't know how to query '#{key}'"
+        end
+        value = instance_variable_get(key)
+      end
+
+      QueryResult.new(value, schema)
+    end
+
+    def events
+      load_fit_file
+      puts EventList.new(self, @store['config']['unit_system']).to_s
+    end
+
+    def show
+      html_file = html_file_name
+
+      generate_html_report #unless File.exists?(html_file)
+
+      @store['file_store'].show_in_browser(html_file)
+    end
+
+    def sources
+      load_fit_file
+      puts DataSources.new(self, @store['config']['unit_system']).to_s
+    end
+
+    def summary
+      load_fit_file
+      puts ActivitySummary.new(self, @store['config']['unit_system'],
+                               { :name => @name,
+                                 :type => activity_type,
+                                 :sub_type => activity_sub_type }).to_s
+    end
+
+    def set(attribute, value)
+      case attribute
+      when 'name'
+        self.name = value
+      when 'type'
+        load_fit_file
+        unless ActivityTypes.values.include?(value)
+          Log.fatal "Unknown activity type '#{value}'. Must be one of " +
+                    ActivityTypes.values.join(', ')
+        end
+        self.sport = ActivityTypes.invert[value]
+      when 'subtype'
+        unless ActivitySubTypes.values.include?(value)
+          Log.fatal "Unknown activity subtype '#{value}'. Must be one of " +
+                    ActivitySubTypes.values.join(', ')
+        end
+        self.sub_sport = ActivitySubTypes.invert[value]
+      when 'norecord'
+        unless %w( true false).include?(value)
+          Log.fatal "norecord must either be 'true' or 'false'"
+        end
+        self.norecord = value == 'true'
+      else
+        Log.fatal "Unknown activity attribute '#{attribute}'. Must be one of " +
+                  'name, type or subtype'
+      end
+      generate_html_report
+    end
+
+    # Return true if this activity generated any personal records.
+    def has_records?
+      !@store['records'].activity_records(self).empty?
+    end
+
+    def html_file_name(full_path = true)
+      fn = "#{@device.short_uid}_#{@fit_file_name[0..-5]}.html"
+      full_path ? File.join(@store['config']['html_dir'], fn) : fn
+    end
+
+    def generate_html_report
+      load_fit_file
+      ActivityView.new(self, @store['config']['unit_system'])
+    end
+
+    def activity_type
+      ActivityTypes[@sport] || 'Undefined'
+    end
+
+    def activity_sub_type
+      ActivitySubTypes[@sub_sport] || 'Undefined'
+    end
+
+    def distance(timestamp, unit_system)
+      load_fit_file
+
+      @fit_activity.records.each do |record|
+        if record.timestamp >= timestamp
+          unit = { :metric => 'km', :statute => 'mi'}[unit_system]
+          value = record.get_as('distance', unit)
+          return '-' unless value
+          return "#{'%.2f %s' % [value, unit]}"
+        end
+      end
+
+      '-'
+    end
+
+    def load_fit_file(filter = nil)
+      return if @fit_activity
+
+      fit_file = File.join(fit_file_dir(@fit_file_name), @fit_file_name)
+      begin
+        @fit_activity = Fit4Ruby.read(fit_file, filter)
+      rescue Fit4Ruby::Error
+        Log.fatal "#{@fit_file_name} corrupted: #{$!}"
+      end
+
+      unless @fit_activity
+        Log.fatal "#{fit_file} does not contain any activity records"
+      end
+    end
+
+    private
+
+    # Determine the right directory for the given FIT file. The resulting path
+    # looks something like /home/user/.postrunner/devices/garmin-fenix3-1234/
+    # activity/5A.
+    def fit_file_dir(fit_file_base_name)
+      # The first letter of the FIT file specifies the creation year.
+      # The second letter of the FIT file specifies the creation month.
+      dir = File.join(@store['config']['devices_dir'], @device.long_uid,
+                      'activity', fit_file_base_name[0..1])
+    end
+
+  end
+
+end
+
diff --git a/lib/postrunner/FFS_Device.rb b/lib/postrunner/FFS_Device.rb
new file mode 100644
index 0000000..47c473b
--- /dev/null
+++ b/lib/postrunner/FFS_Device.rb
@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FFS_Device.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 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 'perobs'
+require 'postrunner/FFS_Activity'
+
+module PostRunner
+
+  # Objects of this class can store the activities and monitoring data of a
+  # specific device. The device gets a random number assigned as a unique but
+  # anonymous ID. It also gets a long ID assigned that is a String of the
+  # manufacturer, the product name and the serial number concatenated by
+  # dashes. All objects are transparently stored in the PEROBS::Store.
+  class FFS_Device < PEROBS::Object
+
+    po_attr :activities, :monitors, :short_uid, :long_uid
+
+    # Create a new FFS_Device object.
+    # @param store [PEROBS::Store] The store to persist the data
+    # @param short_uid [Fixnum] A random number used a unique ID
+    # @param long_uid [String] A string consisting of the manufacturer and
+    #        product name and the serial number.
+    def initialize(store, short_uid = nil, long_uid = nil)
+      super(store)
+      init_attr(:short_uid, short_uid)
+      init_attr(:long_uid, long_uid)
+      init_attr(:activities, @store.new(PEROBS::Array))
+      init_attr(:monitorings, @store.new(PEROBS::Array))
+    end
+
+    # Add a new FIT file for this device.
+    # @param fit_file_name [String] The full path to the FIT file
+    # @param fit_entity [Fit4Ruby::FitEntity] The content of the FIT file
+    # @param overwrite [Boolean] A flag to indicate if an existing file should
+    #        be replaced with the new one.
+    # @return [FFS_Activity or FFS_Monitoring] Corresponding entry in the
+    #         FitFileStore or nil if file could not be added.
+    def add_fit_file(fit_file_name, fit_entity, overwrite)
+      case fit_entity.class
+      when Fit4Ruby::Activity.class
+        entity = activity_by_file_name(File.basename(fit_file_name))
+        entities = @activities
+        new_entity_class = FFS_Activity
+      when Fit4Ruby::Monitoring.class
+        entity = monitoring_by_file_name(File.basename(fit_file_name))
+        entities = @monitorings
+        new_entity_class = FFS_Monitoring
+      else
+        Log.fatal "Unsupported FIT entity #{fit_entity.class}"
+      end
+
+      if entity
+        if overwrite
+          # Replace the old file. All meta-information will be lost.
+          entities.delete_if { |e| e.fit_file_name == fit_file_name }
+          entity = @store.new(new_entity_class, myself, fit_file_name,
+                              fit_entity)
+        else
+          # Refuse to replace the file.
+          return nil
+        end
+      else
+        # Add the new file to the list.
+        entity = @store.new(new_entity_class, myself, fit_file_name, fit_entity)
+      end
+      entity.store_fit_file(fit_file_name)
+      entities << entity
+      entities.sort!
+
+      # Scan the activity for any potential new personal records and register
+      # them.
+      if entity.is_a?(FFS_Activity)
+        records = @store['records']
+        records.scan_activity_for_records(entity, true)
+      end
+
+      entity
+    end
+
+    # Return the activity with the given file name.
+    # @param file_name [String] Base name of the fit file.
+    # @return [FFS_Activity] Corresponding FFS_Activity or nil.
+    def activity_by_file_name(file_name)
+      @activities.find { |a| a.fit_file_name == file_name }
+    end
+
+    # Return the monitoring with the given file name.
+    # @param file_name [String] Base name of the fit file.
+    # @return [FFS_Activity] Corresponding FFS_Monitoring or nil.
+    def monitoring_by_file_name(file_name)
+      @monitorings.find { |a| a.fit_file_name == file_name }
+    end
+
+  end
+
+end
+
diff --git a/lib/postrunner/FitFileStore.rb b/lib/postrunner/FitFileStore.rb
new file mode 100644
index 0000000..c52d5a5
--- /dev/null
+++ b/lib/postrunner/FitFileStore.rb
@@ -0,0 +1,349 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitFileStore.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# 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 'fit4ruby'
+require 'perobs'
+
+require 'postrunner/Log'
+require 'postrunner/DirUtils'
+require 'postrunner/FFS_Device'
+require 'postrunner/ActivityListView'
+require 'postrunner/ViewButtons'
+
+module PostRunner
+
+  # The FitFileStore stores all FIT file and provides access to the contained
+  # data.
+  class FitFileStore < PEROBS::Object
+
+    include DirUtils
+
+    po_attr :devices
+
+    attr_reader :store, :views
+
+    # Create a new FIT file store.
+    # @param store [PEROBS::Store] Data store
+    # @param cfg [RuntimeConfig] Runtime configuration data
+    def initialize(store)
+      super
+      @data_dir = store['config']['data_dir']
+      # Ensure that we have an Array in the store to hold all known devices.
+      @store['devices'] = @store.new(PEROBS::Hash) unless @store['devices']
+
+      @devices_dir = File.join(@data_dir, 'devices')
+      # It's generally not a good idea to store absolute file names in the
+      # database. We'll make an exception here as this is the only way to
+      # propagate this path to FFS_Activity or FFS_Monitoring objects. The
+      # store entry is updated on each program run, so the DB can be moved
+      # safely to another directory.
+      @store['config']['devices_dir'] = @devices_dir
+      create_directory(@devices_dir, 'devices')
+
+      # Define which View objects the HTML output will consist of. This
+      # doesn't really belong in this class 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")
+      ])
+    end
+
+    # Version upgrade logic.
+    def handle_version_update
+      # Nothing here so far.
+    end
+
+    # Add a file to the store.
+    # @param fit_file_name [String] Name of the FIT file
+    # @param overwrite [TrueClass, FalseClass] If true, an existing file will
+    #        be replaced.
+    # @return [FFS_Activity or FFS_Monitoring] Corresponding entry in the
+    #         FitFileStore or nil if file could not be added.
+    def add_fit_file(fit_file_name, fit_entity = nil, overwrite = false)
+      # If we the file hasn't been read yet, read it in as a
+      # Fit4Ruby::Activity or Fit4Ruby::Monitoring entity.
+      unless fit_entity
+        return nil unless (fit_entity = read_fit_file(fit_file_name))
+      end
+
+      unless [ Fit4Ruby::Activity,
+               Fit4Ruby::Monitoring ].include?(fit_entity.class)
+        Log.critical "Unsupported FIT file type #{fit_entity.class}"
+      end
+
+      # Generate a String that uniquely identifies the device that generated
+      # the FIT file.
+      id = extract_fit_file_id(fit_entity)
+      long_uid = "#{id[:manufacturer]}-#{id[:product]}-#{id[:serial_number]}"
+
+      # Make sure the device that created the FIT file is properly registered.
+      device = register_device(long_uid)
+      # Store the FIT entity with the device.
+      activity = device.add_fit_file(fit_file_name, fit_entity, overwrite)
+
+      # The activity might be already stored or invalid. In that case we
+      # abort this method.
+      return nil unless activity
+
+      @store['records'].scan_activity_for_records(activity)
+
+      # Generate HTML file for this activity.
+      activity.generate_html_report
+
+      # The HTML activity views contain links to their predecessors and
+      # successors. After inserting a new activity, we need to re-generate
+      # these views as well.
+      if (pred = predecessor(activity))
+        pred.generate_html_report
+      end
+      if (succ = successor(activity))
+        succ.generate_html_report
+      end
+
+      Log.info "#{fit_file_name} successfully added to archive"
+
+      activity
+    end
+
+    # Delete an activity from the database. It will only delete the entry in
+    # the database. The original activity file will not be deleted from the
+    # file system.
+    # @param activity [FFS_Activity] Activity to delete
+    def delete_activity(activity)
+      pred = predecessor(activity)
+      succ = successor(activity)
+
+      activity.device.activities.delete(activity)
+
+      # The HTML activity views contain links to their predecessors and
+      # successors. After deleting an activity, we need to re-generate these
+      # views.
+      pred.generate_html_report if pred
+      succ.generate_html_report if succ
+
+      generate_html_index_pages
+    end
+
+    # Rename the specified activity and update all HTML pages that contain the
+    # name.
+    # @param activity [FFS_Activity] Activity to rename
+    # @param name [String] New name
+    def rename_activity(activity, name)
+      activity.set('name', name)
+      generate_html_index_pages
+    end
+
+    # Set the specified attribute of the given activity to a new value.
+    # @param activity [FFS_Activity] Activity to rename
+    # @param attribute [String] name of the attribute to change
+    # @param value [any] new value of the attribute
+    def set_activity_attribute(activity, attribute, value)
+      activity.set(attribute, value)
+      case attribute
+      when 'norecord', 'type'
+        # If we have changed a norecord setting or an activity type, we need
+        # to regenerate all reports and re-collect the record list since we
+        # don't know which Activity needs to replace the changed one.
+        check
+      end
+      generate_html_index_pages
+    end
+
+    # Perform the necessary report updates after the unit system has been
+    # changed.
+    def change_unit_system
+      # If we have changed the unit system we need to re-generate all HTML
+      # reports.
+      activities.each do |activity|
+        activity.generate_html_report
+      end
+      @store['records'].generate_html_reports
+      generate_html_index_pages
+    end
+
+
+    # @return [Array of FFS_Device] List of registered devices.
+    def devices
+      @store['devices']
+    end
+
+    # @return [Array of FFS_Activity] List of stored activities.
+    def activities
+      list = []
+      @store['devices'].each do |id, device|
+        list += device.activities
+      end
+      list.sort
+    end
+
+    # Return the reference index of the given FFS_Activity.
+    # @param activity [FFS_Activity]
+    # @return [Fixnum] Reference index as used in the UI
+    def ref_by_activity(activity)
+      return nil unless (idx = activities.index(activity))
+
+      idx + 1
+    end
+
+    # Return the next Activity after the provided activity. Note that this has
+    # a lower index. If none is found, return nil.
+    def successor(activity)
+      all_activities = activities
+      idx = all_activities.index(activity)
+      return nil if idx.nil? || idx == 0
+      all_activities[idx - 1]
+    end
+
+    # Return the previous Activity before the provided activity.
+    # If none is found, return nil.
+    def predecessor(activity)
+      all_activities = activities
+      idx = all_activities.index(activity)
+      return nil if idx.nil?
+      # Activities indexes are reversed. The predecessor has a higher index.
+      all_activities[idx + 1]
+    end
+
+    # Find a specific subset of the activities based on their index.
+    # @param query [String]
+    def find(query)
+      case query
+      when /\A-?\d+$\z/
+        index = query.to_i
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        if index <= 0
+          Log.error 'Index must be larger than 0'
+          return []
+        end
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        if (a = activities[index - 1])
+          return [ a ]
+        end
+      when /\A-?\d+--?\d+\z/
+        idxs = query.match(/(?<sidx>-?\d+)-(?<eidx>-?[0-9]+)/)
+        if (sidx = idxs['sidx'].to_i) <= 0
+          Log.error 'Start index must be larger than 0'
+          return []
+        end
+        if (eidx = idxs['eidx'].to_i) <= 0
+          Log.error 'End index must be larger than 0'
+          return []
+        end
+        if eidx < sidx
+          Log.error 'Start index must be smaller than end index'
+          return []
+        end
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        unless (as = activities[(sidx - 1)..(eidx - 1)]).empty?
+          return as
+        end
+      else
+        Log.error "Invalid activity query: #{query}"
+      end
+
+      []
+    end
+
+    # This methods checks all stored FIT files for correctness, updates all
+    # indexes and re-generates all HTML reports.
+    def check
+      records = @store['records']
+      records.delete_all_records
+      activities.sort do |a1, a2|
+        a1.timestamp <=> a2.timestamp
+      end.each do |a|
+        a.check
+        records.scan_activity_for_records(a)
+      end
+      records.generate_html_reports
+      generate_html_index_pages
+    end
+
+    # Show the activity list in a web browser.
+    def show_list_in_browser
+      generate_html_index_pages
+      @store['records'].generate_html_reports
+      show_in_browser(File.join(@store['config']['html_dir'], 'index.html'))
+    end
+
+    def list_activities
+      puts ActivityListView.new(self).to_s
+    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)
+      cmd = "#{ENV['BROWSER'] || 'firefox'} \"#{html_file}\" &"
+
+      unless system(cmd)
+        Log.fatal "Failed to execute the following shell command: #{$cmd}\n" +
+                  "#{$!}"
+      end
+    end
+
+    private
+
+    def read_fit_file(fit_file_name)
+      begin
+        return Fit4Ruby.read(fit_file_name)
+      rescue Fit4Ruby::Error
+        Log.error $!
+        return nil
+      end
+    end
+
+    def extract_fit_file_id(fit_entity)
+      fit_entity.device_infos.each do |di|
+        if di.device_index == 0
+          return {
+            :manufacturer => di.manufacturer,
+            :product => di.garmin_product || di.product,
+            :serial_number => di.serial_number
+          }
+        end
+      end
+      Log.fatal "Fit entity has no device info for 0"
+    end
+
+    def register_device(long_uid)
+      unless @store['devices'].include?(long_uid)
+        Log.info "New device registered: #{long_uid}"
+
+        # Generate a unique ID for the device that does not allow any insight
+        # on the number of and type of managed devices.
+        begin
+          short_uid = rand(2**32)
+        end while @store['devices'].find { |luid, d| d.short_uid == short_uid }
+
+        @store['devices'][long_uid] =
+          @store.new(FFS_Device, short_uid, long_uid)
+
+        # Create the directory to store the FIT files of this device.
+        create_directory(File.join(@devices_dir, long_uid), long_uid)
+      end
+
+      @store['devices'][long_uid]
+    end
+
+    def generate_html_index_pages
+      # Ensure that HTML index is up-to-date.
+      ActivityListView.new(self).update_index_pages
+    end
+
+  end
+
+end
+
diff --git a/lib/postrunner/Main.rb b/lib/postrunner/Main.rb
index c388910..29b8e47 100644
--- a/lib/postrunner/Main.rb
+++ b/lib/postrunner/Main.rb
@@ -3,7 +3,7 @@
 #
 # = Main.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
@@ -16,7 +16,10 @@ require 'perobs'
 
 require 'postrunner/version'
 require 'postrunner/Log'
+require 'postrunner/DirUtils'
 require 'postrunner/RuntimeConfig'
+require 'postrunner/FitFileStore'
+require 'postrunner/PersonalRecords'
 require 'postrunner/ActivitiesDB'
 require 'postrunner/MonitoringDB'
 require 'postrunner/EPO_Downloader'
@@ -25,20 +28,33 @@ module PostRunner
 
   class Main
 
+    include DirUtils
+
     def initialize(args)
       @filter = nil
       @name = nil
       @attribute = nil
       @value = nil
-      @activities = nil
-      @monitoring = nil
       @db_dir = File.join(ENV['HOME'], '.postrunner')
 
       return if (args = parse_options(args)).nil?
 
-      @cfg = RuntimeConfig.new(@db_dir)
+      create_directory(@db_dir, 'PostRunner data')
       @db = PEROBS::Store.new(File.join(@db_dir, 'database'))
+      # Create a hash to store configuration data in the store unless it
+      # exists already.
+      unless @db['config']
+        @db['config'] = @db.new(PEROBS::Hash)
+        @db['config']['unit_system'] = :metric
+        @db['config']['html_dir'] = File.join(@db_dir, 'html')
+        @db['config']['version'] = VERSION
+      end
+      @db['config']['data_dir'] = @db_dir
+
+      setup_directories
       execute_command(args)
+
+      @db.sync
     end
 
     private
@@ -104,7 +120,7 @@ EOT
           return nil
         end
         opts.on('--version', 'Show version number') do
-          $stderr.puts VERSION
+          puts VERSION
           return nil
         end
 
@@ -190,16 +206,50 @@ EOT
       end
     end
 
+    def setup_directories
+      create_directory(@db['config']['html_dir'], 'HTML output')
+
+      %w( icons jquery flot openlayers postrunner ).each do |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__),
+                                           '..', '..', 'misc'))
+        unless Dir.exists?(misc_dir)
+          Log.fatal "Cannot find 'misc' directory under '#{misc_dir}': #{$!}"
+        end
+        src_dir = File.join(misc_dir, dir)
+        unless Dir.exists?(src_dir)
+          Log.fatal "Cannot find '#{src_dir}': #{$!}"
+        end
+        dst_dir = @db['config']['html_dir']
+
+        begin
+          FileUtils.cp_r(src_dir, dst_dir)
+        rescue IOError
+          Log.fatal "Cannot copy auxilliary data directory '#{dst_dir}': #{$!}"
+        end
+      end
+    end
+
     def execute_command(args)
-      @activities = ActivitiesDB.new(@db_dir, @cfg)
-      @monitoring = MonitoringDB.new(@db, @cfg)
+      # Create or load the FitFileStore data.
+      unless (@ffs = @db['file_store'])
+        @ffs = @db['file_store'] = @db.new(FitFileStore)
+      end
+      # Create or load the PersonalRecords data.
+      unless (@records = @db['records'])
+        @records = @db['records'] = @db.new(PersonalRecords)
+      end
       handle_version_update
+      import_legacy_archive
 
       case (cmd = args.shift)
       when 'check'
         if args.empty?
-          @activities.check
-          @activities.generate_all_html_reports
+          @ffs.check
+          Log.info "Datebase cleanup started. Please wait ..."
+          @db.gc
+          Log.info "Database cleanup finished"
         else
           process_files_or_activities(args, :check)
         end
@@ -214,19 +264,19 @@ EOT
         if args.empty?
           # If we have no file or directory for the import command, we get the
           # most recently used directory from the runtime config.
-          process_files([ @cfg.get_option(:import_dir) ], :import)
+          process_files([ @db['config']['import_dir']  ], :import)
         else
           process_files(args, :import)
           if args.length == 1 && Dir.exists?(args[0])
             # If only one directory was specified as argument we store the
             # directory for future use.
-            @cfg.set_option(:import_dir, args[0])
+            @db['config']['import_dir'] = args[0]
           end
         end
       when 'list'
-        @activities.list
+        @ffs.list_activities
       when 'records'
-        @activities.show_records
+        @ffs.show_records
       when 'rename'
         unless (@name = args.shift)
           Log.fatal 'You must provide a new name for the activity'
@@ -242,7 +292,7 @@ EOT
         process_activities(args, :set)
       when 'show'
         if args.empty?
-          @activities.show_list_in_browser
+          @ffs.show_list_in_browser
         else
           process_activities(args, :show)
         end
@@ -282,7 +332,7 @@ EOT
 
       activity_refs.each do |a_ref|
         if a_ref[0] == ':'
-          activities = @activities.find(a_ref[1..-1])
+          activities = @ffs.find(a_ref[1..-1])
           if activities.empty?
             Log.warn "No matching activities found for '#{a_ref}'"
             return
@@ -292,6 +342,8 @@ EOT
           Log.fatal "Activity references must start with ':': #{a_ref}"
         end
       end
+
+      nil
     end
 
     def process_files(files_or_dirs, command)
@@ -339,9 +391,9 @@ EOT
       end
 
       if fit_entity.is_a?(Fit4Ruby::Activity)
-        return @activities.add(fit_file_name, fit_entity)
-      elsif fit_entity.is_a?(Fit4Ruby::Monitoring_B)
-        return @monitoring.add(fit_file_name, fit_entity)
+        return @ffs.add_fit_file(fit_file_name, fit_entity)
+      #elsif fit_entity.is_a?(Fit4Ruby::Monitoring_B)
+      #  return @monitoring.add(fit_file_name, fit_entity)
       else
         Log.error "#{fit_file_name} is not a recognized FIT file"
         return false
@@ -353,15 +405,15 @@ EOT
       when :check
         activity.check
       when :delete
-        @activities.delete(activity)
+        @ffs.delete_activity(activity)
       when :dump
         activity.dump(@filter)
       when :events
         activity.events
       when :rename
-        @activities.rename(activity, @name)
+        @ffs.rename_activity(activity, @name)
       when :set
-        @activities.set(activity, @attribute, @value)
+        @ffs.set_activity_attribute(activity, @attribute, @value)
       when :show
         activity.show
       when :sources
@@ -382,9 +434,9 @@ EOT
         Log.fatal("You must specify 'metric' or 'statute' as unit system.")
       end
 
-      if @cfg[:unit_system].to_s != args[0]
-        @cfg.set_option(:unit_system, args[0].to_sym)
-        @activities.generate_all_html_reports
+      if @db['config']['unit_system'].to_s != args[0]
+        @db['config']['unit_system'] = args[0].to_sym
+        @ffs.change_unit_system
       end
     end
 
@@ -393,16 +445,16 @@ EOT
         Log.fatal('You must specify a directory')
       end
 
-      if @cfg[:html_dir] != args[0]
-        @cfg.set_option(:html_dir, args[0])
-        @activities.create_directories
-        @activities.generate_all_html_reports
+      if @db['config']['html_dir'] != args[0]
+        @db['config']['html_dir'] =  args[0]
+        @ffs.create_directories
+        @ffs.generate_all_html_reports
       end
     end
 
     def update_gps_data
       epo_dir = File.join(@db_dir, 'epo')
-      @cfg.create_directory(epo_dir, 'GPS Data Cache')
+      create_directory(epo_dir, 'GPS Data Cache')
       epo_file = File.join(epo_dir, 'EPO.BIN')
 
       if !File.exists?(epo_file) ||
@@ -410,7 +462,7 @@ EOT
         # The EPO file only changes every 6 hours. No need to download it more
         # frequently if it already exists.
         if EPO_Downloader.new.download(epo_file)
-          unless (remotesw_dir = @cfg[:import_dir])
+          unless (remotesw_dir = @db['config']['import_dir'])
             Log.error "No device directory set. Please import an activity " +
                       "from your device first."
             return
@@ -433,14 +485,38 @@ EOT
     end
 
     def handle_version_update
-      if @cfg.get_option(:version) != VERSION
+      if @db['config']['version'] != VERSION
         Log.warn "PostRunner version upgrade detected."
-        @activities.handle_version_update
-        @cfg.set_option(:version, VERSION)
+        @ffs.handle_version_update
+        @db['config']['version'] = VERSION
         Log.info "Version upgrade completed."
       end
     end
 
+    # Earlier versions of PostRunner used a YAML file to store the activity
+    # data. This method transfers the data from the old storage to the new
+    # FitFileStore based database.
+    def import_legacy_archive
+      old_fit_dir = File.join(@db_dir, 'old_fit_dir')
+      create_directory(old_fit_dir, 'Old Fit')
+
+      cfg = RuntimeConfig.new(@db_dir)
+      ActivitiesDB.new(@db_dir, cfg).activities.each do |activity|
+        file_name = File.join(@db_dir, 'fit', activity.fit_file)
+        next unless File.exists?(file_name)
+
+        Log.info "Converting #{activity.fit_file} to new DB format"
+        @db.transaction do
+          new_activity = @ffs.add_fit_file(file_name)
+          new_activity.sport = activity.sport
+          new_activity.sub_sport = activity.sub_sport
+          new_activity.name = activity.name
+          new_activity.norecord = activity.norecord
+          FileUtils.move(file_name, File.join(old_fit_dir, activity.fit_file))
+        end
+      end
+    end
+
   end
 
 end
diff --git a/lib/postrunner/PersonalRecords.rb b/lib/postrunner/PersonalRecords.rb
index bfa4a57..a509abb 100644
--- a/lib/postrunner/PersonalRecords.rb
+++ b/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,15 +72,14 @@ 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)
+      def initialize(activity = nil, sport = nil, distance = nil,
+                     duration = nil, start_time = nil)
         @activity = activity
         @sport = sport
         @distance = distance
@@ -94,32 +87,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(store, result = nil)
+        super(store)
+        if result
+          init_attr(:activity, result.activity)
+          init_attr(:sport, result.sport)
+          init_attr(:distance, result.distance)
+          init_attr(:duration, result.duration)
+          init_attr(:start_time, result.start_time)
+        end
+      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
-
-      def initialize(sport, year)
-        @sport = sport
-        @year = year
-        @distance_record = nil
-        @speed_records = {}
-        PersonalRecords::SpeedRecordDistances[@sport].each_key do |dist|
-          @speed_records[dist] = nil
+      po_attr :sport, :year, :distance_record, :speed_records
+
+      def initialize(store, sport = nil, year = nil)
+        super(store)
+        init_attr(:sport, sport)
+        init_attr(:year, year)
+        init_attr(:distance_record, nil)
+        init_attr(: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 +148,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 +162,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 +174,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 +234,32 @@ 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(store, sport = nil)
+        super(store)
+        init_attr(:sport, sport)
+        init_attr(:all_time, @store.new(RecordSet, sport, nil))
+        init_attr(: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,160 @@ module PostRunner
 
     end
 
-    def initialize(activities)
-      @activities = activities
-      @db_dir = activities.db_dir
-      @records_file = File.join(@db_dir, 'records.yml')
-      delete_all_records
+    def initialize(store)
+      super
+      init_attr(:sport_records, @store.new(PEROBS::Hash))
+      delete_all_records if @sport_records.empty?
+    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
+
+        # 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
 
-      load_records
+      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 +502,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 +510,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
diff --git a/lib/postrunner/RecordListPageView.rb b/lib/postrunner/RecordListPageView.rb
index 01dafb3..7161cb5 100644
--- a/lib/postrunner/RecordListPageView.rb
+++ b/lib/postrunner/RecordListPageView.rb
@@ -17,6 +17,7 @@ require 'postrunner/View'
 require 'postrunner/ViewFrame'
 require 'postrunner/ViewButtons'
 require 'postrunner/PagingButtons'
+require 'postrunner/Activity'
 
 module PostRunner
 
@@ -27,16 +28,15 @@ module PostRunner
     include Fit4Ruby::Converters
 
     # Create a RecordListPageView object.
-    # @param db [ActivityDB] Activity database
+    # @param ffs [FitFileStore] Activity database
     # @param records [PersonalRecords] Database with personal records
     # @param page_count [Fixnum] Number of total pages
     # @param page_index [Fixnum] Index of the page
-    def initialize(db, records, page_count, page_index)
-      @db = db
-      @unit_system = @db.cfg[:unit_system]
+    def initialize(ffs, records, page_count, page_index)
+      #@unit_system = ffs.store['config']['unit_system']
       @records = records
 
-      views = @db.views
+      views = ffs.views
       views.current_page = "records-0.html"
 
       pages = PagingButtons.new((0..(page_count - 1)).map do |i|
@@ -55,7 +55,7 @@ module PostRunner
           ViewFrame.new("All-time #{@sport_name} Records",
                         frame_width, @records.all_time).to_html(@doc)
 
-          @records.yearly.sort{ |y1, y2| y2[0] <=> y1[0] }.
+          @records.yearly.sort{ |y1, y2| y2[0].to_i <=> y1[0].to_i }.
                           each do |year, record|
             next if record.empty?
             ViewFrame.new("#{year} #{@sport_name} Records",