postrunner 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5442c8e0d9d50397dc5fae363f102b851cffca2
-  data.tar.gz: f774c976a32016ef7815dfba94ee154555adaffb
+  metadata.gz: 10eb940a7f897be53510322b131e9307a844b3d3
+  data.tar.gz: 85b3a20f60cd7b20bede30072eae6d51af9bf93c
 SHA512:
-  metadata.gz: 69c25003d3de0d97c30f5714b37084332536ac2949a0eda529333424bbe533361c62df559e4de5cdd80534b6dce1256e0df9af966eb942bd4591829956c57765
-  data.tar.gz: 929fcc906deede1c84d728b0ecba0208a761f5d5310f2a98e873e6c61a28b25e5fc949bbcbcc95a19f9a111d57ced4b773f978768bb9ff0cb6bccb99d39efac0
+  metadata.gz: 1c59ca7d3109f211b7719bf1f5b526702c664d38b71766777784bfafef0edd72782efa580b79d9bfadfee5c9aacf79d1be62c9e7aaf9901275d2d04cec5cbe6d
+  data.tar.gz: 3b1d77b712513e49a922bc94a1a44f8e88c9681d36c62df7c797bda14207b60721efb3cee5bf7393452fd8c1993a8f2dd597f1bdecef074113587fd7ce20c7ab

data/README.md

@@ -6,44 +6,107 @@ PostRunner is an application to manage FIT files such as those produced by Garmi
 
 PostRunner is a Ruby application. You need to have a Ruby 2.0 or later runtime environment installed.
 
-    $ gem install postrunner
+```
+$ gem install postrunner
+```
 
 ## Usage
 
+### Importing FIT files
+
 To get started you need to connect your device to your computer and mount it as a drive. Only devices that expose their data as FAT file system are supported. Older devices use proprietary drivers and are not supported by postrunner. Once the device is mounted find out the full path to the directory that contains your FIT files. You can then import all files on the device.
 
-    $ postrunner import /var/run/media/user/GARMIN/GARMIN/ACTIVITY/
+```
+$ postrunner import /var/run/media/user/GARMIN/GARMIN/ACTIVITY/
+```
     
 The above command assumes that your device is mounted as /var/run/media/user. Please replace this with the path to your device. Files that have been imported previously will not be imported again. 
 
+### Viewing FIT file data on the console
+
 Now you can list all the FIT files in your data base.
 
-    $ postrunner list
+```
+$ postrunner list
+```
     
-The first column is the index you can use to reference FIT files. To get a summary of the most recent activity use the following command.
+The first column is the index you can use to reference FIT files. To
+get a summary of the most recent activity use the following command.
+References to already imported activities start with a colon followed
+by the index number.
+
+```
+$ postrunner summary :1
+```
 
-    $ postrunner summary :1
-    
 To get a summary of the oldest activity you can use
 
-    $ postrunner summary :-1
-    
+```
+$ postrunner summary :-1
+```
+
+To select multiple activities you can use a range.
+
+```
+$ postrunner summary :1-3
+```
+
 You can also get a full dump of the content of a FIT file.
 
-    $ postrunner dump 1234568.FIT
+```
+$ postrunner dump 1234568.FIT
+```
     
 If the file is already in the data base you can also use the reference notation.
 
-    $ postrunner dump :1
+```
+$ postrunner dump :1
+```
     
 This will provide you with a lot more information contained in the FIT files that is not available through Garmin Connect or most other tools.
 
+### Viewing FIT file data in your web browser
+
+You can also view the full details of your activity in your browser.
+This view includes a map (internet connection for map data required)
+and charts for speed, pace, heart rate, cadence and the like.
+
+```
+$ postrunner show
+```
+
+This will open an overview of the most recent activities in your web
+browser. It will use Firefox by default. You can overwrite this by
+setting the BROWSER environment variable.
+
+To view a specific run directly, you can use similar specifications
+like those explained above.
+
+```
+$ postrunner show :1
+```
+
 ## Contributing
 
-PostRunner is currently work in progress. It does some things I want with files from my Garmin FR620. It's certainly possible to do more things and support more devices. Patches are welcome!
+PostRunner is currently work in progress. It does some things I want
+with files from my Garmin FR620. It's certainly possible to do more
+things and support more devices. Patches are welcome!
 
 1. Fork it ( https://github.com/scrapper/postrunner/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## License
+
+PostRunner is licensed under the GNU GPL version 2.
+
+The distribution includes third party components that are licensed
+under different OSI compatible terms.
+
+* flot: MIT License
+* jquery: MIT License
+* openlayers: 2 clause BSD license
+* Oxygen Icons: GNU LGPLv3 (https://techbase.kde.org/Projects/Oxygen/Licensing)
+

data/Rakefile

@@ -1,6 +1,16 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
+# Add the include path for the fit4ruby library. We assume it is located in
+# the same directory as the postrunner directory.
+fit4ruby = File.realpath(File.join(File.dirname(__FILE__), '..',
+                                                'fit4ruby', 'lib'))
+if ENV['RUBYLIB']
+  ENV['RUBYLIB'] += ":#{fit4ruby}"
+else
+  ENV['RUBYLIB'] = fit4ruby
+end
+
 RSpec::Core::RakeTask.new
 
 task :default => :spec

data/lib/postrunner/ActivitiesDB.rb

@@ -1,22 +1,34 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ActivitiesDB.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014 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/Activity'
 require 'postrunner/PersonalRecords'
-require 'postrunner/FlexiTable'
+require 'postrunner/ActivityListView'
 
 module PostRunner
 
   class ActivitiesDB
 
-    include Fit4Ruby::Converters
-
-    attr_reader :db_dir, :fit_dir
+    attr_reader :db_dir, :cfg, :fit_dir, :html_dir, :activities
 
-    def initialize(db_dir)
+    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')
 
       create_directories
@@ -34,16 +46,20 @@ module PostRunner
         Log.fatal "The archive file '#{@archive_file}' is corrupted"
       end
 
-      # The reference to this object is needed inside Activity object but is
-      # not stored in the archive file. We have to retrofit the Activity
-      # instances with this data.
+      # Not all instance variables of Activity are stored in the file. The
+      # normal constructor is not run during YAML::load_file. We have to
+      # initialize those instance variables in a secondary step.
       @activities.each do |a|
-        a.db = self
+        a.late_init(self)
       end
 
       @records = PersonalRecords.new(self)
     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
+    # otherwise.
     def add(fit_file)
       base_fit_file = File.basename(fit_file)
       if @activities.find { |a| a.fit_file == base_fit_file }
@@ -77,6 +93,16 @@ module PostRunner
 
       activity.register_records(@records)
 
+      # 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_view
+      end
+      if (succ = successor(activity))
+        succ.generate_html_view
+      end
+
       sync
       Log.info "#{fit_file} successfully added to archive"
 
@@ -84,7 +110,17 @@ module PostRunner
     end
 
     def delete(activity)
+      pred = predecessor(activities)
+      succ = successor(activities)
+
       @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 as well.
+      pred.generate_html_view if pred
+      succ.generate_html_view if succ
+
       sync
     end
 
@@ -139,6 +175,22 @@ module PostRunner
       []
     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)
+      idx = @activities.index(activity)
+      return nil if idx.nil? || idx == 0
+      @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.
+    def predecessor(activity)
+      idx = @activities.index(activity)
+      return nil if idx.nil? || idx >= @activities.length - 2
+      @activities[idx + 1]
+    end
+
     def map_to_files(query)
       case query
       when /\A-?\d+$\z/
@@ -171,36 +223,43 @@ module PostRunner
       []
     end
 
+    # 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'))
+    end
+
     def list
-      i = 0
-      t = FlexiTable.new
-      t.head
-      t.row(%w( Ref. Activity Start Distance Duration Pace ),
-            { :halign => :left })
-      t.set_column_attributes([
-        { :halign => :right },
-        {}, {},
-        { :halign => :right },
-        { :halign => :right },
-        { :halign => :right }
-      ])
-      t.body
-      @activities.each do |a|
-        t.row([
-          i += 1,
-          a.name[0..19],
-          a.timestamp.strftime("%a, %Y %b %d %H:%M"),
-          "%.2f" % (a.total_distance / 1000),
-          secsToHMS(a.total_timer_time),
-          speedToPace(a.avg_speed) ])
-      end
-      puts t.to_s
+      puts ActivityListView.new(self).to_s
     end
 
     def show_records
       puts @records.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
+
+    # This method can be called to re-generate all HTML reports and all HTML
+    # index files.
+    def generate_all_html_reports
+      Log.info "Re-generating all HTML report files..."
+      # Generate HTML views for all activities in the DB.
+      @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
+      Log.info "HTML index files have been updated."
+    end
+
     private
 
     def sync
@@ -211,11 +270,18 @@ module PostRunner
       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')
     end
 
     def create_directory(dir, name)
@@ -229,6 +295,28 @@ module PostRunner
       end
     end
 
+    def create_symlink(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 = File.join(@html_dir, dir)
+      unless File.exists?(dst_dir)
+        begin
+          FileUtils.ln_s(src_dir, dst_dir)
+        rescue IOError
+          Log.fatal "Cannot create symbolic link to '#{dst_dir}': #{$!}"
+        end
+      end
+    end
+
   end
 
 end

data/lib/postrunner/Activity.rb

@@ -1,14 +1,25 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Activity.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014 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 'postrunner/ActivityReport'
+require 'postrunner/ActivitySummary'
 require 'postrunner/ActivityView'
 
 module PostRunner
 
   class Activity
 
-    attr_reader :fit_file, :name, :fit_activity
-    attr_accessor :db
+    attr_reader :db, :fit_file, :name, :fit_activity, :html_dir, :html_file
 
     # 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.
@@ -16,16 +27,24 @@ module PostRunner
                             avg_speed )
 
     def initialize(db, fit_file, fit_activity, name = nil)
-      @db = db
       @fit_file = fit_file
       @fit_activity = fit_activity
       @name = name || fit_file
+      late_init(db)
 
       @@CachedVariables.each do |v|
         v_str = "@#{v}"
         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
+
+    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")
     end
 
     def check
@@ -61,21 +80,19 @@ module PostRunner
     end
 
     def show
-      @fit_activity = load_fit_file unless @fit_activity
-      view = ActivityView.new(self, File.join(@db.db_dir, 'html'))
-      #view = TrackView.new(self, '../../html')
-      #view.generate_html
-      #chart = ChartView.new(self, '../../html')
-      #chart.generate_html
+      generate_html_view #unless File.exists?(@html_file)
+
+      @db.show_in_browser(@html_file)
     end
 
     def summary
       @fit_activity = load_fit_file unless @fit_activity
-      puts ActivityReport.new(@fit_activity).to_s
+      puts ActivitySummary.new(@fit_activity, name, @db.cfg[:unit_system]).to_s
     end
 
     def rename(name)
       @name = name
+      generate_html_view
     end
 
     def register_records(db)
@@ -90,6 +107,12 @@ module PostRunner
       end
     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))
+    end
+
     private
 
     def load_fit_file(filter = nil)

data/lib/postrunner/ActivityListView.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ActivitListView.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014 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 'postrunner/FlexiTable'
+require 'postrunner/HTMLBuilder'
+require 'postrunner/ViewWidgets'
+
+module PostRunner
+
+  class ActivityListView
+
+    class ActivityLink
+
+      def initialize(activity)
+        @activity = activity
+      end
+
+      def to_html(doc)
+        doc.a(@activity.name, { :class => 'activity_link',
+                                :href => @activity.fit_file[0..-5] + '.html' })
+      end
+
+      def to_s
+        @activity.name[0..19]
+      end
+
+    end
+
+    include Fit4Ruby::Converters
+    include ViewWidgets
+
+    def initialize(db)
+      @db = db
+      @unit_system = @db.cfg[:unit_system]
+      @page_size = 20
+      @page_no = -1
+      @last_page = (@db.activities.length - 1) / @page_size
+    end
+
+    def update_html_index
+      0.upto(@last_page) do |page_no|
+        @page_no = page_no
+        generate_html_index_page
+      end
+    end
+
+    def to_html(doc)
+      generate_table.to_html(doc)
+    end
+
+    def to_s
+      generate_table.to_s
+    end
+
+    private
+
+    def generate_html_index_page
+      doc = HTMLBuilder.new
+
+      doc.html {
+        head(doc)
+        body(doc)
+      }
+
+      write_file(doc)
+    end
+
+    def head(doc)
+      doc.head {
+        doc.meta({ 'http-equiv' => 'Content-Type',
+                   'content' => 'text/html; charset=utf-8' })
+        doc.title("PostRunner Activities")
+        style(doc)
+      }
+    end
+
+    def style(doc)
+      view_widgets_style(doc)
+      doc.style(<<EOT
+body {
+  font-family: verdana,arial,sans-serif;
+  margin: 0px;
+}
+.main {
+  text-align: center;
+}
+.widget_frame {
+  width: 900px;
+}
+.activity_link {
+  padding: 0px 3px 0px 3px;
+}
+.ft_cell {
+  height: 30px
+}
+EOT
+               )
+    end
+
+    def body(doc)
+      doc.body {
+        first_page = @page_no == 0 ? nil: 'index.html'
+        prev_page = @page_no == 0 ? nil :
+                    @page_no == 1 ? 'index.html' :
+                                    "index#{@page_no - 1}.html"
+        prev_page = @page_no == 0 ? nil :
+                    @page_no == 1 ? 'index.html' :
+                                    "index#{@page_no - 1}.html"
+        next_page = @page_no < @last_page ? "index#{@page_no + 1}.html" : nil
+        last_page = @page_no == @last_page ? nil : "index#{@last_page}.html"
+        titlebar(doc, first_page, prev_page, nil, next_page, last_page)
+
+        doc.div({ :class => 'main' }) {
+          frame(doc, 'Activities') {
+            generate_table.to_html(doc)
+          }
+        }
+        footer(doc)
+      }
+    end
+
+    def generate_table
+      i = @page_no < 0 ? 0 : @page_no * @page_size
+      t = FlexiTable.new
+      t.head
+      t.row(%w( Ref. Activity Start Distance Duration Pace ),
+            { :halign => :left })
+      t.set_column_attributes([
+        { :halign => :right },
+        {}, {},
+        { :halign => :right },
+        { :halign => :right },
+        { :halign => :right }
+      ])
+      t.body
+      activities = @page_no == -1 ? @db.activities :
+        @db.activities[(@page_no * @page_size)..
+                       ((@page_no + 1) * @page_size - 1)]
+      activities.each do |a|
+        t.row([
+          i += 1,
+          ActivityLink.new(a),
+          a.timestamp.strftime("%a, %Y %b %d %H:%M"),
+          local_value(a.total_distance, 'm', '%.2f',
+                      { :metric => 'km', :statute => 'mi' }),
+          secsToHMS(a.total_timer_time),
+          pace(a.avg_speed) ])
+      end
+
+      t
+    end
+
+    def write_file(doc)
+      output_file = File.join(@db.html_dir,
+                              "index#{@page_no == 0 ? '' : @page_no}.html")
+      begin
+        File.write(output_file, doc.to_html)
+      rescue IOError
+        Log.fatal "Cannot write activity index file '#{output_file}: #{$!}"
+      end
+    end
+
+    def local_value(value, from_unit, format, units)
+      to_unit = units[@unit_system]
+      return '-' unless value
+      value *= conversion_factor(from_unit, to_unit)
+      "#{format % [value, to_unit]}"
+    end
+
+    def pace(speed)
+      case @unit_system
+      when :metric
+        "#{speedToPace(speed)}"
+      when :statute
+        "#{speedToPace(speed, 1609.34)}"
+      else
+        Log.fatal "Unknown unit system #{@unit_system}"
+      end
+    end
+
+  end
+
+end
+