postrunner 0.0.6 → 0.0.7

data/lib/postrunner/NavButtonRow.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = NavButtonRow.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.
+#
+
+require 'postrunner/HTMLBuilder'
+
+module PostRunner
+
+  # Auxilliary class that stores the name of an icon file and a URL as a
+  # String. It is used to describe a NavButtonRow button.
+  class NavButtonDef < Struct.new(:icon, :url)
+  end
+
+  # A NavButtonRow is a row of buttons used to navigate between HTML pages.
+  class NavButtonRow
+
+    # A class to store the icon and URL of a button in the NavButtonRow
+    # objects.
+    class Button
+
+      # Create a Button object.
+      # @param icon [String] File name of the icon file
+      # @param url [String] URL of the page to change to
+      def initialize(icon, url = nil)
+        @icon = icon
+        @url = url
+      end
+
+      # Add the object as HTML Elements to the document.
+      # @param doc [HTMLBuilder] XML Document
+      def to_html(doc)
+        if @url
+          doc.a({ :href => @url }) {
+            doc.img({ :src => "icons/#{@icon}", :class => 'active_button' })
+          }
+        else
+          doc.img({ :src => "icons/#{@icon}", :class => 'inactive_button' })
+        end
+      end
+
+    end
+
+    # Create a new NavButtonRow object.
+    # @param float [String, Nil] specifies if the HTML representation should
+    # be a floating object that floats left or right.
+    def initialize(float = nil)
+      unless float.nil? || %w( left right ).include?(float)
+        raise ArgumentError "float argument must be nil, 'left' or 'right'"
+      end
+
+      @float = float
+      @buttons = []
+    end
+
+    # Add a new button to the NavButtonRow object.
+    # @param icon [String] File name of the icon file
+    # @param url [String] URL of the page to change to
+    def addButton(icon, url = nil)
+      @buttons << Button.new(icon, url)
+    end
+
+    # Add the object as HTML Elements to the document.
+    # @param doc [HTMLBuilder] XML Document
+    def to_html(doc)
+      doc.unique(:nav_button_row_style) {
+        doc.head { doc.style(style) }
+      }
+      doc.div({ :class => 'nav_button_row',
+                :style => "width: #{@buttons.length * (32 + 10)}px; " +
+                          "#{@float ? "float: #{@float};" :
+                             'margin-left: auto; margin-right: auto'}"}) {
+        @buttons.each { |btn| btn.to_html(doc) }
+      }
+    end
+
+    private
+
+    def style
+      <<"EOT"
+.nav_button_row {
+  padding: 3px 30px;
+}
+.active_button {
+  padding: 5px;
+}
+.inactive_button {
+  padding: 5px;
+  opacity: 0.4;
+}
+EOT
+    end
+
+  end
+
+end

data/lib/postrunner/PagingButtons.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = PagingButtons.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.
+#
+
+require 'postrunner/NavButtonRow'
+
+module PostRunner
+
+  # A class to generate a set of forward/backward buttons for an HTML page. It
+  # can also include jump to first/last buttons.
+  class PagingButtons
+
+    # Create a new PagingButtons object.
+    # @param page_urls [Array of String] Sorted list of all possible pages
+    # @param end_buttons [Boolean] If true jump to first/last buttons are
+    #        included
+    def initialize(page_urls, end_buttons = true)
+      if page_urls.empty?
+        raise ArgumentError.new("'page_urls' must not be empty")
+      end
+      @pages = page_urls
+      @current_page_index = 0
+      @end_buttons = end_buttons
+    end
+
+    # Return the URL of the current page
+    def current_page
+      @pages[@current_page_index]
+    end
+
+    # Set the URL for the current page. It must be included in the URL set
+    # passed at creation time. The forward/backward links will be derived from
+    # the setting of the current page.
+    # @param page_url [String] URL of the page
+    def current_page=(page_url)
+      unless (@current_page_index = @pages.index(page_url))
+        raise ArgumentError.new("URL #{page_url} is not a known page URL")
+      end
+    end
+
+    # Iterate over all buttons. A NavButtonDef object is passed to the block
+    # that contains the icon and URL for the button. If no URL is set, the
+    # button is inactive.
+    def each
+      %w( first back forward last ).each do |button_name|
+        button = NavButtonDef.new
+        button.icon = button_name + '.png'
+        button.url =
+          case button_name
+          when 'first'
+            @current_page_index == 0 || !@end_buttons ? nil : @pages.first
+          when 'back'
+            @current_page_index == 0 ? nil :
+              @pages[@current_page_index - 1]
+          when 'forward'
+            @current_page_index == @pages.length - 1 ? nil :
+              @pages[@current_page_index + 1]
+          when 'last'
+            @current_page_index == @pages.length - 1 ||
+              !@end_buttons ? nil : @pages.last
+          end
+
+        yield(button)
+      end
+    end
+
+  end
+
+end

data/lib/postrunner/PersonalRecords.rb

@@ -3,7 +3,7 @@
 #
 # = PersonalRecords.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,115 +14,349 @@ require 'fileutils'
 require 'yaml'
 
 require 'fit4ruby'
+require 'postrunner/BackedUpFile'
+require 'postrunner/RecordListPageView'
+require 'postrunner/ActivityLink'
 
 module PostRunner
 
   class PersonalRecords
 
+    include Fit4Ruby::Converters
+
+    SpeedRecordDistances = {
+      'cycling' => {
+        5000.0 => '5 km',
+        8000.0 => '8 km',
+        9000.0 => '9 km',
+        10000.0 => '10 km',
+        20000.0 => '20 km',
+        40000.0 => '40 km',
+        80000.0 => '80 km',
+        90000.0 => '90 km',
+        12000.0 => '120 km',
+        18000.0 => '180 km',
+      },
+      'running' => {
+        1000.0 => '1 km',
+        1609.0 => '1 mi',
+        2000.0 => '2 km',
+        3000.0 => '3 km',
+        5000.0 => '5 km',
+        10000.0 => '10 km',
+        20000.0 => '20 km',
+        30000.0 => '30 km',
+        21097.5 => 'Half Marathon',
+        42195.0 => 'Marathon'
+      },
+      'swimming' => {
+        100.0 => '100 m',
+        300.0 => '300 m',
+        400.0 => '400 m',
+        750.0 => '750 m',
+        1500.0 => '1.5 km',
+        1930.0 => '1.2 mi',
+        3000.0 => '3 km',
+        4000.0 => '4 km',
+        3860.0 => '2.4 mi'
+      },
+      'walking' => {
+        1000.0 => '1 km',
+        1609.0 => '1 mi',
+        5000.0 => '5 km',
+        10000.0 => '10 km',
+        21097.5 => 'Half Marathon',
+        42195.0 => 'Marathon'
+      }
+    }
+
     class Record
 
-      attr_accessor :distance, :duration, :start_time, :fit_file
+      include Fit4Ruby::Converters
+
+      attr_accessor :activity, :sport, :distance, :duration, :start_time
 
-      def initialize(distance, duration, start_time, fit_file)
+      def initialize(activity, sport, distance, duration, start_time)
+        @activity = activity
+        @sport = sport
         @distance = distance
         @duration = duration
         @start_time = start_time
-        @fit_file = fit_file
+      end
+
+      def to_table_row(t)
+        t.row((@duration.nil? ?
+               [ 'Longest Run', '%.1f m' % @distance, '-' ] :
+               [ 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") ])
       end
 
     end
 
-    include Fit4Ruby::Converters
+    class RecordSet
 
-    def initialize(activities)
-      @activities = activities
-      @db_dir = activities.db_dir
-      @records_file = File.join(@db_dir, 'records.yml')
-      @records = []
+      include Fit4Ruby::Converters
 
-      load_records
-    end
+      attr_reader :year
 
-    def register_result(distance, duration, start_time, fit_file)
-      @records.each do |record|
-        if record.duration > 0
-          if duration > 0
-            # This is a speed record for a popular distance.
-            if distance == record.distance
-              if duration < record.duration
-                record.duration = duration
-                record.start_time = start_time
-                record.fit_file = fit_file
-                Log.info "New record for #{distance} m in " +
-                         "#{secsToHMS(duration)}"
-                return true
-              else
-                # No new record for this distance.
-                return false
-              end
-            end
+      def initialize(sport, year)
+        @sport = sport
+        @year = year
+        @distance = nil
+        @speed_records = {}
+        PersonalRecords::SpeedRecordDistances[@sport].each_key do |dist|
+          @speed_records[dist] = nil
+        end
+      end
+
+      def register_result(result)
+        if result.duration
+          # We have a potential speed record for a known distance.
+          unless PersonalRecords::SpeedRecordDistances[@sport].
+                 include?(result.distance)
+            Log.fatal "Unknown record distance #{result.distance}"
+          end
+
+          old_record = @speed_records[result.distance]
+          if old_record.nil? || old_record.duration > result.duration
+            @speed_records[result.distance] = result
+            Log.info "New #{@year ? @year.to_s : 'all-time'} " +
+                     "#{result.sport} speed record for " +
+                     "#{PersonalRecords::SpeedRecordDistances[@sport][
+                        result.distance]}: " +
+                     "#{secsToHMS(result.duration)}"
+            return true
           end
         else
-          if distance > record.distance
-            # This is a new distance record.
-            record.distance = distance
-            record.duration = 0
-            record.start_time = start_time
-            record.fit_file = fit_file
-            Log.info "New distance record #{distance} m"
+          # We have a potential distance record.
+          if @distance.nil? || result.distance > @distance.distance
+            @distance = result
+            Log.info "New #{@year ? @year.to_s : 'all-time'} " +
+                     "#{result.sport} distance record: #{result.distance} m"
             return true
-          else
-            # No new distance record.
-            return false
           end
         end
+
+        false
+      end
+
+      def delete_activity(activity)
+        if @distance && @distance.activity == activity
+          @distance = nil
+        end
+        PersonalRecords::SpeedRecordDistances[@sport].each_key do |dist|
+          if @speed_records[dist] && @speed_records[dist].activity == activity
+            @speed_records[dist] = nil
+          end
+        end
+      end
+
+      # Return true if no Record is stored in this RecordSet object.
+      def empty?
+        return false if @distance
+        @speed_records.each_value { |r| return false if r }
+
+        true
+      end
+
+      # Iterator for all Record objects that are stored in this data structure.
+      def each(&block)
+        yield(@distance) if @distance
+        @speed_records.each_value do |record|
+          yield(record) if record
+        end
+      end
+
+      def to_s
+        return '' if empty?
+
+        generate_table.to_s + "\n"
+      end
+
+      def to_html(doc)
+        generate_table.to_html(doc)
+      end
+
+      private
+
+      def generate_table
+        t = FlexiTable.new
+        t.head
+        t.row([ 'Record', 'Time/Dist.', 'Avg. Pace', 'Ref.', 'Activity',
+                'Date' ],
+              { :halign => :center })
+        t.set_column_attributes([
+          {},
+          { :halign => :right },
+          { :halign => :right },
+          { :halign => :right },
+          { :halign => :left },
+          { :halign => :left }
+        ])
+        t.body
+
+        records = @speed_records.values.delete_if { |r| r.nil? }
+        records << @distance if @distance
+
+        records.sort { |r1, r2| r1.distance <=> r2.distance }.each do |r|
+          r.to_table_row(t)
+        end
+
+        t
+      end
+
+
+    end
+
+    class SportRecords
+
+      attr_reader :sport, :all_time, :yearly
+
+      def initialize(sport)
+        @sport = sport
+        @all_time = RecordSet.new(@sport, nil)
+        @yearly = {}
+      end
+
+      def register_result(result)
+        year = result.start_time.year
+        unless @yearly[year]
+          @yearly[year] = RecordSet.new(@sport, year)
+        end
+
+        new_at = @all_time.register_result(result)
+        new_yr = @yearly[year].register_result(result)
+
+        new_at || new_yr
+      end
+
+      def delete_activity(activity)
+        ([ @all_time ] + @yearly.values).each do |r|
+          r.delete_activity(activity)
+        end
+      end
+
+      # Return true if no record is stored in this SportRecords object.
+      def empty?
+        return false unless @all_time.empty?
+        @yearly.each_value { |r| return false unless r.empty? }
+
+        true
+      end
+
+      # Iterator for all Record objects that are stored in this data structure.
+      def each(&block)
+        records = @yearly.values
+        records << @all_time if @all_time
+        records.each { |r| r.each(&block) }
+      end
+
+      def to_s
+        return '' if empty?
+
+        str = "All-time records:\n\n#{@all_time.to_s}" unless @all_time.empty?
+        @yearly.values.sort{ |r1, r2| r2.year <=> r1.year }.each do |record|
+          unless record.empty?
+            str += "Records of #{record.year}:\n\n#{record.to_s}"
+          end
+        end
+
+        str
+      end
+
+      def to_html(doc)
+        return nil if empty?
+
+        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
+            unless record.empty?
+              doc.h3("Records of #{record.year}")
+              record.to_html(doc)
+            end
+          end
+        }
       end
 
-      # We have not found a record.
-      @records << Record.new(distance, duration, start_time, fit_file)
-      if duration == 0
-        Log.info "New distance record #{distance} m"
-      else
-        Log.info "New record for #{distance}m in #{secsToHMS(duration)}"
+    end
+
+    def initialize(activities)
+      @activities = activities
+      @db_dir = activities.db_dir
+      @records_file = File.join(@db_dir, 'records.yml')
+      delete_all_records
+
+      load_records
+    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}"
+        return false
       end
 
-      true
+      result = Record.new(activity, sport, distance, duration, start_time)
+      @sport_records[sport].register_result(result)
+    end
+
+    def delete_all_records
+      @sport_records = {}
+      SpeedRecordDistances.keys.each do |sport|
+        @sport_records[sport] = SportRecords.new(sport)
+      end
     end
 
-    def delete_activity(fit_file)
-      @records.delete_if { |r| r.fit_file == fit_file }
+    def delete_activity(activity)
+      @sport_records.each_value { |r| r.delete_activity(activity) }
     end
 
     def sync
       save_records
+
+      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],
+                                "records-#{i}.html")
+        RecordListPageView.new(@activities, record, max, i).
+                               write(output_file)
+      end
     end
 
     def to_s
-      record_names = { 1000.0 => '1 km', 1609.0 => '1 mi', 5000.0 => '5 km',
-                       21097.5 => '1/2 Marathon',  42195.0 => 'Marathon' }
-      t = FlexiTable.new
-      t.head
-      t.row([ 'Record', 'Time/Dist.', 'Avg. Pace', 'Ref.', 'Activity', 'Date' ],
-            { :halign => :center })
-      t.set_column_attributes([
-        {},
-        { :halign => :right },
-        { :halign => :right },
-        { :halign => :right },
-        { :halign => :right },
-        { :halign => :left }
-      ])
-      t.body
-      @records.sort { |r1, r2| r1.distance <=> r2.distance }.each do |r|
-        activity = @activities.activity_by_fit_file(r.fit_file)
-        t.row((r.duration == 0 ?
-               [ 'Longest Run', '%.1f m' % r.distance, '-' ] :
-               [ record_names[r.distance], secsToHMS(r.duration),
-                speedToPace(r.distance / r.duration) ]) +
-              [ @activities.ref_by_fit_file(r.fit_file),
-                activity.name, r.start_time.strftime("%Y-%m-%d") ])
-      end
-      t.to_s
+      str = ''
+      @sport_records.each do |sport, record|
+        next if record.empty?
+        str += "Records for activity type #{sport}:\n\n#{record.to_s}"
+      end
+
+      str
+    end
+
+    # Iterator for all Record objects that are stored in this data structure.
+    def each(&block)
+      @sport_records.each_value { |r| r.each(&block) }
+    end
+
+    # Return an Array of all the records associated with the given Activity.
+    def activity_records(activity)
+      records = []
+      each do |record|
+      #  puts record.activity
+        if record.activity.equal?(activity) && !records.include?(record)
+          records << record
+        end
+      end
+
+      records
     end
 
     private
@@ -130,25 +364,50 @@ module PostRunner
     def load_records
       begin
         if File.exists?(@records_file)
-          @records = YAML.load_file(@records_file)
+          @sport_records = YAML.load_file(@records_file)
         else
           Log.info "No records file found at '#{@records_file}'"
         end
-      rescue StandardError
+      rescue IOError
         Log.fatal "Cannot load records file '#{@records_file}': #{$!}"
       end
 
-      unless @records.is_a?(Array)
+      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
-        File.open(@records_file, 'w') { |f| f.write(@records.to_yaml) }
-      rescue StandardError
+        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