timert 1.0.0

data/lib/timert/timer.rb

@@ -0,0 +1,38 @@
+module Timert
+  class Timer  
+    attr_reader :path, :today
+
+    def initialize(today)
+      @today = today
+    end
+
+    def start(time = nil)
+      if !on?
+        started = true
+        today.add_start(time || now)          
+      end
+      {time: today.last_start, started: started}
+    end
+
+    def stop(time = nil)
+      if on?
+        stopped = true
+        today.add_stop(time || now)
+      end
+      {time: today.last_stop, stopped: stopped}
+    end
+
+    def add_task(task)
+      today.add_task(task)    
+    end
+
+    private    
+    def now
+      Time.now.to_i
+    end
+
+    def on?
+      today.is_interval_started?
+    end  
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,148 @@
+require 'timecop'
+require_relative '../lib/timert/application'
+require_relative '../lib/timert/database'
+require_relative '../lib/timert/database_file'
+
+describe Timert::Application do
+  let(:path) { './spec/data/timert' }
+  let(:database) { Timert::Database.new(Timert::DatabaseFile.new(path)) }
+  let(:app_with_no_args) { Timert::Application.new([], path) }
+  
+  after(:each) do
+    File.delete(path)
+  end
+
+  context 'when initialized with empty arguments' do
+    it 'should be initialized without errors' do
+      expect { app_with_no_args }.to_not raise_error
+    end
+  end
+
+  context 'when initialized with start argument' do
+    before do
+      Timecop.freeze(Time.new(2013, 6, 12, 13, 56))
+      @app = Timert::Application.new(["start"], path)      
+    end
+
+    after do
+      Timecop.return
+    end
+    
+    it 'should perform start operation' do
+      expect(database.today.last_start).to eq(Time.now.to_i)
+    end
+
+    it 'should have a method that returns hash result' do
+      expect(@app.result["message"].instance_of?(String)).to eq(true)
+    end
+
+    context 'and then initialized with stop argument' do
+      before do
+        Timecop.freeze(Time.new(2013, 6, 12, 14, 34))
+        @app = Timert::Application.new(["stop"], path)      
+      end
+
+      after do
+        Timecop.return
+      end
+      
+      it 'should perform stop operation' do
+        expect(database.today.last_stop).to eq(Time.now.to_i)
+      end
+
+      it 'should have a method that returns hash result' do
+        expect(@app.result["message"].instance_of?(String)).to eq(true)
+      end
+    end
+
+    context 'and then initialized with stop and time argument' do
+      before do
+        Timecop.freeze(2013, 6, 12, 16, 00)
+        @app = Timert::Application.new(["stop", "15:59"], path)
+      end
+
+      after do
+        Timecop.return
+      end
+
+      it 'should stop with given time' do
+        expect(database.today.last_stop).to eq(Time.now.to_i - 60)
+      end
+    end
+
+    context 'and then initialized with stop and invalid time argument' do
+      it 'should not raise an error' do
+        Timecop.freeze(2013, 6, 12, 15, 00) do
+          Timert::Application.new(["stop", "9"], path)
+          expect { Timert::Application.new(["stop", "9"], path) }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  context 'when initialized with start and time argument' do
+    before do
+      Timecop.freeze(2013, 3, 20, 16, 00)
+      @app = Timert::Application.new(["start", "15:59"], path)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    it 'should start with given time' do
+      expect(database.today.last_start).to eq(Time.now.to_i - 60)
+    end    
+  end
+
+  context 'when initialized with start and invalid time argument' do
+    before do 
+      Timecop.freeze(Time.new(2013, 1, 10, 15)) do
+        Timert::Application.new(["start"], path)
+      end
+      Timecop.freeze(Time.new(2013, 1, 10, 16)) do
+        Timert::Application.new(["stop"], path)
+      end
+    end    
+
+    it 'should not raise an error' do
+      Timecop.freeze(2013, 1, 10, 17, 00) do
+        expect { Timert::Application.new(["start", "9"], path) }.to_not raise_error
+      end
+    end
+  end
+
+  context 'when initialized with report argument' do
+    before do
+      @app = Timert::Application.new(["report"], path)      
+    end
+
+    it 'should have a method that returns hash result' do
+      expect(@app.result["message"].include?("REPORT")).to eq(true)
+    end
+  end
+
+  context 'when initialized with argument other than start, stop or report' do
+    before do
+      @app = Timert::Application.new(["testing the new app"], path)      
+    end
+
+    it 'should add task' do
+      expect(database.today.tasks).to eq(["testing the new app"])
+    end
+
+    context 'and then initialized with argument that fullfills the same requirements' do
+      before do
+        @app = Timert::Application.new(["writing emails"], path)
+      end      
+
+      it 'should add another task' do
+        expect(database.today.tasks).to eq(["testing the new app", "writing emails"])
+      end
+    end
+
+    it 'should have a method that returns hash result' do
+      expect(@app.result["message"].instance_of?(String)).to eq(true)
+    end
+  end
+end

data/spec/argument_parser_spec.rb

@@ -0,0 +1,47 @@
+require 'timecop'
+require_relative '../lib/timert/argument_parser'
+
+describe Timert::ArgumentParser do
+  let(:ap_with_empty_array) { Timert::ArgumentParser.new([]) }
+  let(:ap_with_start) { Timert::ArgumentParser.new(['start']) }
+  let(:ap_with_start_at) { Timert::ArgumentParser.new(['start', '16:50']) }
+  let(:ap_with_stop_at) { Timert::ArgumentParser.new(['stop', '19']) }
+
+  it 'should be initialized with one array argument' do
+    expect { ap_with_empty_array }.to_not raise_error
+  end
+
+  it 'should have action method' do
+    expect(ap_with_start.action).to eq('start')
+  end
+
+  context 'when a time argument is given with the start action' do
+    it 'should have argument method that returns numeric representation of that time' do
+      Timecop.freeze(Time.new(2013, 4, 6, 16, 50)) do
+        expect(ap_with_start_at.argument).to eq(Time.now.to_i)
+      end
+    end
+  end
+
+  context 'when a time argument is given with the stop action' do
+    it 'should have argument method that returns numeric representation of that time' do
+      Timecop.freeze(Time.new(2013, 4, 6, 19)) do
+        expect(ap_with_stop_at.argument).to eq(Time.now.to_i)
+      end
+    end
+  end
+
+  it 'should have argument equal to nil if one-element array is passed' do
+    expect(ap_with_start.argument).to eq(nil)
+  end
+
+  it 'should have action equal to help and argument equal to nil if empty array is passed' do
+    expect(ap_with_empty_array.action).to eq("help")
+    expect(ap_with_empty_array.argument).to eq(nil)
+  end
+
+  it 'should have add_task action when no-api argument is passed' do
+    expect(Timert::ArgumentParser.new(['buy bananas']).action).to eq('add_task')
+    expect(Timert::ArgumentParser.new(['buy bananas']).argument).to eq('buy bananas')
+  end
+end

data/spec/database_file_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/timert/database_file'
+
+describe Timert::DatabaseFile do
+  let(:path) { './spec/data/timert' }
+
+  before(:each) do
+    @file = Timert::DatabaseFile.new(path)
+  end
+
+  after(:each) do
+    File.delete(path)
+  end
+  
+  it "should load data that's been saved" do
+    data = {
+      "example" => "This is a sample data."
+    }
+    @file.save(data)
+    expect(@file.load).to eq(data)
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,58 @@
+require 'timecop'
+require 'date'
+
+require_relative '../lib/timert/database'
+require_relative '../lib/timert/database_file'
+require_relative '../lib/timert/day'
+
+describe Timert::Database do
+  before(:each) do
+    @path = "./spec/data/test_data"
+    @db = Timert::Database.new(Timert::DatabaseFile.new(@path))
+  end
+
+  after(:each) do
+    File.delete(@path)
+  end
+
+  it 'should have a method for getting the current day' do
+    write_day = Timert::Day.new(tasks: ["emails"])    
+    @db.save(write_day)
+    read_day = @db.day
+    expect(write_day.to_hash).to eq(read_day.to_hash)
+  end
+
+  it 'should have a method for getting one of the past days' do
+    write_day = Timecop.freeze(Time.new(2013, 8, 12, 12)) do
+      @db.save(Timert::Day.new(tasks: ["meeting"]))    
+      @db.day
+    end
+    read_day = Timecop.freeze(Time.new(2013, 8, 14, 12)) do
+      @db.day(Date.today - 2)
+    end
+    expect(write_day).to eq(read_day)
+  end
+
+  it 'should save current day' do
+    day = Timert::Day.new(tasks: ["emails", "reading"])
+    @db.save(day)
+    expect(@db.day).to eq(day)
+  end
+
+  it 'should have a method for getting a range of days' do
+    first = Timert::Day.new(tasks: ["emails"], date: Date.new(2013, 9, 10))
+    second = Timert::Day.new(tasks: ["meetings"], date: Date.new(2013, 9, 11))
+    
+    past = Timecop.freeze(first.date) do
+      @db.save(first)
+      Date.today - 5
+    end
+    
+    present = Timecop.freeze(second.date) do
+      @db.save(second)
+      Date.today
+    end
+    
+    expect(@db.days(Range.new(past, present))).to eq([first, second])
+  end
+end

data/spec/date_util_spec.rb

@@ -0,0 +1,19 @@
+require 'timecop'
+require_relative '../lib/timert/date_util'
+
+describe Timert::DateUtil do
+  it 'should return formatted hour' do
+    time = Time.new(2000, 1, 1, 14, 20, 13)
+    expect(Timert::DateUtil.format_hour(time.to_i)).to eq(time.to_s.split[1])
+  end
+
+  it 'should return formatted date' do
+    expect(Timert::DateUtil.format_date(Date.new(2013, 3, 14))).to eq("2013-03-14")
+  end
+
+  it 'should parse time' do
+    Timecop.freeze(Time.new(2013, 2, 28)) do
+      expect(Timert::DateUtil.parse_time("11:14")).to eq(Time.new(2013, 2, 28, 11, 14).to_i)
+    end
+  end
+end

data/spec/day_spec.rb

@@ -0,0 +1,220 @@
+require 'date'
+require 'timecop'
+
+require_relative '../lib/timert/day'
+
+describe Timert::Day do
+  let(:now) { Time.now.to_i}
+  let(:day) { Timert::Day.new }
+  
+  it 'should have method intervals that returns array' do
+    expect(day.intervals.instance_of?(Array)).to eq(true)
+  end
+
+  context 'containing a completed, 100 seconds interval' do
+    before do
+      day.add_start(now)
+      day.add_stop(now + 100)
+    end
+
+    it 'should have a method intervals that returns an array with start and stop times' do
+      expect(day.intervals).to eq([{"start" => now, "stop" => now + 100}])      
+    end
+
+    it 'should have a method that returns total elapsed time' do
+      expect(day.total_elapsed_time).to eq(100)
+    end
+
+    it 'should have a method that returns a hash representation of the object' do
+      expect(day.to_hash).to eq({
+        "intervals" => [{"start" => now, "stop" => now + 100}],
+        "tasks" => []})
+    end
+
+    it 'should have a method that says that no interval is started' do
+      expect(day.is_interval_started?).to eq(false)
+    end
+
+    it 'should have a method that returns the time of the last start' do
+      expect(day.last_start).to eq(now)      
+    end
+
+    it 'should have a method that returns the time of the last stop' do
+      expect(day.last_stop).to eq(now + 100)
+    end
+
+    it "should not add a new interval when no interval is started" do
+      expect { day.add_stop(now + 200) }.to_not change(day, :intervals)
+    end
+  end
+
+  it "should not add a new interval when the last one hasn't been completed" do
+    day.add_start(now)
+    expect { day.add_start(now) }.not_to change(day, :intervals)
+  end
+
+  it 'should have a method that returns total elapsed time' do
+    day.add_start(Time.new(2013, 6, 10, 12, 34).to_i)
+    day.add_stop(Time.new(2013, 6, 10, 14, 51, 10).to_i)
+    day.add_start(Time.new(2013, 6, 10, 16, 10, 20).to_i)
+    day.add_stop(Time.new(2013, 6, 10, 17, 15, 41).to_i)    
+    expect(day.total_elapsed_time).to eq(duration(3, 22, 31))
+  end
+
+  context "when calculating total elapsed time and when last interval isn't finished" do
+    let(:now) { Time.new(2013, 6, 10, 18, 10) }
+    
+    context 'and the day is today' do
+      let(:start_of_work) { Time.new(2013, 6, 10, 12, 0) }
+
+      it "should assume the interval's end to now" do
+        Timecop.freeze(now) do
+          day.add_start(start_of_work.to_i)
+           # It is 6h and 10min between work started at 12:00 and now (18:10).
+          expect(day.total_elapsed_time).to eq(duration(6, 10, 0))
+        end
+      end
+    end
+
+    context "and the day is yesterday" do
+      let(:start_of_work) { Time.new(2013, 6, 9, 13, 30) }
+
+      it "should assume the interval's end to the last second of yesteday" do
+        day.add_start(start_of_work.to_i)
+        Timecop.freeze(now) do
+          # It is 10h and 30min between work started at 13:30 and end of the day.
+          expect(day.total_elapsed_time).to eq(duration(10, 30, 0))
+        end
+      end
+    end
+  end
+
+  it 'should have tasks method that returns an array' do
+    expect(day.tasks.instance_of?(Array)).to eq(true)    
+  end
+
+  it 'should add tasks' do
+    day.add_task("watching youtube")
+    day.add_task("walking the dog")
+    expect(day.tasks).to eq(["watching youtube", "walking the dog"])
+  end
+
+  context 'after initialized with hash data' do
+    let(:valid_params) do
+      { 
+        intervals: [{"start" => now, "stop" => now + 300}],
+        tasks: ["debugging", "emails"],
+        date: Time.now.to_date
+      } 
+    end
+
+    let(:day) { Timert::Day.new(valid_params) }
+
+    it "should raise error if tasks aren't an array" do      
+      expect { Timert::Day.new(valid_params.merge(tasks: "mails")) }.to raise_error
+    end
+
+    it "should raise error if intervals aren't an array" do
+      expect { Timert::Day.new(valid_params.merge(intervals: {"start" => 0})) }.to raise_error
+    end
+
+    it 'should have a method intervals that returns array with start and stop times' do
+      expect(day.intervals).to eq([{"start" => now, "stop" => now + 300}])
+    end
+
+    it 'should have a method tasks that returns an array of tasks' do
+      expect(day.tasks).to eq(["debugging", "emails"])            
+    end
+
+    it "should have a method that returns the day's date" do
+      expect(day.date).to eq(Time.now.to_date)      
+    end
+
+    it "should have to_hash method that returns day's state" do
+      hash = {
+        "intervals" => [{"start" => now, "stop" => now + 300}],
+        "tasks" => ["debugging", "emails"]        
+      }
+      expect(day.to_hash).to eq(hash)  
+    end
+  end
+
+  it "should return start time when it's added" do
+    expect(day.add_start(now)).to eq(now)
+  end
+
+  it "should return stop time when it's added" do
+    day.add_start(now - 100)
+    expect(day.add_stop(now)).to eq(now)
+  end
+
+  it 'should be equal to other day with the same data' do
+    first_day = Timert::Day.new(tasks: ["emails"])
+    second_day = Timert::Day.new(tasks: ["emails"])
+    expect(first_day).to eq(second_day)
+  end
+
+  it 'should raise an ArgumentError if passed stop time is lower than last start time' do
+    day.add_start(now)
+    expect { day.add_stop(now - 300) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise an ArgumentError if passed start time is lower than last start time' do
+    day.add_start(now)
+    day.add_stop(now + 600)
+    expect { day.add_start(now - 500) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise an ArgumentError if passed start time is equal to last start time' do
+    day.add_start(now)
+    day.add_stop(now + 600)
+    expect { day.add_start(now) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise an ArgumentError if passed start time is lower than last stop time' do
+    day.add_start(now)
+    day.add_stop(now + 1000)
+    expect { day.add_start(now + 500) }.to raise_error(ArgumentError)
+  end
+
+  it 'should not raise an ArgumentError if passed start time is equal to last stop time' do
+    day.add_start(now)
+    day.add_stop(now + 1000)
+    expect { day.add_start(now + 1000) }.not_to raise_error
+  end
+
+  context "when it's initialized with date" do
+    let(:day) { Timert::Day.new(date: Date.new(2013, 5, 12)) }
+    before do
+      Timecop.freeze(Time.new(2013, 5, 12, 12, 30))      
+    end
+
+    after do
+      Timecop.return
+    end
+
+    it "should raise error if a start time with a different date is added" do
+      expect { day.add_start(Time.new(2013, 6, 14, 12).to_i) }.to raise_error
+    end
+
+    it "should raise error if a stop time with a different date is added" do
+      day.add_start(now)      
+      expect { day.add_stop(Time.new(2013, 6, 14, 12).to_i) }.to raise_error
+    end
+  end
+
+  context "when a task is added more than once" do
+    before do
+      day.add_task("mails")
+      day.add_task("mails")      
+    end
+
+    it "should ignore it" do
+      expect(day.to_hash).to eq({"tasks" => ["mails"], "intervals" => []})
+    end
+  end
+
+  def duration(hours, minutes, seconds)
+    hours * 60 * 60 + minutes * 60 + seconds
+  end
+end