tamarillo 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rbenv-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/bundle

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tim Uruski
+
+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.md

@@ -0,0 +1,83 @@
+# Tamarillo
+
+A command line [pomodoro/tomato](http://www.pomodorotechnique.com/) timer.
+
+Currently this will just keep track of whether you are in the middle of
+a tomato. If you are it will display how much time remains. If you
+complete to the tomato without being interrupted, it will log it as
+completed for the day. You can also interrupt a tomato, which will
+freeze it for later analysis.
+
+It also makes it easy to includes the  current tomato status in your
+prompt. Tomatoes are stored in `~/.tamarillo` by default.
+
+[![Build Status](https://secure.travis-ci.org/timuruski/tamarillo.png)](http://travis-ci.org/timuruski/tamarillo)
+
+
+## Why Tamarillo?
+
+The tamarillo is a cousin to the tomato, which is also related to
+eggplants,  potatoes and the deadly nightshade. When tomatoes were
+first introduced to Europe, they were not popular because people
+associated them with the deadly poisons of their cousins.
+
+Also I wasn't clever enough to come up with Tomatillo at the time. In
+any case, tamarillos are delicious if you can find them. I recommend
+stewing them and then serving over vanilla ice cream; home made if you
+can.
+
+
+## Examples
+
+These examples are just thought experiments, this interface has not been
+implemented yet.
+
+### Starting and stopping a tomato
+
+```
+  $ tam start
+  > tamarillo started
+
+  $ tam stop
+  > tomato stopped around ~17m
+
+  $ tam pause
+  > tomato paused around ~16m
+
+  $ tam interrupt
+  > tomato interrupted around ~14m
+```
+
+### Status of current tomato
+
+```
+  $ tam status
+  > ~19m # rough time only, don't sweat the seconds
+
+  $ tam
+  > ~19m
+
+  $ tam status --full
+  > active 19:21
+```
+
+### Configuration
+
+```
+$ tam config --duration=25
+> tamarillo duration is 25 minutes
+
+$ tam config --alert=growl
+> tamarillo will use Growl for notifications
+
+$ tam config --daemon ~/.tamarillo/pid
+> tamarillo will monitor the current tomato from here
+```
+
+
+## Future ideas
+
+* task management, tomatoes are assigned to a task
+* daemon process for monitoring the current tomato
+* notification helper app for various environments
+* instaweb view of history

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+# require 'cucumber'
+require 'cucumber/rake/task'
+
+desc "Interactive pomodoro console"
+task :console do
+  exec("irb -Ilib -r'bundler/setup' -r'tamarillo'")
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--color'
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  tag_opts = ' --tags ~@pending'
+  tag_opts = " --tags #{ENV['TAGS']}" if ENV['TAGS']
+  t.cucumber_opts = "features --format progress -x -s#{tag_opts}"
+  t.fork = false
+end
+task :default => [:spec, :features]

data/bin/tam

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'tamarillo/command'
+Tamarillo::Command.new.execute(*ARGV)

data/features/config.feature

@@ -0,0 +1,44 @@
+Feature: configuration
+
+  Scenario: Outputting the current config
+    Given the default configuration
+    When I run `tam config`
+    Then the exit status should be 0
+    Then the output should contain:
+    """
+    duration: 25
+    """
+
+  Scenario: Setting the tomato duration
+    Given the default configuration
+    When I run `tam config duration=15`
+    And I run `tam config`
+    Then the exit status should be 0
+    Then the output should contain:
+    """
+    duration: 15
+    """
+
+  Scenario: Setting invalid duration
+    Given the default configuration
+    When I run `tam config duration=invalid_input`
+    And I run `tam config`
+    Then the exit status should be 0
+    Then the output should contain:
+    """
+    duration: 25
+    """
+
+  Scenario: Changing the tomato duration
+    Given there is no active tomato
+    When I run `tam config duration=5`
+    And I run `tam start`
+    And I run `tam`
+    Then the output should contain:
+    """
+    About 5 minutes
+    """
+    And the output should not contain:
+    """
+    About 25 minutes
+    """

data/features/step_definitions/tamarillo_steps.rb

@@ -0,0 +1,50 @@
+After do
+  # Kill any forked monitor processes.
+  storage = Tamarillo::Storage.new(tamarillo_path)
+  if monitor_pid = storage.read_monitor
+    Process.kill('QUIT', monitor_pid)
+  end
+end
+
+def tamarillo_path
+  Pathname.new("#{current_dir}/tamarillo")
+end
+
+def clear_tomatoes
+  # Not happy with how specific to implementation this is.
+  # Giving the Storage system a way to remove tomatoes might be good.
+  in_current_dir do
+    year = Time.new.year
+    FileUtils.remove_dir("tamarillo/#{year}", :force)
+  end
+end
+
+Given /^the default configuration$/ do
+  Tamarillo::Storage.new(tamarillo_path)
+  Tamarillo::Config.new.write(tamarillo_path.join('config.yml'))
+end
+
+Given /^there is no active tomato$/ do
+  clear_tomatoes
+end
+
+Given /^there is an active tomato$/ do
+  clock = Tamarillo::Clock.now
+  tomato = Tamarillo::Tomato.new(25 * 60, clock)
+  storage = Tamarillo::Storage.new(tamarillo_path)
+  storage.write_tomato(tomato)
+end
+
+Given /^there is a completed tomato$/ do
+  clear_tomatoes
+  time = Time.now - (25 * 60)
+  clock = Tamarillo::Clock.new(time)
+  tomato = Tamarillo::Tomato.new(25 * 60, clock)
+  storage = Tamarillo::Storage.new(tamarillo_path)
+  storage.write_tomato(tomato)
+end
+
+
+Then /^the output should be empty$/ do
+  assert_exact_output('', all_output)
+end

data/features/support/env.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+require 'aruba/cucumber'
+require 'tamarillo'
+
+ENV['TAMARILLO_PATH'] = 'tamarillo'

data/features/tamarillo.feature

@@ -0,0 +1,47 @@
+Feature: tamarillo
+
+  Scenario: First usage
+    Given there is no active tomato
+    When I run `tam`
+    Then the exit status should be 0
+    Then the output should be empty
+
+  Scenario: Starting a tomato
+    Given the default configuration
+      And there is no active tomato
+    When I run `tam start`
+    Then the output should match /About \d+ minutes/
+      And the exit status should be 0
+
+  Scenario: Tomato status
+    Given there is an active tomato
+    When I run `tam`
+    Then the output should match /About \d+ minutes/
+
+  Scenario: Interrupting a tomato
+    Given there is an active tomato
+    When I run `tam interrupt`
+    And I run `tam`
+    Then the output should be empty
+
+  Scenario: A tomato is completed
+    Given there is a completed tomato
+    When I run `tam`
+    Then the output should be empty
+
+  Scenario: Invalid command
+    When I run `tam blah`
+    Then the exit status should be 1
+    And the output should contain:
+    """
+    Invalid command 'blah'
+    """
+
+  Scenario: Tomato status for prompt
+    Given there is an active tomato
+    When I run `tam status --prompt`
+    Then the output should match:
+    """
+    \d\d:\d\d \d{4} \d{4}
+    """
+

data/lib/tamarillo/clock.rb

@@ -0,0 +1,33 @@
+require 'date'
+
+# Internal: Keeps track of time elapsed.
+#
+# The Clock model reprensents the amount of time elapsed since
+# the time a Pomodoro/Tomato began, typically measured in 
+# 15-25 minute blocks.
+#
+module Tamarillo
+  class Clock
+    attr_reader :start_time, :start_date
+
+    # Public: Initialize a new clock.
+    #
+    # start_time - A Time instance when the clock was started.
+    def initialize(start_time)
+      @start_time = start_time
+      @start_date = start_time.to_date
+    end
+
+    # Public: Returns a clock starting at the current time.
+    def self.now
+      new(Time.now)
+    end
+
+    # Public: Calculate time elapsed.
+    #
+    # Returns the number of seconds since the clock started.
+    def elapsed
+      Time.now.to_i - @start_time.to_i
+    end
+  end
+end

data/lib/tamarillo/command.rb

@@ -0,0 +1,68 @@
+require 'tamarillo'
+
+module Tamarillo
+  class Command
+    DEFAULT_PATH = '~/.tamarillo'
+    DEFAULT_COMMAND = 'status'
+
+    VALID_COMMANDS = %w[status config start stop interrupt]
+
+    def initialize
+      config = Tamarillo::Config.load(config_path)
+      storage = Storage.new(tamarillo_path, config)
+      @controller = Controller.new(config, storage)
+    end
+
+    def execute(*args)
+      command = parse_command_name!(args)
+      send(command.to_sym, *args.drop(1))
+    end
+
+    def status(*args)
+      format = Formats::HUMAN
+      format = Formats::PROMPT if args.include?('--prompt')
+
+      status = @controller.status(format)
+      puts status unless status.nil?
+    end
+
+    def start(*args)
+      tomato = @controller.start_new_tomato
+      status unless tomato.nil?
+    end
+
+    def interrupt(*args)
+      @controller.interrupt_current_tomato
+    end
+    alias :stop :interrupt
+
+    def config(*args)
+      params = Hash[args.map { |pair| pair.split('=', 2) }]
+      @controller.update_config(params)
+      puts @controller.config.to_yaml
+    end
+
+    private
+
+    def parse_command_name!(args)
+      name = args.first || DEFAULT_COMMAND
+      unless VALID_COMMANDS.include?(name)
+        puts "Invalid command '#{name}'"
+        exit 1
+      end
+
+      name
+    end
+
+    def tamarillo_path
+      path = ENV['TAMARILLO_PATH'] || DEFAULT_PATH
+      Pathname.new(File.expand_path(path))
+    end
+
+    def config_path
+      tamarillo_path.join('config.yml')
+    end
+
+  end
+end
+

data/lib/tamarillo/config.rb

@@ -0,0 +1,95 @@
+require 'yaml'
+require 'tamarillo/notification'
+
+module Tamarillo
+  # Internal: This configures the Tamarillo CLI, which uses values from
+  # this config when generating and interacting with Tomatoes. Currently
+  # it just holds the duration of each tomato, but it will later
+  # configure things like daemon process location and storage interface.
+  class Config
+    DEFAULT_DURATION_IN_MINUTES = 25
+
+    # Public: Gets/Sets the duration of each Tomato in minutes.
+    attr_accessor :duration_in_minutes
+
+    # Public: Initializes a new config.
+    #
+    # options - The hash used to configure Tamarillo.
+    #           :duration_in_minutes - The duration in minutes.
+    def initialize(options = {})
+      self.duration_in_minutes = options[:duration_in_minutes]
+      self.notifier = options[:notifier]
+    end
+
+    # Public: Returns the duration of each tomato in minutes.
+    def duration_in_minutes
+      @duration_in_minutes
+    end
+    alias :duration :duration_in_minutes
+
+    # Public: Sets the duration of each tomato in minutes.
+    #
+    # Uses the default value if the value is invalid.
+    def duration_in_minutes=(value)
+      value = value.to_i
+      @duration_in_minutes = (value > 0) ? value : DEFAULT_DURATION_IN_MINUTES
+    end
+    alias :duration= :duration_in_minutes=
+
+    # Public: Returns the duration of each tomato in seconds.
+    def duration_in_seconds
+      @duration_in_minutes.to_i * 60
+    end
+
+    # Public: Returns the notifier type.
+    def notifier
+      @notifier
+    end
+
+    # Public: Sets the notifier type.
+    def notifier=(value)
+      new_value = Notification.valid!(value)
+      new_value ||= @notifier
+      new_value ||= Notification.default
+
+      @notifier = new_value
+    end
+
+    # Public: Initializes a config from a YAML file.
+    #
+    # This tries to read config data from YAML. If the YAML is missing
+    # values or is invalid, defaults are used. If the file doesn't
+    # exist, then a default configuration is created.
+    #
+    # path - String or Pathname to the YAML file.
+    #
+    # Returns: A config instance.
+    def self.load(path)
+      options = {}
+
+      if File.exist?(path)
+        yaml = YAML.load( File.read(path.to_s) ) || {}
+        options[:duration_in_minutes] = yaml['duration']
+        options[:notifier] = yaml['notifier']
+      end
+
+      new(options)
+    end
+
+    # Public: Write a config out to a file.
+    #
+    # path - a String or Pathname to the destination file.
+    def write(path)
+      File.open(path, 'w') { |f| f << to_yaml }
+    end
+
+    # Public: Returns config in YAML format.
+    def to_yaml
+      options = {
+        'duration' => duration_in_minutes,
+        'notifier' => notifier.to_s }
+      YAML.dump(options)
+    end
+
+  end
+end

data/lib/tamarillo/controller.rb

@@ -0,0 +1,113 @@
+require 'tamarillo'
+
+module Tamarillo
+  # Formats for tomatoes
+  module Formats
+    HUMAN = :human.freeze
+    PROMPT = :prompt.freeze
+  end
+
+  # Public: This is intended to provide an environment for tomatoes to
+  # work from. It integrates the storage, config and monitor into a
+  # single coherant object.
+  class Controller
+    # Initializes a new controller.
+    def initialize(config, storage)
+      @config = config
+      @storage = storage
+    end
+
+    # Public: Formats and returns the status of the current tomato.
+    # Returns nil if no tomato is found.
+    def status(format)
+      tomato = @storage.latest
+      return unless tomato && tomato.active?
+
+      case format
+      when Formats::HUMAN then format_approx_time(tomato.remaining)
+      when Formats::PROMPT then format_prompt(tomato)
+      else raise "Invalid format"
+      end
+    end
+
+    # Public: Starts a new tomato if one is not already running.
+    def start_new_tomato
+      tomato = @storage.latest
+      return if tomato && tomato.active?
+
+      tomato = Tomato.new(@config.duration_in_seconds, Clock.now)
+      @storage.write_tomato(tomato)
+      start_monitor(tomato)
+
+      tomato
+    end
+
+    # Public: Interrupts the current tomato if one is running.
+    def interrupt_current_tomato
+      stop_monitor
+
+      tomato = @storage.latest
+      return if tomato.nil?
+
+      tomato.interrupt!
+      @storage.write_tomato(tomato)
+    end
+
+    # Public: Returns the current config.
+    def config
+      @config
+    end
+
+    # Public: Updates the current config.
+    def update_config(options = {})
+      valid_config_options(options).each do |key,value|
+        @config.send("#{key}=".to_sym, value)
+      end
+
+      @storage.write_config
+    end
+
+    private
+
+    def valid_config_options(options)
+      valid_keys = %w[duration notifier]
+      options.select { |k,_| valid_keys.include?(k.to_s) }
+    end
+
+    def format_approx_time(time)
+      minutes = (time / 60).round
+      'About %d minutes' % minutes
+    end
+
+    def format_time(time)
+      minutes = (time / 60).floor
+      seconds = time % 60
+      "%02d:%02d" % [minutes, seconds]
+    end
+
+    def format_prompt(tomato)
+      [format_time(tomato.remaining), tomato.remaining, tomato.duration].join(' ')
+    end
+
+    def start_monitor(tomato)
+      notifier = Notification.for(@config.notifier)
+      monitor = Monitor.new(tomato, notifier)
+      monitor.start
+      @storage.write_monitor(monitor)
+    end
+
+    def stop_monitor
+      if monitor_pid = @storage.read_monitor
+        begin
+          Process.kill('QUIT', monitor_pid)
+        rescue Errno::ESRCH
+          @storage.clear_monitor
+        rescue Errno::EPERM
+          warn "No privilege to kill monitor process."
+        end
+      end
+    end
+
+  end
+end
+

data/lib/tamarillo/monitor.rb

@@ -0,0 +1,27 @@
+module Tamarillo
+  class Monitor
+    # The time between checks.
+    SLEEP_TIME = 0.3
+    attr_reader :pid
+
+    # Public: Initializes a new monitor.
+    def initialize(tomato, notifier)
+      @tomato = tomato
+      @notifier = notifier
+    end
+
+    # Public: Starts watching a tomato for completion.
+    def start
+      @pid = fork do
+        until @tomato.completed?
+          sleep SLEEP_TIME
+        end
+
+        @notifier.call
+      end
+
+      Process.detach(@pid)
+    end
+
+  end
+end

data/lib/tamarillo/notification/bell.rb

@@ -0,0 +1,15 @@
+module Tamarillo
+  module Notification
+    class Bell
+      CHIME_COUNT = 3
+      CHIME_COMMAND = 'tput bel; sleep 0.2'
+
+      # Public: executes the notification.
+      def call
+        cmd = (1..CHIME_COUNT).map { CHIME_COMMAND }.join(';')
+        system(cmd)
+      end
+
+    end
+  end
+end

data/lib/tamarillo/notification/growl.rb

@@ -0,0 +1,13 @@
+module Tamarillo
+  module Notification
+    class Growl
+      GROWL_COMMAND = %Q{/usr/bin/env growlnotify --message 'Tomato complete.' --sticky}
+
+      # Public: executes the notification.
+      def call
+        system(GROWL_COMMAND)
+      end
+
+    end
+  end
+end