ascii-tracker 0.0.1

data/lib/asciitracker/rdparser.rb

@@ -0,0 +1,168 @@
+=begin
+Subject: ***Re: [SOLUTION] Dice Roller (#61)*
+From: *Dennis Ranke *<mail exoticorn.de>
+Date: Mon, 9 Jan 2006 06:53:10 +0900
+References: 174521 </cgi-bin/scat.rb/ruby/ruby-talk/174521> 174811
+</cgi-bin/scat.rb/ruby/ruby-talk/174811>
+In-reply-to: 174811 </cgi-bin/scat.rb/ruby/ruby-talk/174811>
+
+Hi,
+
+here is my second solution. Quite a bit longer, but a lot nicer.
+For this I implemented a simple recursive descent parser class that 
+allows the tokens and the grammar to be defined in a very clean ruby 
+syntax. I think I'd really like to see a production quality 
+parser(generator) using something like this grammar format.
+=end
+
+class RDParser
+   attr_accessor :pos
+   attr_reader :rules
+
+   def initialize(&block)
+     @lex_tokens = []
+     @rules = {}
+     @start = nil
+     instance_eval(&block)
+   end
+
+   def parse(string)
+     @tokens = []
+     until string.empty?
+       raise "unable to lex '#{string}" unless @lex_tokens.any? do |tok|
+#puts "match(#{string}) <- (#{tok})"
+         match = tok.pattern.match(string)
+         if match
+             s_tok = match.to_s
+puts "(#{s_tok})" unless /^\s+$/.match(s_tok)
+#puts "<<< #{s_tok} | #{tok.pattern} >>>"
+           @tokens << tok.block.call(s_tok) if tok.block
+           string = match.post_match
+#puts "<<<#{s_tok}|||#{match.post_match}>>>"
+           true
+         else
+           false
+         end
+       end
+     end
+     @pos = 0
+     @max_pos = 0
+     @expected = []
+     result = @start.parse
+     if @pos != @tokens.size
+       raise "Parse error. expected: '#{@expected.join(', ')}', found 
+'#{@tokens[@max_pos]}'"
+     end
+     return result
+   end
+
+   def next_token
+     @pos += 1
+     return @tokens[@pos - 1]
+   end
+
+   def expect(tok)
+     t = next_token
+     if @pos - 1 > @max_pos
+       @max_pos = @pos - 1
+       @expected = []
+     end
+     return t if tok === t
+     @expected << tok if @max_pos == @pos - 1 && !@expected.include?(tok)
+     return nil
+   end
+
+   private
+
+   LexToken = Struct.new(:pattern, :block)
+
+   def token(pattern, &block)
+     @lex_tokens << LexToken.new(Regexp.new('\\A' + pattern.source), block)
+   end
+
+   def start(name, &block)
+     rule(name, &block)
+     @start = @rules[name]
+   end
+
+   def rule(name)
+     @current_rule = Rule.new(name, self)
+     @rules[name] = @current_rule
+     yield
+     @current_rule = nil
+   end
+
+   def match(*pattern, &block)
+     @current_rule.add_match(pattern, block)
+   end
+
+   class Rule
+     Match = Struct.new :pattern, :block
+
+     def initialize(name, parser)
+       @name = name
+       @parser = parser
+       @matches = []
+       @lrmatches = []
+     end
+
+     def add_match(pattern, block)
+       match = Match.new(pattern, block)
+       if pattern[0] == @name
+         pattern.shift
+         @lrmatches << match
+       else
+         @matches << match
+       end
+     end
+
+     def parse
+       match_result = try_matches(@matches)
+       return nil unless match_result
+       loop do
+         result = try_matches(@lrmatches, match_result)
+         return match_result unless result
+         match_result = result
+       end
+     end
+
+     private
+
+     def try_matches(matches, pre_result = nil)
+       match_result = nil
+       start = @parser.pos
+       matches.each do |match|
+         r = pre_result ? [pre_result] : []
+         match.pattern.each do |token|
+           if @parser.rules[token]
+             r << @parser.rules[token].parse
+             unless r.last
+               r = nil
+               break
+             end
+           else
+             nt = @parser.expect(token)
+             if nt
+               r << nt
+             else
+               r = nil
+               break
+             end
+           end
+         end
+         if r
+           if match.block
+             match_result = match.block.call(*r)
+           else
+             match_result = r[0]
+           end
+           break
+         else
+           @parser.pos = start
+         end
+       end
+       return match_result
+     end
+   end
+end
+

data/lib/asciitracker/record.rb

@@ -0,0 +1,27 @@
+module AsciiTracker
+  class Record
+
+    attr_reader :date, :span, :desc
+
+    def to_s; "#{date}       #{HHMM.new(span)}  #{desc}" end
+
+    Defaults = { :date => Date.today, :span => 0.0, :desc => nil }
+
+    # span may be any valid HHMM format 
+    # value keys: :date, :span, and :desc
+    def initialize values = {} #date, span, desc = nil
+      values = Defaults.merge(values)
+      @date = values[:date]
+      @span = HHMM.new(values[:span]).to_f
+      @desc = values[:desc]
+    end
+
+    # 35.25 -> [1, 11, 15]
+    def self.hours_to_dhm(hours)
+      d = hours.to_i / 8
+      h = (hours - 8*d).to_i
+      m = ((60 * (hours - 8*d - h)) + 0.5).to_i
+      [d, h, m]
+    end
+  end
+end

data/lib/asciitracker/slot.rb

@@ -0,0 +1,109 @@
+module AsciiTracker
+  class Slot < Record
+
+    attr_reader :t_start, :t_end
+
+    def to_s; "#{date} #{t_start}-#{t_end}  #{desc}" end
+
+    # supports Record values keys plus:
+    # :start and :end
+    # for interval definition
+    def initialize values = {}
+      values = Defaults.merge(values)
+      @t_start = HHMM.new(values[:start])
+      @t_end = HHMM.new(values[:end])
+
+      @duration = (@t_end - @t_start)
+      super values.merge(:span => @duration.to_f)
+
+      @interrupts = []
+    end
+
+    # returns copy only, not suited to add/delelte interrupts 
+    def interrupts; @interrupts.clone end
+
+    # gross length is full slot length without interruptions being subtracted
+    def gross_length
+      @duration.to_f
+    end
+
+    #          [-----]                 -+
+    #          [----------------]       |
+    #                [---]              | <-- overlaping
+    #             [------]              |  
+    #                [------]           |
+    #                [----------]      -+
+    #
+    # self:       [---------]
+    #
+    #      [---]                       -+
+    #         [---]                     | <-- not overlaping
+    #                       [----]      |
+    #                         [-----]  -+
+    # 
+    def _24(a,b)
+      [a.to_f, b < a ? b.to_f + 24 : b.to_f]
+    end
+
+    def overlaps? slr
+      return false unless slr.respond_to?(:t_end)
+      a, b = _24(t_start, t_end)
+      c, d = _24(slr.t_start, slr.t_end)
+      #puts "..a, b, c, d: #{a}, #{b} -> #{c}, #{d}"
+      if d < a
+        #puts "..upgrade: #{a}, #{b} -> #{c}, #{d}"
+        c = c + 24; d = d + 24
+      end
+      #puts "..a, b, c, d: #{a}, #{b} -> #{c}, #{d} | #{c < b && a < d}"
+      c < b && a < d
+      #!slr.nil? && !(slr.t_end <= t_start || t_end <= slr.t_start)
+      #not(slr.t_end <= t_start || t_end <= slr.t_start)
+    end
+
+    # checks for a pure technical fit which does not take into account the
+    # already existing interruptions!
+    def covers? slot_or_span
+      slr = slot_or_span # shortcut for shorter lines below
+      begin
+        a, b = _24(t_start, t_end)
+        c, d = _24(slr.t_start, slr.t_end)
+        if d < a
+          #puts "..upgrade: #{a}, #{b} -> #{c}, #{d}"
+          c = c + 24; d = d + 24
+        end
+        a <= c && d <= b
+      rescue NoMethodError # not a slot?
+        slr.kind_of?(Record) and slr.span <= gross_length
+      end
+    end
+
+    def add_interrupt slot_or_span
+      slr = slot_or_span # shortcut
+      unless covers? slr
+        raise TimecardException, "interrupt not covered! #{slr}"
+      end
+
+      unless slr.span <= span
+        raise TimecardException, "'#{self}' overload(#{span}): #{slr}"
+      end
+      #raise TimecardException, "overload: #{slr}" unless slr.span <= span
+
+      # new interrupts may not overlap with existing ones!
+      if slr.respond_to?(:t_start) 
+        #raise TimecardException, "overlap: #{slr}" if @interrupts.any? do |i| 
+        #    slr.overlaps? i
+        #end
+        if @interrupts.any? { |rec| slr.overlaps? rec }
+          raise TimecardException, "overlap: #{slr}"
+        end
+      end
+
+      @interrupts.push(slr)
+
+      # subtract interrupts from span time
+      #dt_lost = @interrupts.inject(0.0) { |sum, rec| sum + rec.span }
+      dt_lost = @interrupts.inject(0.0) { |sum, rec| sum + (rec.gross_length rescue rec.span) }
+      @span = gross_length - dt_lost
+    end
+  end
+end

data/lib/asciitracker/version.rb

@@ -0,0 +1,3 @@
+module AsciiTracker
+  VERSION = "0.0.1"
+end

data/lib/asciitracker.rb

@@ -0,0 +1,16 @@
+require "asciitracker/version"
+
+require 'date'
+require 'asciitracker/hash_ext'
+require 'asciitracker/hhmm'
+require 'asciitracker/record'
+require 'asciitracker/slot'
+require 'asciitracker/model'
+require 'asciitracker/controller'
+require 'asciitracker/parser'
+require 'asciitracker/app'
+
+module AsciiTracker
+  # Your code goes here...
+end
+

data/spec/model/controller_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+include AsciiTracker 
+describe "AsciiTracker::Controller" do
+  it "finds the class" do
+    Controller.should_not == nil
+  end
+
+  describe "with a controller" do
+    before :each do
+      @c = Controller.new
+    end
+  end
+end
+
+__END__
+
+    it "should have a #new_slot method" do
+      @c.new_day Date.today
+      slot = @c.new_slot(HHMM("10:00"), HHMM("12:00"), "foo bar")
+      @c.new_span  "1.75", "some task"
+      @c.new_txt   "some additional text"
+    end
+
+class ControllerTest < Test::Unit::TestCase
+
+    include Timecard
+   
+    def test_expoeasy
+      puts "\n--> #{self}"
+      c = Controller.new
+      Parser.parse c, <<-EOT
+@expoeasy expoeasy: 
+@wallcms wallcms:
+@private private:
+2008-07-10   18:15-04:15     expoeasy: yui data tables for visitors
+                    0:15     wallcms: commit reviews
+                    0:30     private: family & food
+             20:15-22:15     private: halma
+             23:45-03:45     private: @jussie's weeding
+      EOT
+      assert_equal 5, c.model.records.size
+      assert_equal 3, c.model.projects.size
+      assert_not_nil ee = c.model.records.first
+      assert_equal "expoeasy: yui data tables for visitors", ee.desc
+      assert_equal 4, ee.interrupts.size
+
+      assert_equal 10.00, ee.gross_length
+      assert_equal 3.25, ee.span
+    end
+
+    def test_day_spans
+        puts "\n--> #{self}"
+        c = Controller.new
+        c.new_day   Date.today
+        c.new_span  0, "ueberstundenabbau"
+        assert_equal 1, c.model.records.length
+        rec = c.model.records.first
+        assert_equal 0, rec.span
+        assert_equal Date.today, rec.date
+    end
+
+    def test_slot_span_slot
+        puts "\n--> #{self}"
+        c = Controller.new
+        c.new_day   Date.today
+        c.new_slot(HHMM("10:00"), HHMM("14:00"), "slot 1")
+        c.new_span  2.5, "span"
+        c.new_slot(HHMM("14:00"), HHMM("16:00"), "slot 2")
+        assert_equal 3, c.model.records.length
+        assert_equal [1.5,2.5,2], c.model.records.map { |e| e.span }
+    end
+
+    def test_interrupted_slot
+        puts "\n--> #{self}"
+        c = Controller.new
+        c.new_day   Date.today
+        c.new_slot  HHMM("10:00"), HHMM("14:00"), "office works"
+        c.new_span  "0:15", "annoyance" 
+        c.new_slot  HHMM("10:15"), HHMM("10:30"), "another annoyance"
+        assert_equal 3, c.model.records.length
+        assert_equal 3.5, c.model.records.first.span
+
+        telco = c.new_slot(HHMM("10:30"), HHMM("11:30"), "sysadm")
+        assert_equal 4, c.model.records.length
+        assert_equal 2.5, c.model.records.first.span
+
+        c.new_span  0.25, "telco" # interrupt the sysadm task only!
+        assert_equal 5, c.model.records.length
+        assert_equal 2.5, c.model.records.first.span
+
+        assert_raise(TimecardException) do 
+            c.new_slot  HHMM("09:15"), HHMM("10:15"), "overlap"
+        end
+        assert_raise(TimecardException) do 
+            c.new_slot  HHMM("10:00"), HHMM("11:00"), "overlap"
+        end
+        assert_raise(TimecardException) do 
+            c.new_slot  HHMM("11:00"), HHMM("12:00"), "overlap"
+        end
+        assert_raise(TimecardException) do 
+            c.new_slot  HHMM("13:55"), HHMM("14:05"), "overlap"
+        end
+
+        assert_equal 5, c.model.by_date(Date.today).length
+        #records = c.model.by_date[Date.today]
+        #assert_equal 4, records.length
+    end
+
+    def test_disjunct_slots
+        puts "\n--> #{self}"
+        c = Controller.new
+        c.new_day   Date.today
+        c.new_slot(HHMM("10:00"), HHMM("11:00"), "foo bar")
+        c.new_slot(HHMM("11:00"), HHMM("13:00"), "foo bar")
+        c.new_slot(HHMM("13:00"), HHMM("16:00"), "foo bar")
+        assert_equal 3, c.model.records.length
+        assert_equal [1,2,3], c.model.records.map { |e| e.span }
+    end
+
+    def test_new_record_api
+        puts "\n--> #{self}"
+        c = Controller.new
+        c.new_day   Date.today
+        slot = c.new_slot(HHMM("10:00"), HHMM("12:00"), "foo bar")
+        c.new_span  "1.75", "some task"
+        c.new_txt   "some additional text"
+    end
+end
+

data/spec/model/hhmm_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+include AsciiTracker 
+describe "AsciiTracker::HHMM" do
+  it "finds the class" do
+    HHMM.should_not == nil
+  end
+
+  describe "HHMM calculus" do
+    it "should calc differences" do
+      dt = (HHMM '12:00') - (HHMM '10:00')
+      dt.hours.should == 2.0
+      dt.minutes.should == 0
+    end
+
+    it "should calc midnight overlaps" do
+      hhmm = (HHMM('00:01') - HHMM('23:59'))
+      hhmm.hours.should == 0
+      hhmm.minutes.should == 2
+    end
+
+    it "should calc zero length slots" do
+      hhmm = (HHMM('12:34') - HHMM('12:34'))
+      hhmm.hours.should == 0
+      hhmm.minutes.should == 0
+    end
+    
+    it "should calc 24 hour slots" do
+      hhmm = (HHMM('24:00') - HHMM('00:00'))
+      hhmm.hours.should == 24
+      hhmm.minutes.should == 0
+
+      # 0/end - 24/start ist actually 0 minutes long! 
+      hhmm = (HHMM('00:00') - HHMM('24:00'))
+      hhmm.hours.should == 0
+      hhmm.minutes.should == 0
+    end
+
+    it "should calc long overlaps" do
+      hhmm = (HHMM('02:00') - HHMM('14:00'))
+      hhmm.hours.should == 12
+      hhmm.minutes.should == 0
+      hhmm = (HHMM('02:00') - HHMM('10:00'))
+      hhmm.hours.should == 16
+      hhmm.minutes.should == 0
+    end
+  end
+
+  describe "HHMM parsing" do
+    it "should parse '1:30'" do
+      hhmm = (HHMM '1:30')
+      hhmm.to_a.should == [1, 30]
+      hhmm.to_s.should == "01:30"
+      hhmm.to_f.should == 1.5
+    end
+
+    it "should parse '1.5'" do
+      hhmm = (HHMM '1.5')
+      hhmm.to_a.should == [1, 30]
+      hhmm.to_s.should == "01:30"
+      hhmm.to_f.should == 1.5
+    end
+
+    it "should parse 1.5" do
+      hhmm = (HHMM 1.5)
+      hhmm.to_a.should == [1, 30]
+      hhmm.to_s.should == "01:30"
+      hhmm.to_f.should == 1.5
+    end
+
+    it "should parse (1, 30)" do
+      hhmm = (HHMM 1, 30)
+      hhmm.to_a.should == [1, 30]
+      hhmm.to_s.should == "01:30"
+      hhmm.to_f.should == 1.5
+    end
+
+    it "should parse ('1', '30')" do
+      hhmm = (HHMM '1', '30')
+      hhmm.to_a.should == [1, 30]
+      hhmm.to_s.should == "01:30"
+      hhmm.to_f.should == 1.5
+    end
+  end
+end

data/spec/model/model_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+include AsciiTracker 
+describe "AsciiTracker::Model" do
+  it "finds the class" do
+    Model.should_not == nil
+  end
+
+  describe "with a model" do
+    before :each do
+      @model = Model.new
+    end
+
+    it "should be initially empty" do
+      @model.by_date(Date.today).should == []
+    end
+
+    it "should add slot records" do
+      @model.add_record(Slot.new :start=>"10:45", :end=>"12:15")
+      (records = @model.by_date(Date.today)).should_not == []
+      records.first.span.should == 1.5
+    end
+
+    it "should find best cascaded cover" do
+      @model.add_record Slot.new(:start=>"10:00", :end=>"20:00")
+      @model.add_record Slot.new(:start=>"11:00", :end=>"19:00")
+      @model.add_record Slot.new(:start=>"12:00", :end=>"17:00")
+      slot = Slot.new(:start=>"16:00", :end=>"17:00")
+      (cover = @model.find_best_cover slot).should_not == nil
+      cover.t_start.to_s.should == "12:00"
+      cover.t_end.to_s.should == "17:00"
+
+      slot = Slot.new(:start=>"11:10", :end=>"11:20")
+      (cover = @model.find_best_cover slot).should_not == nil
+      cover.t_start.to_s.should == "11:00"
+      cover.t_end.to_s.should == "19:00"
+    end
+    
+    it "should find best cover" do
+      @model.add_record Slot.new(:start=>"10:00", :end=>"15:00")
+      @model.add_record Slot.new(:start=>"15:00", :end=>"20:00")
+      slot = Slot.new(:start=>"16:00", :end=>"17:00")
+      (overlaps = @model.find_overlaps slot).size.should == 1
+      overlap = overlaps.first
+      overlap.t_start.to_s.should == "15:00"
+      overlap.t_end.to_s.should == "20:00"
+    end
+    
+    it "should find overlaps" do
+      @model.add_record Slot.new(:start=>"10:00", :end=>"20:00")
+      slot = Slot.new(:start=>"11:00", :end=>"13:00")
+      (overlaps = @model.find_overlaps slot).size.should == 1
+      overlap = overlaps.first
+      overlap.t_start.to_s.should == "10:00"
+      overlap.t_end.to_s.should == "20:00"
+    end
+    
+    it "should add non overlapping slot records" do
+      @model.add_record(Slot.new :start=>"10:00", :end=>"11:00")
+      @model.add_record(Slot.new :start=>"11:00", :end=>"13:00")
+      (records = @model.by_date(Date.today)).should_not == []
+      records.first.span.should == 1
+      records.last.span.should == 2
+    end
+    
+   #   @rec.covers?(Slot.new(:start=>"10:45", :end=>"12:15")).should == true
+   #   @rec.covers?(Slot.new(:start=>"10:00", :end=>"12:15")).should == false
+   #   @rec.covers?(Slot.new(:start=>"10:45", :end=>"13:00")).should == false
+  end
+end
+

data/spec/model/record_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+include AsciiTracker 
+describe "AsciiTracker::Record" do
+  it "finds the class" do
+    Record.should_not == nil
+  end
+
+  it "should calc days from hours and minutes" do
+    Record.hours_to_dhm(0.25).should ==  [0,  0, 15]
+    Record.hours_to_dhm(1).should ==     [0,  1,  0]
+    Record.hours_to_dhm(24).should ==    [3,  0,  0]
+    Record.hours_to_dhm(35.25).should == [4,  3, 15]
+  end
+
+  it "should init with fixnum span" do
+    rec = Record.new :span => 1, :desc => "foo bar"
+    rec.span.should == 1.0
+    rec.desc.should == "foo bar"
+  end
+
+  it "should init with string duration span" do
+    rec = Record.new :span => "2.75", :desc => "bar foo"
+    rec.span.should == 2.75
+    rec.desc.should == "bar foo"
+  end
+
+  it "should init with without description text" do
+    rec = Record.new :span => "00:30"
+    rec.span.should == 0.5
+    rec.desc.should == nil
+  end
+end