timeless 0.1.0 → 0.4.0

data/lib/timeless/version.rb

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

data/timeless.gemspec

@@ -8,19 +8,25 @@ Gem::Specification.new do |spec|
   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.summary       = %q{Timeless is a simple but effective command-line time tracker}
+  spec.description   = %q{Timeless comes with a pomodoro timer, with a standard stopwatch (start, top), semantic tags in notes (projects, clients, activites), and reporting and exporting 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.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
 
-  spec.add_runtime_dependency 'slop', '~> 3.6.0', '>= 3.6.0'
+  spec.add_runtime_dependency 'slop', '~> 4.5.0'
   spec.add_runtime_dependency 'chronic'
+  spec.add_runtime_dependency 'notiffany'
 end

metadata

@@ -1,65 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: timeless
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Adolfo Villafiorita
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2015-03-18 00:00:00.000000000 Z
+date: 2017-09-13 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'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: slop
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: 4.5.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: 3.6.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: chronic
+  name: notiffany
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -72,9 +94,9 @@ dependencies:
     - - ">="
       - !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.
+description: Timeless comes with a pomodoro timer, with a standard stopwatch (start,
+  top), semantic tags in notes (projects, clients, activites), and reporting and exporting
+  command.  Data is stored in csv and it can be easily imported into a spreadsheet.
 email:
 - adolfo.villafiorita@me.com
 executables:
@@ -85,10 +107,15 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
-- README.textile
+- README.md
 - Rakefile
-- bin/timeless
+- bin/console
+- bin/setup
+- elisp/forms.el
+- exe/timeless
 - lib/timeless.rb
+- lib/timeless/cli/command_semantics.rb
+- lib/timeless/cli/command_syntax.rb
 - lib/timeless/pomodoro.rb
 - lib/timeless/stopwatch.rb
 - lib/timeless/storage.rb
@@ -114,9 +141,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: Timeless is a simple command line time tracker
+summary: Timeless is a simple but effective command-line time tracker
 test_files: []
-has_rdoc: 

data/README.textile

@@ -1,99 +0,0 @@
-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/bin/timeless

@@ -1,386 +0,0 @@
-#!/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