plan 0.0.1

data/bin/plan

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/plan'
+Plan::CLI.run(ARGV)

data/lib/plan.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/plan/version'
+require File.dirname(__FILE__) + '/plan/advice'
+require File.dirname(__FILE__) + '/plan/item'
+
+module Plan
+  autoload :CLI, File.dirname(__FILE__) + '/plan/cli' 
+end

data/lib/plan/advice.rb

@@ -0,0 +1,17 @@
+module Plan
+
+  class Advice < Exception
+
+    attr_reader :lines
+
+    def initialize(*lines)
+      @lines = lines
+    end
+
+    def message
+      @lines.join("\n")
+    end
+
+  end
+
+end

data/lib/plan/cli.rb

@@ -0,0 +1,168 @@
+require 'json'
+
+module Plan
+
+  class CLI
+
+    class << self
+
+      def run(args)
+        begin
+          command args.first, args[1..-1]
+        rescue Plan::Advice => e
+          e.lines.each do |line|
+            puts "\e[31m[uh-oh]\e[0m #{line}"
+          end
+        end
+      end
+
+      # decide what to do
+      def command(command, paths)
+        # default is list
+        return list([]) if command.nil?
+        # choose other command
+        case command
+        when 'create' then create paths
+        when 'list' then list paths
+        when 'finish' then finish paths
+        when 'unfinish' then unfinish paths
+        when 'cleanup' then cleanup paths
+        when 'help' then help
+        else unknown_command(command)
+        end
+      end
+
+      COMMAND_GLOSSARY = {
+        'create' => 'create a new item',
+        'list' => 'list items',
+        'finish' => 'mark an item finished',
+        'unfinish' => 'mark an item unfinished',
+        'cleanup' => 'remove finished items from view',
+        'help' => 'display a list of commands'
+      }
+
+      # display a list of help
+      def help
+        puts "plan #{Plan::VERSION} - john crepezzi - http://github.com/seejohnrun/plan"
+        COMMAND_GLOSSARY.each do |cmd, description|
+          puts "\e[0;33m#{cmd}\e[0m - #{description}"
+        end
+      end
+
+      # Remove all finished items that are descendents
+      def cleanup(paths)
+        item = path_tree.descend(paths)
+        item.cleanup  
+        save_path_tree
+        # print what happened here
+        print_depth item
+      end
+
+      # Mark a task or group of tasks as "unfinished"
+      def unfinish(paths)
+        if paths.empty?
+          raise Plan::Advice.new 'please drill down to a level to unfinish'
+        end
+        # go to the right depth and unfinish
+        item = path_tree.descend(paths)
+        item.unfinish!
+        save_path_tree
+        # print what happened here
+        print_depth item
+      end
+
+      # Mark a task or group of tasks as "finished"
+      def finish(paths)
+        if paths.empty?
+          raise Plan::Advice.new 'please drill down to a level to finish'
+        end
+        # descend and finish
+        item = path_tree.descend(paths)
+        item.finish!
+        save_path_tree
+        # print what happened here
+        print_depth item
+      end
+
+      # list things at a certain depth
+      def list(paths)
+        item = path_tree.descend(paths)
+        if item.visible_child_count == 0
+          raise Plan::Advice.new 'no events here - create some with `plan create`'
+        end
+        print_depth item
+      end
+
+      # create a new todo
+      def create(paths)
+        if paths.empty?
+          raise Plan::Advice.new 'please provide something to create'
+        end
+        # descend to the right depth
+        item = path_tree.descend(paths[0..-2])
+        # and then create
+        if item.children.any? { |c| !c.hidden? && c.has_label?(paths[-1]) }
+          raise Plan::Advice.new "duplicate entry at level: #{paths[-1]}"
+        else
+          item.children << Item.new(paths[-1])
+          save_path_tree
+          # and say what happened
+          print_depth item
+        end
+      end
+
+      private
+
+      DATA_STORE = ENV['PLAN_DATA_PATH'] || "#{ENV['HOME']}/plan"
+      DATE_FORMAT = '%b. %e, %Y %l:%M %P'
+
+      def unknown_command(cmd)
+        raise Plan::Advice.new "unknown command: #{cmd}. try `plan help` for options."
+      end
+
+      # print the item and its descendents
+      def print_depth(item)
+        return if item.hidden?
+        print_item item, 0
+        list_recur_print item, 2
+      end
+
+      # Used by #print_depth to print its tree
+      def list_recur_print(item, desc = 0)
+        item.children.each do |child|
+          next if child.hidden?
+          print_item child, desc
+          list_recur_print(child, desc + 2)
+        end
+      end
+
+      # output an individual item
+      def print_item(item, desc = 0)
+        if item.finished?
+          puts "\e[1;30m#{'-' * desc}#{desc > 0 ? " #{item.label}" : item.label} \e[1;31m(finished @ #{item.finished.strftime(DATE_FORMAT)})\e[0m"
+        else
+          puts "\e[1;30m#{'-' * desc}\e[0m#{desc > 0 ? " #{item.label}" : item.label}"
+        end
+      end
+
+      # Save any changes to the tree
+      def save_path_tree
+        file = File.open(DATA_STORE, 'w')
+        file.write path_tree.dump.to_json
+        file.close
+      end
+
+      # Get the path tree from the data file
+      def path_tree
+        @path_tree ||= if File.exists?(DATA_STORE)
+          Item.load JSON.parse(File.read(DATA_STORE))
+        else
+          Item.new 'plan'
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/plan/item.rb

@@ -0,0 +1,114 @@
+module Plan
+
+  class Item
+
+    attr_reader :label, :finished, :children
+      
+    # Create a new item
+    def initialize(label, finished = nil, hidden = nil)
+      @label = label.strip
+      @finished = finished.is_a?(Fixnum) ? Time.at(finished) : nil
+      @hidden = hidden
+      @children = []
+    end
+
+    # determine whether a label is a duplicate of this item's label
+    # downcases to get rid of basic mistakes
+    def has_label?(other_label)
+      label.downcase == other_label.downcase
+    end
+
+    # for fuzzy matching on descending - so you can do things like
+    # todo create so hi - instead of
+    # todo create something hi
+    def has_label_like?(other_label)
+      label.downcase.include? other_label.downcase
+    end
+
+    # count of the visible children
+    def visible_child_count
+      children.count { |c| !c.hidden? }
+    end
+
+    # remove all finished items from this tree, by hiding them
+    def cleanup
+      @hidden = true if finished?
+      children.each { |c| c.cleanup }
+    end
+
+    # mark a finish date for this item
+    def finish!(at = Time.now)
+      @finished = at unless finished? # don't overwrite
+      children.each { |c| c.finish!(at) unless c.hidden? } # and finish each child
+    end
+
+    # mark a finished item as unfinished
+    # and all descendents
+    def unfinish!
+      @finished = nil
+      children.each { |c| c.unfinish! unless c.hidden? }
+    end
+
+    # return a boolean indicating whether or not this item is hidden
+    def hidden?
+      !!@hidden
+    end
+
+    # return whether this item is finished
+    def finished?
+      !!@finished && children.all? { |c| c.finished? || c.hidden? }
+    end
+
+    # recursively descent through children until you find the given item
+    def descend(paths)
+      return self if paths.empty?
+      # prefer exact matches
+      next_items = children.select { |c| !c.hidden? && c.has_label?(paths.first) }
+      # fall back on approximates
+      if next_items.empty?
+        next_items = children.select { |c| !c.hidden? && c.has_label_like?(paths.first) }
+      end
+      # give an error if we have no matches
+      if next_items.empty?
+        lines = []
+        lines << "no match for #{paths.first}"
+        unless children.empty?
+          lines << "available options are: #{children.reject(&:hidden?).map(&:label).join(', ')}"
+        end
+        raise Plan::Advice.new *lines
+      end
+      # give an error if we have too many matches
+      if next_items.count > 1
+        lines = []
+        lines << "ambiguous match for '#{paths.first}' - please choose one of:"
+        next_items.each do |np|
+          lines << "* #{np.label}"
+        end
+        raise Plan::Advice.new *lines
+      end 
+      # and off we go, continuing to descent
+      next_items.first.descend(paths[1..-1])
+    end
+
+    # Load a Item from a data hash
+    def self.load(data)
+      item = Item.new data['label'], data['finished'], data['hidden']
+      data['children'] && data['children'].each do |child|
+        item.children << Item.load(child) 
+      end
+      item
+    end
+
+    # dump a nested representation of this item
+    def dump
+      data = {}
+      data['label'] = label
+      data['finished'] = finished.nil? ? nil : finished.to_i
+      data['children'] = children.map(&:dump)
+      data['hidden'] = true if hidden?
+      data
+    end
+
+  end
+
+end

data/lib/plan/version.rb

@@ -0,0 +1,5 @@
+module Plan
+
+  VERSION = '0.0.1'
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/plan'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: plan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- John Crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70151867057320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151867057320
+description: plan is a simple command-line todo-list manager
+email: john.crepezzi@gmail.com
+executables:
+- plan
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/plan/advice.rb
+- lib/plan/cli.rb
+- lib/plan/item.rb
+- lib/plan/version.rb
+- lib/plan.rb
+- bin/plan
+- spec/spec_helper.rb
+homepage: http://github.com/seejohnrun/plan
+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: plan
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: simple command-line todo-list manager
+test_files:
+- spec/spec_helper.rb