stack.rb

#!/usr/bin/env ruby
require 'rubygems'
require 'pp'
require 'json'
require 'uuid'

def help
  puts <<HELP
Usage: stack command [arguments]

Commands:
  help                  Show this help message.

  list                  List items in the stack.

  push <description>    Add a new item to the stack.
  pop                   Remove the most-recent item from the stack.
  drop <index>          Remove the specified item from the stack.
  touch <index>         Move the specified item to the top of the stack.

  tag <index> <tag>     Add the specified tag to the specified item.
  tag <index> -<tag>    Remove the specified tag from the specified item.

  archive <index>       Move the item to the archive. See 'list' behavior below.
  archive list          List the archived items, ordered by date last touched.
  archive clear         Clear the archive."
HELP
end

def datadir
  dropbox = "#{ENV['HOME']}/Dropbox"
  winDropbox = "#{ENV['HOME']}/My Dropbox"
  if File.directory?(dropbox)
    data = "#{dropbox}/.stack-data"
  elsif File.directory?(winDropbox)
    data = "#{winDropbox}/.stack-data"
  end

  if !File.directory?(data)
    puts "Creating stack data dir at #{data}"
    Dir.mkdir(data)
  end
  return data
end

class Record
  attr_accessor :id
  attr_accessor :description
  attr_accessor :last_activity
  attr_accessor :tags
  attr_accessor :archived

  def initialize(description)
    @id = UUID.new.generate
    @description = description
    @last_activity = now
    @tags = []
    @archived = false
  end

  def self.load(file)
    text = File.read(file)
    json = JSON.parse(text)
    record = Record.new(json['description'])
    record.id = json['id']
    record.last_activity = json['last_activity']
    record.tags = json['tags']
    record.archived = json['archived'] || false
    return record
  end

  def to_json
    json = {}
    self.instance_variables.each do |var|
      key = var[1..-1]
      json[key] = self.instance_variable_get(var.to_sym)
    end
    JSON.unparse(json)
  end

  def store
    File.open(path, "w") do |file|
      file.write(to_json)
    end
  end

  def delete
    File.delete(path)
  end

  def path
    File.join(DATADIR, @id)
  end

  def touch
    @last_activity = now
  end

  def add_tag(tag)
    if !@tags.include?(tag)
      @tags.push(tag)
    end
  end

  def remove_tag(tag)
    @tags.delete(tag)
  end

  def has_tag?(tag)
    @tags != nil && @tags.include?(tag)
  end

  def self.load_all_records(dir)
    records = []
    Dir.foreach(dir) do |file|
      # Bafflingly, on Windows, char literal comparison fails.
      if file[0] != '.' && file[0] != 46  # 46: decimal value of '.'
        records.push(Record.load(File.join(dir, file)))
      end
    end
    records.sort { |a, b| a.last_activity <=> b.last_activity }
  end

  def self.load_records(dir, archived)
    records = load_all_records(dir)
    return records.select { |r| r.archived == archived }
  end
end

def list(archived)
  records = Record.load_records(DATADIR, archived)
  reversed = records.reverse
  reversed.each do |r|
    if !archived
      str = "#{records.index(r) + 1}. "
    else
      str = ""
    end
    str += r.description
    if r.tags != nil && r.tags.length > 0
      str += "   [#{r.tags.join(',')}]"
    end
    puts str
  end
end

def push(description)
  record = Record.new(description)
  record.store
end

def pop
  records = Record.load_records(DATADIR, false)
  record = records.last
  record.delete
end

# drops the 1-based index from the list
def drop(index)
  record = item(index)
  record.delete
end

# moves the 1-based index to the top of the list
def touch(index)
  record = item(index)
  record.touch
  record.store
end

def item(index)
  records = Record.load_records(DATADIR, false)
  records[index - 1]
end

def now()
  Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
end

def assert_arg_count(args, count)
  if args.count != count
    throw "expected exactly #{count} argument(s); got #{args.count}"
  end
end

def run(args)
  if args.count == 0
    help
    return -1
  end

  command = args.shift.to_sym

  case command
    when :help
      help
      return 0

    when :list
      assert_arg_count(args, 0)
      list(false)
      return 0

    when :push
      if args.count == 0
        throw "expected an item description"
      end
      push(args.join(' '))
      return 0

    when :pop
      assert_arg_count(args, 0)
      pop
      return 0

    when :drop
      assert_arg_count(args, 1)
      drop(args[0].to_i)
      return 0

    when :touch
      assert_arg_count(args, 1)
      touch(args[0].to_i)
      return 0

    when :tag
      assert_arg_count(args, 2)
      record = item(args[0].to_i)
      if args[1].start_with?("-")
        record.remove_tag(args[1][1..-1])
      else
        record.add_tag(args[1])
      end
      record.store
      return 0

    when :archive
      assert_arg_count(args, 1)
      if args[0].to_sym == :list
        list(true)
      elsif args[0].to_sym == :clear
        Record.load_records(DATADIR, true).each { |r| r.delete }
      else
        record = item(args[0].to_i)
        record.archived = true
        record.store
      end
      return 0

  end

  help
  return -1
end


DATADIR = datadir()
statusCode = run(ARGV.clone)
exit(statusCode)