breaktime 0.1.2

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Cairns
+
+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,73 @@
+# Breaktime
+
+Breaktime loves your eyes. That's why it gives them a screen break every so often - as often as you like. It hides in the background, waiting for it's moment to shine. When it's time for you to take a break it opens a dialog box with a timer counting down from 10, giving you the chance to cancel. But when the timer hits zero your screensaver will pop up, forcing you to go and make some tea/coffee/mojitos.
+
+You can set how often it runs, which day(s) of the week it runs, and which system command you want to execute when it's time for a break. All of this can be configured with some lovely YAML.
+
+## Installation
+
+As breaktime is a ruby gem, you need to have access to the rubygems command line tool, `gem`. If you do, installation will hopefully be as simple as:
+
+    $ gem install breaktime
+
+But breaktime depends on the [green_shoes](https://github.com/ashbb/green_shoes) gem, which itself depends on gtk2. Building this gem requires native extensions, so you will need to have the right libraries to get it to install.
+
+## Usage
+
+After installing you have access to the `breaktime` command line tool.
+
+```bash
+$ breaktime --help
+NAME
+  breaktime
+
+SYNOPSIS
+  breaktime (start|stop|dialog|now) [options]+
+
+DESCRIPTION
+  Give your eyes scheduled screen breaks
+
+PARAMETERS
+  --config, -c <s>:   Configuration yaml file (default: /home/jon/.breaktime.yml)
+   --level, -l <s>:   Output level = (debug|info|warn|error|fatal) (default: info)
+        --help, -h:   Show this message
+```
+
+Simply running `breaktime` on its own should work - it will run every 60 minutes by default, and will try and work out the right screensaver command for your OS and window manager. If it can't work out your OS, then you can just set the **command** in the YAML file (read on).
+
+If you want to do a bit more fine-tuning, create a YAML file at `$HOME/.breaktime.yml` that looks like this (everything's optional):
+
+```yml
+command: xscreensaver-command -a
+interval: 40
+daemonize: true
+log_file: /path/to/log/file.log
+pid_file: /path/to/pid/file.pid
+days:
+  - monday
+  - tuesday
+  - wednesday
+  - thursday
+  - friday
+```
+
+* **command** is the system command run every break time
+* **interval** is the time, in minutes, between each break
+* **daemonize** says whether the scheduling should run as a background process (daemon)
+* **log_file** specifies the file that output is written to (only if **daemonize** is true)
+* **pid_file** specifies the file that contains the PID (only if **daemonize** is true)
+* **days** allows you to specify which days of the week to run it
+
+If you want your YAML file to be elsewhere, then just pass it as the `--config` parameter to the breaktime command.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT

data/Rakefile

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

data/bin/breaktime

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'breaktime'
+Breaktime::Main.start

data/breaktime.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'breaktime/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "breaktime"
+  gem.version       = Breaktime::VERSION
+  gem.authors       = ["Jon Cairns"]
+  gem.email         = ["jon@joncairns.com"]
+  gem.description   = %q{Enforce screen breaks at regular intervals, when you want them}
+  gem.summary       = %q{Breaktime}
+  gem.homepage      = "https://github.com/joonty/breaktime"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = ['breaktime']
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib","lib/breaktime"]
+  gem.add_dependency 'green_shoes', '~> 1.1.373'
+  gem.add_dependency 'trollop', '~> 2.0.0'
+  gem.add_dependency 'rufus-scheduler', '~> 2.0.17'
+  gem.add_dependency 'log4r', '~> 1.1.10'
+  gem.add_dependency 'dante', '~> 0.1.5'
+end

data/lib/breaktime.rb

@@ -0,0 +1,26 @@
+# The encapsulating module for the breaktime gem.
+#
+# Breaktime gives you regular screen breaks on a schedule that you choose.
+#
+# This should be run as the command line tool `breaktime`. For more information
+# try running `breaktime --help`.
+module Breaktime
+  lib_dir = File.dirname(__FILE__) + File::SEPARATOR + 'breaktime'
+  $:.unshift lib_dir
+
+  # Exit status codes.
+  EX_OK = 0                # Everything fine
+  EX_UNKNOWN = 1           # Unknown exception
+  EX_OS_UNKNOWN = 2        # Unknown OS
+  EX_LINUX_WM_UNKNOWN = 3  # Unknown window manager (linux)
+  EX_SIGNAL = 128          # Process signal caught
+  EX_INTERRUPT = 130       # Control-C caught
+  EX_BREAK_CANCELLED = 254 # Cancel from the countdown GUI
+  EX_CLI = 255             # CLI option errors
+
+  require 'rubygems'
+  require 'bundler/setup'
+  require 'version'
+  require 'command'
+  require 'main'
+end

data/lib/breaktime/cli.rb

@@ -0,0 +1,55 @@
+require 'trollop'
+
+class Breaktime::CLI
+  attr_reader :options, :mode
+
+  # Available sub commands (modes) for CLI.
+  SUB_COMMANDS = %w(start stop dialog now)
+
+  # Default location of YAML config file.
+  DEFAULT_CONFIG = ENV['HOME'] + File::SEPARATOR + ".breaktime.yml"
+
+  def initialize
+    @options = parse_cli_options
+    @mode = ARGV.shift || 'start'
+  end
+
+	private
+  # Parse CLI options with Trollop.
+  def parse_cli_options
+    Trollop::options do
+      banner <<-BAN
+NAME
+  breaktime
+
+SYNOPSIS
+  breaktime (#{SUB_COMMANDS.join("|")}) [options]+
+
+DESCRIPTION
+  Give your eyes scheduled screen breaks by starting up the screensaver at 
+  regular intervals. By default it will give you a break every 60 minutes. 
+  It is configurable via a YAML file which sits at $HOME/.breaktime.yml by
+  default.
+
+USAGE
+  breaktime (start) - start breaktime, as a daemon by default
+  breaktime stop    - stop a daemonized process
+  breaktime now     - run the command to have a break instantly
+  breaktime dialog  - show the countdown dialog box
+
+PARAMETERS
+BAN
+
+      opt :config, 
+          "Configuration yaml file", 
+          :short => '-c', 
+          :default => DEFAULT_CONFIG
+
+      opt :level, 
+          "Output level = (debug|info|warn|error|fatal)", 
+          :short => '-l', 
+          :default => 'info'
+
+    end
+  end
+end

data/lib/breaktime/command.rb

@@ -0,0 +1,50 @@
+require 'linux_win_manager'
+
+# Used to determine and run the screensaver command.
+class Breaktime::Command
+  class OSUnknown < StandardError; end
+
+  attr_reader :command
+
+  # Determine the default screensaver command based on the user's OS.
+  #
+  # If Linux, use the LinuxWinManager class to determine the appropriate
+  # command.
+  def self.system_default(log)
+    case RbConfig::CONFIG['target_os']
+    when 'linux'
+      require 'linux_win_manager'
+      log.debug { "Using Linux, detecting window manager and appropriate command" }
+      Breaktime::LinuxWinManager.detect_command(log)
+
+    when 'darwin10'
+      log.debug { "Using Mac OSX10" }
+      'open -a /System/Library/Frameworks/ScreenSaver.framework/Versions/A/Resources/ScreenSaverEngine.app'
+
+    when /mswin.*$/
+      log.debug { "Using Windows" }
+      'rundll32.exe user32.dll,LockWorkStation'
+
+    else
+      raise OSUnknown, 'Unknown OS'
+    end
+  end
+
+  # Store the command if specified, or determine the system default.
+  def initialize(command, log)
+    @command = if command.nil?
+      self.class.system_default(log)
+    else
+      log.debug { "User defined command: #{command}" }
+      command
+    end
+  end
+
+  # Execute the command with Kernel#exec.
+  #
+  # This replaces the current process, exiting when the command exits.
+  def execute
+    exec @command
+  end
+
+end

data/lib/breaktime/dialog.rb

@@ -0,0 +1,30 @@
+require 'green_shoes'
+
+module Breaktime
+  # The shoes GUI app for notifying the user about their imminent breaktime.
+  #
+  # They have 10 seconds to cancel the break. If they cancel the process exits
+  # with EX_BREAK_CANCELLED, otherwise EX_OK. This is used by calling processes
+  # to determine what to do.
+  Shoes.app :height => 60, :width => 380, :title => 'Take a break!' do
+    seconds = 10
+    str = "Take a break! You have %d seconds to cancel."
+
+    background white
+    flow :margin => 4 do
+      @sent = para str % seconds
+
+      button "Cancel" do
+        exit Breaktime::EX_BREAK_CANCELLED
+      end
+
+      every 1 do |i|
+        if i >= seconds
+          exit Breaktime::EX_OK
+        else
+          @sent.text = str % (seconds - i)
+        end
+      end
+    end
+  end
+end

data/lib/breaktime/linux_win_manager.rb

@@ -0,0 +1,28 @@
+# Used to detect the Linux window manager.
+#
+# This information is used to determine the default screensaver command.
+class Breaktime::LinuxWinManager
+  # Thrown if the window manager can't be detected.
+  class ManagerUnknown < StandardError; end
+
+  @@managers = {'kcmserver' => 'dcop kdesktop KScreensaverIface lock',
+               'gnome-session' => 'gnome-screensaver-command -a',
+               'xfce-mcs-manage' => 'xscreensaver-command --lock'}
+
+  attr_reader :cmd
+
+  # Check the process list for known window manager services.
+  #
+  # If the service is found, return the associated command for starting the
+  # screensaver.
+  def self.detect_command(log)
+    log.debug { "Checking for known window manager processes: #{@@managers.keys.join(", ")}" }
+    lines = `ps -eo args|egrep "#{@@managers.keys.join("|")}"|grep -v "egrep"`.split "\n"
+
+    lines.any? or raise ManagerUnknown, 'Unable to detect a known window manager'
+
+    m = @@managers.keys.select {|k| lines.first.include? k}
+    log.debug { "Found #{m.first}" }
+    @@managers[m.first]
+  end
+end

data/lib/breaktime/main.rb

@@ -0,0 +1,209 @@
+require 'yaml'
+require 'log4r'
+require 'schedule'
+require 'dante'
+require 'cli'
+
+# Handles configuration options, CLI stuff and process daemonizing.
+class Breaktime::Main
+  include Log4r
+
+  attr_reader :options, :log, :cli
+
+  # Default options that can be overridden in the YAML file.
+  DEFAULT_OPTIONS = {'interval' => 60,
+                     'pid_path' => ENV['HOME'] + File::SEPARATOR + "breaktime.pid",
+                     'log_path' => ENV['HOME'] + File::SEPARATOR + "breaktime.log",
+                     'daemonize' => true,
+                     'days' => ['monday',
+                                'tuesday',
+                                'wednesday',
+                                'thursday',
+                                'friday',
+                                'saturday',
+                                'sunday']}
+
+  # Set up the logger, parse CLI options and the YAML file.
+  def initialize
+    create_logger 'error'
+    @cli = Breaktime::CLI.new
+    @options = DEFAULT_OPTIONS
+    set_log_level @cli.options[:level]
+
+    parse_yaml_file
+  end
+
+  # Exit with a trollop message.
+  def die(message)
+    Trollop::die message
+  end
+
+  # Print out the gem motto and exit with the given exit code.
+  def say_goodbye(exit_code)
+    puts "\n\s\sBreaktime says, \"Have a break, have an unbranded chocolate snack.\""
+    exit exit_code
+  end
+
+  # Run the given mode.
+  #
+  # The mode is one of the command line modes (run with the --help flag).
+  def run_mode(mode)
+    command = Breaktime::Command.new @options['command'], @log
+
+    # Switch on CLI mode.
+    case mode
+    # Schedule the breaktime.
+    when "start"
+      @log.info { "When it's breaktime I'll run: `#{command.command}`" }
+      startd
+
+    # Stop a currently running daemonized process.
+    when "stop"
+      @log.info { "Stopping breaktime background process" }
+      stopd
+      say_goodbye Breaktime::EX_OK
+
+    # Open a dialog to notify the user about an impending screen break.
+    when "dialog"
+			@log.info { "Opening dialog" }
+      require 'dialog'
+      # Automatically loads green shoes window
+
+    # Run the command that will start the break.
+    when "now"
+      command.execute
+
+    # Unknown mode.
+    else
+      die "unknown mode #{mode.inspect}"
+
+    end
+  end
+
+  # Start the scheduler as a daemon.
+  #
+  # The process can be kept on top if the "daemonize" option is set to be false
+  # in the configuration YAML file.
+  #
+  # The logger output format is changed to add the time, as this is more
+  # helpful for debugging.
+  #
+  # Uses Dante for daemonizing.
+  def startd
+    dante_opts = {:daemonize => @options['daemonize'], 
+                  :pid_path => @options['pid_path'], 
+                  :log_path => @options['log_path']}
+
+    if dante_opts[:daemonize]
+      @log.info { "Starting daemon, PID file => #{dante_opts[:pid_path]}, log file => #{dante_opts[:log_path]}" }
+    end
+
+    schedule = Breaktime::Schedule.new(@options['interval'], @options['days'], @cli.options, @log)
+
+    Dante::Runner.new('breaktime').execute(dante_opts) do
+      schedule.start
+    end
+  end
+
+  # Stop the daemonized process, if it is running.
+  def stopd
+    dante_opts = {:kill => true,
+                  :pid_path => @options['pid_path']}
+    Dante::Runner.new('breaktime').execute(dante_opts)
+  end
+
+  class << self
+    # Create a new Main object and run the mode given as a CLI parameter.
+    #
+    # Also rescue exceptions and display helpful messages.
+    # 
+    # TODO: tidy this up
+    def start
+      main = self.new
+      main.log.debug { "Starting cli mode: #{main.cli.mode}" }
+
+      begin
+        main.run_mode main.cli.mode
+      # Exception handling and appropriate exit codes.
+      rescue Breaktime::LinuxWinManager::ManagerUnknown
+        main.log.fatal do
+          <<-FATAL
+    It looks like you're using Linux, but I'm unable to detect your window manager to determine how to start your screensaver.
+
+    To get round this problem, just specify a "command" in your $HOME/.breaktime.yml file, and this will be executed at the start of your break.
+          FATAL
+        end
+        exit Breaktime::EX_LINUX_WM_UNKNOWN
+
+      rescue Breaktime::Command::OSUnknown
+        main.log.fatal do
+          <<-FATAL
+    I can't work out which operating system you're using. If you think this is unreasonable then please let me know on Github.
+
+    To get round this problem in the meantime, just specify a "command" in your $HOME/.breaktime.yml file, and this will be executed at the start of your break.
+            FATAL
+        end
+        exit Breaktime::EX_OS_UNKNOWN
+
+      rescue Interrupt
+        main.log.warn { "Caught Control-C, shutting down..." }
+        main.say_goodbye Breaktime::EX_INTERRUPT
+
+      rescue SignalException => e
+        main.log.warn { "Caught signal #{e.message}, shutting down..." }
+        main.say_goodbye Breaktime::EX_SIGNAL
+
+      rescue SystemExit
+        raise
+
+      rescue Exception => e
+        main.log.fatal { "Unexpected exception {#{e.class.name}}: #{e.message}" }
+        main.log.debug { $!.backtrace.join("\n\t") }
+        exit Breaktime::EX_UNKNOWN
+
+      end
+    end
+  end
+
+  private
+
+  # Create a Log4r logger with the given log level.
+  #
+  # The logger prints to stdout by default, and spits out the level, time and
+  # message.
+  def create_logger(level)
+    @log = Logger.new 'breaktime'
+    outputter = Outputter.stdout
+    outputter.formatter = PatternFormatter.new(:pattern => "[%l] %d :: %m")
+    @log.outputters << outputter
+    @log.level = ERROR
+  end
+
+  # Overwrite the current logger level.
+  def set_log_level(level)
+    @log.level = self.class.const_get(level.upcase)
+  end
+
+  # Parse the YAML configuration file.
+  #
+  # Any errors in the parsing cause the program to exit, but a YAML file is not
+  # required - the defaults are used if it doesn't exist.
+  #
+  # TODO: separate into separate module/class?
+  def parse_yaml_file
+    @log.debug { "Configuration yaml file: #{@cli.options[:config]}" }
+    if File.exist? @cli.options[:config]
+      begin
+        @options.merge! YAML.load_file(@cli.options[:config])
+      rescue Exception => e
+        @log.debug { e.message }
+        Trollop::die :config, "must be a valid yaml file"
+      end
+    elsif @cli.options[:config] != Breaktime::CLI::DEFAULT_CONFIG
+      Trollop::die :config, "must be a valid yaml file"
+    else
+      @log.warn { "No configuration file found at #{Breaktime::CLI::DEFAULT_CONFIG}, using defaults" }
+      @log.info { "Check the README for info on creating a configuration file" }
+    end
+  end
+end

data/lib/breaktime/schedule.rb

@@ -0,0 +1,84 @@
+require 'rufus/scheduler'
+
+# Schedule the running of the breaktime dialog and screensaver.
+#
+# Uses rufus-scheduler to schedule the task running.
+class Breaktime::Schedule
+  def initialize(interval, days, cli_options, log)
+    @interval = interval.to_s + 'm'
+    @cli_options = cli_options
+    @days = days
+    @log = log
+  end
+
+  # Start the scheduler to run at a given interval.
+  #
+  # The interval (60 minutes by default) can be set in the configuration YAML
+  # file. The days at which breaktime runs can also be set.
+  #
+  # When it's time to run, `run_dialog()` is called.
+  def start
+    scheduler = Rufus::Scheduler.start_new
+
+    @log.info { "Taking a break every #{@interval}" }
+
+    scheduler.every @interval do
+      t = Time.now
+      # Check whether the current day is included in the list
+      if @days.detect {|d| t.send(d + '?')}
+        @log.info { "Starting 10 second warning..." }
+        run_dialog
+      else
+        @log.info { "Not running breaktime today" }
+      end
+    end
+
+    scheduler.join
+  end
+
+  private
+  # Open the countdown dialog, showing the user their break is about to start.
+  #
+  # Only if the process returns the EX_OK status code will the screensaver
+  # command run.
+  #
+  # This calls `exec_self()`, which runs same process name as the current
+  # command, but runs it as a `system()` call. It passes the same CLI arguments
+  # as those passed by the user.
+  def run_dialog
+    retcode_d = exec_self "dialog", :level => 'error'
+
+    case retcode_d
+    when Breaktime::EX_OK
+      @log.info { "Taking a break..." }
+      retcode_i = exec_self "now", :level => 'error'
+      if retcode_i == 0
+        @log.info { "Command returned" }
+      else
+        @log.error { "Failed to run breaktime with the `now` mode" }
+      end
+    when Breaktime::EX_BREAK_CANCELLED
+      @log.warn { "Cancelled screen break" }
+    else
+      @log.error { "Failed to run breaktime with the `dialog` mode" }
+    end
+  end
+
+  # Execute the breaktime command with a given mode and CLI arguments.
+  #
+  # The exit code is returned.
+  def exec_self(mode, args = {})
+    arg_str = ''
+    @cli_options.merge(args).each do |n,v|
+      if v && !n.to_s.include?("_given")
+        arg_str += " --#{n} #{v}"
+      end
+    end
+    exec_str = "#{$PROGRAM_NAME} #{mode} #{arg_str}"
+    @log.debug { "Executing `#{exec_str}`" }
+    system exec_str
+    $?
+  end
+
+
+end

data/lib/breaktime/version.rb

@@ -0,0 +1,3 @@
+module Breaktime
+  VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: breaktime
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Jon Cairns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: green_shoes
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.373
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.373
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.17
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+- !ruby/object:Gem::Dependency
+  name: dante
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+description: Enforce screen breaks at regular intervals, when you want them
+email:
+- jon@joncairns.com
+executables:
+- breaktime
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/breaktime
+- breaktime.gemspec
+- lib/breaktime.rb
+- lib/breaktime/cli.rb
+- lib/breaktime/command.rb
+- lib/breaktime/dialog.rb
+- lib/breaktime/linux_win_manager.rb
+- lib/breaktime/main.rb
+- lib/breaktime/schedule.rb
+- lib/breaktime/version.rb
+homepage: https://github.com/joonty/breaktime
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/breaktime
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Breaktime
+test_files: []