ruby-jira-cli 0.0.3

data/lib/jira/commands/comment/update.rb

@@ -0,0 +1,88 @@
+module Jira
+  class Comment < Thor
+
+    desc 'update', 'Update a comment to the input ticket'
+    def update(ticket=Jira::Core.ticket)
+      Command::Comment::Update.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Comment
+      class Update < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return unless comments?
+          api.patch endpoint,
+            params:  params,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def params
+          { body: body }
+        end
+
+        def comments?
+          if json.empty?
+            puts "Ticket #{ticket} has no comments."
+            return false
+          end
+          true
+        end
+
+        def endpoint
+          "issue/#{ticket}/comment/#{to_update['id']}"
+        end
+
+        def on_success
+          ->{
+            puts "Successfully updated comment originally from"\
+            " #{to_update['updateAuthor']['displayName']}."
+          }
+        end
+
+        def on_failure
+          ->{ puts "No comment updated." }
+        end
+
+        def to_update
+          @to_update ||= comments[
+            io.select("Select a comment to update:", comments.keys)
+          ]
+        end
+
+        def comments
+          @comments ||= (
+            comments = {}
+            json.each do |comment|
+              comments[description_for(comment)] = comment
+            end
+            comments
+          )
+        end
+
+        def description_for(comment)
+          author = comment['updateAuthor']['displayName']
+          updated_at = Jira::Format.time(Time.parse(comment['updated']))
+          body = comment['body'].split.join(" ")
+          truncate("#{author} @ #{updated_at}: #{body}", 160)
+        end
+
+        def json
+          @json ||= api.get("issue/#{ticket}/comment")['comments']
+        end
+
+      end
+    end
+  end
+end

data/lib/jira/commands/comment.rb

@@ -0,0 +1,14 @@
+require 'jira/commands/comment/add'
+require 'jira/commands/comment/delete'
+require 'jira/commands/comment/list'
+require 'jira/commands/comment/update'
+
+module Jira
+  class CLI < Thor
+
+    desc 'comment <command>', 'Commands for comment operations in JIRA'
+    subcommand 'comment', Comment
+
+  end
+
+end

data/lib/jira/commands/delete.rb

@@ -0,0 +1,92 @@
+module Jira
+  class CLI < Thor
+
+    desc "delete", "Deletes a ticket in JIRA and the git branch"
+    method_option :force, type: :boolean, default: false
+    def delete(ticket=Jira::Core.ticket)
+      Command::Delete.new(ticket, options[:force]).run
+    end
+
+  end
+
+  module Command
+    class Delete < Base
+
+      attr_accessor :ticket, :force
+
+      def initialize(ticket, force)
+        self.ticket = ticket
+        self.force = force
+      end
+
+      def run
+        return if ticket.empty?
+        return if metadata.empty?
+        return if metadata['fields'].nil?
+        return if subtasks_failure?
+
+        api.delete "issue/#{ticket}?deleteSubtasks=#{force}",
+          success: on_success,
+          failure: on_failure
+      end
+
+    private
+
+      def on_success
+        -> do
+          on_failure and return unless create_branch?
+          on_failure and return unless delete_branch?
+        end
+      end
+
+      def on_failure
+        -> { puts "No change made to ticket #{ticket}." }
+      end
+
+      def branches
+        branches = `git branch --list 2> /dev/null`.split(' ')
+        branches.delete("*")
+        branches.delete(ticket.to_s)
+        branches
+      end
+
+      def create_branch?
+        response = io.yes?("Create branch?")
+
+        if branches.count == 1 or response
+          io.say("Creating a new branch.")
+          new_branch = io.ask("Branch?").strip
+          new_branch.delete!(" ")
+          on_failure and return false if new_branch.empty?
+          `git branch #{new_branch} 2> /dev/null`
+        end
+        true
+      end
+
+      def delete_branch?
+        response = self.io.select("Select a branch:", branches)
+        `git checkout #{response} 2> /dev/null`
+        `git branch -D #{ticket} 2> /dev/null`
+        true
+      end
+
+      def subtasks_failure?
+        return false unless subtask?
+        if !metadata['fields']['subtasks'].empty? && !force
+          self.force = io.yes?("Delete all sub-tasks for ticket #{ticket}?")
+          return true unless force
+        end
+        false
+      end
+
+      def subtask?
+        metadata['fields']['issuetype']['subtask']
+      end
+
+      def metadata
+        @metadata ||= api.get("issue/#{ticket}")
+      end
+
+    end
+  end
+end

data/lib/jira/commands/describe.rb

@@ -0,0 +1,64 @@
+module Jira
+  class CLI < Thor
+
+    desc "describe", "Describes the input ticket"
+    def describe(ticket=Jira::Core.ticket)
+      Command::Describe.new(ticket).run
+    end
+
+  end
+
+  module Command
+    class Describe < Base
+
+      attr_accessor :ticket
+
+      def initialize(ticket)
+        self.ticket = ticket
+      end
+
+      def run
+        return if json.empty?
+        return unless errors.empty?
+        render_table(header, [row])
+      end
+
+      def header
+        [ 'Ticket', 'Assignee', 'Status', 'Summary', 'Description' ]
+      end
+
+      def row
+        [ ticket, assignee, status, summary, description ]
+      end
+
+      def errors
+        @errors ||= (json['errorMessages'] || []).join('. ')
+      end
+
+      def assignee
+        (fields['assignee'] || {})['name'] || 'Unassigned'
+      end
+
+      def status
+        (fields['status'] || {})['name'] || 'Unknown'
+      end
+
+      def summary
+        truncate(json['fields']['summary'], 45)
+      end
+
+      def description
+        json['fields']['description']
+      end
+
+      def fields
+        json['fields'] || {}
+      end
+
+      def json
+        @json ||= api.get "issue/#{ticket}"
+      end
+
+    end
+  end
+end

data/lib/jira/commands/install.rb

@@ -0,0 +1,121 @@
+module Jira
+  class CLI < Thor
+
+    desc "install", "Guides the user through JIRA CLI installation"
+    def install
+      Command::Install.new.run
+    end
+
+    no_tasks do
+      def try_install_cookie
+        return false if Jira::Core.cookie.empty?
+        puts "  ... cookie expired, renewing your cookie"
+        Command::Install.new.run_rescue_cookie
+        puts "Cookie renewed, updating .jira-rescue-cookie"
+        File.open(Jira::Core.rescue_cookie_path, "a") do |f|
+          f << "r"
+        end
+        puts "  ... updated .jira-rescue-cookie"
+        return true
+      rescue Interrupt, StandardError
+        false
+      end
+    end
+
+  end
+
+  module Command
+    class Install < Base
+
+      def run
+        io.say('Please enter your JIRA information.')
+        inifile[:global] = base_params
+        inifile.write # Do this now because cookie authentication uses api calls
+
+        inifile.delete_section("cookie") if inifile.has_section?("cookie")
+        case authentication
+        when "basic"
+          inifile[:global][:password] = password
+        when "token"
+          inifile[:global][:token] = token
+        when "cookie"
+          response = cookie(session_params)
+          inifile[:cookie] = {}
+          inifile[:cookie][:name] = response['name']
+          inifile[:cookie][:value] = response['value']
+        end
+        inifile.write
+      end
+
+      def run_rescue_cookie
+        response = cookie(rescue_cookie_params)
+        config = Jira::Core.config
+        config[:cookie] = {}
+        config[:cookie][:name] = response['name']
+        config[:cookie][:value] = response['value']
+        config.write
+      end
+
+    private
+
+      def base_params
+        {
+          url:      url,
+          username: username
+        }
+      end
+
+      def rescue_cookie_params
+        {
+          username: Jira::Core.username,
+          password: password
+        }
+      end
+
+      def session_params
+        {
+          username: username,
+          password: password
+        }
+      end
+
+      def authentication
+        @authentication ||= io.select(
+          "Select an authentication type:",
+          ["basic", "cookie", "token"]
+        )
+      end
+
+      def url
+        @url ||= io.ask("JIRA URL:")
+      end
+
+      def username
+        @username ||= io.ask("JIRA username:")
+      end
+
+      def password
+        io.mask("JIRA password:")
+      end
+
+      def token
+        io.ask("JIRA token:")
+      end
+
+      def cookie(params)
+        response = auth_api.post('session', params: params)
+        return {} unless response['errorMessages'].nil?
+        response['session']
+      end
+
+      def inifile
+        @inifile ||= IniFile.new(
+          comment:  '#',
+          encoding: 'UTF-8',
+          filename: Jira::Core.cli_path
+        )
+      end
+
+    end
+  end
+end

data/lib/jira/commands/link.rb

@@ -0,0 +1,94 @@
+module Jira
+  class CLI < Thor
+
+    desc "link", "Creates a link between two tickets in JIRA"
+    def link(ticket=Jira::Core.ticket)
+      Command::Link.new(ticket).run
+    end
+
+  end
+
+  module Command
+    class Link < Base
+
+      attr_accessor :ticket
+
+      def initialize(ticket)
+        self.ticket = ticket
+      end
+
+      def run
+        return if ticket.empty?
+        return if metadata.empty?
+        return if issue_link_type.empty?
+        return if outward_ticket.empty?
+        return unless invalid_ticket?
+
+        begin
+          api.post "issueLink",
+            params: params,
+            success: on_success,
+            failure: on_failure
+        rescue CommandException
+        end
+      end
+
+    private
+
+      def params
+        {
+          type: {
+            name: issue_link_type[:name]
+          },
+          inwardIssue: {
+            key: ticket
+          },
+          outwardIssue: {
+            key: outward_ticket
+          }
+        }
+      end
+
+      def issue_link_type
+        return @issue_link_type unless @issue_link_type.nil?
+
+        types = {}
+        metadata['issueLinkTypes'].each do |type|
+          data = {
+            id:       type['id'],
+            name:     type['name'],
+            inward:   type['inward'],
+            outward:  type['outward']
+          }
+          types[type['name']] = data
+        end
+        choice = io.select("Select a link type:", types.keys)
+        @issue_link_type = types[choice]
+      end
+
+      def on_success
+        ->{
+          puts "Successfully linked ticket #{ticket} to"\
+          " ticket #{outward_ticket}."
+        }
+      end
+
+      def on_failure
+        ->{ puts "No ticket linked." }
+      end
+
+      def outward_ticket
+        @outward_ticket ||= io.ask("Outward ticket:").strip
+      end
+
+      def invalid_ticket?
+        !Jira::Core.ticket?(outward_ticket)
+      end
+
+      def metadata
+        @metadata ||= api.get("issueLinkType")
+      end
+
+    end
+  end
+end

data/lib/jira/commands/log/add.rb

@@ -0,0 +1,52 @@
+module Jira
+  class Log < Thor
+
+    desc 'add', 'Logs work against the input ticket'
+    method_option :time, aliases: "-t", type: :string, default: nil, lazy_default: "", banner: "TIME"
+    def add(ticket=Jira::Core.ticket)
+      Command::Log::Add.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    module Log
+      class Add < Base
+
+        attr_accessor :ticket, :options
+
+        def initialize(ticket, options)
+          self.ticket = ticket
+          self.options = options
+        end
+
+        def run
+          return if time_spent.empty?
+          api.post "issue/#{ticket}/worklog",
+            params:  params,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def params
+          { timeSpent: time_spent }
+        end
+
+        def time_spent
+          @time_spent ||= options['time'] || io.ask("Time spent on ticket #{ticket}:")
+        end
+
+        def on_success
+          ->{ puts "Successfully logged #{time_spent} on ticket #{ticket}." }
+        end
+
+        def on_failure
+          ->{ puts "No work was logged on ticket #{ticket}." }
+        end
+
+      end
+    end
+  end
+end

data/lib/jira/commands/log/delete.rb

@@ -0,0 +1,80 @@
+module Jira
+  class Log < Thor
+
+    desc 'delete', 'Deletes logged work against the input ticket'
+    def delete(ticket=Jira::Core.ticket)
+      Command::Log::Delete.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Log
+      class Delete < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return unless logs?
+          api.delete endpoint,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def logs?
+          if json.empty?
+            puts "Ticket #{ticket} has no work logged."
+            return false
+          end
+          true
+        end
+
+        def endpoint
+          "issue/#{ticket}/worklog/#{to_delete['id']}"
+        end
+
+        def on_success
+          ->{ puts "Successfully deleted #{to_delete['timeSpent']}." }
+        end
+
+        def on_failure
+          ->{ puts "No logged work deleted." }
+        end
+
+        def to_delete
+          @to_delete ||= logs[
+            io.select("Select a worklog to delete:", logs.keys)
+          ]
+        end
+
+        def logs
+          @logs ||= (
+            logs = {}
+            json.each do |log|
+              logs[description_for(log)] = log
+            end
+            logs
+          )
+        end
+
+        def description_for(log)
+          author = log['updateAuthor']['displayName']
+          updated_at = Jira::Format.time(Time.parse(log['updated']))
+          time_spent = log['timeSpent']
+          "#{author} @ #{updated_at}: #{time_spent}"
+        end
+
+        def json
+          @json ||= api.get("issue/#{ticket}/worklog")['worklogs']
+        end
+
+      end
+    end
+  end
+end

data/lib/jira/commands/log/list.rb

@@ -0,0 +1,69 @@
+module Jira
+  class Log < Thor
+
+    desc 'list', 'Lists work logged on the input ticket'
+    def list(ticket=Jira::Core.ticket)
+      Command::Log::List.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Log
+      class List < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket=Jira::Core.ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          if logs.empty?
+            puts "Ticket #{ticket} has no work logged."
+            return
+          end
+          render_table(header, rows)
+        end
+
+      private
+
+        attr_accessor :log
+
+        def header
+          [ 'Author', 'Updated At', 'Time Spent' ]
+        end
+
+        def rows
+          rows = []
+          logs.each do |log|
+            self.log = log
+            rows << row
+          end
+          rows
+        end
+
+        def row
+          [ author, updated_at, time_spent ]
+        end
+
+        def author
+          log['updateAuthor']['displayName']
+        end
+
+        def updated_at
+          Jira::Format.time(Time.parse(log['updated']))
+        end
+
+        def time_spent
+          log['timeSpent']
+        end
+
+        def logs
+          @logs ||= api.get("issue/#{ticket}/worklog")['worklogs']
+        end
+
+      end
+    end
+  end
+end