ruby-jira-cli 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b229a4bc96644bd3e819673aa12a382530c9ed74
+  data.tar.gz: 0273cb796258b0e39599830647b9dedff8519479
+SHA512:
+  metadata.gz: e14df53c00913ae286f0cd053f4f8d92adbb8526f2271d4201e217b72ba166e1a967796988c38b4851d40b0da1797f14a2609b8dcf4aee041aa3932ca6c8cee5
+  data.tar.gz: 6ee3d17a550cf5f974440e032af391edd58b5e108c4f60e610c96958e7a9c4890c4807086151350ec1fd05e60459f48e003324bd984e302ce88881f55423dede

data/README.md

@@ -0,0 +1,47 @@
+# JIRA CLI
+
+Ruby gem CLI tool used to manage JIRA workflows leveraging git
+
+* * *
+
+### Available Commands
+
+    jira all                # Describes all local branches that match JIRA ticketing syntax
+    jira assign             # Assign a ticket to a user
+    jira attachments        # View ticket attachments
+    jira checkout <ticket>  # Checks out a ticket from JIRA in the git branch
+    jira comment <command>  # Commands for comment operations in JIRA
+    jira delete             # Deletes a ticket in JIRA and the git branch
+    jira describe           # Describes the input ticket
+    jira help [COMMAND]     # Describe available commands or one specific command
+    jira install            # Guides the user through JIRA CLI installation
+    jira link               # Creates a link between two tickets in JIRA
+    jira log <command>      # Commands for logging operations in JIRA
+    jira new                # Creates a new ticket in JIRA and checks out the git branch
+    jira rename             # Updates the summary of the input ticket
+    jira sprint             # Lists sprint info
+    jira tickets [jql]      # List the in progress tickets of the input username (or jql)
+    jira transition         # Transitions the input ticket to the next state
+    jira version            # Displays the version
+    jira vote <command>     # Commands for voting operations in JIRA
+    jira watch <command>    # Commands for watching tickets in JIRA
+
+### Gem Installation
+
+Rubygems:
+
+    gem install ruby-jira-cli
+
+Manually:
+
+    git clone git@github.com:ajmyers01/jira-cli.git
+    cd jira-cli
+    ./scripts/install
+
+### Project Installation
+
+In order to use this tool, you'll need to run the installation script in the
+git repository that you're managing via JIRA.
+
+    cd path/to/jira/repo
+    jira install

data/bin/jira

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'jira'
+begin
+  Jira::CLI.start
+  File.delete(Jira::Core.rescue_cookie_path) if File.exist?(Jira::Core.rescue_cookie_path)
+rescue Faraday::Error, UnauthorizedException
+  if Jira::CLI.new.try_install_cookie
+    if File.read(Jira::Core.rescue_cookie_path).count('r') < 3
+      puts "Re-running: jira #{ARGV.join(' ')}"
+      Process.waitpid(
+        Process.fork do
+          Process.exec("jira #{ARGV.join(' ')}")
+        end
+      )
+      exit
+    end
+  end
+  puts "JIRA failed connect, you may need to rerun 'jira install'"
+rescue GitException
+  puts "JIRA commands can only be run within a git repository."
+rescue InstallationException
+  puts "Please run #{Jira::Format.summary('jira install')} before "\
+       "running this command."
+rescue Interrupt
+end

data/lib/jira/api.rb

@@ -0,0 +1,76 @@
+module Jira
+  class API
+
+    def get(path, options={})
+      response = client.get(path, options[:params] || {}, headers)
+      process(response, options)
+    end
+
+    def post(path, options={})
+      response = client.post(path, options[:params] || {}, headers)
+      process(response, options)
+    end
+
+    def patch(path, options={})
+      response = client.put(path, options[:params] || {}, headers)
+      process(response, options)
+    end
+
+    def delete(path, options={})
+      response = client.delete(path, options[:params] || {}, headers)
+      process(response, options)
+    end
+
+  protected
+
+    def process(response, options)
+      raise UnauthorizedException if response.status == 401
+      body = response.body || {}
+      json = (body if body.class == Hash) || {}
+      if response.success? && json['errorMessages'].nil?
+        respond_to(options[:success], body)
+      else
+        puts json['errorMessages'].join('. ') unless json['errorMessages'].nil?
+        respond_to(options[:failure], body)
+      end
+      body
+    end
+
+    def respond_to(block, body)
+      return if block.nil?
+      case block.arity
+      when 0
+        block.call
+      when 1
+        block.call(body)
+      end
+    end
+
+    def client
+      @client ||= Faraday.new(endpoint) do |faraday|
+        faraday.request  :basic_auth, Jira::Core.username, Jira::Core.password unless Jira::Core.password.nil?
+        faraday.request  :token_auth, Jira::Core.token unless Jira::Core.token.nil?
+        faraday.request  :json
+        faraday.response :json
+        faraday.adapter  :net_http
+      end
+    end
+
+    def endpoint
+      "#{Jira::Core.url}/rest/api/2"
+    end
+
+    def headers
+      { 'Content-Type' => 'application/json' }.merge(cookies)
+    end
+
+    def cookies
+      cookie = Jira::Core.cookie
+      unless cookie.empty?
+        return { 'cookie' => "#{cookie[:name]}=#{cookie[:value]}" }
+      end
+      {}
+    end
+
+  end
+end

data/lib/jira/auth_api.rb

@@ -0,0 +1,11 @@
+module Jira
+  class AuthAPI < API
+
+  protected
+
+    def endpoint
+      "#{Jira::Core.url}/rest/auth/1"
+    end
+
+  end
+end

data/lib/jira/command.rb

@@ -0,0 +1,60 @@
+# external dependencies
+require 'time'
+
+# internal dependencies
+require 'jira/api'
+require 'jira/sprint_api'
+require 'jira/auth_api'
+require 'jira/core'
+
+module Jira
+  module Command
+    class Base
+
+      def run
+        raise NotImplementedError
+      end
+
+    protected
+
+      def api
+        @api ||= Jira::API.new
+      end
+
+      def auth_api
+        @auth_api ||= Jira::AuthAPI.new
+      end
+
+      # TODO: Move this to relevant subcommand Base
+      def body(text=nil)
+        @body ||= (
+          comment = text || io.ask("Leave a comment for ticket #{ticket}:", default: 'Empty comment').strip
+          comment = comment.gsub(/\@[a-zA-Z]+/, '[~\0]') || comment
+          comment.gsub('[~@', '[~') || comment
+        )
+      end
+
+      def sprint_api
+        @sprint_api ||= Jira::SprintAPI.new
+      end
+
+      def io
+        @io ||= TTY::Prompt.new
+      end
+
+      def render_table(header, rows)
+        puts TTY::Table.new(header, rows).render(:unicode, padding: [0, 1], multiline: true)
+      end
+
+      def truncate(string, limit=80)
+        return string if string.length < limit
+        string[0..limit-3] + '...'
+      end
+
+    end
+  end
+end
+
+# load commands
+commands_directory = File.join(File.dirname(__FILE__), 'commands', '*.rb')
+Dir[commands_directory].each { |file| require file }

data/lib/jira/commands/all.rb

@@ -0,0 +1,72 @@
+module Jira
+  class CLI < Thor
+
+    desc "all", "Describes all local branches that match JIRA ticketing syntax"
+    def all
+      Command::All.new.run
+    end
+
+  end
+
+  module Command
+    class All < Base
+
+      def run
+        if tickets.empty?
+          puts 'No tickets'
+          return
+        end
+        return if json.empty?
+        return unless errors.empty?
+        render_table(header, rows)
+      end
+
+    private
+
+      def header
+        [ 'Ticket', 'Assignee', 'Status', 'Summary' ]
+      end
+
+      def rows
+        json['issues'].map do |issue|
+          [
+            issue['key'],
+            issue['fields']['assignee']['name'] || 'Unassigned',
+            issue['fields']['status']['name'] || 'Unknown',
+            truncate(issue['fields']['summary'], 45)
+          ]
+        end
+      end
+
+      def errors
+        @errors ||= (json['errorMessages'] || []).join('. ')
+      end
+
+      def json
+        @json ||= api.get "search", params: params
+      end
+
+      def params
+        {
+          jql: "key in (#{tickets.join(',')})"
+        }
+      end
+
+      def tickets
+        @tickets ||= (
+          tickets = []
+          branches.each do |branch|
+            ticket = branch.delete('*').strip
+            tickets << ticket if Jira::Core.ticket?(ticket, false)
+          end
+          tickets
+        )
+      end
+
+      def branches
+        `git branch`.strip.split("\n")
+      end
+
+    end
+  end
+end

data/lib/jira/commands/assign.rb

@@ -0,0 +1,65 @@
+module Jira
+  class CLI < Thor
+
+    desc "assign", "Assign a ticket to a user"
+    method_option :assignee, aliases: "-a", type: :string, default: nil, lazy_default: "auto", banner: "ASSIGNEE"
+    def assign(ticket=Jira::Core.ticket)
+      Command::Assign.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    class Assign < Base
+
+      attr_accessor :ticket, :options
+
+      def initialize(ticket, options={})
+        self.ticket = ticket
+        self.options = options
+      end
+
+      def run
+        api.patch path,
+          params:  params,
+          success: on_success,
+          failure: on_failure
+      end
+
+    private
+
+      def on_success
+        -> do
+          puts "Ticket #{ticket} assigned to #{name}."
+        end
+      end
+
+      def on_failure
+        ->(json) do
+          message = (json['errors'] || {})['assignee']
+          puts message || "Ticket #{ticket} was not assigned."
+        end
+      end
+
+      def path
+        "issue/#{ticket}/assignee"
+      end
+
+      def params
+        { name: assignee }
+      end
+
+      def name
+        assignee == '-1' ? 'default user' : "'#{assignee}'"
+      end
+
+      def assignee
+        @assignee ||= (
+          assignee = options['assignee'] || io.ask('Assignee?', default: 'auto')
+          assignee == 'auto' ? '-1' : assignee
+        )
+      end
+
+    end
+  end
+end

data/lib/jira/commands/attachments.rb

@@ -0,0 +1,45 @@
+module Jira
+  class CLI < Thor
+
+    desc "attachments", "View ticket attachments"
+    def attachments(ticket=Jira::Core.ticket)
+      Command::Attachments.new(ticket).run
+    end
+
+  end
+
+  module Command
+    class Attachments < Base
+
+      attr_accessor :ticket
+
+      def initialize(ticket)
+        self.ticket = ticket
+      end
+
+      def run
+        return if ticket.empty?
+        return if metadata.empty?
+        return if metadata['fields'].nil?
+
+        attachments=metadata['fields']['attachment']
+        if !attachments.nil? and attachments.count > 0
+          attachments.each do |attachment|
+            name=attachment['filename']
+            url=attachment['content']
+
+            puts "#{Jira::Format.user(name)} #{url}"
+          end
+        else
+          puts "No attachments found for ticket #{ticket}."
+        end
+      end
+
+    private
+
+      def metadata
+        @metadata ||= api.get("issue/#{ticket}")
+      end
+    end
+  end
+end

data/lib/jira/commands/checkout.rb

@@ -0,0 +1,87 @@
+module Jira
+  class CLI < Thor
+
+    desc "checkout <ticket>", "Checks out a ticket from JIRA in the git branch"
+    method_option :remote, aliases: "-r", type: :string, default: nil, lazy_default: "", banner: "REMOTE"
+    def checkout(ticket)
+      Command::Checkout.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    class Checkout < Base
+
+      attr_accessor :ticket, :options
+
+      def initialize(ticket, options)
+        self.ticket = ticket
+        self.options = options
+      end
+
+      def run
+        return unless Jira::Core.ticket?(ticket)
+        return if metadata.empty?
+        unless metadata['errorMessages'].nil?
+          on_failure
+          return
+        end
+        unless remote?
+          on_failure
+          return
+        end
+
+        create_branch unless branches.include?(ticket)
+        checkout_branch
+        reset_branch unless branches.include?(ticket)
+        on_success
+      end
+
+    private
+
+      def on_success
+        puts "Ticket #{ticket} checked out."
+      end
+
+      def on_failure
+        puts "No ticket checked out."
+      end
+
+      def branches
+        @branches ||= `git branch --list 2> /dev/null`.split(' ')
+        @branches.delete("*")
+        @branches
+      end
+
+      def create_branch
+        `git branch #{ticket} 2> /dev/null`
+      end
+
+      def checkout_branch
+        `git checkout #{ticket} 2> /dev/null`
+      end
+
+      def metadata
+        @metadata ||= api.get("issue/#{ticket}")
+      end
+
+      def remote
+        @remote ||= options['remote'] || io.select('Remote?', remotes)
+      end
+
+      def remotes
+        @remotes ||= `git remote 2> /dev/null`.split(' ')
+      end
+
+      def remote?
+        return true if remotes.include?(remote)
+        false
+      end
+
+      def reset_branch
+        `git reset --hard #{remote} 2> /dev/null`
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Jira
+  class Comment < Thor
+
+    desc 'add', 'Add a comment to the input ticket'
+    method_option :text, aliases: "-t", type: :string, default: nil, lazy_default: "", banner: "TEXT"
+    def add(ticket=Jira::Core.ticket)
+      Command::Comment::Add.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    module Comment
+      class Add < Base
+
+        attr_accessor :ticket, :options
+
+        def initialize(ticket, options)
+          self.ticket = ticket
+          self.options = options
+        end
+
+        def run
+          return if text.empty?
+          api.post "issue/#{ticket}/comment",
+            params:  params,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def params
+          { body: text }
+        end
+
+        def text
+          body(options['text'])
+        end
+
+        def on_success
+          ->{ puts "Successfully posted your comment." }
+        end
+
+        def on_failure
+          ->{ puts "No comment posted." }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Jira
+  class Comment < Thor
+
+    desc 'delete', 'Delete a comment to the input ticket'
+    def delete(ticket=Jira::Core.ticket)
+      Command::Comment::Delete.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Comment
+      class Delete < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return unless comments?
+          api.delete endpoint,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def comments?
+          if json.empty?
+            puts "Ticket #{ticket} has no comments."
+            return false
+          end
+          true
+        end
+
+        def endpoint
+          "issue/#{ticket}/comment/#{to_delete['id']}"
+        end
+
+        def on_success
+          ->{ puts "Successfully deleted comment from #{to_delete['updateAuthor']['displayName']}" }
+        end
+
+        def on_failure
+          ->{ puts "No comment deleted." }
+        end
+
+        def to_delete
+          @to_delete ||= comments[
+            io.select("Select a comment to delete:", 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/list.rb

@@ -0,0 +1,72 @@
+module Jira
+  class Comment < Thor
+
+    desc 'list', 'Lists the comments of the input ticket'
+    def list(ticket=Jira::Core.ticket)
+      Command::Comment::List.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Comment
+      class List < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return if comments.nil?
+
+          if comments.empty?
+            puts "Ticket #{ticket} has no comments."
+            return
+          end
+          render_table(header, rows)
+        end
+
+      private
+
+        attr_accessor :comment
+
+        def header
+          [ 'Author', 'Updated At', 'Body' ]
+        end
+
+        def rows
+          rows = []
+          comments.each do |comment|
+            self.comment = comment
+            rows << row
+          end
+          rows
+        end
+
+        def row
+          [ author, updated_at, body ]
+        end
+
+        def author
+          comment['updateAuthor']['displayName']
+        end
+
+        def updated_at
+          Jira::Format.time(Time.parse(comment['updated']))
+        end
+
+        def body
+          body = comment['body'].gsub("\r\n|\r|\n", ";")
+          truncate(body, 45)
+        end
+
+        def comments
+          @comments ||= api.get("issue/#{ticket}/comment")['comments']
+        end
+
+      end
+    end
+  end
+end