pt 0.1

data/Changelog.md

@@ -0,0 +1,3 @@
+# pt changelog
+
+## v0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Raul Murciano raul@murciano.net 
+
+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,49 @@
+# pt
+
+Minimal client to use Pivotal Tracker from the console.
+
+## Setup
+
+    gem install pt
+
+The first time you run it, `pt` will ask you some data about your Pivotal Tracker account and your current project.
+
+## Usage
+
+Run `pt` from the root folder of your project.
+
+    pt          # shows your "My work" tasks list
+
+Run `pt create` to create a new bug, chore or feature.
+
+The rest of the commands will open you a list of your tasks and let you interact with it:
+
+    pt open     # open a task in the browser
+
+    pt assign   # assign owner
+
+    pt comment  # add a comment
+
+    pt estimate # estimate a task in points scale
+
+    pt start    # mark a task as started
+
+    pt finish   # indicate you've finished a task
+
+    pt deliver  # indicate the task is delivered
+
+    pt accept   # mark a task as accepted
+
+    pt reject   # mark a task as rejected, explaining why
+
+## Thanks to...
+
+- the [Pivotal Tracker](https://www.pivotaltracker.com) guys for making a planning tool that doesn't suck and has an API
+- [Justin Smestad](https://github.com/jsmestad) for his nice `pivotal-tracker` gem
+- [Bryan Liles](http://smartic.us/) for letting me take over the gem name
+
+## License
+See the LICENSE file included in the distribution.
+
+## Copyright
+Copyright (C) 2011 Raul Murciano <raul@murciano.net>.

data/RakeFile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+desc 'Run tests'
+Rake::TestTask.new('test') do |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end

data/bin/pt

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require File.dirname(__FILE__) + '/../lib/pt'
+
+PT::UI.new ARGV

data/lib/pt.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+
+module PT
+  class InputError < StandardError; end
+  VERSION = '0.1'
+end
+
+require 'pt/client'
+require 'pt/data_row'
+require 'pt/data_table'
+require 'pt/ui'

data/lib/pt/client.rb

@@ -0,0 +1,96 @@
+require 'pivotal-tracker'
+
+class PT::Client
+
+  def self.get_api_token(email, password)
+    PivotalTracker::Client.token(email, password)
+  rescue RestClient::Unauthorized
+    raise PT::InputError.new("Bad email/password combination.")
+  end
+
+  def initialize(api_number)
+    PivotalTracker::Client.token = api_number
+  end
+
+  def get_projects
+    PivotalTracker::Project.all
+  end
+
+  def get_project(project_id)
+    PivotalTracker::Project.find(project_id)
+  end
+
+  def get_membership(project, email)
+    PivotalTracker::Membership.all(project).select{ |m| m.email == email }.first
+  end
+
+  def get_current_iteration(project)
+    PivotalTracker::Iteration.current(project)
+  end
+
+  def get_my_work(project, user_name)
+    project.stories.all :mywork => user_name
+  end
+
+  def get_my_open_tasks(project, user_name)
+    project.stories.all :owner => user_name
+  end
+
+  def get_my_tasks_to_estimate(project, user_name)
+    project.stories.all(:owner => user_name, :story_type => 'feature').select{ |t| t.estimate == -1 }
+  end
+
+  def get_my_tasks_to_start(project, user_name)
+    tasks = project.stories.all(:owner => user_name, :current_state => 'unscheduled,rejected')
+    tasks.reject{ |t| (t.story_type == 'feature') && (t.estimate == -1) }
+  end
+
+  def get_my_tasks_to_finish(project, user_name)
+    project.stories.all(:owner => user_name, :current_state => 'started')
+  end
+
+  def get_my_tasks_to_deliver(project, user_name)
+    project.stories.all(:owner => user_name, :current_state => 'finished')
+  end
+
+  def get_my_tasks_to_accept(project, user_name)
+    project.stories.all(:owner => user_name, :current_state => 'delivered')
+  end
+
+  def get_my_tasks_to_reject(project, user_name)
+    project.stories.all(:owner => user_name, :current_state => 'delivered')
+  end
+
+  def get_tasks_to_assign(project, user_name)
+    project.stories.all.select{ |t| t.owned_by == nil }
+  end
+
+  def get_members(project)
+    project.memberships.all
+  end
+
+  def mark_task_as(project, task, state)
+    task = PivotalTracker::Story.find(task.id, project.id)
+    task.update(:current_state => state)
+  end
+
+  def estimate_task(project, task, points)
+    task = PivotalTracker::Story.find(task.id, project.id)
+    task.update(:estimate => points)
+  end
+
+  def assign_task(project, task, owner)
+    task = PivotalTracker::Story.find(task.id, project.id)
+    task.update(:owned_by => owner)
+  end
+
+  def comment_task(project, task, comment)
+    task = PivotalTracker::Story.find(task.id, project.id)
+    task.notes.create(:text => comment)
+  end
+
+  def create_task(project, name, owner, requester, task_type)
+    project.stories.create(:name => name, :owned_by => owner, :requested_by => requester, :story_type => task_type)
+  end
+
+end

data/lib/pt/data_row.rb

@@ -0,0 +1,22 @@
+class PT::DataRow
+
+  attr_accessor :num, :record
+
+  def initialize(orig, dataset)
+    @record = orig
+    @num = dataset.index(orig) + 1
+  end
+
+  def method_missing(method)
+    @record.send method
+  end
+
+  def to_s
+    @record.send(self.to_s_attribute)
+  end
+
+  def to_s_attribute
+    @n.to_s
+  end
+
+end

data/lib/pt/data_table.rb

@@ -0,0 +1,62 @@
+require 'hirb'
+
+module PT
+
+  class DataTable
+
+    extend ::Hirb::Console
+
+    def initialize(dataset)
+      @rows = dataset.map{ |row| DataRow.new(row, dataset) }
+    end
+
+    def print
+      if @rows.empty?
+        puts "\n         -- empty list --         \n"
+      else
+        self.class.table @rows, :fields => [:num] + self.class.fields, :unicode => true, :description => false
+      end
+    end
+
+    def [](pos)
+      pos = pos.to_i
+      (pos < 1 || pos > @rows.length) ? nil : @rows[pos-1].record
+    end
+
+    def length
+      @rows.length
+    end
+
+    def self.fields
+      []
+    end
+
+  end
+
+
+  class ProjectTable < DataTable
+
+    def self.fields
+      [:name]
+    end
+
+  end
+
+
+  class TasksTable < DataTable
+
+    def self.fields
+      [:name, :current_state]
+    end
+
+  end
+
+  class MembersTable < DataTable
+
+    def self.fields
+      [:name]
+    end
+
+  end
+
+end

data/lib/pt/ui.rb

@@ -0,0 +1,292 @@
+require 'yaml'
+require 'colored'
+require 'highline'
+
+class PT::UI
+
+  GLOBAL_CONFIG_PATH = ENV['HOME'] + "/.pt"
+  LOCAL_CONFIG_PATH = Dir.pwd + '/.pt'
+
+  def initialize(args)
+    @io = HighLine.new
+    @global_config = load_global_config
+    @client = PT::Client.new(@global_config[:api_number])
+    @local_config = load_local_config
+    @project = @client.get_project(@local_config[:project_id])
+    command = args[0].to_sym rescue :my_work
+    params = args[1..-1]
+    commands.include?(command.to_sym) ? send(command.to_sym) : help(command)
+  end
+
+  def my_work
+    title("My Work for #{user_s} in #{project_to_s}")
+    stories = @client.get_my_work(@project, @local_config[:user_name])
+    PT::TasksTable.new(stories).print
+  end
+
+  def create
+    title("Let's create a new task:")
+    name = ask("Name for the new task:")
+    if ask('Do you want to assign it now? (y/n)').downcase == 'y'
+      members = @client.get_members(@project)
+      table = PT::MembersTable.new(members)
+      owner = select("Please select a member to assign him the task", table).name
+    else
+      owner = nil
+    end
+    requester = @local_config[:user_name]
+    task_type = ask('Type? (c)hore, (b)ug, anything else for feature)')
+    task_type = case task_type
+    when 'c', 'chore'
+      'chore'
+    when 'b', 'bug'
+      'bug'
+    else
+      'feature'
+    end
+    result = @client.create_task(@project, name, owner, requester, task_type)
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task created, yay!")
+    end
+  end
+
+  def open
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_open_tasks(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to open it in the browser", table)
+    `open #{task.url}`
+  end
+
+  def comment
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_work(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to comment it", table)
+    comment = ask("Write your comment")
+    if @client.comment_task(@project, task, comment)
+      congrats("Comment sent, thanks!")
+    else
+      error("Ummm, something went wrong.")
+    end
+  end
+
+  def assign
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_tasks_to_assign(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a task to assign it an owner", table)
+    members = @client.get_members(@project)
+    table = PT::MembersTable.new(members)
+    owner = select("Please select a member to assign him the task", table).name
+    result = @client.assign_task(@project, task, owner)
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task assigned, thanks!")
+    end
+
+  end
+
+  def estimate
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_estimate(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to estimate it", table)
+    estimation = ask("How many points you estimate for it? (#{@project.point_scale})")
+    result = @client.estimate_task(@project, task, estimation)
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task estimated, thanks!")
+    end
+  end
+
+  def start
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_start(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to mark it as started", table)
+    result = @client.mark_task_as(@project, task, 'started')
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task started, go for it!")
+    end
+  end
+
+  def finish
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_finish(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to mark it as finished", table)
+    if task.story_type == 'chore'
+      result = @client.mark_task_as(@project, task, 'accepted')
+    else
+      result = @client.mark_task_as(@project, task, 'finished')
+    end
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Another task bites the dust, yeah!")
+    end
+  end
+
+  def deliver
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_deliver(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to mark it as delivered", table)
+    result = @client.mark_task_as(@project, task, 'delivered')
+    error(result.errors.errors) if result.errors.any?
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task delivered, congrats!")
+    end
+  end
+
+  def accept
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_accept(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to mark it as accepted", table)
+    result = @client.mark_task_as(@project, task, 'accepted')
+    if result.errors.any?
+      error(result.errors.errors)
+    else
+      congrats("Task accepted, hooray!")
+    end
+  end
+
+  def reject
+    title("Tasks for #{user_s} in #{project_to_s}")
+    tasks = @client.get_my_tasks_to_reject(@project, @local_config[:user_name])
+    table = PT::TasksTable.new(tasks)
+    task = select("Please select a story to mark it as rejected", table)
+    comment = ask("Please explain why are you rejecting the task")
+    if @client.comment_task(@project, task, comment)
+      result = @client.mark_task_as(@project, task, 'rejected')
+      congrats("Task rejected, thanks!")
+    else
+      error("Ummm, something went wrong.")
+    end
+  end
+
+  protected
+
+  def commands
+    (public_methods - Object.public_methods).sort
+  end
+
+  # Config
+
+  def load_global_config
+    config = YAML.load(File.read(GLOBAL_CONFIG_PATH)) rescue {}
+    if config.empty?
+      message "I can't find info about your Pivotal Tracker account in #{GLOBAL_CONFIG_PATH}"
+      while !config[:api_number] do
+        config[:email] = ask "What is your email?"
+        password = ask_secret "And your password? (won't be displayed on screen)"
+        begin
+          config[:api_number] = PT::Client.get_api_token(config[:email], password)
+        rescue PT::InputError => e
+          error e.message + " Please try again."
+        end
+      end
+      congrats "Thanks!",
+               "Your API id is " + config[:api_number],
+               "I'm saving it in #{GLOBAL_CONFIG_PATH} to don't ask you again."
+      save_config(config, GLOBAL_CONFIG_PATH)
+    end
+    config
+  end
+
+  def load_local_config
+    config = YAML.load(File.read(LOCAL_CONFIG_PATH)) rescue {}
+    if config.empty?
+      message "I can't find info about this project in #{LOCAL_CONFIG_PATH}"
+      projects = PT::ProjectTable.new(@client.get_projects)
+      project = select("Please select the project for the current directory", projects)
+      config[:project_id], config[:project_name] = project.id, project.name
+      membership = @client.get_membership(project, @global_config[:email])
+      config[:user_name], config[:user_id], config[:user_initials] = membership.name, membership.id, membership.initials
+      congrats "Thanks! I'm saving this project's info",
+               "in #{LOCAL_CONFIG_PATH}: remember to .gitignore it!"
+      save_config(config, LOCAL_CONFIG_PATH)
+    end
+    config
+  end
+
+  def save_config(config, path)
+    File.new(path, 'w') unless File.exists?(path)
+    File.open(path, 'w') {|f| f.write(config.to_yaml) }
+  end
+
+  # I/O
+
+  def split_lines(text)
+    text.respond_to?(:join) ? text.join("\n") : text
+  end
+
+  def title(*msg)
+    puts "\n#{split_lines(msg)}".bold
+  end
+
+  def congrats(*msg)
+    puts "\n#{split_lines(msg).green.bold}"
+  end
+
+  def message(*msg)
+    puts "\n#{split_lines(msg)}"
+  end
+
+  def error(*msg)
+    puts "\n#{split_lines(msg).red.bold}"
+  end
+
+  def select(msg, table)
+    if table.length > 0
+      begin
+        table.print
+        row = ask "#{msg} (1-#{table.length}, 'q' to exit)"
+        quit if row == 'q'
+        selected = table[row]
+        error "Invalid selection, try again:" unless selected
+      end until selected
+      selected
+    else
+      table.print
+      message "Sorry, there are no options to select."
+      quit
+    end
+  end
+
+  def quit
+    message "bye!"
+    exit
+  end
+
+  def ask(msg)
+    @io.ask("#{msg.bold}")
+  end
+
+  def ask_secret(msg)
+    @io.ask("#{msg.bold}"){ |q| q.echo = '*' }
+  end
+
+  def help(command)
+    error "Command <#{command}> unknown.", "Available commands:" + commands.map{ |c| "\n- #{c}" }.join
+  end
+
+  def user_s
+    "#{@local_config[:user_name]} (#{@local_config[:user_initials]})"
+  end
+
+  def project_to_s
+    "Project #{@local_config[:project_name].upcase}"
+  end
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: pt
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Raul Murciano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pivotal-tracker
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hirb
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: colored
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Minimalist, opinionated client to manage your Pivotal Tracker tasks from the command line.
+email: 
+- raul@murciano.net
+executables: 
+- pt
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pt/client.rb
+- lib/pt/data_row.rb
+- lib/pt/data_table.rb
+- lib/pt/ui.rb
+- lib/pt.rb
+- Changelog.md
+- Gemfile
+- LICENSE
+- RakeFile
+- README.md
+- bin/pt
+has_rdoc: true
+homepage: http://www.github.com/raul/pt
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pt
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Client to use Pivotal Tracker from the console.
+test_files: []
+