gwtf 0.0.1

data/bin/gwtf

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# 1.9 adds realpath to resolve symlinks; 1.8 doesn't
+# have this method, so we add it so we get resolved symlinks
+# and compatibility
+unless File.respond_to? :realpath
+  class File #:nodoc:
+    def self.realpath path
+      return realpath(File.readlink(path)) if symlink?(path)
+      path
+    end
+  end
+end
+$: << File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../lib')
+
+require 'rubygems'
+require 'gli'
+require 'gwtf'
+
+include GLI
+
+program_desc 'Go With The Flow'
+
+version Gwtf::VERSION
+
+config_file '.gwtf'
+
+desc 'Path to storage directory'
+long_desc "Where to store the database of items"
+default_value File.join(Etc.getpwuid.dir, ".gwtf.d")
+arg_name "data_dir"
+flag [:data, :d]
+
+desc 'Active project'
+long_desc "Change the active project"
+default_value "default"
+arg_name "project"
+flag [:project, :p]
+
+Gwtf.each_command do |command|
+  load command
+end
+
+pre do |global,command,options,args|
+  project_dir = File.join(global[:data], global[:project])
+
+  unless File.directory?(project_dir)
+    puts "Created a new project %s in %s" % [global[:project], project_dir]
+    Gwtf::Items.setup(project_dir)
+  end
+
+  @items = Gwtf::Items.new(project_dir)
+
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit GLI.run(ARGV)

data/lib/gwtf.rb

@@ -0,0 +1,40 @@
+module Gwtf
+  require 'gwtf/items'
+  require 'gwtf/item'
+  require 'gwtf/version'
+  require 'json'
+  require 'yaml'
+  require 'fileutils'
+  require 'tempfile'
+
+  def self.each_command
+    commands_dir = File.join(File.dirname(__FILE__), "gwtf", "commands")
+    Dir.entries(commands_dir).grep(/_command.rb$/).sort.each do |command|
+      yield File.join(commands_dir, command)
+    end
+  end
+
+  # borrowed from ohai, thanks Adam.
+  def self.seconds_to_human(seconds)
+    days = seconds.to_i / 86400
+    seconds -= 86400 * days
+
+    hours = seconds.to_i / 3600
+    seconds -= 3600 * hours
+
+    minutes = seconds.to_i / 60
+    seconds -= 60 * minutes
+
+    if days > 1
+      return sprintf("%d days %d hours %d minutes %d seconds", days, hours, minutes, seconds)
+    elsif days == 1
+      return sprintf("%d day %d hours %d minutes %d seconds", days, hours, minutes, seconds)
+    elsif hours > 0
+      return sprintf("%d hours %d minutes %d seconds", hours, minutes, seconds)
+    elsif minutes > 0
+      return sprintf("%d minutes %d seconds", minutes, seconds)
+    else
+      return sprintf("%d seconds", seconds)
+    end
+  end
+end

data/lib/gwtf/commands/done_command.rb

@@ -0,0 +1,13 @@
+desc 'Mark an item as done'
+arg_name 'Item id'
+command [:done, :d] do |c|
+  c.action do |global_options,options,args|
+    raise "Please specify an item ID to mark as done" if args.empty?
+
+    item = @items.load_item(args.first)
+    item.close
+    item.save
+
+    puts "Marked item #{args.first} as done"
+  end
+end

data/lib/gwtf/commands/edit_command.rb

@@ -0,0 +1,35 @@
+desc 'Edit an item using EDITOR'
+arg_name 'Item id'
+command [:edit, :vi, :e] do |c|
+  c.action do |global_options,options,args|
+    raise "Please specify an item ID to edit" if args.empty?
+    raise "EDITOR environment variable should be set" unless ENV.include?("EDITOR")
+
+    item = @items.load_item(args.first)
+
+    descr_sep = "== EDIT BETWEEN THESE LINES =="
+
+    temp_item = {"description" => "#{descr_sep}\n#{item.description}\n#{descr_sep}", "subject" => item.subject}
+
+    begin
+      tmp = Tempfile.new("gwtf")
+      tmp.write(temp_item.to_yaml)
+      tmp.rewind
+      system("%s %s" % [ENV["EDITOR"], tmp.path])
+      edited_item = YAML.load_file(tmp.path)
+    ensure
+      tmp.close
+      tmp.unlink
+    end
+
+    item.subject = edited_item["subject"] if edited_item["subject"]
+
+    if edited_item["description"] =~ /#{descr_sep}\n(.+)\n#{descr_sep}/m
+      item.description = $1
+    end
+
+    item.save
+
+    puts "Item #{item.item_id} has been saved"
+  end
+end

data/lib/gwtf/commands/list_command.rb

@@ -0,0 +1,24 @@
+desc 'List active items'
+command [:list, :ls, :l] do |c|
+  c.desc 'Also show closed items'
+  c.default_value false
+  c.switch [:all, :a]
+
+  c.action do |global_options,options,args|
+    count = {"open" => 0, "closed" => 0}
+
+    @items.each_item do |item|
+      count[ item[:status] ] += 1
+
+      item.has_description ? id = "*#{item.item_id.to_s}" : id = item.item_id.to_s
+
+      puts "%5s %-3s%8s" % [ id, "", item.subject] if item.open?
+      puts "%5s %-3s%8s" % [ id, "C", item.subject] if (item.closed? && options[:all])
+    end
+
+    puts
+    puts "Items: %d / %d" % [count["open"], count["open"] + count["closed"]]
+  end
+end
+
+

data/lib/gwtf/commands/log_command.rb

@@ -0,0 +1,36 @@
+desc 'Log work performed against an item'
+arg_name 'id log text'
+command :log do |c|
+  c.desc 'Days spent'
+  c.default_value 0
+  c.flag [:days, :d]
+
+  c.desc 'Hours spent'
+  c.default_value 0
+  c.flag [:hour, :h]
+
+  c.desc 'Minutes spent'
+  c.default_value 0
+  c.flag [:min, :m]
+
+  c.action do |global_options,options,args|
+    raise "Please specify an item ID to work on" if args.empty?
+    raise "Please supply log text" if args.size == 1
+
+    elapsed_time = Float(options[:days]) * 60 * 60 * 24
+    elapsed_time += Float(options[:hour]) * 60 * 60
+    elapsed_time += Float(options[:min]) * 60
+
+    item = @items.load_item(args.first)
+
+    description = args[1..-1].join(" ")
+
+    item.record_work(description, elapsed_time)
+
+    item.save
+
+    puts "Logged '#{description}' against item #{item.item_id} for #{Gwtf.seconds_to_human(elapsed_time)}"
+  end
+end
+
+

data/lib/gwtf/commands/new_command.rb

@@ -0,0 +1,31 @@
+desc 'Create an item'
+arg_name 'Short item description'
+command [:new, :n] do |c|
+  c.desc 'Invoke EDITOR to provide a long form description'
+  c.default_value false
+  c.switch [:edit, :e]
+
+  c.action do |global_options,options,args|
+    if options[:edit]
+      raise "EDITOR is not set" unless ENV.include?("EDITOR")
+
+      begin
+        tmp = Tempfile.new("gwtf")
+        system("%s %s" % [ENV["EDITOR"], tmp.path])
+        description = tmp.read.chomp
+      ensure
+        tmp.close
+        tmp.unlink
+      end
+    else
+      description = nil
+    end
+
+    item = @items.new_item
+    item.subject = args.join(" ")
+    item.description = description if description
+    item.save
+
+    puts "Item #{item.item_id} saved"
+  end
+end

data/lib/gwtf/commands/open_command.rb

@@ -0,0 +1,18 @@
+desc 'Re-open a previously closed item'
+arg_name 'Item id'
+command [:open, :o] do |c|
+  c.action do |global_options,options,args|
+    raise "Please specify an item ID to mark re-open" if args.empty?
+
+    item = @items.load_item(args.first)
+
+    raise "Item #{args.first} was already open" if item.open?
+
+    item.open
+    item.save
+
+    puts "Item #{args.first} as been re-opened"
+  end
+end
+
+

data/lib/gwtf/commands/shell_command.rb

@@ -0,0 +1,43 @@
+desc 'Start work on an item in a subshell'
+arg_name 'Item id'
+command :shell do |c|
+  c.action do |global_options,options,args|
+    raise "Please specify an item ID to work on" if args.empty?
+    raise "SHELL is not set, cannot create sub shell" unless ENV.include?("SHELL")
+
+    start_time = Time.now
+    item = @items.load_item(args.first)
+
+    puts "Starting work on item #{item.item_id}, exit to record the action and time"
+
+    ENV["GWTF_ITEM"] = item.item_id.to_s
+    ENV["GWTF_PROJECT"] = global_options[:project]
+    ENV["GWTF_SUBJECT"] = item.subject
+
+    system(ENV["SHELL"])
+
+    elapsed_time = Time.now - start_time
+
+    STDOUT.sync = true
+
+    print "Optional description for work log: "
+
+    begin
+      description = STDIN.gets.chomp
+    rescue Exception
+      puts
+      description = ""
+    end
+
+    description = "Worked in a subshell" if description == ""
+    description = description + " (#{Gwtf.seconds_to_human(elapsed_time.round)})"
+
+    item.record_work(description, elapsed_time.round)
+
+    item.save
+
+    puts "Recorded #{elapsed_time} seconds of work against item #{item.item_id}"
+  end
+end
+
+

data/lib/gwtf/commands/show_command.rb

@@ -0,0 +1,44 @@
+desc 'Show an item'
+arg_name 'Item ID'
+command [:show, :s] do |c|
+  c.action do |global_options,options,args|
+    raise "Please supply an item ID to show" if args.empty?
+
+    item = @items.load_item(args.first)
+
+    time_worked = item.work_log.inject(0) do |result, log|
+      begin
+        result + log["elapsed"]
+      rescue
+        result
+      end
+    end
+
+    puts "         ID: %s" % [ item.item_id ]
+    puts "    Subject: %s" % [ item.subject ]
+    puts "     Status: %s" % [ item.status ]
+    puts "Time Worked: %s" % [ Gwtf.seconds_to_human(time_worked) ]
+    puts "    Created: %s" % [ Time.parse(item.created_at).strftime("%D %R") ]
+    puts "     Closed: %s" % [ Time.parse(item.closed_at).strftime("%D %R") ] if item.closed?
+
+    if item.has_description?
+      puts
+      puts "Description:"
+
+      item.description.split("\n").each do |line|
+        puts "%13s%s" % [ "", line]
+      end
+
+      puts
+    end
+
+    time_spent = 0
+
+    item.work_log.each_with_index do |log, idx|
+      puts
+      puts "Work Log: " if idx == 0
+
+      puts "%27s %s" % [Time.parse(log["time"]).strftime("%D %R"), log["text"]]
+    end
+  end
+end

data/lib/gwtf/item.rb

@@ -0,0 +1,157 @@
+module Gwtf
+  class Item
+    attr_accessor :file
+
+    def initialize(file=nil)
+      @item = default_item
+      @file = file
+
+      load_item if file
+    end
+
+    def open?
+      @item["status"] == "open"
+    end
+
+    def closed?
+      !open?
+    end
+
+    def load_item
+      raise "A file to read from has not been specified" unless @file
+
+      read_item = JSON.parse(File.read(@file))
+
+      @item.merge!(read_item)
+    end
+
+    def backup_dir
+      File.join(File.dirname(file), "backups")
+    end
+
+    def save(backup=true)
+      raise "No item_id set, cannot save item" unless @item["item_id"]
+
+      if backup && File.exist?(@file)
+        backup_name = File.basename(@file) + "-" + Time.now.to_f.to_s
+
+        FileUtils.mv(@file, File.join(backup_dir, backup_name))
+      end
+
+      File.open(@file, "w") do |f|
+        f.print to_json
+      end
+
+      @file
+    end
+
+    def default_item
+      {"description" => nil,
+       "subject" => nil,
+       "created_at" => Time.now,
+       "edited_at" => nil,
+       "closed_at" => nil,
+       "status" => "open",
+       "item_id" => nil,
+       "work_log" => []}
+    end
+
+    def to_hash
+      @item
+    end
+
+    def record_work(text, elapsed=0)
+      update_property(:edited_at, Time.now)
+
+      @item["work_log"] << {"text" => text, "time" => Time.now, "elapsed" => elapsed}
+    end
+
+    def open
+      update_property(:closed_at, nil)
+      update_property(:status, "open")
+    end
+
+    def close
+      update_property(:closed_at, Time.now)
+      update_property(:status, "closed")
+    end
+
+    def to_json
+      JSON.pretty_generate(@item)
+    end
+
+    def to_yaml
+      @item.to_yaml
+    end
+
+    def update_property(property, value)
+      property = property.to_s
+
+      raise "No such property: #{property}" unless @item.include?(property)
+
+      @item["edited_at"] = Time.now
+      @item[property] = value
+    end
+
+    def [](property)
+      property = property.to_s
+
+      raise "No such property: #{property}" unless @item.include?(property)
+
+      @item[property]
+    end
+
+    def []=(property, value)
+      update_property(property, value)
+    end
+
+    # simple read from the class:
+    #
+    #   >> i.description
+    #   => "Sample Item"
+    #
+    # method like writes:
+    #
+    #   >> i.description "This is a test"
+    #   => "This is a test"
+    #
+    # assignment
+    #
+    #   >> i.description = "This is a test"
+    #   => "This is a test"
+    #
+    # boolean
+    #
+    #   >> i.description?
+    #   => false
+    #   >> i.description "foo"
+    #   => foo
+    #   >> i.has_description?
+    #   => true
+    #   >> i.has_description
+    #   => true
+    def method_missing(method, *args)
+      method = method.to_s
+
+      if @item.include?(method)
+        if args.empty?
+          return @item[method]
+        else
+          return update_property(method, args.first)
+        end
+
+      elsif method =~ /^has_(.+?)\?*$/
+        return !@item[$1].nil?
+
+      elsif method =~ /^(.+)\?$/
+        return !@item[$1].nil?
+
+      elsif method =~ /^(.+)=$/
+        property = $1
+        return update_property(property, args.first) if @item.include?(property)
+      end
+
+      raise NameError, "undefined local variable or method `#{method}'"
+    end
+  end
+end

data/lib/gwtf/items.rb

@@ -0,0 +1,71 @@
+module Gwtf
+  class Items
+    def self.config_file(data_dir)
+      File.expand_path(File.join(data_dir, "..", "gwtf.json"))
+    end
+
+    def self.setup(data_dir)
+      require 'fileutils'
+
+      raise "#{data_dir} already exist" if File.exist?(data_dir)
+
+      FileUtils.mkdir_p(File.join(data_dir, "backups"))
+      FileUtils.mkdir_p(File.join(data_dir, "archive"))
+      FileUtils.mkdir_p(File.join(data_dir, "garbage"))
+
+      unless File.exist?(config_file(data_dir))
+        File.open(config_file(data_dir), "w") do |f|
+          f.print({"next_item" => 0}.to_json)
+        end
+      end
+    end
+
+    def initialize(data_dir)
+      raise "Data directory #{data_dir} does not exist" unless File.directory?(data_dir)
+
+      @data_dir = data_dir
+      @config = read_config
+    end
+
+    def new_item
+      item = Item.new
+      item.item_id = @config["next_item"]
+      item.file = File.join(@data_dir, "#{item.item_id}.gwtf")
+
+      @config["next_item"] += 1
+      save_config
+
+      item
+    end
+
+    def load_item(item)
+      raise "Item #{item} does not exist" unless File.exist?(file_for_item(item))
+
+      Item.new(file_for_item(item))
+    end
+
+    def read_config
+      JSON.parse(File.read(Items.config_file(@data_dir)))
+    end
+
+    def save_config
+      raise "Config has not been loaded" unless @config
+
+      File.open(Items.config_file(@data_dir), "w") do |f|
+        f.print(@config.to_json)
+      end
+    end
+
+    def items
+      Dir.entries(@data_dir).grep(/\.gwtf$/).sort.map{|i| File.basename(i, ".gwtf")}
+    end
+
+    def file_for_item(item)
+      File.join(@data_dir, "#{item}.gwtf")
+    end
+
+    def each_item
+      items.each {|item| yield load_item(item) }
+    end
+  end
+end

data/lib/gwtf/version.rb

@@ -0,0 +1,3 @@
+module Gwtf
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: gwtf
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-10 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A Unix cli centric todo manager
+email: rip@devco.net
+executables: 
+- gwtf
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/gwtf
+- lib/gwtf/commands/show_command.rb
+- lib/gwtf/commands/open_command.rb
+- lib/gwtf/commands/shell_command.rb
+- lib/gwtf/commands/done_command.rb
+- lib/gwtf/commands/log_command.rb
+- lib/gwtf/commands/edit_command.rb
+- lib/gwtf/commands/new_command.rb
+- lib/gwtf/commands/list_command.rb
+- lib/gwtf/version.rb
+- lib/gwtf/item.rb
+- lib/gwtf/items.rb
+- lib/gwtf.rb
+has_rdoc: true
+homepage: http://devco.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Go With The Flow
+test_files: []
+