muon 0.0.2

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in muon-cli.gemspec
+gemspec
+
+# gem 'ruby-debug19'

data/README.md

@@ -0,0 +1,52 @@
+muon
+=================
+
+muon is going to be a distributed time tracking tool. It already tracks time, but it's not distributed yet.
+
+Installation
+------------
+```
+gem install muon
+```
+
+Usage
+------------
+```
+cd ~/myproject
+muon init
+muon start
+# do some work
+muon stop
+muon log
+```
+
+You'll find more details via `muon help`.
+
+Configuration
+-------------
+You can set up some handy aliases:
+```
+muon config --global alias.a start
+muon config --global alias.z stop
+muon config --global alias.st status
+```
+
+Bash completion
+------------
+```
+source /path/to/muon/extras/muon-completion.bash
+```
+
+Bash prompt
+------------
+```
+source /path/to/muon/extras/muon-prompt.sh
+```
+Then add `$(__muon_ps1)` somewhere in your $PS1, for example:
+```
+export PS1='\w$(__muon_ps1) \$ '
+```
+Or with some colors:
+```
+export PS1='\w\[\033[31m\]$(__muon_ps1) \[\033[00m\]\$ '
+```

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList["test/*_test.rb"]
+end
+
+task :default => :test

data/bin/muon

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(__FILE__ + '/../../lib')
+
+require 'muon'
+require 'muon/app'
+require 'gli'
+
+include GLI
+
+program_desc 'muon tracks your working time'
+version Muon::VERSION
+
+desc 'Set up current directory as muon project'
+command :init do |c|
+  c.action do |global, options, arguments|
+    @app.init_directory
+  end
+end
+
+desc 'Start tracking time'
+command :start do |c|
+  c.action do |global, options, arguments|
+    @app.start_tracking(arguments[0])
+  end
+end
+
+desc 'Stop tracking time'
+command :stop do |c|
+  c.action do |global, options, arguments|
+    @app.stop_tracking(arguments[0])
+  end
+end
+
+desc 'Cancel current tracking entry'
+command :abort do |c|
+  c.action do |global, options, arguments|
+    @app.abort_tracking
+  end
+end
+
+desc 'Add complete tracking entry'
+command :commit do |c|
+  c.action do |global, options, arguments|
+    @app.commit_entry(arguments[0], arguments[1])
+  end
+end
+
+desc 'Display tracking status'
+command :status do |c|
+  c.action do |global, options, arguments|
+    @app.show_status
+  end
+end
+
+desc 'Display total time on given day'
+command :total do |c|
+  c.action do |global, options, arguments|
+    @app.show_total(arguments[0])
+  end
+end
+
+desc 'Display time entries'
+command :log do |c|
+  c.flag [:n, :"max-count"]
+  c.action do |global, options, arguments|
+    limit = options[:n] ? options[:n].to_i : nil
+    @app.show_log(limit)
+  end
+end
+
+desc 'Set or see goal for current month'
+command :goal do |c|
+  c.action do |global, options, arguments|
+    if arguments.length == 0
+      @app.show_goal
+    elsif arguments.length > 0
+      @app.set_goal(arguments[0])
+    end
+  end
+end
+
+desc 'Get or set config options'
+command :config do |c|
+  c.switch :global
+  c.action do |global, options, arguments|
+    if arguments.length == 1
+      @app.read_config_option(arguments[0], options)
+    elsif arguments.length > 1
+      @app.set_config_option(arguments[0], arguments[1], options)
+    end
+  end
+end
+
+desc 'Register project in ~/.muonprojects'
+command :register do |c|
+  c.action do |global, options, arguments|
+    @app.register_global_project
+  end
+end
+
+@app = Muon::App.new(Dir.pwd)
+
+exit GLI.run(@app.dealiasify(ARGV))

data/extras/muon-completion.bash

@@ -0,0 +1 @@
+complete -W "abort commit config goal help init log register start status stop total" muon

data/extras/muon-prompt.sh

@@ -0,0 +1,20 @@
+__muon_dir ()
+{
+    if [ -d ".muon" ]; then
+        echo ".muon"
+    else
+        echo ""
+    fi
+}
+
+__muon_ps1 ()
+{
+    local dir="$(__muon_dir)"
+    if [ -n "$dir" ]; then
+        if [ -f "$dir/current" ]; then
+            echo " [●]"
+        else
+            echo " [ ]"
+        fi
+    fi
+}

data/lib/muon.rb

@@ -0,0 +1 @@
+require 'muon/version'

data/lib/muon/app.rb

@@ -0,0 +1,136 @@
+require "time"
+require "chronic_duration"
+require "muon/config"
+require "muon/entry"
+require "muon/format"
+require "muon/project"
+
+module Muon
+  class App
+    def initialize(working_dir, home_dir = ENV["HOME"], output = $stdout)
+      @working_dir = working_dir
+      @home_dir = home_dir
+      @output = output
+      @project = Project.new(working_dir)
+      @config = Config.new(config_file, global_config_file)
+    end
+
+    attr_reader :project
+
+    def init_directory
+      project.init_directory
+    end
+
+    def start_tracking(start_time = nil)
+      start_time = Time.parse(start_time) if start_time
+      project.start_tracking(start_time)
+    end
+
+    def stop_tracking(end_time = nil)
+      end_time = Time.parse(end_time) if end_time
+      project.stop_tracking(end_time)
+    end
+
+    def abort_tracking
+      project.abort_tracking
+    end
+
+    def commit_entry(start_time, end_time)
+      start_time = Time.parse(start_time)
+      end_time = Time.parse(end_time)
+      project.commit_entry(start_time, end_time)
+    end
+
+    def show_status
+      if @project.tracking?
+        @output.puts "Time tracking is running since #{Format.duration @project.tracking_duration}."
+      else
+        @output.puts "Time tracking is stopped."
+      end
+      @output.puts "Today's total time is #{Format.duration @project.day_total_time(Time.now)}."
+    end
+
+    def show_total(date = nil)
+      if date.nil?
+        date = Time.now
+      else
+        date = Time.parse(date)
+      end
+      @output.puts "Total time on #{date.strftime('%Y-%m-%d')} is #{Format.duration @project.day_total_time(date)}."
+    end
+
+    def show_log(limit = nil)
+      entries = @project.history_entries
+      entries = entries.take(limit) if limit
+      entries.each do |entry|
+        @output.puts "#{entry.start_time} - #{entry.end_time} (#{Format.duration entry.duration})"
+      end
+    end
+
+    def show_goal
+      if project.has_goal?
+        @output.puts "The goal for this month is #{Format.duration project.goal}."
+        @output.puts "Time left to achieve this goal: #{Format.duration project.goal_remaining_time}."
+      else
+        @output.puts "No goal has been set."
+      end
+    end
+
+    def set_goal(duration)
+      duration = ChronicDuration.parse(duration)
+      project.goal = duration
+      @output.puts "Setting goal for this month to #{Format.duration duration}."
+    end
+
+    def dealiasify(args)
+      dealiased = @config.get_option("alias.#{args.first}")
+      if dealiased
+        [dealiased] + args.drop(1)
+      else
+        args
+      end
+    end
+
+    def read_config_option(key, options = {})
+      if options[:global]
+        @output.puts @config.get_global_option(key)
+      else
+        @output.puts @config.get_option(key)
+      end
+    end
+
+    def set_config_option(key, value, options = {})
+      if options[:global]
+        @config.set_global_option(key, value)
+      else
+        @config.set_option(key, value)
+      end
+    end
+
+    def global_projects
+      File.open(global_projects_file, "r") do |f|
+        f.lines.to_a.map(&:strip).map { |path| Project.new(path) }
+      end
+    end
+
+    def register_global_project
+      File.open(global_projects_file, "a") { |f| f << "#{@working_dir}\n" }
+    end
+
+    private
+
+    # attr_reader :history
+
+    def config_file
+      File.join(project.working_dir, "config")
+    end
+
+    def global_config_file
+      File.join(@home_dir, ".muonconfig") if @home_dir
+    end
+
+    def global_projects_file
+      File.join(@home_dir, ".muonprojects") if @home_dir
+    end
+  end
+end

data/lib/muon/config.rb

@@ -0,0 +1,66 @@
+require "yaml"
+
+module Muon
+  class Config
+    attr_reader :local_file, :global_file
+
+    def initialize(local_file, global_file)
+      @local_file, @global_file = local_file, global_file
+    end
+
+    def get_option(key)
+      get_local_option(key) || get_global_option(key)
+    end
+
+    def get_local_option(key)
+      get_option_from_file(local_file, key)
+    end
+
+    def set_local_option(key, value)
+      set_option_in_file(local_file, key, value)
+    end
+
+    alias :set_option :set_local_option
+
+    def get_global_option(key)
+      get_option_from_file(global_file, key)
+    end
+
+    def set_global_option(key, value)
+      set_option_in_file(global_file, key, value)
+    end
+
+    private
+
+    def get_option_from_file(file, key)
+      config = read_config_file(file) || {}
+      group, name = split_config_key(key)
+      config[group] ||= {}
+      config[group][name]
+    end
+
+    def set_option_in_file(file, key, value)
+      config = read_config_file(file) || {}
+      group, name = *key.split(".", 2)
+      config[group] ||= {}
+      config[group][name] = value
+      write_config_file(file, config)
+    end
+
+    def read_config_file(file)
+      return nil unless File.exists?(file)
+      YAML.load_file(file)
+    end
+
+    def write_config_file(file, config)
+      File.open(file, "w") { |f| f.write YAML.dump(config) }
+    end
+
+    def split_config_key(key)
+      parts = key.split(".")
+      group = parts.slice(0, parts.length - 1).join(".")
+      name = parts.last
+      [group, name]
+    end
+  end
+end

data/lib/muon/entry.rb

@@ -0,0 +1,33 @@
+require "time"
+
+module Muon
+  class Entry
+    attr_reader :start_time, :end_time, :parent_hash
+
+    def initialize(start_time, end_time, parent_hash = nil)
+      @start_time, @end_time = start_time, end_time
+      @parent_hash = parent_hash
+    end
+
+    def duration
+      (end_time - start_time).to_i
+    end
+
+    def with_parent_hash(new_parent_hash)
+      raise "Already have parent hash" if parent_hash
+      Entry.new(start_time, end_time, new_parent_hash)
+    end
+
+    def to_s
+      "parent #{parent_hash}\n" +
+      "#{start_time},#{end_time}\n"
+    end
+
+    def self.from_s(str)
+      parent_hash = str.lines.to_a[0].sub(/^parent /, "").strip
+      parent_hash = nil if parent_hash == ""
+      start_time, end_time = *str.lines.to_a[1].strip.split(",")
+      new(Time.parse(start_time), Time.parse(end_time), parent_hash)
+    end
+  end
+end

data/lib/muon/format.rb

@@ -0,0 +1,21 @@
+module Muon
+  class Format
+    def self.duration(seconds)
+      seconds ||= 0
+      seconds = seconds.to_i
+      minutes = seconds / 60
+      if minutes == 0
+        "#{seconds} seconds"
+      else
+        seconds = seconds % 60
+        hours = minutes / 60
+        if hours == 0
+          "#{minutes} minutes, #{seconds} seconds"
+        else
+          minutes = minutes % 60
+          "#{hours} hours, #{minutes} minutes, #{seconds} seconds"
+        end
+      end
+    end
+  end
+end

data/lib/muon/history.rb

@@ -0,0 +1,67 @@
+require "digest/sha1"
+
+module Muon
+  class History
+    def initialize(working_dir)
+      @working_dir = working_dir
+    end
+
+    def entries
+      if block_given?
+        entry = load_entry(head)
+        while entry
+          yield entry
+          entry = load_entry(entry.parent_hash)
+        end
+      else
+        enum_for :entries
+      end
+    end
+
+    def append(entry)
+      self.head = save_entry(entry.with_parent_hash(head))
+    end
+
+    private
+
+    def head_file
+      File.join(@working_dir, "HEAD")
+    end
+
+    def head
+      if File.exists?(head_file)
+        File.read(head_file).strip
+      else
+        nil
+      end
+    end
+
+    def head=(hash)
+      File.open(head_file, "w") { |f| f.write(hash + "\n") }
+    end
+
+    def load_entry(hash)
+      return nil if hash.nil?
+      File.open(file_for_hash(hash), "r") { |f| Entry.from_s(f.read) }
+    end
+
+    def save_entry(entry)
+      contents = entry.to_s
+      hash = compute_hash(contents)
+      File.open(file_for_hash(hash), "w") { |f| f.write(contents) }
+      return hash
+    end
+
+    def file_for_hash(hash)
+      File.join(@working_dir, "objects", hash)
+    end
+
+    def verify_hash(contents, hash)
+      raise "Hash #{hash} does not match contents!" if compute_hash(compute_hash) != hash
+    end
+
+    def compute_hash(contents)
+      Digest::SHA1.hexdigest(contents)
+    end
+  end
+end

data/lib/muon/project.rb

@@ -0,0 +1,128 @@
+require "muon/history"
+
+module Muon
+  class Project
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+      @history = History.new(working_dir)
+    end
+
+    def name
+      File.basename(path)
+    end
+
+    def working_dir
+      File.join(path, ".muon")
+    end
+
+    def init_directory
+      raise "Already initialized!" if Dir.exists?(working_dir)
+      Dir.mkdir(working_dir)
+      Dir.mkdir(File.join working_dir, "objects")
+    end
+
+    def tracking?
+      File.exists?(File.join(working_dir, "current"))
+    end
+
+    def start_tracking(start_time = nil)
+      raise "Already tracking!" if tracking_file_exists?
+      start_time ||= Time.now
+      create_tracking_file(start_time.to_s)
+    end
+
+    def stop_tracking(end_time = nil)
+      raise "Not tracking!" unless tracking_file_exists?
+      start_time = Time.parse(read_tracking_file)
+      end_time ||= Time.now
+      commit_entry(start_time.to_s, end_time.to_s)
+      delete_tracking_file
+    end
+
+    def abort_tracking
+      raise "Not tracking!" unless tracking_file_exists?
+      delete_tracking_file
+    end
+
+    def tracking_duration
+      (Time.now - Time.parse(read_tracking_file)).to_i
+    end
+
+    def commit_entry(start_time, end_time)
+      entry = Entry.new(start_time, end_time)
+      history.append(entry)
+    end
+
+    def history_entries
+      history.entries
+    end
+
+    def day_total_time(date = Time.now)
+      date = date.strftime("%Y%m%d")
+      history.entries.select { |e| e.start_time.strftime("%Y%m%d") == date }.map(&:duration).inject(&:+)
+    end
+
+    def month_total_time(date = Time.now)
+      date = date.strftime("%Y%m")
+      history.entries.select { |e| e.start_time.strftime("%Y%m") == date }.map(&:duration).inject(&:+)
+    end
+
+    def has_goal?
+      goal_file_exists?
+    end
+
+    def goal
+      read_goal_file.to_i
+    end
+
+    def goal=(seconds)
+      write_goal_file(seconds.to_s)
+    end
+
+    def goal_remaining_time
+      goal - month_total_time
+    end
+
+    private
+
+    attr_reader :history
+
+    def tracking_file
+      File.join(working_dir, "current")
+    end
+
+    def tracking_file_exists?
+      File.exists?(tracking_file)
+    end
+
+    def read_tracking_file
+      File.open(tracking_file, "r") { |f| f.read }
+    end
+
+    def create_tracking_file(contents = "")
+      File.open(tracking_file, "w") { |f| f.puts(contents) }
+    end
+
+    def delete_tracking_file
+      File.unlink(tracking_file)
+    end
+
+    def goal_file
+      File.join(working_dir, "goal")
+    end
+
+    def goal_file_exists?
+      File.exists?(goal_file)
+    end
+
+    def read_goal_file
+      File.open(goal_file, "r") { |f| f.read }
+    end
+
+    def write_goal_file(contents = "")
+      File.open(goal_file, "w") { |f| f.puts(contents) }
+    end
+  end
+end

data/lib/muon/version.rb

@@ -0,0 +1,3 @@
+module Muon
+  VERSION = "0.0.2"
+end

data/muon.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/muon/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["DRUG"]
+  # gem.email         = [""]
+  gem.description   = %q{Distributed time tracking tool}
+  gem.summary       = %q{Distributed time tracking tool}
+  gem.homepage      = "http://drug.org.pl"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "muon"
+  gem.require_paths = ["lib"]
+  gem.version       = Muon::VERSION
+
+  gem.add_dependency('gli', "~> 1.0")
+  gem.add_dependency('chronic_duration', "~> 0.9.6")
+
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('delorean')
+end

data/test/cli_test.rb

@@ -0,0 +1,174 @@
+require 'test_helper'
+require 'tmpdir'
+require 'stringio'
+require 'delorean'
+
+class CliTest < Test::Unit::TestCase
+  include Delorean
+
+  def setup
+    @dir = Dir.mktmpdir
+    @home_dir = Dir.mktmpdir
+    @output = StringIO.new
+    @app = Muon::App.new(@dir, @home_dir, @output)
+    @app.init_directory
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@dir)
+    FileUtils.remove_entry_secure(@home_dir)
+  end
+
+  def test_init_initializes_only_once
+    assert_raise(RuntimeError) { @app.init_directory }
+  end
+
+  def test_start_creates_tracking_file
+    @app.start_tracking
+    assert File.exists?("#{@dir}/.muon/current")
+  end
+
+  def test_start_fails_if_already_tracking
+    @app.start_tracking
+    assert_raise(RuntimeError) { @app.start_tracking }
+  end
+
+  def test_stop_stops_and_creates_history_entry
+    @app.start_tracking
+    @app.stop_tracking
+    assert ! File.exists?("#{@dir}/.muon/current")
+    assert File.exists?("#{@dir}/.muon/HEAD")
+  end
+
+  def test_stop_fails_if_not_tracking_yet
+    assert_raise(RuntimeError) { @app.stop_tracking }
+  end
+
+  def test_abort_stop_and_does_not_create_entry
+    @app.start_tracking
+    @app.abort_tracking
+    assert ! File.exists?("#{@dir}/.muon/current")
+    assert ! File.exists?("#{@dir}/.muon/HEAD")
+  end
+
+  def test_commit_creates_history_entry
+    @app.commit_entry("00:01", "00:05")
+    assert File.exists?("#{@dir}/.muon/HEAD")
+  end
+
+  def test_status_reports_whether_running
+    @app.show_status
+    assert_equal "Time tracking is stopped.\n", @output.string.lines.to_a[0]
+
+    @app.start_tracking
+    reset_output
+    @app.show_status
+    assert_equal "Time tracking is running since 0 seconds.\n", @output.string.lines.to_a[0]
+  end
+
+  def test_status_reports_todays_total_time
+    time_travel_to("yesterday 12:00") { @app.start_tracking }
+    time_travel_to("yesterday 12:10") { @app.stop_tracking }
+    time_travel_to("today 00:00") { @app.start_tracking }
+    time_travel_to("today 00:05") { @app.stop_tracking }
+
+    @app.show_status
+    assert_equal "Time tracking is stopped.\nToday's total time is 5 minutes, 0 seconds.\n", @output.string
+  end
+
+  def test_total_calculates_total_time_for_a_day
+    time_travel_to("2012-01-01 12:00") { @app.start_tracking }
+    time_travel_to("2012-01-01 12:10") { @app.stop_tracking }
+    time_travel_to("2012-01-02 00:00") { @app.start_tracking }
+    time_travel_to("2012-01-02 00:05") { @app.stop_tracking }
+
+    @app.show_total('2012-01-01')
+    assert_equal "Total time on 2012-01-01 is 10 minutes, 0 seconds.\n", @output.string
+
+    reset_output
+    @app.show_total('2012-01-05')
+    assert_equal "Total time on 2012-01-05 is 0 seconds.\n", @output.string
+  end
+
+  def test_log_lists_entries
+    time_travel_to("2012-08-01") do
+      @app.commit_entry("00:01", "00:05")
+      @app.commit_entry("00:10", "00:20")
+    end
+
+    @app.show_log
+    assert_equal "2012-08-01 00:10:00 +0200 - 2012-08-01 00:20:00 +0200 (10 minutes, 0 seconds)\n", @output.string.lines.to_a[0]
+    assert_equal "2012-08-01 00:01:00 +0200 - 2012-08-01 00:05:00 +0200 (4 minutes, 0 seconds)\n", @output.string.lines.to_a[1]
+    assert_equal 2, @output.string.lines.to_a.length
+
+    reset_output
+    @app.show_log(1)
+    assert_equal "2012-08-01 00:10:00 +0200 - 2012-08-01 00:20:00 +0200 (10 minutes, 0 seconds)\n", @output.string.lines.to_a[0]
+    assert_equal 1, @output.string.lines.to_a.length
+  end
+
+  def test_goal_for_month
+    time_travel_to("2012-08-01") do
+      @app.commit_entry("00:00", "00:05")
+      @app.commit_entry("00:10", "00:20")
+
+      test_command do
+        @app.show_goal
+        assert_equal "No goal has been set.\n", output
+      end
+
+      test_command do
+        @app.set_goal('30:00:00')
+        assert_equal "Setting goal for this month to 30 hours, 0 minutes, 0 seconds.\n", output
+      end
+
+      test_command do
+        @app.show_goal
+        assert_equal "The goal for this month is 30 hours, 0 minutes, 0 seconds.\n", output_lines[0]
+        assert_equal "Time left to achieve this goal: 29 hours, 45 minutes, 0 seconds.\n", output_lines[1]
+        assert_equal 2, output_lines.length
+      end
+    end
+  end
+
+  def test_config_setting_and_reading
+    @app.set_config_option("alias.ci", "commit")
+
+    @app.read_config_option("alias.ci")
+    assert_equal "commit\n", @output.string
+
+    reset_output
+    @app.read_config_option("xxx.y")
+    assert_equal "\n", @output.string
+  end
+
+  def test_dealiasify_replaces_aliases
+    @app.set_config_option("alias.ci", "commit")
+    assert_equal ["commit", "00:01", "00:05"], @app.dealiasify(["ci", "00:01", "00:05"])
+  end
+
+  def test_register_global_project
+    @app.register_global_project
+    assert_equal File.basename(@dir), @app.global_projects[0].name
+    assert_equal @dir, @app.global_projects[0].path
+  end
+
+  private
+
+  def test_command
+    yield
+    reset_output
+  end
+
+  def reset_output
+    @output.string = ""
+  end
+
+  def output
+    @output.string
+  end
+
+  def output_lines
+    @output.string.lines.to_a
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'muon/app'

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: muon
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- DRUG
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: chronic_duration
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delorean
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Distributed time tracking tool
+email: 
+executables:
+- muon
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/muon
+- extras/muon-completion.bash
+- extras/muon-prompt.sh
+- lib/muon.rb
+- lib/muon/app.rb
+- lib/muon/config.rb
+- lib/muon/entry.rb
+- lib/muon/format.rb
+- lib/muon/history.rb
+- lib/muon/project.rb
+- lib/muon/version.rb
+- muon.gemspec
+- test/cli_test.rb
+- test/test_helper.rb
+homepage: http://drug.org.pl
+licenses: []
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Distributed time tracking tool
+test_files:
+- test/cli_test.rb
+- test/test_helper.rb