thyme 0.0.10 → 0.0.16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5abf29ab5c23ad3c627e59ba2359fe9edadd4e29d3a9867a8bd5544bc3f4b9a1
+  data.tar.gz: 843d993b305a5e72067ba9e426f0b840fdc3f5f352c092fb3dff46087558c809
+SHA512:
+  metadata.gz: 8258374971ba89526629690016690128b84cd3ba7a77adfaead03cdac0f463db4df4dbf02462938194f64483a9bd2f16fdd0a96c73a3f4a659745ffa401c4c52
+  data.tar.gz: 9bf433d64f8268e896a385e49777bb25d279f2b98af52bfc24c5598710dc1635a2161a54de9012aad992f762c9148b56dd45b816d699dc34e3322c7dad7d0796

data/README.md

@@ -1,74 +1,76 @@
-Description
-===========
+# Description
 
 Thyme is a console pomodoro timer.
 
-Installation
-============
+# Installation
 
     $ gem install thyme
 
-Usage
-=====
+# Usage
 
 Start thyme with:
 
     $ thyme
     [=                                        ] 24:59
 
-You'll have 25 minutes by default.  `Ctrl-C` to interrupt.  You can also start
+You'll have 25 minutes by default. `Ctrl-C` to interrupt. You can also start
 it in daemon mode, which is only useful if you've got tmux integration to notify
 you of the timer:
 
     $ thyme -d
 
-To interrupt the timer in daemon mode, simply run `thyme --stop`.  Or wait 25
-minutes for it to kill itself.
+Some other useful commands:
 
-Configure
-=========
+    $ thyme           # run again to pause/unpause
+    $ thyme -s        # stops daemon
+    $ thyme -d -r     # repeats timer until you manually stop it
+    $ thyme -d -r 10  # repeats timer exactly 10 times
 
-Thyme is configurable and extensible.  All configurations live in the
-`~/.thymerc` file:
+# Configure
 
-    set :timer, 25*60
-    set :interval, 1
-    set :tmux, true
-    set :tmux_theme, "#[fg=mycolor,bg=mycolor]#[fg=%s]%s#[fg=mycolor,bg=mycolor]"
+Configurations live in the `~/.thymerc` file:
 
-    option :b, :break, 'start a break' do
-      set :timer, 5*60
-      run
-    end
+    set :timer, 25*60              # 25 minute pomodoros
+    set :timer_break, 5*60         # 5 minute breaks
+    set :warning, 5*60             # show warning color in tmux at <5 minutes, 0 to disable
+    set :warning_color, 'red,bold' # warning color for tmux is red/bold
+    set :break_color, 'blue'       # break color is blue
+    set :interval, 1               # refresh timer every 1 second
+    set :tmux, true                # turn on tmux integration
+    set :tmux_theme, "#[fg=mycolor,bg=mycolor]#[fg=%s]%s#[fg=mycolor,bg=mycolor]"
 
+    # adds `-t --today` option, which opens a text file in vim
     option :t, :today, 'open today sheet' do
       `vim -O ~/.thyme-today.md ~/.thyme-records.md < \`tty\` > \`tty\``
     end
 
-    before do
-      `mplayer ~/music/flight-of-the-bumble-bee.mp3 &`
+    # adds `-s --seconds num` option, which allows on the fly timer
+    option :s, 'seconds num', 'run with custom seconds' do |num|
+      set :timer, num.to_i
+      @run = true
     end
 
-    after do |seconds_left|
-      `notify-send -u critical "Thymes Up!"` if seconds_left == 0
+    # execute hook before thyme program starts
+    before(:all) do
+      `mplayer ~/music/flight-of-the-bumble-bee.mp3 &`
     end
 
-The `set` method sets different configurations.  There are only two:
-
-* `:timer` is the number of seconds to countdown from
-* `:interval` is the refresh rate of the progress bar and tmux status in seconds
-* `:tmux` is whether or not you want tmux integration on (off by default)
-* `:tmux_theme` optionally lets you format the tmux status
+    # execute hook before each pomodoro
+    before do
+      `terminal-notifier -message "Let's get started!"`
+    end
 
-The `option` method adds new options to the `thyme` command.  In the above
-example, we can now execute `thyme -b` or `thyme -t`.  Use `thyme -h` to see
-available options.
+    # execute hook after each pomodoro
+    after do |seconds_left|
+      `terminal-notifier -message "Thyme's Up!"` if seconds_left == 0
+    end
 
-The `before` and `after` adds hooks to our timer.  Now before the timer starts,
-an mp3 will play.  After the timer ends, a notification will be sent.
+    # execute hook after thyme program quits
+    after(:all) do
+      `mplayer ~/music/victory.mp3 &`
+    end
 
-Integration
-===========
+# Tmux
 
 For tmux integration, make sure to set the `:tmux` option in `~/.thymerc`:
 
@@ -79,14 +81,55 @@ Then in your `.tmux.conf` file:
     set-option -g status-right '#(cat ~/.thyme-tmux)'
     set-option -g status-interval 1
 
-For vim integration, I like to execute `thyme -d` to toggle the timer.  This only
+For vim integration, I like to execute `thyme -d` to toggle the timer. This only
 works if you have tmux integration setup for the countdown:
 
     nmap <leader>t :!thyme -d<cr>
-    nmap <leader>T :!thyme -s<cr>
 
-License
-=======
+# Plugins
+
+Thyme's functionality can also be extended with plugins. They'll usually be installed
+in `~/.thymerc` like this:
+
+    require 'thyme_growl'
+    use ThymeGrowl, text: 'Go take a break!'
+
+You can create your own plugins. They implement these methods:
+
+    class MyThymePlugin
+      def initialize(thyme, options={})
+        # `thyme` is an instance of Thyme::Config (see lib/thyme/config.rb)
+
+        # adds `-t --today` option, which opens a text file in vim
+        thyme.option :t, :today, 'open today sheet' do
+          `vim -O ~/.thyme-today.md ~/.thyme-records.md < \`tty\` > \`tty\``
+        end
+      end
+
+      def before_all
+        # code to run when thyme starts up
+      end
+
+      def before
+        # code to run when timer starts
+      end
+
+      def tick(seconds_left)
+        # code to run each tick
+      end
+
+      def after(seconds_left)
+        # code to run when timer stops
+      end
+
+      def after_all
+        # code to run when thyme program ends
+      end
+    end
+
+The `before_all`, `before`, `tick`, `after`, and `after_all` methods are all optional.
+
+# License
 
 Copyright Hugh Bien - http://hughbien.com.
 Released under BSD License, see LICENSE.md for more info.

data/bin/thyme

@@ -1,17 +1,19 @@
 #!/usr/bin/env ruby
 require 'optparse'
-require File.expand_path('thyme', File.join(File.dirname(__FILE__), '..', 'lib'))
+require_relative '../lib/thyme'
 
 $0 = 'thyme'
 ARGV.options do |o|
-  thyme = Thyme.new
-  thyme.load_config(o)
+  thyme = Thyme::Console.new
   o.set_summary_indent('  ')
-  o.banner =    "Usage: #{File.basename($0)} [OPTION]"
+  o.banner = "Usage: #{File.basename($0)} [OPTION]"
   o.define_head "Timer for Pomodoro Technique"
+  o.on('-b', '--break', 'run break timer') { thyme.break! }
   o.on('-d', '--daemon', 'run in background') { thyme.daemonize! }
   o.on('-h', '--help', 'show this help message') { puts o; exit }
-  o.on('-s', '--stop', 'stops timer') { thyme.stop; exit }
+  o.on('-r', '--repeat [COUNT]', 'repeat timer') { |count| thyme.repeat!(count) }
+  o.on('-s', '--stop', 'stops running timer') { thyme.stop; exit }
+  thyme.load(o)
   o.parse!
   thyme.run
 end

data/lib/thyme.rb

@@ -1,120 +1,10 @@
-require 'ruby-progressbar'
 require 'date'
-
-class Thyme
-  VERSION = '0.0.10'
-  CONFIG_FILE = "#{ENV['HOME']}/.thymerc"
-  PID_FILE = "#{ENV['HOME']}/.thyme-pid"
-  TMUX_FILE = "#{ENV['HOME']}/.thyme-tmux"
-  OPTIONS = [:timer, :tmux, :interval, :tmux_theme]
-
-  def initialize
-    @timer = 25 * 60
-    @tmux = false
-    @interval = 1
-    @tmux_theme = "#[default]#[fg=%s]%s#[default]" 
-  end
-
-  def run
-    before_hook = @before
-    seconds_start = @timer
-    seconds_left = seconds_start + 1
-    start_time = DateTime.now
-    min_length = (seconds_left / 60).floor.to_s.length
-    tmux_file = File.open(TMUX_FILE, "w")
-    bar = ProgressBar.create(
-      title: format(seconds_left-1, min_length),
-      total: seconds_start,
-      length: 50,
-      format: '[%B] %t')
-    while seconds_left > 0
-      seconds_passed = seconds_since(start_time)
-      seconds_left = [seconds_start - seconds_passed, 0].max
-      title = format(seconds_left, min_length)
-      fg = color(seconds_left)
-      bar.title = title
-      bar.progress = seconds_passed
-      if @tmux
-        tmux_file.truncate(0)
-        tmux_file.rewind
-        tmux_file.write(@tmux_theme % [fg, title])
-        tmux_file.flush
-      end
-      if before_hook
-        self.instance_exec(&before_hook)
-        before_hook = nil
-      end
-      sleep(@interval)
-    end
-  rescue SignalException => e
-    puts ""
-  ensure
-    tmux_file.close
-    File.delete(TMUX_FILE) if File.exists?(TMUX_FILE)
-    File.delete(PID_FILE) if File.exists?(PID_FILE)
-    seconds_left = [seconds_start - seconds_since(start_time), 0].max
-    self.instance_exec(seconds_left, &@after) if @after
-  end
-
-  def stop
-    return if !File.exists?(PID_FILE)
-    pid = File.read(PID_FILE).to_i
-    File.delete(PID_FILE)
-    Process.kill('TERM', pid) if pid > 1
-  end
-
-  def daemonize!
-    Process.daemon
-    File.open(PID_FILE, "w") { |f| f.print(Process.pid) }
-  end
-
-  def set(opt, val)
-    raise ThymeError.new("Invalid option: #{opt}") if !OPTIONS.include?(opt.to_sym)
-    self.instance_variable_set("@#{opt}", val)
-  end
-
-  def before(&block)
-    @before = block
-  end
-
-  def after(&block)
-    @after = block
-  end
-
-  def option(optparse, short, long, desc, &block)
-    optparse.on("-#{short}", "--#{long}", desc) { self.instance_exec(&block); exit }
-  end
-
-  def load_config(optparse)
-    return if !File.exists?(CONFIG_FILE)
-    app = self
-    Object.class_eval do
-      define_method(:set) { |opt,val| app.set(opt,val) }
-      define_method(:before) { |&block| app.before(&block) }
-      define_method(:after) { |&block| app.after(&block) }
-      define_method(:option) { |sh,lo,desc,&b| app.option(optparse,sh,lo,desc,&b) }
-    end
-    load(CONFIG_FILE, true)
-  end
-
-  private
-  def seconds_since(time)
-    ((DateTime.now - time) * 24 * 60 * 60).to_i
-  end
-
-  def format(seconds, min_length)
-    min = (seconds / 60).floor
-    lead = ' ' * (min_length - min.to_s.length)
-    sec = (seconds % 60).floor
-    sec = "0#{sec}" if sec.to_s.length == 1
-    @interval < 60 ?
-      "#{lead}#{min}:#{sec}" :
-      "#{lead}#{min}m"
-  end
-
-  def color(seconds)
-    seconds < (5*60) ? 'red,bold' : 'default'
-  end
-end
-
-class ThymeError < StandardError; end;
+require 'ruby-progressbar'
+require_relative 'thyme/config'
+require_relative 'thyme/console'
+require_relative 'thyme/error'
+require_relative 'thyme/format'
+require_relative 'thyme/hooks_plugin'
+require_relative 'thyme/timer'
+require_relative 'thyme/tmux'
+require_relative 'thyme/version'

data/lib/thyme/config.rb

@@ -0,0 +1,78 @@
+module Thyme
+  # Configure state for the application. This can be done via the thymerc file or CLI flags.
+  # Public methods in this file are exposed to the thymerc file.
+  class Config
+    CONFIG_FILE = "#{ENV['HOME']}/.thymerc"
+    PID_FILE = "#{ENV['HOME']}/.thyme-pid"
+    TMUX_FILE = "#{ENV['HOME']}/.thyme-tmux"
+    OPTIONS = [:default_color, :break_color, :interval, :timer, :timer_break, :tmux, :tmux_theme, :warning, :warning_color]
+    OPTIONS.each { |opt| attr_reader(opt) }
+    attr_accessor :break, :daemon, :repeat, :repeat_index, :optparse
+
+    def initialize
+      # options set via config file
+      @break_color = 'default'
+      @default_color = 'default'
+      @interval = 1
+      @timer = 25 * 60
+      @timer_break = 5 * 60
+      @tmux = false
+      @tmux_theme = "#[default]#[fg=%s]%s#[default]" 
+      @warning = 5 * 60
+      @warning_color = 'red,bold'
+
+      # plugins set via config file
+      @plugins = []
+      @hooks_plugin = use(Thyme::HooksPlugin)
+
+      # settings via command line
+      @break = false
+      @daemon = false
+      @repeat = 1
+      @repeat_index = 1
+    end
+
+    def set(opt, val)
+      raise Thyme::Error.new("Invalid option: #{opt}") if !OPTIONS.include?(opt.to_sym)
+      self.instance_variable_set("@#{opt}", val)
+    end
+
+    def use(plugin_class, *args, &block)
+      plugin = plugin_class.new(self, *args, &block)
+      @plugins << plugin
+      plugin
+    end
+
+    def before(kind = :each, &block)
+      type = kind == :all ? :before_all : :before
+      @hooks_plugin.add(type, &block)
+    end
+
+    def after(kind = :each, &block)
+      type = kind == :all ? :after_all : :after
+      @hooks_plugin.add(type, &block)
+    end
+
+    def tick(&block)
+      @hooks_plugin.add(:tick, &block)
+    end
+
+    def option(short, long, desc, &block)
+      return if !@optparse
+      @optparse.on("-#{short}", "--#{long}", desc) do |*args|
+        self.instance_exec(*args, &block)
+        exit if !@run
+      end
+    end
+
+    def send_to_plugin(message, *args)
+      @plugins.each do |plugin|
+        begin
+          plugin.public_send(message, *args) if plugin.respond_to?(message)
+        rescue
+          $stderr.puts "Exception raised from #{plugin.class}:", $!, $@
+        end
+      end
+    end
+  end
+end

data/lib/thyme/console.rb

@@ -0,0 +1,58 @@
+module Thyme
+  # Exposes application to the CLI in bin/thyme
+  class Console
+    attr_accessor :config
+
+    def initialize
+      @config = Config.new
+    end
+
+    def break!
+      @config.break = true
+    end
+
+    def daemonize!
+      @config.daemon = true
+      Process.daemon if !ENV['THYME_TEST']
+    end
+
+    def repeat!(count = 0)
+      @config.repeat = count.to_i
+    end
+
+    def stop
+      timer.stop
+    end
+
+    def run
+      timer.run
+    end
+
+    # Loads the thymerc configuration file. Requires optparse b/c users can extend CLI via thymerc
+    def load(optparse, &block)
+      return if block.nil? && !File.exists?(Config::CONFIG_FILE)
+      config = @config
+      config.optparse = optparse
+      environment = Class.new do
+        define_method(:set) { |opt,val| config.set(opt,val) }
+        define_method(:use) { |plugin,*args,&b| config.use(plugin,*args,&b) }
+        define_method(:before) { |*args,&block| config.before(*args,&block) }
+        define_method(:after) { |*args,&block| config.after(*args,&block) }
+        define_method(:tick) { |&block| config.tick(&block) }
+        define_method(:option) { |sh,lo,desc,&b| config.option(sh,lo,desc,&b) }
+      end.new
+
+      if block # for test environment
+        environment.instance_eval(&block)
+      else
+        environment.instance_eval(File.read(Config::CONFIG_FILE), Config::CONFIG_FILE)
+      end
+    end
+
+    private
+
+    def timer
+      Timer.new(@config)
+    end
+  end
+end

data/lib/thyme/error.rb

@@ -0,0 +1,4 @@
+module Thyme
+  class Error < StandardError; end # catch all error for Thyme
+  class StopTimer < StandardError; end # used to stop repeat timers
+end

data/lib/thyme/format.rb

@@ -0,0 +1,43 @@
+module Thyme
+  # Methods used to nicely format output to the user
+  class Format
+    def initialize(config)
+      @config = config
+    end
+
+    def seconds_since(time)
+      ((DateTime.now - time) * 24 * 60 * 60).to_i
+    end
+
+    # Displays time depending on configured interval eg. 15m OR 15:20
+    def time_left(seconds, min_length)
+      min = (seconds / 60).floor
+      lead = ' ' * [0, min_length - min.to_s.length].max
+      sec = (seconds % 60).floor
+      sec = "0#{sec}" if sec.to_s.length == 1
+      @config.interval < 60 ?
+        "#{lead}#{min}:#{sec} #{repeat_subtitle}".sub(/\s*$/, '') :
+        "#{lead}#{min}m #{repeat_subtitle}".sub(/\s*$/, '')
+    end
+
+    def repeat_subtitle
+      if @config.repeat == 1
+        ''
+      elsif @config.repeat == 0
+        "(#{@config.repeat_index})"
+      else
+        "(#{@config.repeat_index}/#{@config.repeat})"
+      end
+    end
+
+    def tmux_color(seconds)
+      if @config.break
+        @config.break_color
+      elsif seconds < @config.warning
+        @config.warning_color
+      else
+        @config.default_color
+      end
+    end
+  end
+end

data/lib/thyme/hooks_plugin.rb

@@ -0,0 +1,33 @@
+module Thyme
+  # Generic plugin for users to run Ruby code in Thyme event callbacks in thymerc
+  class HooksPlugin
+    def initialize(config)
+      @config = config
+      @hooks = {before_all: [], before: [], tick: [], after: [], after_all: []}
+    end
+
+    def add(type, &block)
+      @hooks[type] << block
+    end
+
+    def before_all
+      @hooks[:before_all].each { |b| @config.instance_exec(&b) }
+    end
+
+    def before
+      @hooks[:before].each { |b| @config.instance_exec(&b) }
+    end
+
+    def tick(seconds_left)
+      @hooks[:tick].each { |t| @config.instance_exec(seconds_left, &t) }
+    end
+
+    def after(seconds_left)
+      @hooks[:after].each { |a| @config.instance_exec(seconds_left, &a) }
+    end
+
+    def after_all
+      @hooks[:after_all].each { |a| @config.instance_exec(&a) }
+    end
+  end
+end

data/lib/thyme/timer.rb

@@ -0,0 +1,124 @@
+module Thyme
+  # The actual timer logic where you can pause, unpause, or stop one or more timers
+  class Timer
+    def initialize(config)
+      @config = config
+      @format = Format.new(config)
+      @tmux = Tmux.new(config)
+    end
+
+    def stop
+      send_signal('TERM')
+    end
+
+    def run
+      # pause/unpause timer if it's already running
+      send_signal('USR1') and return if File.exists?(Config::PID_FILE)
+
+      begin
+        File.open(Config::PID_FILE, "w") { |f| f.print(Process.pid) }
+        @tmux.open
+        if @config.repeat == 1
+          run_single
+        else
+          while @config.repeat_index <= @config.repeat || @config.repeat == 0
+            @config.break = false
+            run_single
+            if @config.repeat_index < @config.repeat || @config.repeat == 0
+              @config.break = true
+              run_single
+            end
+            @config.repeat_index += 1
+          end
+        end
+      rescue Thyme::StopTimer
+        # stop signal received
+      ensure
+        @tmux.close
+        File.delete(Config::PID_FILE) if File.exists?(Config::PID_FILE)
+      end
+    end
+
+    private
+
+    # TODO: refactor this method, too large!
+    def run_single
+      seconds_total = @config.break ? @config.timer_break : @config.timer
+      seconds_left = seconds_total + 1
+      start_time = DateTime.now
+      paused_time = nil
+      min_length = (seconds_left / 60).floor.to_s.length
+      started = false
+      @bar ||= ENV['THYME_TEST'].nil? && !@config.daemon ?
+        ProgressBar.create(
+          title: @format.time_left(seconds_left-1, min_length),
+          total: seconds_total,
+          length: 50,
+          format: '[%B] %t') : nil
+      @bar.reset if @bar
+      while seconds_left > 0
+        begin
+          if paused_time
+            sleep(@config.interval)
+            next
+          end
+          seconds_passed = @format.seconds_since(start_time)
+          seconds_left = [seconds_total - seconds_passed, 0].max
+          title = @format.time_left(seconds_left, min_length)
+          if @bar
+            @bar.title = title
+            if seconds_left == 0 && !last?
+              @bar.progress = seconds_passed - 0.01 # prevent bar from finishing
+            else
+              @bar.progress = seconds_passed
+            end
+          end
+          @tmux.tick(@format.tmux_color(seconds_left), title)
+          unless started
+            started = true
+            @config.send_to_plugin(:before_all) if first?
+            @config.send_to_plugin(:before)
+          end
+          @config.send_to_plugin(:tick, seconds_left)
+          sleep(@config.interval)
+        rescue SignalException => e
+          if e.signm == 'SIGUSR1' && paused_time.nil?
+            paused_time = DateTime.now
+          elsif e.signm == 'SIGUSR1'
+            delta = DateTime.now - paused_time
+            start_time += delta
+            paused_time = nil
+          else
+            puts ""
+            @interrupted = true
+            raise Thyme::StopTimer
+          end
+        end
+      end
+    ensure
+      seconds_left = [seconds_total - @format.seconds_since(start_time), 0].max
+      @config.send_to_plugin(:after, seconds_left)
+      @config.send_to_plugin(:after_all) if @interrupted || last?
+    end
+
+    def first?
+      @config.repeat == 1 || (!@config.break && @config.repeat_index == 1)
+    end
+
+    def last?
+      @config.repeat == @config.repeat_index
+    end
+
+    # Since timers can be daemonized, we'll use Unix signals to trigger events such as
+    # pause/unpause in a separate process.
+    def send_signal(signal)
+      pid = File.read(Config::PID_FILE).to_i
+      Process.kill(signal, pid) if pid > 1
+    rescue Errno::ESRCH, Errno::ENOENT # process is already dead, cleanup files
+      File.delete(Config::TMUX_FILE) if File.exists?(Config::TMUX_FILE)
+      File.delete(Config::PID_FILE) if File.exists?(Config::PID_FILE)
+    ensure
+      true
+    end
+  end
+end

data/lib/thyme/tmux.rb

@@ -0,0 +1,31 @@
+module Thyme
+  # Provides tmux integration. Thyme outputs the timer to TMUX_FILE. Tmux reads this file and
+  # outputs to its bar.
+  class Tmux
+    def initialize(config)
+      @config = config
+    end
+
+    def open
+      return if !@config.tmux
+      @tmux_file = File.open(Config::TMUX_FILE, "w")
+      @tmux_file.truncate(0)
+      @tmux_file.rewind
+      @tmux_file.write('')
+      @tmux_file.flush
+    end
+
+    def tick(color, title)
+      return if !@tmux_file
+      @tmux_file.truncate(0)
+      @tmux_file.rewind
+      @tmux_file.write(@config.tmux_theme % [color, title])
+      @tmux_file.flush
+    end
+
+    def close
+      @tmux_file.close if @tmux_file
+      File.delete(Config::TMUX_FILE) if File.exists?(Config::TMUX_FILE)
+    end
+  end
+end

data/lib/thyme/version.rb

@@ -0,0 +1,3 @@
+module Thyme
+  VERSION = '0.0.16'
+end

metadata

@@ -1,32 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: thyme
 version: !ruby/object:Gem::Version
-  version: 0.0.10
-  prerelease: 
+  version: 0.0.16
 platform: ruby
 authors:
 - Hugh Bien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-07 00:00:00.000000000 Z
+date: 2020-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 description: Extensible and configurable timer for Pomodoro Technique.
 email:
 - hugh@hughbien.com
@@ -39,28 +36,35 @@ files:
 - README.md
 - bin/thyme
 - lib/thyme.rb
-homepage: http://thymerb.com
-licenses: []
+- lib/thyme/config.rb
+- lib/thyme/console.rb
+- lib/thyme/error.rb
+- lib/thyme/format.rb
+- lib/thyme/hooks_plugin.rb
+- lib/thyme/timer.rb
+- lib/thyme/tmux.rb
+- lib/thyme/version.rb
+homepage: http://hughbien.com/thyme/
+licenses:
+- BSD
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 3.1.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Timer for Pomodoro Technique
 test_files: []