ascii-tracker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b848e61d0882fc155ab6294909494690761926e7
+  data.tar.gz: d22e74f6102673c75c40e3fc2e58a41c6f1b713a
+SHA512:
+  metadata.gz: a42bcb45db21c925574b5ca04bd1fc9ca144f562f34c8fbe8379927b6dba116cbf128c2e9845f232e7f6e25eaaf8d8a13186a74d8a83c86c20970dc5949589cc
+  data.tar.gz: 16f78a6fd81fb919caf62ad6899eeb3597ea5d5d85f93d7618a91ae28545806e443396fbba80d0eefefc9fbb31a6247084c0ec8ba70cc406f7a2749b6d05749c

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in asciitracker.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, all_on_start: true, cli: '--format nested --debug --color' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('lib/asciitracker.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008/13 dirk luesebrink. See LICENSE for details.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ASCII Timecard tracking 
+
+Text file based time tracking, no web app, no mouse clicking.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'asciitracker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install asciitracker
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ascii-tracker.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'asciitracker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ascii-tracker"
+  spec.version       = AsciiTracker::VERSION
+  spec.authors       = ["dirk lu\xCC\x88sebrink"]
+  spec.email         = ["dirk.luesebrink@gmail.com"]
+  spec.description   = %q{
+    keeping track of time in a textfile. now web app, no mouse clicking. No GUI
+    is as easy as "12:13-17:34", and no time tracker i know of allows you to
+    add interrupts like: '0:13 pause: phone call with mum'
+  }
+  spec.summary       = %q{time tracking the ascii way}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "applix"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'guard-rspec'
+
+  if RUBY_PLATFORM.match /java/i
+    spec.add_development_dependency 'ruby-debug'
+  else
+    spec.add_development_dependency 'debugger'
+  end
+end

data/bin/atracker.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pp'
+require 'ostruct'
+require 'applix'
+require 'asciitracker'
+
+# example cmdline:
+#
+#   $ ./slotter.rb --report=2013-02-01--2013-03-01.txt \
+#       scan ~/.timecard \
+#       range 2013-02-01 2013-03-01 \
+#       group report
+#
+Applix.main(ARGV, debug: false) do
+
+  class Context 
+    attr_reader :argv, :values
+    def initialize argv, config
+      @argv = argv
+      @values = OpenStruct.new(config)
+    end
+
+    def set_default_values defaults 
+      @values = OpenStruct.new(defaults.merge(@values.marshal_dump))
+    end
+
+    def forward(target)
+      begin
+        (op = @argv.shift) && target.send(op, self)
+      rescue ArgumentError => e
+        target.send(op)
+      end
+    end
+  end
+
+  prolog do |argv, config|
+    @context = Context.new(argv, config)
+    @app = AsciiTracker::App.new(@context)
+  end
+
+  handle(:any) do |*args, opts|
+    @context.forward(@app)
+  end
+end

data/lib/asciitracker/app.rb

@@ -0,0 +1,189 @@
+module AsciiTracker
+  class App
+    def initialize(context)
+      context.set_default_values :report => "report.txt"
+      @c = Controller.new
+    end
+
+    def stop 
+      puts "Stop!"
+    end
+
+    def foo context
+      puts "Hey!"
+      context.forward(self)
+    end
+
+    def scan context
+      filename = context.argv.shift
+      puts "scanning file: #{filename}"
+      AsciiTracker::Parser.parse @c, IO.read(filename)
+      #puts "records:\n#{records.join("\n")}"
+      #puts "--> 2: #{@c.model}"
+      #puts "--> 3: #{@c.model.records}"
+
+      context.forward(self)
+    end
+
+    def group(context)
+      @groups = group_by_project
+      @groups.each do |project_id, records| 
+        @groups[project_id] = {
+          project_id: project_id, 
+          records: records,
+          total: records.inject(0.0) { |sum, rec| sum + rec.span }
+        }
+      end
+
+      # XXX: this only works when assuming full days
+      @holidays = @groups["holidays"].records rescue []
+      @freedays = @groups["feiertag"].records rescue []
+      @sickdays = @groups["sickdays"].records rescue []
+      @abbau = @groups["ueberstundenabbau"].records rescue []
+
+      context.forward(self)
+    end
+
+    def weekdays_in_range(first_day, last_day)
+      range = (first_day...last_day)
+      #(t..(t+7)).select { |e|  [0,6].include? e.wday  }.map { |e| e.to_s 
+      puts "================#{range}"
+      range.reject { |e| [0,6].include? e.wday }.size
+    end
+
+    def report(context)
+      append_or_overwrite = context.values.append ? "a+" : "w"
+      report = File.open context.values.report, append_or_overwrite
+
+      workcount = weekdays_in_range(*@selection_range) \
+        - (sickcount = @sickdays.size) \
+        - (holicount = @holidays.size) \
+        - (freecount = @freedays.size) \
+
+        netto = total = @selection.inject(0.0) { |sum, rec| sum + rec.span }
+
+            %w{ishapes pause ueberstunden holidays feiertag}.each do |tag|
+              netto -= (pause = @groups[tag].total rescue 0)
+            end
+            #pause = @groups["pause"].total rescue 0
+            #netto -= pause
+            #abbau = @groups["ueberstundenabbau"].total rescue 0
+            #netto -= abbau
+            #netto -= @groups["holidays"].total rescue 0
+            #netto -= @groups["feiertag"].total rescue 0
+
+            report.puts(<<-EOT % [netto, total])
+reporting period: #{@selection_range.join(" until ")}
+#{@selection.size} records in #{@groups.size} groups
+#{@workdays.size} days booked(#{workcount} working(weekdays), #{sickcount} sickdays, #{holicount} holidays, #{@freedays.size} freeday)
+            ---
+%.2f netto working hours in total(%.2f brutto)
+            ---
+freedays: #{@freedays.map {|rec| rec.date.strftime("%e.%b")}.join(", ") }
+holidays: #{@holidays.map {|rec| rec.date.strftime("%e.%b")}.join(", ") }
+sickdays: #{@sickdays.map {|rec| rec.date.strftime("%e.%b")}.join(", ") }
+            ---
+            EOT
+
+@groups.each do |project_id, group| 
+  #puts ">>>> #{project_id}:\n#{records.join("\n")}"
+  #total = group.records.inject(0.0) { |sum, rec| sum + rec.span }
+  #h1 = "#{group.total} hours #{group.project_id}"
+  if context.values.brief
+    p = [group.total, group.project_id]
+    report.puts("%6.2f hours #{group.project_id}" % p)
+    next
+  end
+
+  headline = group_head(group, workcount)
+  report.puts <<-EOT
+
+  #{headline}
+  #{'-' * headline.size}
+                    EOT
+  group.records.each do |rec| 
+    #report.puts ("%5.2f" % rec.span) << "\t#{rec}"
+    report.puts(("%s(%5.2f)" % [HHMM.new(rec.span), rec.span]) << "\t#{rec}")
+  end
+end
+report.puts <<-TXT
+<<< end of reporting period: #{@selection_range.join(" until ")}
+
+            TXT
+context.forward(self)
+    end
+
+    # grouping records by projects
+    def group_by_project
+
+      groups = {} 
+      groups[:unaccounted] = @selection.dup
+
+      @c.model.projects.each do |project_id, expressions|
+        group = (groups[project_id] ||= [])
+        expressions.each do |re| 
+          matching_records, rest = groups[:unaccounted].partition do |rec| 
+            re.match(rec.desc) 
+          end
+          group.push(*matching_records)
+          groups[:unaccounted] = rest
+        end
+      end
+      groups.delete_if { |k,v| v.nil? or v.empty? }
+      groups
+    end
+
+    def range(context)
+      a = Date.parse(context.argv.shift)
+      b = Date.parse(context.argv.shift)
+      puts "selected date range: #{a} #{b}"
+
+      select_in_range(a, b)
+      context.forward(self)
+    end
+
+    def before(context)
+      a = Date.parse(context.argv.shift)
+      select_in_range(Date.today - (365*10), a)
+      context.forward(self)
+    end
+
+    def after(context)
+      a = Date.parse(context.argv.shift)
+      select_in_range(a, Date.today+1)
+      context.forward(self)
+    end
+
+    def today(context)
+      a = Date.today
+      select_in_range(a, a+1)
+      context.forward(self)
+    end
+
+    def select_in_range first_day, last_day
+      @selection = []
+      @workdays = []
+      @selection_range = [first_day, last_day]
+      day = first_day
+      while day < last_day
+        dayrecs = @c.model.by_date(day)
+        @selection.push(*dayrecs)
+        @workdays.push(day) unless dayrecs.empty?
+        day += 1
+      end
+      puts "#{@selection.size} records in range"
+    end
+    private :select
+
+    def group_head group, work_days
+      per_day  = "%.3f" % [group.total / work_days]
+      days = group.total.to_i / 8
+      h = group.total - (days * 8)
+      thours = "%.2f" % group.total
+      hours = "%.2f" % h
+      d,h,m = Record.hours_to_dhm(group.total)
+          "#{thours} hours | #{d}d #{h}h #{m}m | #{per_day} hours/day: #{group.project_id}"
+    end
+  end
+end
+

data/lib/asciitracker/controller.rb

@@ -0,0 +1,62 @@
+module AsciiTracker 
+  class Controller
+    attr_reader :model
+
+    def initialize 
+      @model = Model.new
+    end
+
+    # match(:day, :slot)  { |a,b| [[:day, *a], [:slot, *b]] }
+    # match(:day, :span)  { |a,b| [[:day, *a], [:span, *b]] }
+    def new_day date
+      @day = date
+      @rec = @slot = nil
+    end
+
+    # match(:slot)        { |a|   [[:slot, *a]] }
+    def new_slot start, stop, desc = nil
+      #slot = Slot.new :date=>@day, :start=> start, :end=>stop, :desc=>desc
+      @rec = @slot = Slot.new(
+        :start => start, :end =>stop, :desc =>desc, :date => @day.dup
+      )
+
+      # updates parant records when this slot is an interruption
+      overlaps = @model.find_overlaps(@slot, @day)
+      puts "new slot(#{@slot}), overlaps: #{overlaps}"
+      unless overlaps.empty?
+        # parents are covers which are a subset of overlaps
+        if parent = @model.find_best_cover(@slot, @day)
+          parent.add_interrupt(@slot)
+        else
+          raise TimecardException, <<-EOM
+          #{@slot}
+overlaps with:
+          #{overlaps.first} ...
+                    EOM
+        end
+      end
+
+      # add record to model after interrupt calculation to save self
+      # interruption checks
+      @model.add_record(@slot, @day)
+    end
+
+    # match(:span)        { |a|   [[:span, *a]] }
+    def new_span span, desc = nil
+      @rec = Record.new :span=>span, :desc=>desc, :date => @day.dup
+      @slot.add_interrupt(@rec) if @slot
+      @model.add_record(@rec, @day)
+    end
+
+    # match(:desc)        { |txt| [[:txt, txt]] } #@m.append_txt(txt) }
+    def new_txt txt = nil
+      @rec.desc << " #{txt}"
+    end
+
+    # match(/@.+/, String) { |project_id, re| [project_id[1..-1], Regexp.new(re)] }
+    def new_project_re project_id, re
+      puts "project expression: #{project_id}, #{re}"
+      @model.projects[project_id].push(re)
+    end
+  end
+end

data/lib/asciitracker/hash_ext.rb

@@ -0,0 +1,15 @@
+class Hash;def /(key);self[key];end end
+
+class Hash
+  # _why's hash implant with a twist: the difference is to throw a
+  # NoMethodError instead returning nil when asking for a non-existing value 
+  def method_missing(m,*a)
+    if m.to_s =~ /=$/
+      self[$`.to_sym] = a[0]
+    elsif a.empty?
+      self[m]
+    else
+      raise NoMethodError, "#{m}"
+    end
+  end
+end

data/lib/asciitracker/hhmm.rb

@@ -0,0 +1,58 @@
+module AsciiTracker
+
+  class HHMM < Struct.new :hours, :minutes
+
+    include Comparable
+    def <=>(other)
+      a = (hours <=> other.hours)
+      a == 0 ? (minutes <=> other.minutes) : a
+    end
+
+    #def -(other); self.to_f - other.to_f end
+    #def +(other); self.to_f + other.to_f end
+    def -(other)
+      m = to_minutes - other.to_minutes
+      (m += 24 * 60) if m < 0
+      HHMM.new *(m.divmod 60)
+    end
+
+    def to_a; [hours, minutes] end
+    def to_s; "%02d:%02d" % [hours, minutes] end
+    def to_f; (minutes.to_f/60) + hours end
+    def to_minutes; (60*hours) + minutes end
+
+    # "12:30", "1:15" or "00:45" for hours and minutes
+    #   or
+    # "1.5" for fractions of an hour notation
+    def self.parse txt
+      if (m = txt.match(/^(\d?\d):(\d\d)/))
+        HHMM.new m[1].to_i, m[2].to_i
+      else 
+        minutes = ((Float(txt) * 60) + 0.5).to_i
+        HHMM.new(minutes / 60, minutes % 60)
+      end
+    end
+
+    # five ways to express 1 hour and 30 minutes:
+    #   1 arg:  ["1:30"], ["1.5"] or [1.5]
+    #           or a HHMM object to be cloned from
+    #   2 args: [1, 30], ["1", "30"], 
+    def initialize *args
+      if 2 == args.length # [1, 30] or ["1", "30"]
+        super *(args.map{ |e| Integer(e) })
+      else
+        hhmm = args.first
+        hhmm = HHMM.parse(hhmm.to_s) unless hhmm.kind_of? HHMM 
+        self.hours, self.minutes = hhmm.hours, hhmm.minutes
+      end
+    end
+  end
+
+  def HHMM *args; HHMM.new(*args); end
+
+  module Helper
+    def hhmm(*args)
+      HHMM.new(*args)
+    end
+  end
+end

data/lib/asciitracker/model.rb

@@ -0,0 +1,37 @@
+module AsciiTracker
+  class Model
+
+    attr_reader :records, :projects 
+
+    def initialize 
+      @records = [ ]
+      @by_date = { }
+      @projects = Hash.new { |hash, project_id| hash[project_id] = [] }
+    end
+
+    def by_date(date)
+      (@by_date[date] ||= [])
+    end
+
+    def add_record rec, date = Date.today
+      @records.push(rec)
+      (@by_date[date] ||= []).push(rec)
+      rec
+    end
+
+    def find_overlaps rec, date = Date.today
+      by_date(date).find_all { |a| a.overlaps?(rec) rescue false }
+    end
+
+    def find_best_cover rec, date = Date.today
+      by_date(date).inject(nil) do |best, test| 
+        if test.respond_to?(:covers?) # spans never cover
+          if test.covers?(rec) && (best.nil? || (best.covers? test))
+            best = test 
+          end
+        end
+        best
+      end
+    end
+  end
+end

data/lib/asciitracker/parser.rb

@@ -0,0 +1,86 @@
+require 'asciitracker/rdparser'
+
+module AsciiTracker
+
+  Parser = RDParser.new do
+
+    def parse model, txt
+      @model = model
+      super(txt)
+      @model
+    end
+
+    def push_line line
+      line.each do |rec|
+        puts "--> #{rec.join("|")}"
+        @model.send "new_#{rec.shift}", *rec
+      end
+    end
+
+    token(/\s+/)
+    token(/\d\d\d\d-\d\d-\d\d/)     { |txt| puts "2:#{txt}"; Date.parse(txt) }
+    token(/([012]?\d):([0-5]\d)/)   { |txt| HHMM.new(txt) }
+    token(/\d\d?(.\d\d?)?/)            { |m| m.to_f }
+    token(/-/)                      { |m| m }
+    #token(/[:;#]?.*/)               { |txt| txt }
+    token(/@\S+/)                   { |txt| txt }
+    token(/[:;#]?.*/)               { |txt| txt.sub /^[:;#]\s*/, '' }
+    #token(/.+/)                     { |m| m }
+
+    start :records do
+      match(:records, :line)   { |lol, line|   push_line(line) }
+      match(:line)             { |line|        push_line(line) }
+    end
+
+    #date          slot
+    #date                      span
+    #              slot
+    #                          span
+    #                                   desc
+
+    rule :line do
+      match(:project_re)  { |a|   [[:project_re, *a]] }
+      match(:day, :slot)  { |a,b| [[:day, *a], [:slot, *b]] }
+      match(:day, :span)  { |a,b| [[:day, *a], [:span, *b]] }
+      match(:slot)        { |a|   [[:slot, *a]] }
+      match(:span)        { |a|   [[:span, *a]] }
+      match(:desc)        { |txt| [[:txt, txt]] } #@m.append_txt(txt) }
+    end
+
+    rule :project_re do
+      #match('/', /[^\/]+/, '/', String) { |_, id, _, re| [id, re] }
+      #match(/\/[^\/]+\/.+/) { |_, id, _, re| [id, re] }
+      #match(/\/[^\/]+\/.+/) { |x| [x] }
+      match(/@.+/, String) do |project_id, re|
+        [project_id[1..-1], Regexp.new(re, Regexp::IGNORECASE)]
+      end
+    end
+
+    rule :day do
+      match(Date)   # { |date| puts "1:#{date}"; date }
+    end
+
+    rule :slot do
+      match(:hhmm,'-',:hhmm, :desc) { |t1, _, t2, desc| [t1, t2, desc] }
+      match(:hhmm,'-',:hhmm) { |t1, _, t2| [t1, t2, nil] }
+    end
+
+    rule :span do
+      #match(:hhmm, :desc) { |hhmm, desc| @m.new_span(hhmm.to_f, desc) }
+      #match(:hhmm)        { |hhmm| @m.new_span(hhmm.to_f) }
+      match(:hhmm, :desc) { |hhmm, desc| [hhmm.to_f, desc] }
+      match(:hhmm)        { |hhmm, desc| [hhmm.to_f, nil] }
+    end
+
+    rule :hhmm do
+      match(Float)    { |x| HHMM.new(x) }
+      match(HHMM)     { |x| x }
+    end
+
+    rule :desc do
+      match(String)       { |txt| txt }
+      # strip optional marker
+      # match(String)       { |txt| txt.sub /^[:;#]\s*/, ''  }
+    end
+  end
+end