ascii-tracker 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b848e61d0882fc155ab6294909494690761926e7
-  data.tar.gz: d22e74f6102673c75c40e3fc2e58a41c6f1b713a
+  metadata.gz: 4d87cd7fac6f81bd5d1bb27cc10c61ac39470270
+  data.tar.gz: 72bc11acb60ff36a25a5e4b4af3420ae64c7c9f2
 SHA512:
-  metadata.gz: a42bcb45db21c925574b5ca04bd1fc9ca144f562f34c8fbe8379927b6dba116cbf128c2e9845f232e7f6e25eaaf8d8a13186a74d8a83c86c20970dc5949589cc
-  data.tar.gz: 16f78a6fd81fb919caf62ad6899eeb3597ea5d5d85f93d7618a91ae28545806e443396fbba80d0eefefc9fbb31a6247084c0ec8ba70cc406f7a2749b6d05749c
+  metadata.gz: ae181b06b65b5201befe60fecfadfb6968d5908b5fe7c913484082e6487f5cd264c7a412341f63ef362e4441dff5c4ec026fa4c82125c772d019c860f6183c2a
+  data.tar.gz: 935678933dc414e9af31f5fea0084f4e36a5ccd075fac96d51a6ee7f99fbdeecedc27a286c9e4947d8042204c82097a5eaf5a114d0ba7ada861b2ccedcaf01f4

data/Guardfile

@@ -3,7 +3,7 @@
 
 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(%r{^lib/(.+)\.rb$})     { |m| "spec/model/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
   watch('lib/asciitracker.rb')  { "spec" }
 end

data/bin/{atracker.rb → atracker}

@@ -29,11 +29,9 @@ Applix.main(ARGV, debug: false) do
     end
 
     def forward(target)
-      begin
-        (op = @argv.shift) && target.send(op, self)
-      rescue ArgumentError => e
-        target.send(op)
-      end
+      (op = @argv.shift) and target.send(op, self)
+    rescue ArgumentError => e
+      target.send(op)
     end
   end
 

data/lib/asciitracker.rb

@@ -2,6 +2,7 @@ require "asciitracker/version"
 
 require 'date'
 require 'asciitracker/hash_ext'
+require 'asciitracker/exceptions'
 require 'asciitracker/hhmm'
 require 'asciitracker/record'
 require 'asciitracker/slot'

data/lib/asciitracker/app.rb

@@ -5,19 +5,10 @@ module AsciiTracker
       @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)
+      AsciiTracker::Parser.parse(@c, IO.read(filename))
       #puts "records:\n#{records.join("\n")}"
       #puts "--> 2: #{@c.model}"
       #puts "--> 3: #{@c.model.records}"

data/lib/asciitracker/controller.rb

@@ -17,18 +17,18 @@ module AsciiTracker
     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
+        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}"
+      #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
+          raise Exception, <<-EOM
           #{@slot}
 overlaps with:
           #{overlaps.first} ...

data/lib/asciitracker/exceptions.rb

@@ -0,0 +1,22 @@
+module AsciiTracker
+
+  class Exception < RuntimeError
+    attr_accessor :reason
+    attr_reader :callstack
+
+    def initialize *args
+      super *args
+      @callstack = caller
+    end
+  end
+
+  class InvalidInterrupt < AsciiTracker::Exception; end
+  class NotYetImplemented < AsciiTracker::Exception; end
+
+  module Exceptions
+    def not_yet_implemented txt = nil
+      txt ||= "#{caller[0]} (caller: #{caller[1]})"
+      raise NotYetImplemented, txt
+    end
+  end
+end

data/lib/asciitracker/slot.rb

@@ -80,21 +80,21 @@ module AsciiTracker
     def add_interrupt slot_or_span
       slr = slot_or_span # shortcut
       unless covers? slr
-        raise TimecardException, "interrupt not covered! #{slr}"
+        raise Exception, "interrupt not covered! #{slr}"
       end
 
       unless slr.span <= span
-        raise TimecardException, "'#{self}' overload(#{span}): #{slr}"
+        raise Exception, "'#{self}' overload(#{span}): #{slr}"
       end
-      #raise TimecardException, "overload: #{slr}" unless slr.span <= span
+      #raise Exception, "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| 
+        #raise Exception, "overlap: #{slr}" if @interrupts.any? do |i| 
         #    slr.overlaps? i
         #end
         if @interrupts.any? { |rec| slr.overlaps? rec }
-          raise TimecardException, "overlap: #{slr}"
+          raise Exception, "overlap: #{slr}"
         end
       end
 

data/lib/asciitracker/version.rb

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

data/spec/model/asciitracker/slot_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+include AsciiTracker 
+describe AsciiTracker::Record do
+
+  it "finds the class" do
+    Slot.should_not == nil
+  end
+
+  describe "with 10:45 - 12:15" do
+    let(:rec) { Slot.new start: "10:45", end: "12:15", desc: "foo bar" }
+
+    it "should fit Records" do
+      # span are always contained...
+      rec.covers?(Record.new(:span => 0.5)).should == true
+      rec.covers?(Record.new(:span => 1.5)).should == true
+    end
+
+    it "should not cover records with are to long" do
+      rec.covers?(Record.new(:span => "1:31")).should == false
+      rec.covers?(Record.new(:span => 5.0)).should == false
+    end
+
+    it "should calc slot covers" do
+      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
+  
+  it "should construct from start, end and desc options" do
+    rec = Slot.new :start => "10:15", :end => "10:45", :desc => "foo bar"
+    rec.desc.should == "foo bar"
+    rec.t_start.should == (HHMM "10:15")
+    rec.t_end.should == (HHMM "10:45")
+    rec.span.should == 0.5
+    rec.gross_length.should == 0.5
+    rec.interrupts.length.should == 0
+  end
+
+  it "should support long overlaps around midnight" do
+    rec = Slot.new :start => "14:00", :end => "02:00"
+    rec.interrupts.length.should == 0
+    rec.span.should == 12
+  end
+
+  it "should cover slots over midnight" do
+    rec = Slot.new :start=>"23:00", :end=>"01:00", :desc=>"foo bar"
+    rec.covers?(Record.new(:span => 1.0)).should == true
+  end
+
+  it "should support slots over midnight" do
+    rec = Slot.new :start=>"23:00", :end=>"01:00", :desc=>"foo bar"
+    rec.span.should == 2
+    rec.interrupts.length.should == 0
+
+    rec = Slot.new :start=>"20:00", :end=>"05:00", :desc=>"foo bar"
+    rec.span.should == 9
+    rec.interrupts.length.should == 0
+  end
+
+  describe "with base slot" do
+    let(:base) { Slot.new start: '5:00', end: '6:00' }
+
+    it "sould calc overlaps" do
+      a = Slot.new :start => "4:00", :end => "4:30"
+      base.overlaps?(a).should == false
+
+      a1 = Slot.new :start => "4:00", :end => "5:00"
+      base.overlaps?(a1).should == false
+
+      b = Slot.new :start => "1:00", :end => "5:30"
+      base.overlaps?(b).should == true
+
+      c = Slot.new :start => "1:00", :end => "7:00"
+      base.overlaps?(c).should == true
+
+      d = Slot.new :start => "5:15", :end => "5:45"
+      base.overlaps?(d).should == true
+
+      d1 = Slot.new :start => "5:00", :end => "5:45"
+      base.overlaps?(d1).should == true
+
+      d2= Slot.new :start => "5:15", :end => "6:00"
+      base.overlaps?(d2).should == true
+
+      e = Slot.new :start => "5:30", :end => "7:00"
+      base.overlaps?(e).should == true
+
+      f = Slot.new :start => "7:00", :end => "9:00"
+      base.overlaps?(f).should == false
+
+      f1 = Slot.new :start => "6:00", :end => "9:00"
+      base.overlaps?(f1).should == false
+    end
+  end
+
+  describe "with base over around midnight" do
+    let(:base) { Slot.new start: '22:00', end: '02:00' }
+
+    it "should calc overlaps around midnight" do
+      # before
+      a = Slot.new :start => "20:00", :end => "21:59"
+      base.covers?(a).should == false
+      base.overlaps?(a).should == false
+      # after
+      a = Slot.new :start => "02:01", :end => "04:00"
+      base.covers?(a).should == false
+      base.overlaps?(a).should == false
+
+      a = Slot.new :start => "23:00", :end => "23:10"
+      puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
+      base.covers?(a).should == true
+      base.overlaps?(a).should == true
+
+      a = Slot.new :start => "23:00", :end => "01:00"
+      puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
+      base.covers?(a).should == true
+      base.overlaps?(a).should == true
+
+      a = Slot.new :start => "01:00", :end => "01:10"
+      puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
+      base.overlaps?(a).should == true
+      base.covers?(a).should == true
+    end
+  end
+
+  context 'interrups' do
+    
+    let(:rec) { Slot.new start: '10:00', end: '12:30', desc: 'whatever' }
+    it 'inits slots as uninterrupted' do
+      rec.interrupts.length.should be(0)
+    end
+
+    context 'with spans' do
+      let(:one_hour) { Record.new span: 1, desc: 'one hour of wasted time' }
+
+      it 'aggregates interrupts and subtracts the interupt time from record' do
+        expect { rec.add_interrupt one_hour }.not_to raise_error
+        rec.interrupts.length.should eq(1)
+        rec.span.should eq(1.5)
+        
+        expect { rec.add_interrupt one_hour }.not_to raise_error
+        rec.interrupts.length.should eq(2)
+        rec.span.should eq(0.5)
+      end
+
+      it 'raises error on interrupt not fitting the record' do
+        expect { rec.add_interrupt one_hour }.not_to raise_error
+        expect { rec.add_interrupt one_hour }.not_to raise_error
+        expect { rec.add_interrupt one_hour }.to raise_error(
+          AsciiTracker::Exception, /overload\(0.5\).*one hour of wasted time/
+        )
+      end
+    end
+
+    context 'with other slots' do
+      let(:rec) { Slot.new start: '10:00', end: '12:30', desc: 'foo bar' }
+
+      it 'aggregates interrupts and subtracts the interupt time from record' do
+        rec.add_interrupt(Slot.new start: '10:00', end: '12:00', desc: '?')
+        rec.interrupts.length.should eq(1)
+        rec.span.should eq(0.5)
+
+        rec.add_interrupt(Slot.new start: '12:00', end: '12:15', desc: '?')
+        rec.interrupts.length.should eq(2)
+        rec.span.should eq(0.25)
+
+        rec.add_interrupt(Slot.new start: '12:15', end: '12:30', desc: '?')
+        rec.interrupts.length.should eq(3)
+        rec.span.should eq(0.0)
+      end
+ 
+      it 'bails out on records overlapping start or end time' do
+        expect { 
+          rec.add_interrupt(Slot.new start: '12:30', end: '13:00', desc: 'X')
+        }.to raise_error(
+          AsciiTracker::Exception, /interrupt not covered!.*12:30-13:00/
+        )
+
+        expect { 
+          rec.add_interrupt(Slot.new start: '09:30', end: '11:00', desc: 'X')
+        }.to raise_error(
+          AsciiTracker::Exception, /interrupt not covered!.*09:30-11:00/
+        )
+
+        expect { 
+          rec.add_interrupt(Slot.new start: '09:59', end: '12:01', desc: 'X')
+        }.to raise_error(
+          AsciiTracker::Exception, /interrupt not covered!.*09:59-12:01/
+        )
+      end
+
+      it 'raises error on stuffin slot to overfilled record' do
+        rec.add_interrupt(Slot.new start: '10:00', end: '12:30', desc: '?')
+        rec.interrupts.length.should eq(1)
+        rec.span.should eq(0.0) 
+        # rec is full now
+
+        expect { 
+          rec.add_interrupt(Slot.new start: '10:01', end: '10:02', desc: 'X')
+        }.to raise_error(
+          AsciiTracker::Exception, /overload\(0.0\): 2013-07-11 10:01-10:02  X/
+        )
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ascii-tracker
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - dirk lüsebrink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-10 00:00:00.000000000 Z
+date: 2013-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: applix
@@ -86,7 +86,7 @@ description: "\n    keeping track of time in a textfile. now web app, no mouse c
 email:
 - dirk.luesebrink@gmail.com
 executables:
-- atracker.rb
+- atracker
 extensions: []
 extra_rdoc_files: []
 files:
@@ -98,10 +98,11 @@ files:
 - README.md
 - Rakefile
 - ascii-tracker.gemspec
-- bin/atracker.rb
+- bin/atracker
 - lib/asciitracker.rb
 - lib/asciitracker/app.rb
 - lib/asciitracker/controller.rb
+- lib/asciitracker/exceptions.rb
 - lib/asciitracker/hash_ext.rb
 - lib/asciitracker/hhmm.rb
 - lib/asciitracker/model.rb
@@ -110,11 +111,11 @@ files:
 - lib/asciitracker/record.rb
 - lib/asciitracker/slot.rb
 - lib/asciitracker/version.rb
-- spec/model/controller_spec.rb
-- spec/model/hhmm_spec.rb
-- spec/model/model_spec.rb
-- spec/model/record_spec.rb
-- spec/model/slot_spec.rb
+- spec/model/asciitracker/controller_spec.rb
+- spec/model/asciitracker/hhmm_spec.rb
+- spec/model/asciitracker/model_spec.rb
+- spec/model/asciitracker/record_spec.rb
+- spec/model/asciitracker/slot_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -141,9 +142,9 @@ signing_key:
 specification_version: 4
 summary: time tracking the ascii way
 test_files:
-- spec/model/controller_spec.rb
-- spec/model/hhmm_spec.rb
-- spec/model/model_spec.rb
-- spec/model/record_spec.rb
-- spec/model/slot_spec.rb
+- spec/model/asciitracker/controller_spec.rb
+- spec/model/asciitracker/hhmm_spec.rb
+- spec/model/asciitracker/model_spec.rb
+- spec/model/asciitracker/record_spec.rb
+- spec/model/asciitracker/slot_spec.rb
 - spec/spec_helper.rb

data/spec/model/slot_spec.rb

@@ -1,207 +0,0 @@
-require 'spec_helper'
-
-include AsciiTracker 
-describe "AsciiTracker::Record" do
-  it "finds the class" do
-    Slot.should_not == nil
-  end
-
-  describe "with 10:45 - 12:15" do
-    before :each do 
-      @rec = Slot.new :start=>"10:45", :end=>"12:15", :desc=>"foo bar"
-    end
-
-    it "should fit Records" do
-      # span are always contained...
-      @rec.covers?(Record.new(:span => 0.5)).should == true
-      @rec.covers?(Record.new(:span => 1.5)).should == true
-    end
-
-    it "should not cover records with are to long" do
-      @rec.covers?(Record.new(:span => "1:31")).should == false
-      @rec.covers?(Record.new(:span => 5.0)).should == false
-    end
-
-    it "should calc slot covers" do
-      @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
-  
-  it "should construct from start, end and desc options" do
-    rec = Slot.new :start => "10:15", :end => "10:45", :desc => "foo bar"
-    rec.desc.should == "foo bar"
-    rec.t_start.should == (HHMM "10:15")
-    rec.t_end.should == (HHMM "10:45")
-    rec.span.should == 0.5
-    rec.gross_length.should == 0.5
-    rec.interrupts.length.should == 0
-  end
-
-  it "should support long overlaps around midnight" do
-    rec = Slot.new :start => "14:00", :end => "02:00"
-    rec.interrupts.length.should == 0
-    rec.span.should == 12
-  end
-
-  it "should cover slots over midnight" do
-    rec = Slot.new :start=>"23:00", :end=>"01:00", :desc=>"foo bar"
-    rec.covers?(Record.new(:span => 1.0)).should == true
-  end
-
-  it "should support slots over midnight" do
-    rec = Slot.new :start=>"23:00", :end=>"01:00", :desc=>"foo bar"
-    rec.span.should == 2
-    rec.interrupts.length.should == 0
-
-    rec = Slot.new :start=>"20:00", :end=>"05:00", :desc=>"foo bar"
-    rec.span.should == 9
-    rec.interrupts.length.should == 0
-  end
-
-  describe "with base slot" do
-    before :each do 
-      @base = Slot.new :start => "5:00", :end => "6:00"
-    end
-
-    it "sould calc overlaps" do
-      a = Slot.new :start => "4:00", :end => "4:30"
-      @base.overlaps?(a).should == false
-
-      a1 = Slot.new :start => "4:00", :end => "5:00"
-      @base.overlaps?(a1).should == false
-
-      b = Slot.new :start => "1:00", :end => "5:30"
-      @base.overlaps?(b).should == true
-
-      c = Slot.new :start => "1:00", :end => "7:00"
-      @base.overlaps?(c).should == true
-
-      d = Slot.new :start => "5:15", :end => "5:45"
-      @base.overlaps?(d).should == true
-
-      d1 = Slot.new :start => "5:00", :end => "5:45"
-      @base.overlaps?(d1).should == true
-
-      d2= Slot.new :start => "5:15", :end => "6:00"
-      @base.overlaps?(d2).should == true
-
-      e = Slot.new :start => "5:30", :end => "7:00"
-      @base.overlaps?(e).should == true
-
-      f = Slot.new :start => "7:00", :end => "9:00"
-      @base.overlaps?(f).should == false
-
-      f1 = Slot.new :start => "6:00", :end => "9:00"
-      @base.overlaps?(f1).should == false
-    end
-  end
-
-  describe "with base over around midnight" do
-    before :each do 
-      @base = Slot.new :start => "22:00", :end => "02:00"
-    end
-
-    it "should calc overlaps around midnight" do
-      # before
-      a = Slot.new :start => "20:00", :end => "21:59"
-      @base.covers?(a).should == false
-      @base.overlaps?(a).should == false
-      # after
-      a = Slot.new :start => "02:01", :end => "04:00"
-      @base.covers?(a).should == false
-      @base.overlaps?(a).should == false
-
-      a = Slot.new :start => "23:00", :end => "23:10"
-      puts " -- #{[@base.t_start, @base.t_end, a.t_start, a.t_end].join(', ')}"
-      @base.covers?(a).should == true
-      @base.overlaps?(a).should == true
-
-      a = Slot.new :start => "23:00", :end => "01:00"
-      puts " -- #{[@base.t_start, @base.t_end, a.t_start, a.t_end].join(', ')}"
-      @base.covers?(a).should == true
-      @base.overlaps?(a).should == true
-
-      a = Slot.new :start => "01:00", :end => "01:10"
-      puts " -- #{[@base.t_start, @base.t_end, a.t_start, a.t_end].join(', ')}"
-      @base.overlaps?(a).should == true
-      @base.covers?(a).should == true
-    end
-  end
-end
-__END__
-
-class SlotTest < Test::Unit::TestCase
-
-  include Timecard
-
-
-  def test_overlaps_around_midnight
-    puts "\n--> #{self}"
-
-    base = Slot.new :start => "22:00", :end => "02:00"
-
-    # before
-    a = Slot.new :start => "20:00", :end => "21:59"
-    assert ! base.covers?(a)
-    assert ! base.overlaps?(a)
-    # after
-    a = Slot.new :start => "02:01", :end => "04:00"
-    assert ! base.covers?(a)
-    assert ! base.overlaps?(a)
-
-    a = Slot.new :start => "23:00", :end => "23:10"
-    puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
-    assert base.covers?(a)
-    assert base.overlaps?(a)
-
-    a = Slot.new :start => "23:00", :end => "01:00"
-    puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
-    assert base.covers?(a)
-    assert base.overlaps?(a)
-
-    a = Slot.new :start => "01:00", :end => "01:10"
-    puts " -- #{[base.t_start, base.t_end, a.t_start, a.t_end].join(', ')}"
-    assert base.overlaps?(a)
-    assert base.covers?(a)
-  end
-
-    def test_add_interrupt_slot_or_span
-        puts "\n--> #{self}"
-        rec = Slot.new :start=>"10:00", :end=>"12:30", :desc=>"foo bar"
-        assert_equal 2.5, rec.span 
-        assert_equal 0, rec.interrupts.length
-
-        wasted_time = Record.new :span => 1, :desc => "one hour of wasted time"
-        rec.add_interrupt wasted_time
-        assert_equal 1, rec.interrupts.length
-        assert_equal 1.5, rec.span 
-        rec.add_interrupt wasted_time
-        assert_equal 2, rec.interrupts.length
-        assert_equal 0.5, rec.span 
-
-        assert_raise(TimecardException) { rec.add_interrupt(wasted_time) }
-
-        rec = Slot.new :start=>"10:00", :end=>"12:30", :desc=>"foo bar"
-        slot = Slot.new :start=>"10:00", :end => "12:00", :desc => "intruppt"
-        rec.add_interrupt(slot)
-        assert_equal 0.5, rec.span 
-
-        slot = Slot.new :start=>"12:30", :end => "13:00", :desc => "intruppt"
-        assert_raise(TimecardException) { rec.add_interrupt(slot) }
-        slot = Slot.new :start=>"09:30", :end => "11:00", :desc => "intruppt"
-        assert_raise(TimecardException) { rec.add_interrupt(slot) }
-
-        slot = Slot.new :start=>"12:00", :end => "12:15", :desc => "intruppt"
-        rec.add_interrupt(slot)
-        assert_equal 0.25, rec.span 
-        slot = Slot.new :start=>"12:15", :end => "12:30", :desc => "intruppt"
-        rec.add_interrupt(slot)
-        assert_equal 0.0, rec.span 
-
-        slot = Slot.new :start=>"12:15", :end => "12:30", :desc => "intruppt"
-        assert_raise(TimecardException) { rec.add_interrupt(slot) }
-    end
-end
-