tamarillo 0.1.0

data/lib/tamarillo/notification/none.rb

@@ -0,0 +1,13 @@
+module Tamarillo
+  module Notification
+    # Public: Provides a no-op for the notification system.
+    class None
+
+      # Public: executes the notification.
+      def call
+        # NO-OP
+      end
+
+    end
+  end
+end

data/lib/tamarillo/notification/speech.rb

@@ -0,0 +1,13 @@
+module Tamarillo
+  module Notification
+    class Speech
+      SPEECH_COMMAND = %Q{say "Tomato complete."}
+
+      # Public: executes the notification.
+      def call
+        system(SPEECH_COMMAND)
+      end
+
+    end
+  end
+end

data/lib/tamarillo/notification/touch.rb

@@ -0,0 +1,16 @@
+module Tamarillo
+  module Notification
+    class Touch
+      # Public: initializes a new notifier.
+      def initialize(path)
+        @path = File.expand_path(path)
+      end
+
+      # Public: executes the notification.
+      def call
+        system("touch #{@path}")
+      end
+
+    end
+  end
+end

data/lib/tamarillo/notification.rb

@@ -0,0 +1,36 @@
+require 'tamarillo/notification/bell'
+require 'tamarillo/notification/growl'
+require 'tamarillo/notification/none'
+require 'tamarillo/notification/speech'
+require 'tamarillo/notification/touch'
+
+module Tamarillo
+  module Notification
+    BELL = :bell.freeze
+    GROWL = :growl.freeze
+    NONE = :none.freeze
+    SPEECH = :speech.freeze
+
+    VALID = [BELL, GROWL, NONE, SPEECH]
+
+    # Public: Returns a valid notification type.
+    def self.valid!(value)
+      value = value.to_s.downcase.to_sym
+      VALID.include?(value) ? value : nil
+    end
+
+    def self.default
+      BELL
+    end
+
+    # Public: Resolves a notification class.
+    def self.for(type)
+      case type
+      when BELL then Bell.new
+      when GROWL then Growl.new
+      when SPEECH then Speech.new
+      else None.new
+      end
+    end
+  end
+end

data/lib/tamarillo/storage.rb

@@ -0,0 +1,118 @@
+require 'tamarillo/clock'
+require 'tamarillo/config'
+require 'tamarillo/tomato'
+require 'tamarillo/tomato_file'
+require 'fileutils'
+require 'pathname'
+
+# Public: Stores tomatoes using the filesystem.
+#
+# This model represents a directory of Tomato files and configuration.
+# It can read and write them, and find the latest one for the current
+# day.
+module Tamarillo
+  class Storage
+    # Returns: the String path to the storage directory.
+    attr_reader :path
+    # Returns: the Config for this storage.
+    # Used to set the duration when reading tomatoes in.
+    attr_reader :config
+
+    # Public: Initialize a new storage object.
+    def initialize(path, config = nil)
+      @config = config || Tamarillo::Config.new
+      @path = Pathname.new(path)
+      FileUtils.mkdir_p(@path)
+    end
+
+    # Public: Write the config to the filesystem.
+    #
+    # Returns the Pathname to the config that was written.
+    def write_config
+      File.open(config_path, 'w') { |f| f << @config.to_yaml }
+    end
+
+    # Public: Write a tomato to the filesystem.
+    #
+    # tomato - A Tomato instance.
+    #
+    # Returns the Pathname to the tomato that was written.
+    def write_tomato(tomato)
+      tomato_file = TomatoFile.new(tomato)
+      tomato_path = @path.join(tomato_file.path)
+      FileUtils.mkdir_p(File.dirname(tomato_path))
+      File.open(tomato_path, 'w') { |f| f << tomato_file.content }
+
+      tomato_path
+    end
+
+    # Public: Writes a monitor pid.
+    #
+    # monitor - The monitor to write.
+    def write_monitor(monitor)
+      File.open(monitor_path, 'w') { |f| f << monitor.pid }
+    end
+
+    # Public: Read a tomato from the filesystem.
+    #
+    # path - A String path to a tomato file.
+    #
+    # Returns a Tomato instance if found, nil if not found.
+    def read_tomato(path)
+      return unless File.exist?(path)
+
+      data = File.readlines(path)
+      start_time = Time.iso8601(data[0]).localtime
+      state = data[2]
+
+      clock = Clock.new(start_time)
+      duration = config.duration_in_seconds
+      tomato = Tomato.new(duration, clock)
+      tomato.interrupt! if state == 'interrupted'
+      
+      tomato
+    end
+
+    # Public: Returns the pid of monitor.
+    def read_monitor
+      if File.exists?(monitor_path)
+        File.read(monitor_path).to_i
+      end
+    end
+
+    # Public: Removes monitor pid-file.
+    def clear_monitor
+      File.delete(monitor_path) if File.exists?(monitor_path)
+    end
+
+    # Public: Returns a Tomato instance if one exists.
+    def latest
+      return unless File.directory?(tomato_dir)
+      # p Dir.glob(tomato_dir.join('*'))
+
+      # XXX tomato_dir.to_s because FakeFS chokes on Pathname.
+      if latest_name = Dir.glob(tomato_dir.join('*')).sort.last
+        read_tomato(latest_name)
+      end
+    end
+
+    private
+
+    # Private: Returns a Pathname to the config.
+    def config_path
+      @path.join('config.yml')
+    end
+
+    # Private: Returns a Pathmame to the monitor pid.
+    def monitor_path
+      @path.join('monitor.pid')
+    end
+
+    # Private: Returns a Pathname to the current day.
+    def tomato_dir
+      base_path = File.dirname(TomatoFile.path(Time.now))
+      @path.join(base_path)
+    end
+
+  end
+end

data/lib/tamarillo/tomato.rb

@@ -0,0 +1,96 @@
+require 'date'
+
+module Tamarillo
+  # Public: A unit of work.
+  #
+  # A Tomato is a 'pomodoro', it keeps track of the amount of time you
+  # have focused on a single task. It can be interrupted or completed.
+  class Tomato
+    # Internal: A set of valid states a Tomato can be in.
+    module States
+      ACTIVE = :active.freeze
+      COMPLETED = :completed.freeze
+      INTERRUPTED = :interrupted.freeze
+    end
+
+    # Public: Gets/Sets the length of the tomato in seconds.
+    attr_accessor :duration
+
+    # Public: Initializes a new Tomato.
+    #
+    # duration - The length of the Tomato in seconds.
+    # clock    - A Clock instance to keep track of elapsed time.
+    def initialize(duration, clock)
+      @duration = duration
+      @clock = clock
+    end
+
+    # Public: Returns the starting Time of the Tomato.
+    def started_at
+      @clock.start_time
+    end
+
+    # Public: Returns the Date the Tomato was started on.
+    def date
+      @clock.start_date
+    end
+
+    # Public: Returns true if two Tomatoes share a start Time.
+    def eql?(other)
+      other.started_at == started_at ||
+      super(other)
+    end
+
+    # Public: Returns the number of seconds until completion.
+    def remaining
+      return 0 if @interrupted
+
+      d = @duration - @clock.elapsed
+      d > 0 ? d : 0
+    end
+
+    # Public: Returns the number of seconds elapsed since start.
+    def elapsed
+      @clock.elapsed
+    end
+
+    # Public: Marks the tomato as interrupted.
+    #
+    # Returns the Tomato.
+    def interrupt!
+      @interrupted = true
+      self
+    end
+
+    # Public: Returns true if the Tomato has not been completed or
+    # interrupted.
+    def active?
+      States::ACTIVE == state
+    end
+
+    # Public: Returns true if the elapsed Time matches the duration.
+    def completed?
+      States::COMPLETED == state
+    end
+
+    # Public: Returns true if the Tomato has been interrupted.
+    def interrupted?
+      States::INTERRUPTED == state
+    end
+
+    # Public: Returns which state the Tomato is in.
+    #
+    # I'd rather keep this internal, but the storage system needs to
+    # know what state the tamato was in when it was written.
+    def state
+      if @interrupted
+        States::INTERRUPTED
+      elsif remaining == 0
+        States::COMPLETED
+      else
+        States::ACTIVE
+      end
+    end
+
+  end
+end

data/lib/tamarillo/tomato_file.rb

@@ -0,0 +1,60 @@
+require 'time'
+
+module Tamarillo
+  # Internal: Represents a tomato in the filesystem.
+  class TomatoFile
+    FILENAME_FORMAT = '%Y%m%d%H%M%S'
+    PATH_FORMAT = '%Y/%m%d'
+
+    # Public: Initializes a new tomato file.
+    #
+    # tomato - A Tomato instance to serialize.
+    def initialize(tomato)
+      @tomato = tomato
+    end
+
+    # Public; Returns the filename of the Tomato.
+    def name
+      @tomato.started_at.strftime(FILENAME_FORMAT)
+    end
+
+    # Public: Returns a String path to the Tomato.
+    def path
+      self.class.path(@tomato.started_at)
+    end
+    
+    # Public: Generate a path from a time.
+    #
+    # time - A Tomato's start time Date.
+    #
+    # Returns A String path generated from a Date.
+    def self.path(time)
+      dir = time.strftime(PATH_FORMAT)
+      name = time.strftime(FILENAME_FORMAT)
+
+      "#{dir}/#{name}"
+    end
+
+    # Public: Returns the serialized form of a Tomato.
+    def content
+      [time,task,state].join("\n")
+    end
+
+    private
+
+    # Private: Returns the start time in ISO-8601 format.
+    def time
+      @tomato.started_at.iso8601
+    end
+
+    # Returns: The name of the task being worked on during the Tomato.
+    def task
+      "Some task I'm working on"
+    end
+
+    # Returns the state of the Tomato.
+    def state
+      @tomato.state.to_s
+    end
+  end
+end

data/lib/tamarillo/version.rb

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

data/lib/tamarillo.rb

@@ -0,0 +1,7 @@
+require 'tamarillo/version'
+require 'tamarillo/config'
+require 'tamarillo/controller'
+require 'tamarillo/notification'
+require 'tamarillo/monitor'
+require 'tamarillo/tomato'
+require 'tamarillo/storage'

data/spec/lib/tamarillo/clock_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../../lib/tamarillo/clock'
+require 'timecop'
+
+include Tamarillo
+
+describe Clock do
+  after do
+    Timecop.return
+  end
+
+  it "has a start_time" do
+    now = Time.new(2012,4,1,6,0,0)
+    clock = Clock.new(now)
+    clock.start_time.should == now
+  end
+
+  it "has a start_date" do
+    now = Time.new(2012,1,1,6,0,0)
+    today = Date.new(2012,1,1)
+    clock = Clock.new(now)
+    clock.start_date.should == today
+  end
+
+  it "has an elapsed value" do
+    now = Time.new(2012,1,1,6,0,0)
+    clock = Clock.new(now)
+    Timecop.freeze(2012,1,1,6,0,30)
+
+    clock.elapsed.should == 30
+  end
+
+  describe "#now" do
+    it "creates an instance starting at the current time" do
+      Timecop.freeze(2012,1,1,6,0,30)
+      clock = Clock.now
+      clock.start_time.should == Time.now
+    end
+  end
+end

data/spec/lib/tamarillo/command_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../../lib/tamarillo/command'
+
+describe Tamarillo::Command do
+  before do
+    @stdout = $stdout
+    $stdout = StringIO.new
+  end
+
+  after do
+    $stdout = @stdout
+  end
+
+  it "has an execute command" do
+    expect { subject.execute }
+      .to_not raise_error
+  end
+end

data/spec/lib/tamarillo/config_spec.rb

@@ -0,0 +1,133 @@
+require 'active_support/core_ext/numeric/time'
+require_relative '../../../lib/tamarillo/config'
+
+describe Tamarillo::Config do
+  let(:default_duration) { Tamarillo::Config::DEFAULT_DURATION_IN_MINUTES }
+
+  describe "empty config" do
+    subject { Tamarillo::Config.new }
+    its(:duration_in_minutes) { should == default_duration }
+    its(:duration_in_seconds) { should == default_duration * 60 }
+  end
+
+  describe "duration_in_minutes" do
+    it "can be read" do
+      config = Tamarillo::Config.new(duration_in_minutes: 15)
+      config.duration_in_minutes.should == 15
+    end
+
+    it "can be assigned" do
+      subject.duration_in_minutes = 10
+      subject.duration_in_minutes.should == 10
+    end
+
+    it "assigns the default when value is nil" do
+      subject.duration_in_minutes = nil
+      subject.duration_in_minutes.should == default_duration
+    end
+
+    it "affects the duration in seconds" do
+      subject.duration_in_minutes = 30
+      subject.duration_in_seconds.should == 30 * 60
+    end
+  end
+
+  describe "duration" do
+    it "aliases duration_in_minutes" do
+      expect { subject.duration = 10 }
+        .to change { subject.duration_in_minutes }
+    end
+  end
+
+  describe "duration_in_seconds" do
+    it "converts the duration in minutes into seconds" do
+      config = Tamarillo::Config.new(duration_in_minutes: 15)
+      config.duration_in_seconds.should == 15 * 60
+    end
+  end
+
+  describe "notifier" do
+    it "can be read" do
+      config = Tamarillo::Config.new(notifier: Tamarillo::Notification::SPEECH)
+      config.notifier.should == Tamarillo::Notification::SPEECH
+    end
+
+    it "can be assigned" do
+      config = Tamarillo::Config.new
+      config.notifier = 'Growl'
+      config.notifier.should == Tamarillo::Notification::GROWL
+    end
+
+    it "falls back to the existing value if a new value is invalid" do
+      config = Tamarillo::Config.new(notifier: Tamarillo::Notification::SPEECH)
+      config.notifier = 'bogus'
+      config.notifier.should == Tamarillo::Notification::SPEECH
+    end
+
+    it "has a default value" do
+      config = Tamarillo::Config.new
+      config.notifier.should == Tamarillo::Notification::BELL
+    end
+  end
+
+  describe "read from YAML" do
+    let(:sample_config_path) { Pathname.new('spec/support/sample-config.yml') }
+    let(:invalid_config_path) { Pathname.new('spec/support/invalid-config.yml') }
+
+    describe "duration value" do
+      it "can read the duration from YAML" do
+        config = Tamarillo::Config.load(sample_config_path)
+        config.duration_in_seconds.should == 30 * 60
+      end
+
+      it "uses the default duration if the YAML is malformed" do
+        config = Tamarillo::Config.load(invalid_config_path)
+        config.duration_in_seconds.should == default_duration * 60
+      end
+    end
+
+    describe "notifier value" do
+      it "can read the notifier from YAML" do
+        config = Tamarillo::Config.load(sample_config_path)
+        config.notifier.should == Tamarillo::Notification::GROWL
+      end
+
+      it "uses the default value if the YAML is malformed" do
+        config = Tamarillo::Config.load(invalid_config_path)
+        config.notifier.should == Tamarillo::Notification::BELL
+      end
+    end
+
+    it "creates a default config when path is missing" do
+      config_path = Pathname.new('some/invalid/path')
+      config = Tamarillo::Config.load(config_path)
+      config.duration_in_seconds.should == default_duration * 60
+    end
+  end
+
+  describe "write to YAML" do
+    before do
+      FileUtils.mkdir('tmp') unless File.directory?('tmp')
+    end
+
+    it "can be written to YAML" do
+      config = Tamarillo::Config.new
+      config.duration_in_minutes = 5
+      config.write('tmp/write-test.yml')
+
+      File.read('tmp/write-test.yml').should include('duration: 5')
+    end
+  end
+
+  describe "dumping YAML" do
+    it "outputs a YAML format" do
+      config = Tamarillo::Config.new
+      yaml = config.to_yaml
+      yaml.should == <<EOS
+---
+duration: 25
+notifier: bell
+EOS
+    end
+  end
+end

data/spec/lib/tamarillo/controller_spec.rb

@@ -0,0 +1,137 @@
+require_relative '../../../lib/tamarillo/controller'
+
+describe Tamarillo::Controller do
+  let(:config) { double('config') }
+  let(:storage) { double('storage') }
+
+  subject { Tamarillo::Controller.new(config, storage) }
+
+  describe "#status" do
+    let(:tomato) do
+      stub(:remaining => 1500, :duration => 1500, :active? => true)
+    end
+    let(:storage) { stub(:latest => tomato) }
+
+    it "can return a humanized format" do
+      subject.status(Tamarillo::Formats::HUMAN).should == 'About 25 minutes'
+    end
+
+    it "can return a machine optimized format" do
+      subject.status(Tamarillo::Formats::PROMPT).should == '25:00 1500 1500'
+    end
+
+    it "complains if the format is invalid" do
+      expect { subject.status('invalid') }
+        .should raise_error
+    end
+
+    it "returns nil if no active tomato" do
+      tomato.stub(:active?) { false }
+      subject.status(Tamarillo::Formats::HUMAN).should be_nil
+    end
+  end
+
+  describe "#start_new_tomato" do
+    before do
+      config.stub(:duration_in_seconds => 1500)
+      config.stub(:notifier => nil)
+      storage.stub(:write_monitor)
+      # Prevent monitor forking while testing.
+      Tamarillo::Monitor.any_instance.stub(:start)
+    end
+
+    it "stores a new tomato" do
+      storage.stub(:latest => nil)
+      storage.should_receive(:write_tomato)
+
+      subject.start_new_tomato
+    end
+
+    it "does nothing if a tomato is already in progress." do
+      tomato = stub(:active? => true)
+      storage.stub(:latest => tomato)
+      storage.should_not_receive(:write_tomato)
+
+      subject.start_new_tomato
+    end
+
+    it "uses the configured duration" do
+      storage.stub(:latest => nil)
+      storage.stub(:write_tomato)
+      Tamarillo::Tomato.should_receive(:new).with(1500, anything)
+
+      subject.start_new_tomato
+    end
+
+    it "uses a current clock" do
+      storage.stub(:latest => nil)
+      storage.stub(:write_tomato)
+      Tamarillo::Clock.should_receive(:now)
+
+      subject.start_new_tomato
+    end
+
+    it "returns the started tomato" do
+      storage.stub(:latest => nil)
+      storage.stub(:write_tomato)
+      subject.start_new_tomato.should be_a(Tamarillo::Tomato)
+    end
+  end
+
+  describe "#interrupt_current_tomato" do
+    before do
+      storage.stub(:read_monitor)
+    end
+
+    it "interrupts the current tomato" do
+      tomato = double('tomato')
+      tomato.should_receive(:interrupt!)
+      storage.stub(:write_tomato)
+      storage.should_receive(:latest).and_return(tomato)
+
+      subject.interrupt_current_tomato
+    end
+
+    it "doesn't raise if no tomato is present" do
+      storage.should_receive(:latest).and_return(nil)
+      expect { subject.interrupt_current_tomato }
+        .should_not raise_error(NoMethodError)
+    end
+
+    it "writes the tomato" do
+      tomato = double('tomato')
+      tomato.stub(:interrupt!)
+      storage.stub(:latest => tomato)
+      storage.should_receive(:write_tomato).with(tomato)
+
+      subject.interrupt_current_tomato
+    end
+  end
+
+  describe "#config" do
+    it "returns the passed in config" do
+      subject.config.should == config
+    end
+  end
+
+  describe "#update_config" do
+    before do
+      storage.stub(:write_config)
+    end
+
+    it "can update the duration" do
+      config.should_receive(:duration=).with(10)
+      subject.update_config(:duration => 10)
+    end
+
+    it "ignores bogus arguments" do
+      config.should_not_receive(:foo=).with('bar')
+      subject.update_config(:foo => 'bar')
+    end
+
+    it "writes the config" do
+      storage.should_receive(:write_config)
+      subject.update_config
+    end
+  end
+end