ipt 1.0.0

data/lib/pt/cli.rb

@@ -0,0 +1,163 @@
+require 'yaml'
+require 'highline'
+require 'tempfile'
+require 'uri'
+require 'thor'
+require 'paint'
+
+# String patch monkey
+class String
+  %i[blue yellow green red white black magenta cyan bold].each do |color|
+    define_method(color) do
+      Paint[self, color]
+    end
+  end
+end
+
+module PT
+  class CLI < Thor
+    include PT::Action
+    include PT::IO
+    attr_reader :project
+
+    TYPE=%w[feature bug chore release]
+    ACTION = %w[show open start finish deliver accept reject done assign estimate tasks comment label edit unstart]
+
+    default_task :mywork
+
+    def initialize(*args)
+      super
+      @io = HighLine.new
+      @config = PT::Configuration.new
+      @client = @config.client || Client.new
+      @project = @client.project
+    end
+
+    %w[unscheduled started finished delivered accepted rejected].each do |state|
+      desc "#{state} <owner>", "show all #{state} stories"
+      define_method(state.to_sym) do  |owner = nil|
+        filter =  "state:#{state}"
+        filter << " owner:#{owner}" if owner
+        select_story_from_paginated_table(title: "#{state} stories") do |page|
+          @client.get_stories(filter: filter, page: page)
+        end
+      end
+    end
+
+    ACTION.each do |action|
+      desc "#{action} [id]", "#{action} story"
+      define_method(action.to_sym) do |story_id = nil|
+        if story_id
+          if story = @client.project.story(story_id.to_i)
+            title("#{action} '#{story.name}'")
+            send("#{action}_story", story)
+          else
+            message("No matches found for '#{story_id}', please use a valid pivotal story Id")
+            return
+          end
+        else
+          method_name = "get_stories_to_#{action}"
+          story = select_story_from_paginated_table(default_action: action, title: "Stories to #{action}") do |page|
+            if @client.respond_to?(method_name.to_sym)
+              @client.send("get_stories_to_#{action}", page: page)
+            else
+              @client.get_stories(page: page)
+            end
+          end
+        end
+      end
+    end
+
+    TYPE.each do |type|
+      desc "#{type} <owner>", "show all #{type} stories"
+      define_method(type.to_sym) do  |owner = nil|
+        filter =  "story_type:#{type} -state:accepted"
+        filter << " owner:#{owner}" if owner
+        select_story_from_paginated_table(title: "#{type} stories") do |page|
+          @client.get_stories(filter: filter, page: page)
+        end
+      end
+    end
+
+    desc 'mywork', 'list all your stories'
+    def mywork
+      select_story_from_paginated_table(title: 'My Work') do |page|
+        @client.get_stories(filter: "owner:#{Settings[:user_name]} -state:accepted", page: page)
+      end
+    end
+
+    %w[ current backlog ].each do |scope|
+      desc "#{scope}", 'list all stories for #{scope} iteration'
+      define_method(scope.to_sym) do
+        select_story_from_paginated_table(title: "#{scope} iteration") do |page|
+          @client.get_stories_from_iteration(scope: scope, page: page)
+        end
+      end
+    end
+
+    desc "list [owner]", "list all stories from owner"
+    def list(owner = nil)
+      owner = choose_person.initials unless owner
+      select_story_from_paginated_table(title: "stories for #{owner}") do |page|
+        @client.get_stories(filter: "owner:#{owner} -state:accepted", page: page)
+      end
+    end
+
+    desc "recent", "show stories you've recently shown or commented on with pt"
+    def recent
+      title("Your recent stories from #{project_to_s}")
+      select_story_from_paginated_table(title: "recent stories") do |page|
+        @client.get_stories(filter: Settings[:recent_tasks].join(','), page: page)
+      end
+    end
+
+    desc 'create [title] --owner <owner> --type <type> -m', "create a new story (and include description ala git commit)"
+    long_desc <<-LONGDESC
+      create story with title [title]
+
+      --owner, -o  set owner
+
+      --type , -t  set story type
+
+      -m           enable add description using vim
+
+      omit all parameters will start interactive mode
+    LONGDESC
+    option :type, aliases: :t
+    option :owner, aliases: :o
+    option :m, type: :boolean
+    def create(title =nil)
+      if title
+        owner_id = if options[:owner] && (owner = @client.find_member(options[:owner]))
+                     owner.person.id
+                   else
+                     nil
+                   end
+        description = edit_using_editor if options[:m]
+        params = {
+          name: title,
+          requested_by_id: Settings[:user_id],
+          owner_ids: [owner_id],
+          description: description
+        }
+        params[:story_type] = options[:type] if options[:type]
+        story = @client.create_story(params)
+        congrats("Story with title #{story.name} has been created \n #{story.url}")
+      else
+        create_interactive_story
+      end
+    end
+
+    desc "find [query] " ,"looks in your stories by title and presents it"
+    long_desc <<-LONGDESC
+      search using pivotal tracker search query
+    LONGDESC
+    def find(query=nil)
+      query ||= ask("Please type seach query") { |q| q.readline = true }
+      story = select_story_from_paginated_table(title: "Search result for #{query}")do |page|
+        @client.get_stories(filter: query, page: page)
+      end
+      show_story(story)
+    end
+  end
+end

data/lib/pt/client.rb

@@ -0,0 +1,133 @@
+require 'uri'
+require 'tracker_api'
+
+module PT
+  class Client < SimpleDelegator
+
+    STORY_FIELDS=':default,requested_by(initials),owners(initials),tasks(complete,description),comments(text,file_attachment_ids,person(initials))'
+
+    attr_reader :config, :client, :total_record, :limit
+
+    def initialize
+      @client = TrackerApi::Client.new(token: Settings[:pivotal_api_key])
+      self.__setobj__(@client)
+      @limit = Settings[:limit] || 10
+    end
+
+    def total_page
+      @total_record = @client.last_response.env.response_headers["X-Tracker-Pagination-Total"]
+      @total_record ? (@total_record.to_f/limit).ceil : 1
+    end
+
+    def current_page
+      offset = @client.last_response.env.response_headers["X-Tracker-Pagination-Offset"]
+      offset ? ((offset.to_f/limit)+1).to_i.ceil : 1
+    end
+
+    def project
+      @client.project(Settings[:project_id])
+    end
+
+    def get_stories_to_estimate(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} type:feature estimate:-1"
+      get_stories(params)
+    end
+
+    def get_stories_to_unstart(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} -state:unstarted"
+      get_stories(params)
+    end
+
+    def get_stories_to_start(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} type:feature,bug state:unscheduled,rejected,unstarted"
+      tasks = get_stories(params)
+      tasks.reject{ |t| (t.story_type == 'feature') && (!t.estimate) }
+    end
+
+    def get_stories_to_finish(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} -state:unscheduled,rejected"
+      get_stories(params)
+    end
+
+    def get_stories_to_deliver(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} -state:delivered,accepted,rejected"
+      get_stories(params)
+    end
+
+    def get_stories_to_accept(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} -state:accepted"
+      get_stories(params)
+    end
+
+    def get_stories_to_reject(params={})
+      params[:filter] =  "owner:#{Settings[:user_name]} -state:rejected"
+      get_stories(params)
+    end
+
+    def get_stories_to_assign(params={})
+      params[:filter] =  "-state:accepted"
+      get_stories(params)
+    end
+
+    def get_stories(params={})
+      limit = @limit || 10
+      page = params[:page] || 0
+      offset = page*limit
+      filter = params[:filter] || '-state=accepted'
+      project.stories limit: limit, fields: STORY_FIELDS, auto_paginate: false, offset: offset, filter: filter
+    end
+
+    def get_stories_from_iteration(params={})
+      page = params[:page] || 0
+      puts "page #{page}"
+      scope = params[:scope] || 'current'
+      project.iterations(scope: scope, fields: ":default,stories(#{STORY_FIELDS})")[page]&.stories || []
+    end
+
+
+    def get_member(query)
+      member = project.memberships.select{ |m| m.person.name.downcase.start_with?(query.downcase) || m.person.initials.downcase == query.downcase }
+      member.empty? ? nil : member.first
+    end
+
+    def find_member(query)
+      project.memberships.detect do |m|
+        m.person.name.downcase.start_with?(query.downcase) || m.person.initials.downcase == query.downcase
+      end
+    end
+
+    def get_members
+      project.memberships fields: ':default,person'
+    end
+
+
+    def mark_task_as(task, state)
+      task.current_state = state
+      task.save
+    end
+
+    def estimate_story(task, points)
+      task.estimate = points
+      task.save
+    end
+
+    def assign_story(story, owner)
+      story.add_owner(owner)
+      story.save
+    end
+
+    def add_label(task, label)
+      task.add_label(label)
+      task.save
+    end
+
+    def comment_task(story, comment)
+      task.create_comment(text: comment)
+    end
+
+    def create_story(args)
+      project.create_story(args)
+    end
+
+  end
+end

data/lib/pt/configuration.rb

@@ -0,0 +1,65 @@
+require 'config'
+module PT
+  class Configuration
+    include PT::IO
+    GLOBAL_CONFIG_PATH = ENV['HOME'] + "/.pt.yml"
+    LOCAL_CONFIG_PATH = Dir.pwd + '/.pt.yml'
+
+    attr_reader :client
+
+    def initialize
+      Config.load_and_set_settings(GLOBAL_CONFIG_PATH, get_local_config_path)
+      unless (Settings[:pivotal_api_key] ||= ENV['PIVOTAL_API_KEY'])
+        message "I can't find info about your Pivotal Tracker account in #{GLOBAL_CONFIG_PATH}."
+        Settings[:pivotal_api_key] = ask "What is your token?"
+        congrats "Thanks!",
+          "Your API id is " + Settings[:pivotal_api_key],
+          "I'm saving it in #{GLOBAL_CONFIG_PATH} so you don't have to log in again."
+        save_config({"pivotal_api_key" => Settings[:pivotal_api_key]}, GLOBAL_CONFIG_PATH)
+      end
+      @client = Client.new
+      Settings[:user_name] ||= @client.me.name || ENV['pivotal_user_name']
+      Settings[:user_id] ||= @client.me.id || ENV['pivotal_user_id']
+      Settings[:user_initials] ||= @client.me.initials || ENV['pivotal_user_initials']
+
+
+      unless (Settings[:project_id] ||= ENV['PIVOTAL_PROJECT_ID'])
+        projects = ProjectTable.new(@client.projects)
+        project = select("Please select the project for the current directory", projects)
+        Settings[:project_id], Settings[:project_name] = project.id, project.name
+      end
+
+      save_config(Settings.to_hash, get_local_config_path())
+    end
+
+    def get_local_config_path
+      # If the local config path does not exist, check to see if we're in a git repo
+      # And if so, try the top level of the checkout
+      if (!File.exist?(LOCAL_CONFIG_PATH) && system('git rev-parse 2> /dev/null'))
+        return `git rev-parse --show-toplevel`.chomp() + '/.pt.yml'
+      else
+        return LOCAL_CONFIG_PATH
+      end
+    end
+
+    def save_config(config, path)
+      config = stringify(config)
+      File.new(path, 'w') unless File.exists?(path)
+      File.open(path, 'w') {|f| f.write(config.to_yaml) }
+    end
+
+    private
+
+      def check_local_config_path
+        if GLOBAL_CONFIG_PATH == get_local_config_path()
+          error("Please execute .pt inside your project directory and not in your home.")
+          exit
+        end
+      end
+
+      def stringify(hash)
+        hash.inject({}) { |memo, (k,v)| memo[k.to_s] = v; memo }
+      end
+
+  end
+end

data/lib/pt/data_row.rb

@@ -0,0 +1,83 @@
+require 'iconv' unless "older_ruby?".respond_to?(:force_encoding)
+
+module PT
+  class DataRow
+
+    attr_accessor :num, :record, :state, :owners
+
+    def initialize(orig, dataset)
+      @record = orig
+      @num = dataset.index(orig) + 1
+      if defined? orig.current_state
+        @state = orig.current_state
+      end
+    end
+
+    def method_missing(method)
+      str = @record.send(method).to_s
+      str.respond_to?(:force_encoding) ? str.force_encoding('utf-8') : Iconv.iconv('UTF-8', 'UTF-8', str)
+    end
+
+    def to_s
+      @record.send(self.to_s_attribute)
+    end
+
+    def to_s_attribute
+      @n.to_s
+    end
+
+    def name
+      _name = @record.name
+      if _name.size > 15
+        _name[0..15] + '...'
+      else
+        _name
+      end
+    end
+
+    def owners
+      if @record.instance_variable_get(:@owners).present?
+        @record.owners.map{|o| o.initials == Settings[:user_initials] ? o.initials.red : o.initials }.join(',')
+      end
+    end
+
+    def state
+      state = @record.current_state
+      case state
+      when 'delivered'
+        state.yellow
+      when 'finished'
+        state.blue
+      when 'accepted'
+        state.green
+      when 'rejected'
+        state.red
+      when 'started'
+        state.white
+      else
+        state.black
+      end
+    end
+
+    def story_type
+      t = @record.story_type
+      case t
+      when 'bug'
+        '🐞'
+      when 'feature'
+        '⭐'
+      when 'release'
+        '🏁'
+      when 'chore'
+        '⚙️'
+      else
+        t
+      end
+    end
+
+    def estimate
+      @record.estimate.to_i if @record.estimate
+    end
+
+  end
+end

data/lib/pt/data_table.rb

@@ -0,0 +1,107 @@
+# require 'hirb'
+# require 'hirb-unicode'
+require 'terminal-table'
+
+module PT
+
+  class DataTable
+
+    # extend ::Hirb::Console
+
+    def initialize(dataset, title=nil)
+      @title = title
+      @rows = dataset.map{ |row| DataRow.new(row, dataset) }
+    end
+
+    def print(config={})
+      if @rows.empty?
+        puts "\n#{'-- empty list --'.center(36)}\n"
+      else
+
+        headers = [:num]
+        headers += self.class.headers.present? ? self.class.headers : self.class.fields
+
+        fields = [:num] + self.class.fields
+        rows = []
+        @rows.each_with_index do |row, index|
+          _row = fields.map { |f| row.send(f) }
+          rows << _row
+        end
+        table = Terminal::Table.new(title: @title, headings: headers,
+                                   rows: rows, style: { all_separators: true })
+        puts table
+      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
+
+    def self.headers
+      []
+    end
+
+  end
+
+
+  class ProjectTable < DataTable
+
+    def self.fields
+      [:name]
+    end
+
+  end
+
+
+  class TasksTable < DataTable
+
+    def self.fields
+      [:name, :owners, :story_type, :estimate, :state]
+    end
+
+    def self.headers
+      [:title, :owners, :type, :pt, :state]
+    end
+
+  end
+
+  class MultiUserTasksTable < DataTable
+
+    def self.fields
+      [:owned_by, :name, :state, :id]
+    end
+
+  end
+
+  class PersonsTable < DataTable
+
+    def self.fields
+      [:initials, :name]
+    end
+
+  end
+
+  class TodoTaskTable < DataTable
+
+    def self.fields
+      [:description]
+    end
+  end
+
+  class ActionTable < DataTable
+
+    def self.fields
+      [:action]
+    end
+  end
+
+end