timert 1.0.1 → 1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmI5ZjA5YWRlZjg1ZTIyODMwY2EyMzE4YWFmNjIyZmYxNTNkZjU0Ng==
+    NjE3MmI2YWFkMTgzYzgwMDE3Zjg3NDI3NjIzNDM3ZThkYWM5NWM3MQ==
   data.tar.gz: !binary |-
-    OGNlMDgyNzY2MDU0ODIxMmQ2NzBhZWZlOTMzMjU5MTA3OWY3NGE1Nw==
+    ZTUyMzMzOWY4YmNhZjU2MjUwMDA4YmQ1MTk4ZWYxZTc0MjBlYmU2Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MzQ0NGU2ODI2YzYxNjNhMTNkNjExN2NjZTNkMjg0NWJlNTFkZjNlYTJlNzIw
-    MWIwMTlmZWM3ZGFhNDM3MTc4ODhhZmU2NjdhMGQwYTY5NjQxMTJiMzY4YjVm
-    OTc3NDVhZjAyZWRlMjhhYjRiOTE3YTE5YmY3NTE5MjE1YzE3YzM=
+    ZWE0NzQ4OGE1OWIxNTE3YWE3ZmEyZTlkMDMxYjYyNWIzZjM1ZjMxMzNkYjJl
+    ZTkzZTcxYjUwZWEwZWM5ZGM5Yjc3YzNmMTM3ZDMwOTk2MDFkODhmNzk5OTQ5
+    MDdkMWQ0NzQwYjAyYmJiZmQwNTU1MmU3MmY2ZDg3NDc2ZGU4ZWQ=
   data.tar.gz: !binary |-
-    NjFmYTE0ZDNmNzcwNzRkMDNkMGFjNmYyNjg0OTJkN2ZkYTBlNTY1Njk5Yjk4
-    MTNiNzhmZDI3MGJlOTNhZGUyMWQyNmRjNWIwOWRlNTIyZGI3NmQ0MzA1YTg3
-    ODUyODQ0MTY0ZWRjMTBlOTY3YjhmY2FlMzgzZDc1NDYwZmE0MWE=
+    NDFiNmRmZThmNDVjYjFiNzc1N2M0YzlmMWQ2ZjNhYWRjODAwOWRjNDBkMjA4
+    MGFlOTI5ZTBkNjIzNzYxMTA5ZGI3NDZiNGIwNmIwYzBjZTBiNmNlZjU5Y2Iw
+    M2M5NjRmNDc2OGE5YzQ3NWM2N2YwZDU5NTMxOTZhOTgxNDliZDY=

data/lib/timert/application.rb

@@ -11,7 +11,7 @@ module Timert
     attr_reader :result
 
     def initialize(argv, db_path)
-      @database = Database.new(DatabaseFile.new(db_path))    
+      @database = Database.new(DatabaseFile.new(db_path))
       @timer = Timer.new(@database.today)
       @result = {}
 
@@ -28,7 +28,7 @@ module Timert
           @database.save(@timer.today)
         else
           add_message("timer already started at #{format_hour(timer_result[:time])}")
-        end    
+        end
       rescue ArgumentError => e
         add_message(e.message)
       end
@@ -37,22 +37,22 @@ module Timert
     def stop(time = nil)
       begin
         timer_result = @timer.stop(time)
-        if timer_result[:stopped]      
+        if timer_result[:stopped]
           add_message("stop timer at #{format_hour(timer_result[:time])}")
           @database.save(@timer.today)
         else
           add_message("timer isn't started yet")
-        end    
+        end
       rescue ArgumentError => e
         add_message(e.message)
       end
     end
 
-    def report(time_expression)
+    def report(time_expression = "")
       add_message(Report.generate(@database, time_expression))
     end
 
-    def add_task(task)    
+    def add_task(task)
       add_message("added task: #{task}")
       @timer.add_task(task)
       @database.save(@timer.today)
@@ -68,6 +68,6 @@ module Timert
 
     def add_message(msg)
       @result["message"] = msg
-    end  
+    end
   end
 end

data/lib/timert/argument_parser.rb

@@ -8,9 +8,9 @@ module Timert
       if args.empty?
         @action = "help"
         @argument = nil
-      elsif is_api?(args[0])      
-        @action = args[0]      
-        @argument = api_argument(@action, args[1])
+      elsif is_api?(args[0])
+        @action = args[0]
+        @argument = api_argument(@action, *args[1..-1])
       else
         @action = 'add_task'
         @argument = args.join(" ")
@@ -22,11 +22,11 @@ module Timert
       ["start", "stop", "report"].include?(method_name)
     end
 
-    def api_argument(action, arg)
+    def api_argument(action, *args)
       if is_time_method?(action)
-        parse_time(arg)
+        parse_time(args[0])
       elsif is_report?(action)
-        parse_report_arg(arg)
+        parse_report_arg(args)
       end
     end
 
@@ -38,12 +38,12 @@ module Timert
       method_name == "report"
     end
 
-    def is_month_or_week?(arg)
-      arg == "month" || arg == "week"
+    def is_month_or_week?(args)
+      args.include?("month") || args.include?("week")
     end
 
-    def parse_report_arg(arg)
-      is_month_or_week?(arg) ? arg : arg.to_i
+    def parse_report_arg(args)
+      is_month_or_week?(args) ? args.join(" ") : args[0]
     end
 
     def parse_time(arg)

data/lib/timert/database.rb

@@ -3,7 +3,7 @@ require_relative 'day'
 
 module Timert
   class Database
-    
+
     def initialize(file)
       @file = file
     end
@@ -12,7 +12,7 @@ module Timert
       day
     end
 
-    def day(date = Date.today)    
+    def day(date = Date.today)
       hash_to_day(load_data[key(date)], date)
     end
 
@@ -24,7 +24,7 @@ module Timert
         if range.include?(day.date)
           result << day
         end
-      end 
+      end
       result
     end
 
@@ -35,7 +35,7 @@ module Timert
     end
 
     private
-    
+
     def load_data
       @file.load
     end
@@ -51,7 +51,7 @@ module Timert
     def hash_to_day(day_hash, date)
       if day_hash
         Day.new(
-          intervals: day_hash["intervals"], 
+          intervals: day_hash["intervals"],
           tasks: day_hash["tasks"],
           date: date)
       else

data/lib/timert/date_util.rb

@@ -2,7 +2,7 @@ require 'date'
 
 module Timert
   class DateUtil
-    
+
     def self.format_hour(timestamp)
       timestamp ? Time.at(timestamp).strftime("%H:%M:%S") : ""
     end
@@ -11,6 +11,10 @@ module Timert
       date ? date.strftime("%Y-%m-%d") : ""
     end
 
+    def self.format_month(date)
+      date ? date.strftime("%Y-%m") : ""
+    end
+
     def self.parse_time(arg)
       if arg
         hours, minutes = arg.split(":")

data/lib/timert/day.rb

@@ -4,37 +4,37 @@ module Timert
     attr_reader :intervals, :tasks, :date
     attr_accessor :on
 
-    def initialize(args = {})    
+    def initialize(args = {})
       @intervals = args[:intervals] || []
-      @tasks = args[:tasks] || []  
+      @tasks = args[:tasks] || []
       @date = args[:date]
-      
+
       raise ArgumentError.new("intervals should be an array") if !@intervals.is_a?(Array)
-      raise ArgumentError.new("tasks should be an array") if !@tasks.is_a?(Array)      
+      raise ArgumentError.new("tasks should be an array") if !@tasks.is_a?(Array)
     end
 
     def add_start(time)
-      if !is_interval_started?      
+      if !is_interval_started?
         if time <= last_start
           raise ArgumentError.new("Invalid start time")
         elsif time < last_stop
-          raise ArgumentError.new("Invalid start time. It's before the last stop time.")      
+          raise ArgumentError.new("Invalid start time. It's before the last stop time.")
         elsif !is_date_correct?(time)
           raise ArgumentError.new("Invalid date")
         end
-        @intervals.push({"start" => time}) 
+        @intervals.push({"start" => time})
         time
       end
     end
 
     def add_stop(time)
-      if is_interval_started?      
+      if is_interval_started?
         if time < last_start
           raise ArgumentError.new("Invalid stop time")
         elsif !is_date_correct?(time)
           raise ArgumentError.new("Invalid date")
         end
-        @intervals.last["stop"] = time 
+        @intervals.last["stop"] = time
         time
       end
     end
@@ -57,8 +57,8 @@ module Timert
     end
 
     def is_interval_started?
-      @intervals.length > 0 && 
-        @intervals.last["start"] && 
+      @intervals.length > 0 &&
+        @intervals.last["start"] &&
         !@intervals.last["stop"]
     end
 
@@ -68,18 +68,18 @@ module Timert
 
     def last_start
       last_interval['start'].to_i
-    end  
+    end
 
     def last_stop
       last_interval['stop'].to_i
     end
 
-    private 
-    def interval_duration(interval)    
+    private
+    def interval_duration(interval)
       start, stop = interval["start"], interval["stop"]
-      if start      
+      if start
         stop ||= interval_end_when_start(start)
-        stop.to_i - start.to_i    
+        stop.to_i - start.to_i
       else
         0
       end
@@ -90,11 +90,11 @@ module Timert
     end
 
     def is_date_correct?(timestamp)
-      !@date || Time.at(timestamp).to_date == @date 
+      !@date || Time.at(timestamp).to_date == @date
     end
 
     def interval_end_when_start(timestamp)
-      day_is_today?(timestamp) ? Time.now.to_i : last_second_of_day(timestamp)    
+      day_is_today?(timestamp) ? Time.now.to_i : last_second_of_day(timestamp)
     end
 
     def day_is_today?(timestamp)
@@ -103,7 +103,7 @@ module Timert
 
     def last_second_of_day(timestamp)
       time = Time.at(timestamp)
-      Time.new(time.year, time.month, time.day + 1, 0)
+      Time.new(time.year, time.month, time.day, 23, 59, 60)
     end
   end
 end

data/lib/timert/duration.rb

@@ -2,7 +2,7 @@ module Timert
   class Duration
     attr_reader :hours, :minutes, :seconds, :value
 
-    def initialize(duration)    
+    def initialize(duration)
       @hours = duration / 3600
       @minutes = (duration % 3600) / 60
       @seconds = duration % 60

data/lib/timert/report.rb

@@ -5,49 +5,56 @@ require_relative 'duration'
 
 module Timert
   class Report
-    
+
     def self.generate(database, time_expression = "")
-      if time_expression == "month"
-        report_for_month(database)
-      elsif time_expression == "week"
-        report_for_week(database)
-      else 
+      time_expression = time_expression.to_s
+      if time_expression.include?("month")
+        report_for_month(database, time_expression)
+      elsif time_expression.include?("week")
+        report_for_week(database, time_expression)
+      else
         report_for_day(database, time_expression.to_i)
       end
     end
 
     private
-    def self.report_for_week(database)
+    def self.report_for_week(database, time_expression = "")
+      week_nr = extract_time_modifier(time_expression)
       today = Date.today
-      first = today - today.cwday
+      first = today - today.cwday + 1 + week_nr * 7
       last = first + 6
-      "REPORT FOR THIS WEEK\n".blue +
+
+      title = week_nr != 0 ? "REPORT FOR WEEK #{format_date(first)} - #{format_date(last)}" : "REPORT FOR THIS WEEK"
+      "#{title}\n".blue +
         report_for_range(Range.new(first, last), database)
     end
 
-    def self.report_for_month(database)
+    def self.report_for_month(database, time_expression = "")
+      month_nr = extract_time_modifier(time_expression)
       today = Date.today
-      first = Date.new(today.year, today.month, 1)
-      last = Date.new(today.year, today.month, -1)
-      "REPORT FOR THIS MONTH\n".blue +
+      first = Date.new(today.year, today.month, 1) << -month_nr
+      last = Date.new(today.year, today.month, -1) << -month_nr
+
+      title = month_nr != 0 ? "REPORT FOR MONTH #{format_month(first)}" : "REPORT FOR THIS MONTH"
+      "#{title}\n".blue +
         report_for_range(Range.new(first, last), database)
     end
 
     def self.report_for_range(range, database)
       days = database.days(range)
-      
+
       s = "\nDay/time elapsed\n".green
       total_time, total_rounded_duration = 0, 0
-      
+
       days.each do |day|
         duration = duration(day.total_elapsed_time)
-        s += "#{format_date(day.date)}: ".yellow + 
+        s += "#{format_date(day.date)}: ".yellow +
           "#{duration.to_s} / #{duration.round} " +
           "(#{format_tasks(day)})\n"
         total_time += duration.value
         total_rounded_duration += duration.round.to_f
       end
-      
+
       s += "\nTotal:\n".green
       s += "#{parse_duration(total_time)} / #{total_rounded_duration}"
       s
@@ -56,18 +63,18 @@ module Timert
     def self.report_for_day(database, day_counter = 0)
       date = Date.today + day_counter
       day = database.day(date)
-      if day      
-        "REPORT FOR #{format_date(date)}\n".blue + 
-          "\nTasks:\n".green + 
-          "#{format_tasks(day)}\n" + 
-          "\nWork time:\n".green + 
-          "#{format_intervals(day)}" + 
-          "\nTotal elapsed time:\n".green + 
-          "#{parse_duration(day.total_elapsed_time)}\n" + 
-          "\nSummary:\n".red + 
+      if day
+        "REPORT FOR #{format_date(date)}\n".blue +
+          "\nTasks:\n".green +
+          "#{format_tasks(day)}\n" +
+          "\nWork time:\n".green +
+          "#{format_intervals(day)}" +
+          "\nTotal elapsed time:\n".green +
+          "#{parse_duration(day.total_elapsed_time)}\n" +
+          "\nSummary:\n".red +
           "#{round_duration(day.total_elapsed_time)} #{format_tasks(day)}"
       else
-        "No data"    
+        "No data"
       end
     end
 
@@ -77,18 +84,22 @@ module Timert
 
     def self.format_intervals(day)
       s = ""
-      day.intervals.each do |i| 
+      day.intervals.each do |i|
         start = DateUtil.format_hour(i["start"])
         stop = DateUtil.format_hour(i["stop"])
         s += "#{start} - #{stop}\n"
       end
       s
-    end  
+    end
 
     def self.format_date(date)
       DateUtil.format_date(date)
     end
 
+    def self.format_month(date)
+      DateUtil.format_month(date)
+    end
+
     def self.parse_duration(duration)
       duration(duration).to_s
     end
@@ -100,5 +111,13 @@ module Timert
     def self.round_duration(duration)
       duration(duration).round
     end
+
+    def self.extract_time_modifier(time_expression)
+      if time_expression.include?(" ")
+        time_expression.split(" ")[1].to_i
+      else
+        0
+      end
+    end
   end
-end
+end

data/lib/timert/timer.rb

@@ -1,5 +1,5 @@
 module Timert
-  class Timer  
+  class Timer
     attr_reader :path, :today
 
     def initialize(today)
@@ -9,7 +9,7 @@ module Timert
     def start(time = nil)
       if !on?
         started = true
-        today.add_start(time || now)          
+        today.add_start(time || now)
       end
       {time: today.last_start, started: started}
     end
@@ -23,16 +23,16 @@ module Timert
     end
 
     def add_task(task)
-      today.add_task(task)    
+      today.add_task(task)
     end
 
-    private    
+    private
     def now
       Time.now.to_i
     end
 
     def on?
       today.is_interval_started?
-    end  
+    end
   end
 end

data/spec/application_spec.rb

@@ -7,7 +7,7 @@ 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
@@ -21,13 +21,13 @@ describe Timert::Application do
   context 'when initialized with start argument' do
     before do
       Timecop.freeze(Time.new(2013, 6, 12, 13, 56))
-      @app = Timert::Application.new(["start"], path)      
+      @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
@@ -39,13 +39,13 @@ describe Timert::Application do
     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)      
+        @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
@@ -92,18 +92,18 @@ describe Timert::Application do
 
     it 'should start with given time' do
       expect(database.today.last_start).to eq(Time.now.to_i - 60)
-    end    
+    end
   end
 
   context 'when initialized with start and invalid time argument' do
-    before 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    
+    end
 
     it 'should not raise an error' do
       Timecop.freeze(2013, 1, 10, 17, 00) do
@@ -114,7 +114,7 @@ describe Timert::Application do
 
   context 'when initialized with report argument' do
     before do
-      @app = Timert::Application.new(["report"], path)      
+      @app = Timert::Application.new(["report"], path)
     end
 
     it 'should have a method that returns hash result' do
@@ -124,7 +124,7 @@ describe Timert::Application do
 
   context 'when initialized with argument other than start, stop or report' do
     before do
-      @app = Timert::Application.new(["testing the new app"], path)      
+      @app = Timert::Application.new(["testing the new app"], path)
     end
 
     it 'should add task' do
@@ -134,7 +134,7 @@ describe Timert::Application do
     context 'and then initialized with argument that fullfills the same requirements' do
       before do
         @app = Timert::Application.new(["writing emails"], path)
-      end      
+      end
 
       it 'should add another task' do
         expect(database.today.tasks).to eq(["testing the new app", "writing emails"])

data/spec/database_file_spec.rb

@@ -10,7 +10,7 @@ describe Timert::DatabaseFile do
   after(:each) do
     File.delete(path)
   end
-  
+
   it "should load data that's been saved" do
     data = {
       "example" => "This is a sample data."

data/spec/database_spec.rb

@@ -16,7 +16,7 @@ describe Timert::Database do
   end
 
   it 'should have a method for getting the current day' do
-    write_day = Timert::Day.new(tasks: ["emails"])    
+    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)
@@ -24,7 +24,7 @@ describe Timert::Database do
 
   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.save(Timert::Day.new(tasks: ["meeting"]))
       @db.day
     end
     read_day = Timecop.freeze(Time.new(2013, 8, 14, 12)) do
@@ -42,17 +42,17 @@ describe Timert::Database do
   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

@@ -11,6 +11,10 @@ describe Timert::DateUtil do
     expect(Timert::DateUtil.format_date(Date.new(2013, 3, 14))).to eq("2013-03-14")
   end
 
+  it 'should return formatted month' do
+    expect(Timert::DateUtil.format_month(Date.new(2013, 1, 22))).to eq("2013-01")
+  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)

data/spec/day_spec.rb

@@ -6,7 +6,7 @@ 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
@@ -18,7 +18,7 @@ describe Timert::Day do
     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}])      
+      expect(day.intervals).to eq([{"start" => now, "stop" => now + 100}])
     end
 
     it 'should have a method that returns total elapsed time' do
@@ -36,7 +36,7 @@ describe Timert::Day do
     end
 
     it 'should have a method that returns the time of the last start' do
-      expect(day.last_start).to eq(now)      
+      expect(day.last_start).to eq(now)
     end
 
     it 'should have a method that returns the time of the last stop' do
@@ -57,13 +57,13 @@ describe Timert::Day 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)    
+    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) }
 
@@ -86,11 +86,23 @@ describe Timert::Day do
           expect(day.total_elapsed_time).to eq(duration(10, 30, 0))
         end
       end
+
+      context "and yesterday was the last day of the year" do
+        let(:new_years_eve) { Time.new(2013, 12, 31, 12, 30) }
+        let(:new_year) { Time.new(2014, 1, 1, 11, 0) }
+
+        it "should not raise an error" do
+          day.add_start(new_years_eve.to_i)
+          Timecop.freeze(new_year) do
+            expect{ day.total_elapsed_time }.not_to raise_error
+          end
+        end
+      end
     end
   end
 
   it 'should have tasks method that returns an array' do
-    expect(day.tasks.instance_of?(Array)).to eq(true)    
+    expect(day.tasks.instance_of?(Array)).to eq(true)
   end
 
   it 'should add tasks' do
@@ -101,16 +113,16 @@ describe Timert::Day do
 
   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      
+    it "should raise error if tasks aren't an array" do
       expect { Timert::Day.new(valid_params.merge(tasks: "mails")) }.to raise_error
     end
 
@@ -123,19 +135,19 @@ describe Timert::Day do
     end
 
     it 'should have a method tasks that returns an array of tasks' do
-      expect(day.tasks).to eq(["debugging", "emails"])            
+      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)      
+      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"]        
+        "tasks" => ["debugging", "emails"]
       }
-      expect(day.to_hash).to eq(hash)  
+      expect(day.to_hash).to eq(hash)
     end
   end
 
@@ -186,7 +198,7 @@ describe Timert::Day do
   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))      
+      Timecop.freeze(Time.new(2013, 5, 12, 12, 30))
     end
 
     after do
@@ -198,7 +210,7 @@ describe Timert::Day do
     end
 
     it "should raise error if a stop time with a different date is added" do
-      day.add_start(now)      
+      day.add_start(now)
       expect { day.add_stop(Time.new(2013, 6, 14, 12).to_i) }.to raise_error
     end
   end
@@ -206,7 +218,7 @@ describe Timert::Day do
   context "when a task is added more than once" do
     before do
       day.add_task("mails")
-      day.add_task("mails")      
+      day.add_task("mails")
     end
 
     it "should ignore it" do

data/spec/duration_spec.rb

@@ -1,7 +1,7 @@
 require_relative '../lib/timert/duration'
 
 describe Timert::Duration do
-  
+
   it 'should have a method that returns the number of hours' do
     expect(Timert::Duration.new(3 * 60 * 60 + 2 * 60).hours).to eq(3)
   end
@@ -21,8 +21,8 @@ describe Timert::Duration do
   end
 
   it 'should return formatted total elapsed time' do
-    expect(Timert::Duration.from(5, 45, 5).to_s).to eq("5h 45min 5sec")    
-    expect(Timert::Duration.from(15, 0, 56).to_s).to eq("15h 0min 56sec")    
+    expect(Timert::Duration.from(5, 45, 5).to_s).to eq("5h 45min 5sec")
+    expect(Timert::Duration.from(15, 0, 56).to_s).to eq("15h 0min 56sec")
   end
 
   it 'should have a method that returns rounded duration when a full-hour duration is passed' do

data/spec/report_spec.rb

@@ -3,52 +3,74 @@ require 'timecop'
 require_relative '../lib/timert/report'
 
 describe Timert::Report do
-  let(:today) { Date.new(2013, 2, 20) }
-  let(:yesteday) { Date.new(2013, 2, 19) }
+  let(:monday) { Date.new(2013, 2, 18) }
+  let(:tuesday) { Date.new(2013, 2, 19) }
+  let(:wednesday) { Date.new(2013, 2, 20) }
+  let(:sunday) { Date.new(2013, 2, 24) }
+  let(:last_monday) { Date.new(2013, 2, 11) }
+  let(:last_sunday) { Date.new(2013, 2, 17) }
+  let(:last_month) { Date.new(2013, 1, 10) }
   let(:database) { double }
 
   let(:first_day) do
-    double(total_elapsed_time: 3.5 * 3600, 
-      date: today,
+    double(total_elapsed_time: 3.5 * 3600,
+      date: wednesday,
       tasks: ["emails", "meeting"],
       intervals: [
-        {"start" => time(today, 16), "stop" => time(today, 18, 30)},
-        {"start" => time(today, 19), "stop" => time(today, 20)}
+        {"start" => time(wednesday, 16), "stop" => time(wednesday, 18, 30)},
+        {"start" => time(wednesday, 19), "stop" => time(wednesday, 20)}
       ])
   end
 
   let(:second_day) do
-    double(total_elapsed_time: 7 * 3600, 
-      date: yesteday,
+    double(total_elapsed_time: 7 * 3600,
+      date: tuesday,
       tasks: ["reports", "bugs"],
       intervals: [
-        {"start" => time(yesteday, 11, 30), "stop" => time(yesteday, 16)},
-        {"start" => time(yesteday, 16, 30), "stop" => time(yesteday, 19, 30)}
+        {"start" => time(tuesday, 11, 30), "stop" => time(tuesday, 16)},
+        {"start" => time(tuesday, 16, 30), "stop" => time(tuesday, 19, 30)}
+      ])
+  end
+
+  let(:third_day) do
+    double(total_elapsed_time: 2 * 3600,
+      date: sunday,
+      tasks: ["code review"],
+      intervals: [
+        {"start" => time(sunday, 20, 15), "stop" => time(sunday, 22, 15)}
+      ])
+  end
+
+  let(:last_month_day) do
+    double(total_elapsed_time: 4 * 3600,
+      date: last_month,
+      tasks: ["article"],
+      intervals: [
+        {"start" => time(last_month, 14, 15), "stop" => time(last_month, 18, 15)}
       ])
   end
 
   before(:each) do
-    Timecop.freeze(today)
+    Timecop.freeze(sunday)
   end
 
   after(:each) do
-    Timecop.return    
+    Timecop.return
   end
 
-  it 'should generate report for today' do
-    database.should_receive(:day).with(today).and_return(first_day)
-    
+  it 'should generate report for Sunday' do
+    database.should_receive(:day).with(sunday).and_return(third_day)
+
     report = Timert::Report.generate(database)
-    expect(report.include?("2013-02-20")).to eq(true)
-    expect(report.include?("emails")).to eq(true)
-    expect(report.include?("meeting")).to eq(true)
-    expect(report.include?("3.5")).to eq(true)
+    expect(report.include?("2013-02-24")).to eq(true)
+    expect(report.include?("code review")).to eq(true)
+    expect(report.include?("2")).to eq(true)
   end
 
-  it 'should generate report for any past day' do    
-    database.should_receive(:day).with(yesteday).and_return(second_day)
+  it 'should generate report for any past day' do
+    database.should_receive(:day).with(tuesday).and_return(second_day)
 
-    report = Timert::Report.generate(database, -1)
+    report = Timert::Report.generate(database, -5)
     expect(report.include?("2013-02-19")).to eq(true)
     expect(report.include?("reports")).to eq(true)
     expect(report.include?("bugs")).to eq(true)
@@ -56,25 +78,49 @@ describe Timert::Report do
   end
 
   it 'should generate report for this week' do
-    database.should_receive(:days).and_return([first_day, second_day])
+    database.should_receive(:days).and_return([first_day, second_day, third_day])
+    Range.should_receive(:new).with(monday, sunday)
 
     report = Timert::Report.generate(database, "week")
     expect(report.include?("WEEK")).to eq(true)
     expect(report.include?("2013-02-19")).to eq(true)
     expect(report.include?("2013-02-20")).to eq(true)
+    expect(report.include?("2013-02-24")).to eq(true)
     expect(report.include?("Total")).to eq(true)
+    expect(report.include?("12.5")).to eq(true)
+  end
+
+  it 'should generate report for any past week' do
+    database.should_receive(:days).and_return([first_day, second_day])
+    Range.should_receive(:new).with(last_monday, last_sunday)
+
+    report = Timert::Report.generate(database, "week -1")
+    expect(report.include?("WEEK")).to eq(true)
+    expect(report.include?("2013-02-11")).to eq(true)
+    expect(report.include?("2013-02-17")).to eq(true)
     expect(report.include?("10.5")).to eq(true)
   end
 
   it 'should generate report for this month' do
-    database.should_receive(:days).and_return([first_day, second_day])
+    database.should_receive(:days).and_return([first_day, second_day, third_day])
 
     report = Timert::Report.generate(database, "month")
     expect(report.include?("MONTH")).to eq(true)
     expect(report.include?("2013-02-19")).to eq(true)
     expect(report.include?("2013-02-20")).to eq(true)
+    expect(report.include?("2013-02-24")).to eq(true)
     expect(report.include?("Total")).to eq(true)
-    expect(report.include?("10.5")).to eq(true)
+    expect(report.include?("12.5")).to eq(true)
+  end
+
+  it 'should generate report for any past month' do
+    database.should_receive(:days).and_return([last_month_day])
+
+    report = Timert::Report.generate(database, "month -1")
+    expect(report.include?("MONTH 2013-01")).to eq(true)
+    expect(report.include?("2013-01-10")).to eq(true)
+    expect(report.include?("article")).to eq(true)
+    expect(report.include?("4")).to eq(true)
   end
 
   def time(day, hours, minutes = 0, seconds = 0)

data/spec/timer_spec.rb

@@ -7,9 +7,9 @@ describe Timert::Timer do
   before(:each) do
     @today = Timert::Day.new
     @timer = Timert::Timer.new(@today)
-  end  
+  end
 
-  it 'should return start time when started' do    
+  it 'should return start time when started' do
     Timecop.freeze(Time.new(2013, 2, 14, 22, 0)) do
       expect(@timer.start[:time]).to eq(Time.now.to_i)
     end
@@ -31,16 +31,16 @@ describe Timert::Timer do
       expect(@timer.start(time + 10)[:started]).not_to eq(true)
       @timer.stop
       expect(@timer.start(time + 10)[:started]).to eq(true)
-    end    
+    end
 
     context 'and then stopped' do
-      it 'should return stop time' do    
+      it 'should return stop time' do
         Timecop.freeze(Time.new(2013, 2, 14, 23, 0)) do
-          expect(@timer.stop[:time]).to eq(Time.now.to_i)      
+          expect(@timer.stop[:time]).to eq(Time.now.to_i)
         end
       end
     end
-  end  
+  end
 
   context 'while not running' do
     it "should not stop until it's started" do
@@ -48,7 +48,7 @@ describe Timert::Timer do
       @timer.start
       expect(@timer.stop[:stopped]).to eq(true)
     end
-  end  
+  end
 
   it 'should be able to start with given time' do
     time = Time.now.to_i

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timert
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: '1.1'
 platform: ruby
 authors:
 - Gosia Kwidzinska
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-30 00:00:00.000000000 Z
+date: 2014-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,6 +24,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement