timeless 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a45d84d4290e39bba5b6fe3a99fd101cefd7f97c
+  data.tar.gz: 761ab4cf1594beb69534198f556a11f936806801
+SHA512:
+  metadata.gz: 5b97c16e7cc2fc1b1b919c93518a11c7ae6a115e11ff1138251bf26bd699da7d18b11f59b0a222c4ca242105d596528b52e1bb6149abd4f1df8f4c37adeffd3f
+  data.tar.gz: 72160f36426d2659db29cb1cfc57deb81948e1a24d483639197f881c0068c65b7b06455fc684d018793e091d7d85b0bd5e22d3c96d9b485d116d175affe9fddd

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*~
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Adolfo Villafiorita
+
+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.textile

@@ -0,0 +1,99 @@
+h1. Timeless
+
+Timeless is a simple command line time tracker.
+
+h2. Installation
+
+Add this line to your application's Gemfile:
+
+bc.. ruby
+gem 'timeless'
+
+p. And then execute:
+
+bc. $ bundle
+
+Or install it yourself as:
+
+bc. $ gem install timeless
+
+h2. Usage
+
+timeless is a simple command line time tracker.  Entries store the following information:
+
+# start time
+# end time
+# notes
+
+timeless allows one to
+
+* run a pomodoro timer
+* clock time using a "stopwatch" (with start and stop commands)
+* manually entering data
+* print a text report, possibly filtered by date ranges of notes' content
+* export to csv
+
+Timeless has also some basic support for key-pair values in the notes form.  They can be used to assign a special meaning to some strings and improve filtering and exporting.  Two special keys are @p@ for projects and @c@ for clients.  These two keys are exported in dedicated columns when exporting data to csv.
+
+Some non nominal conditions are also handled (e.g., starting a clock twice, trying to stop when no clock was started).
+
+h2. Examples
+
+Get information about command syntax:
+
+bc. timeless -h
+
+Run a pomodoro timer:
+
+bc.. timeless pom p:project meeting with c:john
+timeless pom --duration 60 p:prj2
+timeless pom --long # default to 50 minutes
+
+p. Start clocking using a stopwatch:
+
+bc.. timeless start requirements doc
+timeless start --at 'thirty minutes ago' fixing bug 182 for c:tim
+timeless start --force --at 'five minutes ago' requirements document for p:prj1
+
+Stop clocking:
+
+bc.. timeless stop 
+timeless stop forgot notes on start
+timeless stop --last # reuse the notes of last entry
+timeless stop --at 'five minutes ago'
+timeless stop --start '1 hour ago' --at 'now' clocked a full entry
+
+p. Enter a full entry:
+
+bc.. timeless clock activity on p:project # from end of last entry to now
+timeless clock --start 'three hours ago' --stop 'five minutes ago'
+
+p. What was i doing?
+
+bc.. timeless forget   # forget pending clock
+timeless last     # print last entry
+timeless current  # print current entry
+
+p. Reporting and exporting
+
+bc.. timeless report
+timeless report --from yesterday --filter p:project
+timeless export
+
+Notice that even though data is stored in csv, the export command exports data in a format which is more easily parsed by a Spreadsheet such as LibreOffice.
+
+h2. If something goes wrong
+
+Data is stored in the CSV file @~/.timeless.csv@.  You can edit the file to manually fix entries if you make some mistake. 
+
+h2. License
+
+Licensed under the terms of the MIT License.
+
+h2. Contributing
+
+# Fork it ( https://github.com/[my-github-username]/timeless/fork )
+# Create your feature branch (`git checkout -b my-new-feature`)
+# Commit your changes (`git commit -am 'Add some feature'`)
+# Push to the branch (`git push origin my-new-feature`)
+# Create a new Pull Request

data/Rakefile

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

data/bin/timeless

@@ -0,0 +1,386 @@
+#!/usr/bin/env ruby
+
+require 'slop'
+require 'date'
+require 'chronic'
+
+require "timeless"
+
+version = Timeless::VERSION
+app_name = "timeless"
+app_one_liner = "A command line time tracker"
+
+man = <<EOS
+NAME
+  #{app_name} -- #{app_one_liner}
+
+SYNOPSYS
+  #{app_name} [-h|-v]
+  #{app_name} command [options] [args]
+
+DESCRIPTION
+  timeless is a simple command line time tracker
+
+  It allows one to:
+
+  * run a pomodoro timer of standard or custom duration
+  * clock time using a \"stopwatch\" (with start and stop commands)
+  * manually entering data
+  * print a text report, possibly filtered by date ranges or strings
+  * export to csv
+
+  Some non nominal conditions are handled (e.g. starting twice, trying to stop
+  when no clock was started).
+
+  Timeless assigns a special meaning to some keypairs in notes.  In particular,
+  you can use:
+
+    p:PROJECT
+    c:NAME
+
+  to specify the project and the client a specific entry refers to.  The information
+  can be used for filtering and when exporting data.
+
+EXAMPLES
+
+  timeless help
+  timeless man
+
+  timeless pom
+
+  timeless start doing something for c:a on p:b
+  timeless stop --at '5 minutes ago'
+
+  timeless report
+  timeless export
+
+VERSION
+  This is version #{version}
+
+LICENSE
+  MIT
+
+SEE ALSO
+  #{app_name} -h
+  https://github.com/avillafiorita/#{app_name}
+EOS
+
+def last_entry
+  start, stop, notes = Timeless::Storage.last
+
+  interval = Time.parse(stop) - Time.parse(start)
+  seconds = interval % 60
+  minutes = (interval / 60) % 60
+  hours = interval / 3600
+  
+  sprintf "Timeless: you clocked %02d:%02d:%02d on %s\nYou stopped clocking at: %s", hours, minutes, seconds, notes, stop
+end
+
+#
+# code shared by stop and clock (which accept slightly different options,
+# but behave in the same way
+#
+def manage_stop start, stop, notes, reuse_last
+  # syntax check:
+  # - --start is illegal if there is a running clock
+  # - --last is illegal if there are notes
+  #
+  # however:
+  # - --last and notes prevail over notes stored when starting the clock
+  if Timeless::Stopwatch.clocking? and start
+    puts "Timeless error: you specified --start with a running clock.  Use 'timeless forget' or drop --start"
+  end
+  if reuse_last and notes != "" then
+    puts "Timeless error: you specified both --last and notes.  Choose one or the other"
+  end
+
+  if reuse_last then
+    _, _, notes = Timeless::Storage.last
+  end
+  
+  if Timeless::Stopwatch.clocking?
+    start, stop, notes = Timeless::Stopwatch.stop(start, stop, notes) # merge passed with data in running clock
+    Timeless::Storage.store(start, stop, notes)
+
+    puts "Clock stopped at #{stop}."
+    puts last_entry
+  else
+    start = start ? start : Timeless::Storage.last[1]
+    stop = stop ? stop : Time.now
+    Timeless::Storage.store(start, stop, notes)
+
+    puts "Clock stopped at #{stop}."
+    puts last_entry
+  end
+end
+
+#
+# Main App Starts Here!
+#
+if ARGV == [] then
+  puts "type 'timeless -h' for help."
+  exit
+end
+
+#begin
+  opts = Slop.parse :help => true, :strict => true do
+
+    banner "#{app_name} [-h|-v]\n#{app_name} command [options] [args]"
+
+    ##############################################################################
+    on "-v", "--version", 'Print version information' do
+      puts "#{app_name} version #{version}"
+    end
+
+    ##############################################################################
+    command :man do
+      banner "#{app_name} man"
+      description "Print usage instruction for #{app_name}"
+
+      run do |_, _|
+        puts man
+      end
+    end
+
+    ##############################################################################
+    command :pom do
+      banner "#{app_name} pom [options] [notes]"
+      description "Start a pomodoro timer."
+
+      on :long, "Use a long timer (50 minutes)"
+      on :duration=, "Duration of the pomodoro timer, in minutes", as: Integer
+
+      run do |opts, args|
+        duration = opts.to_hash[:duration] ||
+                   (opts.to_hash[:long] ? Timeless::Pomodoro::WORKING_LONG : Timeless::Pomodoro::WORKING)
+
+        start, stop, notes = Timeless::Pomodoro.run_pomodoro_timer(duration, args.join(" "))
+        Timeless::Storage.store(start, stop, notes)
+        puts last_entry
+      end
+    end
+
+    ##############################################################################
+    command :start do
+      banner "#{app_name} start [--at chronic expression] [notes]"
+      description "Start clocking."
+
+      on :at=, "Actual start time, using chronic expression"
+      on :force, "Forget existing running timer"
+
+      run do |opts, args|
+        start = Chronic.parse(opts.to_hash[:at]) # nil if no option specified
+        notes = args.join(" ")                   # empty string is no args specified
+        force = opts.to_hash[:force]
+
+        if Timeless::Stopwatch.clocking? and not force 
+          start, notes = Timeless::Stopwatch.get_start # for information purposes only
+          puts "There is a clock started at #{start} (notes: \"#{notes}\").  Use --force to override."
+        else
+          Timeless::Stopwatch.start(start, notes)
+          puts "Clock started at #{start ? start : Time.now}."
+          puts "You may want to specify notes for the entry when you stop clocking." if notes == ""
+        end
+      end
+    end
+
+    ##############################################################################
+    command :forget do
+      banner "#{app_name} forget"
+      description "Forget the timer you started, if any"
+
+      run do |opts, args|
+        Timeless::Stopwatch.forget
+      end
+    end
+
+    ##############################################################################
+    command :stop do
+      banner "#{app_name} stop [--at chronic expression] [--start chronic expression] [--last|notes]"
+      description "Stop clocking, using notes, if specified.  Require a start time if there is no pending clock."
+
+      on :at=, "Stop time, using chronic expression"
+      on :start=, "Start time, using chronic expression.  Required if there is no timer started."
+      on :last, "Reuse notes of last clocked entry"
+      
+
+      run do |opts, args|
+        start = Chronic.parse(opts.to_hash[:start])  # nil if no option specified
+        stop  = Chronic.parse(opts.to_hash[:at])     # nil if no option specified
+        notes = args.join(" ")                       # empty string if no args specified
+
+        manage_stop start, stop, notes, opts[:last]
+      end
+    end
+
+    ##############################################################################
+    command :clock do
+      banner "#{app_name} clock [--start chronic expression] [--stop|--end chronic expression] [--last|notes]"
+      description "Clock an entry specifying start and end time.  Leave any running clock."
+
+      on :start=, "Start time, using chronic expression (start from previous entry if not specified)."
+      on :stop=, "End time, using chronic expression (stop now, if not specified)."
+      on :end=, "End time, an alias for stop."
+      on :last, "Reuse notes of last entry"
+
+      run do |opts, args|
+        start = Chronic.parse(opts.to_hash[:start])   # nil if no option specified
+        stop_opt = Chronic.parse(opts.to_hash[:stop]) # nil if no option specified
+        end_opt  = Chronic.parse(opts.to_hash[:end])  # nil if no option specified
+        stop = stop_opt ? stop_opt : end_opt          # stop_opt if --stop, end_opt if --end, nil otherwise
+        notes = args.join(" ")                        # empty string if no args specified
+
+        if stop_opt and end_opt then
+          puts "Timeless error: specify end time with either --end or --stop (not both)"
+          exit
+        end
+
+        manage_stop start, stop, notes, opts[:last]
+      end
+    end
+
+
+    ##############################################################################
+    command :current do
+      banner "#{app_name} current"
+      description "Show time elapsed since last start command."
+
+      run do |opts, args|
+        if Timeless::Stopwatch.clocking? then
+          start, notes = Timeless::Stopwatch.get_start
+          puts "Timeless: you have been clocking #{"%.0d" % ((Time.now- Time.parse(start)) / 60)} minutes"
+          puts "on: #{notes}" if notes
+        else
+          puts "There is no clock started."
+        end
+      end
+      
+    end
+
+    ##############################################################################
+    command :last do
+      banner "#{app_name} last"
+      description "Show last entry."
+
+      run do |_, _|
+        puts last_entry
+      end
+    end
+
+    ##############################################################################
+    command :list do
+      banner "#{app_name} list key"
+      description "List all values assigned to a given key (e.g., list all projects)"
+
+      run do |_, args|
+        values = Timeless::Storage.get_key args[0]
+        puts "Timeless: list of keys #{args[0]} found in timesheets:"
+        values.each do |value|
+          puts value
+        end
+      end
+    end
+
+    ##############################################################################
+    command :export do
+      banner "#{app_name} export"
+      description "Export to csv"
+
+      run do |_, _|
+        Timeless::Storage.export
+      end
+    end
+
+
+    ##############################################################################
+    command :gaps do
+      banner "#{app_name} gaps"
+      description "List all gaps in the timesheets (periods you have not clocked)"
+
+      on :from=, "From date"
+      on :to=, "To date"
+      on :interval=, "Minimum interval to report (in minutes)", :as => Integer
+
+      run do |opts, _|
+        from = opts.to_hash[:from] ? Chronic.parse(opts.to_hash[:from]) : nil
+        to = opts.to_hash[:to] ? Chronic.parse(opts.to_hash[:to]) : nil
+        interval = opts.to_hash[:interval] || 1
+        
+        entries = Timeless::Storage.get(from, to)
+        previous_stop = from || Time.parse(entries[0][0])
+        day = ""
+
+        printf "%-18s %-5s - %-5s   %-6s  %-s\n", "Day", "Start", "End", "Gap", "Command to fix"
+        entries.sort { |x,y| Time.parse(x[0]) <=> Time.parse(y[0]) }.each do |entry|
+          current_start = Time.parse(entry[0])
+
+          current_day = current_start.strftime("%a %b %d, %Y")
+
+          if (current_start.day == previous_stop.day and current_start - previous_stop > interval * 60) then
+
+            if current_day != day then
+              day = current_day
+            else
+              current_day = "" # avoid printing the day if same as before
+            end
+
+            duration = (current_start - previous_stop) / 60
+            printf "%-18s %5s - %5s   %02i:%02i   %s\n",
+                   current_day,
+                   previous_stop.strftime("%H:%M"),
+                   current_start.strftime("%H:%M"),
+                   duration / 60, duration % 60, 
+                   "timeless clock --start '#{previous_stop}' --end '#{current_start}'"
+
+          end
+          previous_stop = Time.parse(entry[1])
+        end
+
+      end
+    end
+
+    ##############################################################################
+    command :report do
+      banner "#{app_name} report"
+      description "Display a report of entries."
+
+      on :from=, "From date"
+      on :to=, "To date"
+      on :filter=, "With notes containing string"
+
+      run do |opts, args|
+        from = opts.to_hash[:from] ? Chronic.parse(opts.to_hash[:from]) : nil
+        to = opts.to_hash[:to] ? Chronic.parse(opts.to_hash[:to]) : nil
+
+        entries = Timeless::Storage.get(from, to, opts.to_hash[:filter])
+        # it could become a function of a reporting module
+        printf "%-18s %-5s - %-5s %-8s  %-s\n", "Day", "Start", "End", "Duration", "Notes"
+        total = 0
+        day = ""
+        entries.sort { |x,y| Time.parse(x[0]) <=> Time.parse(y[0]) }.each do |entry|
+          current_day = Time.parse(entry[0]).strftime("%a %b %d, %Y")
+          if current_day != day then
+            day = current_day
+          else
+            current_day = "" # avoid printing the day if same as before
+          end
+          
+          duration = (Time.parse(entry[1]) - Time.parse(entry[0])) / 60
+          total = total + duration
+
+          printf "%-18s %5s - %5s   %02i:%02i   %s\n",
+                 current_day,
+                 Time.parse(entry[0]).strftime("%H:%M"),
+                 Time.parse(entry[1]).strftime("%H:%M"),
+                 duration / 60, duration % 60,
+                 entry[2]
+        end
+        puts "----------------------------------------------------------------------"
+        printf "Total                              %02i:%02i\n", total / 60, total % 60
+      end
+    end
+  end
+# rescue
+#   puts "error: unknown option"
+#   puts "type '#{app_name} -h' for help"
+# end

data/lib/timeless.rb

@@ -0,0 +1,7 @@
+require "timeless/version"
+
+module Timeless
+  require "timeless/pomodoro"
+  require "timeless/stopwatch"
+  require "timeless/storage"
+end

data/lib/timeless/pomodoro.rb

@@ -0,0 +1,40 @@
+module Timeless
+  module Pomodoro
+    require 'terminal-notifier'
+    require 'date'
+
+    TITLE = 'Pomodoro'
+    MESSAGE = 'Finish'
+    SOUND = 'Glass'
+    
+    WORKING = 25
+    WORKING_LONG = 50
+
+    BREAK = 5
+    BREAK_LONG = 15
+    
+    INTERVAL = 0.3
+    
+    def self.run_pomodoro_timer total_mins, notes=nil
+      start = Time.now
+      total_secs = total_mins * 60
+      s = 0
+      _s = nil
+      while true
+        s = (Time.now - start).to_i
+        r = total_secs - s
+        printf("\r%i:%02i", r / 60, r % 60) if s != _s
+        break if s >= total_secs
+        _s = s
+        sleep INTERVAL
+      end
+      print "\n"
+      
+      TerminalNotifier.notify(MESSAGE, title: TITLE, sound: SOUND)
+      system "say 'Pomodoro complete. Take a break, now'"
+
+      [start, Time.now, notes]
+    end
+  end
+
+end

data/lib/timeless/stopwatch.rb

@@ -0,0 +1,62 @@
+#
+# implement a stopwatch, which can be started and stopped
+#
+module Timeless
+  module Stopwatch
+    require 'date'
+    
+    def self.start start=nil, notes=nil
+      store_start (start ? start : Time.now), (notes ? notes : "")
+    end
+
+    def self.stop start=nil, stop=nil, notes=nil
+      if not start
+        start, _ = get_start
+      end
+
+      if notes == nil or notes == ""
+        _, notes = get_start
+      end
+
+      if not stop
+        stop = Time.now
+      end
+
+      forget # forget started clock, if any
+
+      [start, stop, notes]
+    end
+
+    #
+    # Storing and retrieving start time and notes
+    #
+    # file containing the start time
+
+    START_FILENAME = File.expand_path("~/.timeless-tmp.csv")
+
+    def self.clocking?
+      File.exists?(START_FILENAME) 
+    end
+
+    def self.get_start
+      if clocking?
+        array = CSV.read(START_FILENAME, "r")
+        [array[0][0], array[0][1]]
+      else
+        [nil, nil]
+      end
+    end
+
+    def self.store_start start, notes
+      CSV.open(START_FILENAME, "w") do |csv|
+        csv << [start, notes]
+      end
+    end
+
+    # forget the start clock
+    def self.forget
+      File.delete(START_FILENAME) if File.exists?(START_FILENAME) 
+    end
+
+  end
+end

data/lib/timeless/storage.rb

@@ -0,0 +1,69 @@
+module Timeless
+  require 'csv'
+  
+  module Storage
+    TIMELESS_FILE=File.expand_path("~/.timeless.csv")
+
+    def self.store start, stop, notes
+      CSV.open(TIMELESS_FILE, "a") do |csv|
+        csv << [start, stop, notes]
+      end
+    end
+
+    def self.last
+      CSV.read(TIMELESS_FILE).last
+    end
+
+    def self.get from_date=nil, to_date=nil, filter=nil
+      entries = CSV.read(TIMELESS_FILE)
+      entries.select do |x|
+        (from_date ? Time.parse(x[0]) >= from_date : true) and
+          (to_date ? Time.parse(x[1]) <= to_date : true) and
+          (filter ? x[2].include?(filter) : true)
+      end
+    end
+
+    # get all unique keys of a given type in file
+    def self.get_key key
+      entries = CSV.read(TIMELESS_FILE)
+      entries.map { |x| extract_kpv key, x[2] }.uniq.sort
+    end
+
+    def self.export
+      entries = CSV.read(TIMELESS_FILE)
+
+      CSV { |csvout| csvout << ["Start Date", "Start Time", "End Date", "End Time", "Duration (s)", "Project", "Notes"] }
+      CSV do |csvout|
+        entries.each do |entry|
+          start = Time.parse(entry[0])
+          stop = Time.parse(entry[1])
+          
+          start_date = start.strftime("%Y-%m-%d")
+          start_time = start.strftime("%H:%M:%S")
+          
+          stop_date = stop.strftime("%Y-%m-%d")
+          stop_time = stop.strftime("%H:%M:%S")
+          
+          duration = stop - start
+        
+          # extract project and client, if present
+          project = extract_kpv "p", entry[2]
+          client = extract_kpv "c", entry[2]
+
+          notes = entry[2]
+
+          csvout << [start_date, start_time, stop_date, stop_time, duration, project, client, notes]
+        end
+      end
+    end
+
+    private
+
+    # return the value of a key-pair value in string or "" if not present
+    def self.extract_kpv key, string
+      match = string.match(/#{key}:([^ ]+)/)
+      match ? match[1] : ""
+    end
+  end
+end
+

data/lib/timeless/version.rb

@@ -0,0 +1,3 @@
+module Timeless
+  VERSION = "0.1.0"
+end

data/timeless.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'timeless/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "timeless"
+  spec.version       = Timeless::VERSION
+  spec.authors       = ["Adolfo Villafiorita"]
+  spec.email         = ["adolfo.villafiorita@me.com"]
+  spec.summary       = %q{Timeless is a simple command line time tracker}
+  spec.description   = %q{Timeless comes with a pomodoro timer, with a standard stopwatch and a simple reporting command.  Data is stored in csv and it can be easily imported into a spreadsheet.}
+  spec.homepage      = "http://github.com/avillafiorita/timeless"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency 'slop', '~> 3.6.0', '>= 3.6.0'
+  spec.add_runtime_dependency 'chronic'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: timeless
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adolfo Villafiorita
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Timeless comes with a pomodoro timer, with a standard stopwatch and a
+  simple reporting command.  Data is stored in csv and it can be easily imported into
+  a spreadsheet.
+email:
+- adolfo.villafiorita@me.com
+executables:
+- timeless
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.textile
+- Rakefile
+- bin/timeless
+- lib/timeless.rb
+- lib/timeless/pomodoro.rb
+- lib/timeless/stopwatch.rb
+- lib/timeless/storage.rb
+- lib/timeless/version.rb
+- timeless.gemspec
+homepage: http://github.com/avillafiorita/timeless
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Timeless is a simple command line time tracker
+test_files: []
+has_rdoc: