postrunner 0.0.2 → 0.0.3

data/lib/postrunner/FlexiTable.rb

@@ -0,0 +1,289 @@
+require 'postrunner/HTMLBuilder'
+
+module PostRunner
+
+  class FlexiTable
+
+    class Attributes
+
+      attr_accessor :min_terminal_width, :halign
+
+      def initialize(attrs = {})
+        @min_terminal_width = nil
+        @halign = nil
+
+        attrs.each do |name, value|
+          ivar_name = '@' + name.to_s
+          unless instance_variable_defined?(ivar_name)
+            Log.fatal "Unsupported attribute #{name}"
+          end
+          instance_variable_set(ivar_name, value)
+        end
+      end
+
+      def [](name)
+        ivar_name = '@' + name.to_s
+        return nil unless instance_variable_defined?(ivar_name)
+
+        instance_variable_get(ivar_name)
+      end
+
+    end
+
+    class Cell
+
+      def initialize(table, row, content, attributes)
+        @table = table
+        @row = row
+        @content = content
+        @attributes = attributes
+
+        @column_index = nil
+        @row_index = nil
+      end
+
+      def min_terminal_width
+        @content.to_s.length
+      end
+
+      def set_indicies(col_idx, row_idx)
+        @column_index = col_idx
+        @row_index = row_idx
+      end
+
+      def to_s
+        s = @content.to_s
+        width = get_attribute(:min_terminal_width)
+        case get_attribute(:halign)
+        when :left, nil
+          s + ' ' * (width - s.length)
+        when :right
+          ' ' * (width - s.length) + s
+        when :center
+          w = width - s.length
+          left_padding = w / 2
+          right_padding = w / 2 + w % 2
+          ' ' * left_padding + s + ' ' * right_padding
+        else
+          raise "Unknown alignment"
+        end
+      end
+
+      def to_html(doc)
+        doc.td(@content.respond_to?('to_html') ?
+               @content.to_html(doc) : @content.to_s)
+      end
+
+      private
+
+      def get_attribute(name)
+        @attributes[name] ||
+          @row.attributes[name] ||
+          @table.column_attributes[@column_index][name]
+      end
+
+    end
+
+    class Row < Array
+
+      attr_reader :attributes
+
+      def initialize(table)
+        @table = table
+        @attributes = Attributes.new
+        super()
+      end
+
+      def cell(content, attributes)
+        c = Cell.new(@table, self, content, attributes)
+        self << c
+        c
+      end
+
+      def set_indicies(col_idx, row_idx)
+        self[col_idx].set_indicies(col_idx, row_idx)
+      end
+
+      def set_row_attributes(attributes)
+        @attributes = Attributes.new(attributes)
+      end
+
+      def to_s
+        s = ''
+        frame = @table.frame
+
+        s << '|' if frame
+        s << join(frame ? '|' : ' ')
+        s << '|' if frame
+
+        s
+      end
+
+      def to_html(doc)
+        doc.tr {
+          each { |c| c.to_html(doc) }
+        }
+      end
+
+    end
+
+    attr_reader :frame, :column_attributes
+
+    def initialize(&block)
+      @head_rows = []
+      @body_rows = []
+      @foot_rows = []
+      @column_count = 0
+
+      @current_section = :body
+      @current_row = nil
+
+      @frame = true
+
+      @column_attributes = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def head
+      @current_section = :head
+    end
+
+    def body
+      @current_section = :body
+    end
+
+    def foot
+      @current_section = :foot
+    end
+
+    def new_row
+      @current_row = nil
+    end
+
+    def cell(content, attributes = {})
+      if @current_row.nil?
+        case @current_section
+        when :head
+          @head_rows
+        when :body
+          @body_rows
+        when :foot
+          @foot_rows
+        else
+          raise "Unknown section #{@current_section}"
+        end << (@current_row = Row.new(self))
+      end
+      @current_row.cell(content, attributes)
+    end
+
+    def row(cells, attributes = {})
+      cells.each { |c| cell(c) }
+      set_row_attributes(attributes)
+      new_row
+    end
+
+    def set_column_attributes(col_attributes)
+      col_attributes.each.with_index do |ca, idx|
+        @column_attributes[idx] = Attributes.new(ca)
+      end
+    end
+
+    def set_row_attributes(row_attributes)
+      unless @current_row
+        raise "No current row. Use after first cell definition but before " +
+              "new_row call."
+      end
+      @current_row.set_row_attributes(row_attributes)
+    end
+
+    def enable_frame(enabled)
+      @frame = enabled
+    end
+
+    def to_s
+      index_table
+      calc_terminal_columns
+
+      s = frame_line_to_s
+      s << rows_to_s(@head_rows)
+      s << frame_line_to_s unless @head_rows.empty?
+      s << rows_to_s(@body_rows)
+      s << frame_line_to_s unless @body_rows.empty?
+      s << rows_to_s(@foot_rows)
+      s << frame_line_to_s unless @foot_rows.empty?
+
+      s
+    end
+
+    def to_html(doc)
+      doc.table {
+        @head_rows.each { |r| r.to_html(doc) }
+        @body_rows.each { |r| r.to_html(doc) }
+        @foot_rows.each { |r| r.to_html(doc) }
+      }
+    end
+
+    private
+
+    def index_table
+      @column_count = (@head_rows[0] || @body_rows[0]).length
+
+      @column_count.times do |i|
+        index_table_rows(i, @head_rows)
+        index_table_rows(i, @body_rows)
+        index_table_rows(i, @foot_rows)
+      end
+    end
+
+    def index_table_rows(col_idx, rows)
+      rows.each.with_index do |r, row_idx|
+        r.set_indicies(col_idx, row_idx)
+      end
+    end
+
+    def calc_terminal_columns
+      @column_count.times do |i|
+        col_mtw = nil
+
+        col_mtw = calc_section_teminal_columns(i, col_mtw, @head_rows)
+        col_mtw = calc_section_teminal_columns(i, col_mtw, @body_rows)
+        col_mtw = calc_section_teminal_columns(i, col_mtw, @foot_rows)
+
+        @column_attributes[i] = Attributes.new unless @column_attributes[i]
+        @column_attributes[i].min_terminal_width = col_mtw
+      end
+    end
+
+    def calc_section_teminal_columns(col_idx, col_mtw, rows)
+      rows.each do |r|
+        if r[col_idx].nil?
+          raise ArgumentError, "Not all rows have same number of cells"
+        end
+
+        mtw = r[col_idx].min_terminal_width
+        if col_mtw.nil? || col_mtw < mtw
+          col_mtw = mtw
+        end
+      end
+
+      col_mtw
+    end
+
+    def rows_to_s(x_rows)
+      x_rows.empty? ? '' : (x_rows.map { |r| r.to_s}.join("\n") + "\n")
+    end
+
+    def frame_line_to_s
+      return '' unless @frame
+      s = '+'
+      @column_attributes.each do |c|
+        s += '-' * c.min_terminal_width + '+'
+      end
+      s + "\n"
+    end
+
+  end
+
+end
+

data/lib/postrunner/HTMLBuilder.rb

@@ -0,0 +1,67 @@
+require 'nokogiri'
+
+module PostRunner
+
+  # Nokogiri is great, but I don't like the HTMLBuilder interface. This class
+  # is a wrapper around Nokogiri that provides a more Ruby-like interface.
+  class HTMLBuilder
+
+    # Create a new HTMLBuilder object.
+    def initialize
+      # This is the Nokogiri Document that will store all the data.
+      @doc = Nokogiri::HTML::Document.new
+      # We only need to keep a stack of the currently edited nodes so we know
+      # where we are in the node tree.
+      @node_stack = []
+    end
+
+    # Any call to an undefined method will create a HTML node of the same
+    # name.
+    def method_missing(method_name, *args)
+      node = Nokogiri::XML::Node.new(method_name.to_s, @doc)
+      if (parent = @node_stack.last)
+        parent.add_child(node)
+      else
+        @doc.add_child(node)
+      end
+      @node_stack.push(node)
+
+      args.each do |arg|
+        if arg.is_a?(String)
+          node.add_child(Nokogiri::XML::Text.new(arg, @doc))
+        elsif arg.is_a?(Hash)
+          # Hash arguments are attribute sets for the node. We just pass them
+          # directly to the node.
+          arg.each { |k, v| node[k] = v }
+        end
+      end
+
+      yield if block_given?
+      @node_stack.pop
+    end
+
+    # Only needed to comply with style guides. This all calls to unknown
+    # method will be handled properly. So, we always return true.
+    def respond_to?(method)
+      true
+    end
+
+    # Dump the HTML document as HTML formatted String.
+    def to_html
+      @doc.to_html
+    end
+
+    private
+
+    def add_child(parent, node)
+      if parent
+        parent.add_child(node)
+      else
+        @doc.add_child(node)
+      end
+    end
+
+  end
+
+end
+

data/lib/postrunner/Main.rb

@@ -1,7 +1,8 @@
 require 'optparse'
 require 'logger'
 require 'fit4ruby'
-require 'postrunner/RuntimeConfig'
+
+require 'postrunner/version'
 require 'postrunner/ActivitiesDB'
 
 module PostRunner
@@ -11,15 +12,19 @@ module PostRunner
   Log.formatter = proc { |severity, datetime, progname, msg|
     "#{severity == Logger::INFO ? '' : "#{severity}:"} #{msg}\n"
   }
+  Log.level = Logger::INFO
 
   class Main
 
     def initialize(args)
       @filter = nil
       @name = nil
-      @activities = ActivitiesDB.new(File.join(ENV['HOME'], '.postrunner'))
+      @activities = nil
+      @db_dir = File.join(ENV['HOME'], '.postrunner')
+
+      return if (args = parse_options(args)).nil?
 
-      execute_command(parse_options(args))
+      execute_command(args)
     end
 
     private
@@ -72,25 +77,30 @@ EOT
 
         opts.separator ""
         opts.separator "General options:"
+        opts.on('--dbdir dir', String,
+                'Directory for the activity database and related files') do |d|
+          @db_dir = d
+        end
         opts.on('-v', '--verbose',
                 'Show internal messages helpful for debugging problems') do
           Log.level = Logger::DEBUG
         end
         opts.on('-h', '--help', 'Show this message') do
           $stderr.puts opts
-          exit
+          return nil
         end
         opts.on('--version', 'Show version number') do
           $stderr.puts VERSION
-          exit
+          return nil
         end
 
         opts.separator <<"EOT"
 
 Commands:
 
-check <fit file> ...
-          Check the provided FIT file(s) for structural errors.
+check [ <fit file> | <ref> ... ]
+          Check the provided FIT file(s) for structural errors. If no file or
+          reference is provided, the complete archive is checked.
 
 dump <fit file> | <ref>
           Dump the content of the FIT file.
@@ -104,11 +114,17 @@ delete <ref>
 list
           List all FIT files stored in the data base.
 
+records
+          List all personal records.
+
 rename <ref>
           Replace the FIT file name with a more meaningful name that describes
           the activity.
 
-summary <fit file> | <ref>
+show <ref>
+          Show the FIT activity in a web browser.
+
+summary <ref>
           Display the summary information for the FIT file.
 EOT
 
@@ -118,9 +134,15 @@ EOT
     end
 
     def execute_command(args)
+      @activities = ActivitiesDB.new(@db_dir)
+
       case (cmd = args.shift)
       when 'check'
-        process_files_or_activities(args, :check)
+        if args.empty?
+          @activities.check
+        else
+          process_files_or_activities(args, :check)
+        end
       when 'delete'
         process_activities(args, :delete)
       when 'dump'
@@ -130,10 +152,14 @@ EOT
         process_files(args, :import)
       when 'list'
         @activities.list
+      when 'records'
+        @activities.show_records
       when 'rename'
         process_activities(args, :rename)
+      when 'show'
+        process_activities(args, :show)
       when 'summary'
-        process_files_or_activities(args, :summary)
+        process_activities(args, :summary)
       when nil
         Log.fatal("No command provided. " +
                   "See 'postrunner -h' for more information.")
@@ -146,30 +172,24 @@ EOT
     def process_files_or_activities(files_or_activities, command)
       files_or_activities.each do |foa|
         if foa[0] == ':'
-          files = @activities.map_to_files(foa[1..-1])
-          if files.empty?
-            Log.warn "No matching activities found for '#{foa}'"
-            return
-          end
-
-          process_files(files, command)
+          process_activities([ foa ], command)
         else
           process_files([ foa ], command)
         end
       end
     end
 
-    def process_activities(activity_files, command)
-      activity_files.each do |a|
-        if a[0] == ':'
-          files = @activities.map_to_files(a[1..-1])
-          if files.empty?
-            Log.warn "No matching activities found for '#{a}'"
+    def process_activities(activity_refs, command)
+      activity_refs.each do |a_ref|
+        if a_ref[0] == ':'
+          activities = @activities.find(a_ref[1..-1])
+          if activities.empty?
+            Log.warn "No matching activities found for '#{a_ref}'"
             return
           end
-          process_files(files, command)
+          activities.each { |a| process_activity(a, command) }
         else
-          Log.fatal "Activity references must start with ':': #{a}"
+          Log.fatal "Activity references must start with ':': #{a_ref}"
         end
       end
 
@@ -193,19 +213,39 @@ EOT
 
     def process_file(file, command)
       case command
-      when :delete
-        @activities.delete(file)
+      when :check, :dump
+        read_fit_file(file)
       when :import
         @activities.add(file)
+      else
+        Log.fatal("Unknown file command #{command}")
+      end
+    end
+
+    def process_activity(activity, command)
+      case command
+      when :check
+        activity.check
+      when :delete
+        @activities.delete(activity)
+      when :dump
+        activity.dump(@filter)
       when :rename
-        @activities.rename(file, @name)
+        @activities.rename(activity, @name)
+      when :show
+        activity.show
+      when :summary
+        activity.summary
       else
-        begin
-          activity = Fit4Ruby::read(file, @filter)
-          #rescue
-          #  Log.error("File '#{file}' is corrupted!: #{$!}")
-        end
-        puts activity.to_s if command == :summary
+        Log.fatal("Unknown activity command #{command}")
+      end
+    end
+
+    def read_fit_file(fit_file)
+      begin
+        return Fit4Ruby::read(fit_file, @filter)
+      rescue StandardError
+        Log.error("Cannot read FIT file '#{fit_file}': #{$!}")
       end
     end
 

data/lib/postrunner/PersonalRecords.rb

@@ -0,0 +1,145 @@
+require 'fileutils'
+require 'yaml'
+
+require 'fit4ruby'
+
+module PostRunner
+
+  class PersonalRecords
+
+    class Record
+
+      attr_accessor :distance, :duration, :start_time, :fit_file
+
+      def initialize(distance, duration, start_time, fit_file)
+        @distance = distance
+        @duration = duration
+        @start_time = start_time
+        @fit_file = fit_file
+      end
+
+    end
+
+    include Fit4Ruby::Converters
+
+    def initialize(activities)
+      @activities = activities
+      @db_dir = activities.db_dir
+      @records_file = File.join(@db_dir, 'records.yml')
+      @records = []
+
+      load_records
+    end
+
+    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
+          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"
+            return true
+          else
+            # No new distance record.
+            return false
+          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
+
+      true
+    end
+
+    def delete_activity(fit_file)
+      @records.delete_if { |r| r.fit_file == fit_file }
+    end
+
+    def sync
+      save_records
+    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
+    end
+
+    private
+
+    def load_records
+      begin
+        if File.exists?(@records_file)
+          @records = YAML.load_file(@records_file)
+        else
+          Log.info "No records file found at '#{@records_file}'"
+        end
+      rescue StandardError
+        Log.fatal "Cannot load records file '#{@records_file}': #{$!}"
+      end
+
+      unless @records.is_a?(Array)
+        Log.fatal "The personal records file '#{@records_file}' is corrupted"
+      end
+    end
+
+    def save_records
+      begin
+        File.open(@records_file, 'w') { |f| f.write(@records.to_yaml) }
+      rescue StandardError
+        Log.fatal "Cannot write records file '#{@records_file}': #{$!}"
+      end
+    end
+
+  end
+
+end
+