jira-cli 0.2.1 → 0.2.2

data/lib/jira/commands/describe.rb

@@ -1,85 +1,68 @@
+require_relative '../command'
+
 module Jira
   class CLI < Thor
 
     desc "describe", "Describes the input ticket"
     def describe(ticket=Jira::Core.ticket)
-      if Jira::Core.ticket?(ticket)
-        output = description(ticket.strip, false, true, true)
-        puts output if !output.strip.empty?
-      end
+      Command::Describe.new(ticket).run
     end
 
-    desc "all", "Describes all local branches that match JIRA ticketing syntax"
-    def all
-      # determine which local branches match JIRA ticket syntax
-      #   TODO - move to Jira::Git
-      tickets = {
-        current: nil,
-        others: []
-      }
-      branches = `git branch`.strip.split("\n")
-      branches.each do |branch|
-        ticket = branch.delete('*').strip
-        if Jira::Core.ticket?(ticket, false)
-          if branch.include?('*')
-            tickets[:current] = ticket
-          else
-            tickets[:others] << ticket
-          end
-        end
+  end
+
+  module Command
+    class Describe < Base
+
+      attr_accessor :ticket
+
+      def initialize(ticket)
+        self.ticket = ticket
       end
 
+      def run
+        return if json.empty?
+        return if errored?
+        render_table(header, [row])
+      end
 
-      # asynchronously fetch and describe tickets
-      output = ""
-      threads = []
-      if !tickets[:current].nil?
-        threads << Thread.new{ puts description(tickets[:current], true) }
+      def header
+        [ 'Ticket', 'Assignee', 'Status', 'Summary' ]
       end
-      mutex = Mutex.new
-      tickets[:others].each do |ticket|
-        threads << Thread.new do
-          out = description(ticket) + "\n"
-          if !out.strip.empty?
-            mutex.synchronize{ output << out }
-          end
-        end
+
+      def row
+        [ ticket, assignee, status, summary ]
+      end
+
+      def errored?
+        return false if errors.empty?
+        puts errors
+        true
       end
-      threads.each{ |thread| thread.join }
-      puts output if !output.empty?
-    end
 
-    protected
-
-      #
-      # Returns a formatted description of the input ticket
-      #
-      # @param ticket [String] the ticket to describe
-      # @param star [Boolean] if true, adds a * indicator
-      #
-      # @return [String] formatted summary string
-      #
-      def description(ticket, star=false, verbose=false, describe=false)
-        self.api.get("issue/#{ticket}", nil, verbose) do |json|
-          summary = json['fields']['summary']
-          status = json['fields']['status']['name']
-          assignee = "nil"
-          if json['fields'].has_key?("assignee")
-            if !json['fields']['assignee'].nil?
-              assignee = json['fields']['assignee']['name']
-            end
-          end
-          description = describe ? "\n" + json['fields']['description'].to_s : ""
-
-          return Jira::Format.ticket(ticket) +
-                (star ? Jira::Format.star : " ") + "  \t" +
-                ("(" + Jira::Format.user(assignee) + ")").ljust(20) +
-                Jira::Format.status(status).ljust(26) +
-                Jira::Format.summary(summary) +
-                description
-        end
-        return ""
+      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 fields
+        json['fields'] || {}
+      end
+
+      def json
+        @json ||= api.get "issue/#{ticket}"
+      end
+
+    end
   end
 end

data/lib/jira/commands/install.rb

@@ -1,29 +1,67 @@
-#
-# Installation Script
-#
+require_relative '../command'
 
 module Jira
   class CLI < Thor
 
-    desc "install", "Guides the user through JIRA installation"
+    desc "install", "Guides the user through JIRA CLI installation"
     def install
+      Command::Install.new.run
+    end
 
-      inifile = IniFile.new(:comment => '#', :encoding => 'UTF-8', :filename => Jira::Core.cli_path)
+  end
 
-      url = self.io.ask("Enter your JIRA URL")
+  module Command
+    class Install < Base
 
-      username = self.io.ask("Enter your JIRA username")
-      password = self.io.ask("Enter your JIRA password", password: true)
+      def run
+        io.say('Please enter your JIRA information.')
+        inifile[:global] = params
+        inifile.write
+      end
 
-      inifile[:global] = {
-        url: url,
-        username: username,
-        password: password
-      }
-      inifile.write
+    private
 
-      Jira::Core.send(:discard_memoized)
-    end
+      def params
+        args = {
+          url:      url,
+          username: username,
+        }
+        response = io.select("Select an authentication type:", ["basic", "token"])
+        case response
+        when "basic"
+          args[:password] = password
+        when "token"
+          args[:token] = token
+        else
+          raise InstallationException
+        end
+        args
+      end
+
+      def url
+        io.ask("JIRA URL:")
+      end
+
+      def username
+        io.ask("JIRA username:")
+      end
 
+      def password
+        io.mask("JIRA password:")
+      end
+
+      def token
+        io.ask("JIRA token:")
+      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

@@ -1,19 +1,44 @@
+require_relative '../command'
+
 module Jira
   class CLI < Thor
 
     desc "link", "Creates a link between two tickets in JIRA"
     def link(ticket=Jira::Core.ticket)
-      self.api.get("issueLinkType") do |json|
-        # determine issue link type
-        issue_link_type = select_issue_link_type(json)
-        break if issue_link_type.nil?
+      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?
 
-        # determine outward ticket
-        outward_ticket = self.io.ask("Outward ticket").strip
-        break if !Jira::Core.ticket?(outward_ticket)
+        begin
+          api.post "issueLink",
+            params: params,
+            success: on_success,
+            failure: on_failure
+        rescue CommandException
+        end
+      end
 
-        # determine api parameters
-        params = {
+      private
+
+      def params
+        {
           type: {
             name: issue_link_type[:name]
           },
@@ -24,41 +49,46 @@ module Jira
             key: outward_ticket
           }
         }
-
-        self.api.post("issueLink", params) do |json|
-          puts "Successfully linked ticket #{ticket} to ticket #{outward_ticket}."
-          return
-        end
       end
-      puts "No ticket linked."
-    end
 
-    protected
-
-      #
-      # Given the issue link type metadata, prompts the user for
-      # the issue link type to use, then return the issue link
-      # type hash
-      #
-      # @param json [Hash] issue link type metadata
-      #
-      # @return [Hash] selected issue link type metadata
-      #
-      def select_issue_link_type(json)
-        issue_link_types = {}
-        json['issueLinkTypes'].each do |issue_link_type|
+      def issue_link_type
+        return @issue_link_type unless @issue_link_type.nil?
+
+        types = {}
+        metadata['issueLinkTypes'].each do |type|
           data = {
-            id:       issue_link_type['id'],
-            name:     issue_link_type['name'],
-            inward:   issue_link_type['inward'],
-            outward:  issue_link_type['outward']
+            id:       type['id'],
+            name:     type['name'],
+            inward:   type['inward'],
+            outward:  type['outward']
           }
-          issue_link_types[issue_link_type['name']] = data
+          types[type['name']] = data
         end
-        issue_link_types['Cancel'] = nil
-        choice = self.io.choose("Select a link type", issue_link_types.keys)
-        return issue_link_types[choice]
+        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?
+        return true unless Jira::Core.ticket?(outward_ticket)
+        return false
+      end
+
+      def metadata
+        @metadata ||= api.get("issueLinkType")
+      end
+
+    end
   end
 end

data/lib/jira/commands/log.rb

@@ -3,7 +3,7 @@ module Jira
 
     desc "log", "Logs work against the input ticket"
     def log(ticket=Jira::Core.ticket)
-      time_spent = self.io.ask("Time spent on ticket #{ticket}")
+      time_spent = self.io.ask("Time spent on ticket #{ticket}:")
       self.api.post("issue/#{ticket}/worklog", { timeSpent: time_spent }) do |json|
         puts "Successfully logged #{time_spent} on ticket #{ticket}."
       end
@@ -11,7 +11,7 @@ module Jira
 
     desc "logd", "Deletes work against the input ticket"
     def logd(ticket=Jira::Core.ticket)
-      logs(ticket) if self.io.agree("List worklogs for ticket #{ticket}")
+      logs(ticket) if self.io.yes?("List worklogs for ticket #{ticket}?")
 
       index = self.get_type_of_index("worklog", "delete")
       puts "No worklog deleted." and return if index < 0
@@ -53,12 +53,12 @@ module Jira
 
     desc "logu", "Updates work against the input ticket"
     def logu(ticket=Jira::Core.ticket)
-      logs(ticket) if self.io.agree("List worklogs for ticket #{ticket}")
+      logs(ticket) if self.io.yes?("List worklogs for ticket #{ticket}?")
 
       index = self.get_type_of_index("worklog", "update")
       puts "No worklog updated." and return if index < 0
 
-      time_spent = self.io.ask("Time spent on #{ticket}").strip
+      time_spent = self.io.ask("Time spent on #{ticket}:").strip
       puts "No worklog updated." and return if time_spent.empty?
 
       self.api.get("issue/#{ticket}/worklog") do |json|

data/lib/jira/commands/new.rb

@@ -1,97 +1,155 @@
+require_relative '../command'
+
 module Jira
   class CLI < Thor
 
     desc "new", "Creates a new ticket in JIRA and checks out the git branch"
-    def new(ticket = Jira::Core.ticket)
-      self.api.get("issue/createmeta") do |meta|
-        # determine project
-        project = self.select_project(meta)
-        break if project.empty?
-
-        # determine issue type
-        issue_type = self.select_issue_type(project)
-        break if issue_type.nil?
-
-        # determine parent (ticket)
-        parent = nil
-        parent = ticket if issue_type['subtask']
-        break if !parent.nil? and !Jira::Core.ticket?(parent)
-
-        # determine summary and description
-        summary = self.io.ask("Summary")
-        description = self.io.ask("Description")
-
-        # determine api parameters
-        params = {
+    def new
+      Command::New.new.run
+    end
+
+  end
+
+  module Command
+    class New < Base
+
+      def run
+        return if metadata.empty?
+        return if project.empty?
+        return if project_metadata.empty?
+        components # Select components if any after a project
+        return if issue_type.empty?
+        return if assign_parent? && parent.empty?
+        return if summary.empty?
+        return if description.empty?
+
+        api.post 'issue',
+          params: params,
+          success: on_success,
+          failure: on_failure
+      end
+
+    private
+
+      attr_accessor :ticket
+
+      def params
+        {
           fields: {
-            project:     { id: project[:id] },
+            project:     { id: project['id'] },
             issuetype:   { id: issue_type['id'] },
             summary:     summary,
-            description: description
+            description: description,
+            parent:      @parent.nil? ? {} : { key: @parent },
+            components:  @components.nil? ? [] : @components
           }
         }
-        params[:fields][:parent] = { key: parent } if !parent.nil?
+      end
+
+      def on_success
+        ->(json) do
+          self.ticket = json['key']
+          io.say("Ticket #{ticket} created.")
+          assign?
+          create_branch? && checkout_branch?
+        end
+      end
+
+      def assign?
+        Command::Assign.new(ticket).run if io.yes?('Assign?')
+      end
+
+      def create_branch?
+        return false if io.no?("Create branch?")
+        `git branch #{ticket} 2> /dev/null`
+        true
+      end
+
+      def checkout_branch?
+        return false if io.no?("Check-out branch?")
+        `git checkout #{ticket} 2> /dev/null`
+        true
+      end
+
+      def on_failure
+        ->{ puts "No ticket created." }
+      end
+
+      def metadata
+        # TODO - {} on 200 but jira error
+        @metadata ||= api.get('issue/createmeta')
+      end
+
+      def project
+        @project ||= projects[
+          io.select("Select a project:", projects.keys)
+        ]
+      end
 
-        # post issue to server
-        self.api.post("issue", params) do |json|
-          ticket = json['key']
-          if self.io.agree("Assign")
-            self.assign(ticket)
+      def projects
+        @projects ||= (
+          projects = {}
+          metadata['projects'].each do |project|
+            projects[project['name']] = {
+              'id'     => project['id'],
+              'issues' => project['issuetypes']
+            }
           end
-          if self.io.agree("Create branch")
-            `git branch #{ticket} 2> /dev/null`
-            if self.io.agree("Check-out branch")
-              `git checkout #{ticket} 2> /dev/null`
-            end
+          projects
+        )
+      end
+
+      def project_metadata
+        id = project['id']
+        @project_metadata ||= api.get("project/#{id}")
+      end
+
+      def components
+        @components ||= (
+          components = {}
+          project_metadata['components'].each do |component|
+            components[component['name']] = {
+               'id'    => component['id']
+            }
           end
-          return
-        end
+          io.multi_select("Select component(s):", components) unless components.empty?
+        )
       end
-      puts "No ticket created."
-    end
 
-    protected
-
-      #
-      # Given the creation metadata, prompts the user for the project to use,
-      # then return the project data hash
-      #
-      # @param json [Hash] creation metadata
-      #
-      # @return [Hash] selected project's metadata
-      #
-      def select_project(json)
-        projects = {}
-        json['projects'].each do |project|
-          data = {
-            id:     project['id'],
-            issues: project['issuetypes']
-          }
-          projects[project['name']] = data
-        end
-        projects['Cancel'] = nil
-        choice = self.io.choose("Select a project", projects.keys)
-        return {} if choice == 'Cancel'
-        return projects[choice]
-      end
-
-      #
-      # Given the project metadata, prompts the user for the issue type to use
-      # and returns the selected issue type.
-      #
-      # @param project_data [Hash] project metadata
-      #
-      # @return [Hash] selected issue type
-      #
-      def select_issue_type(project_data)
-        issue_types = {}
-        project_data[:issues].each do |issue_type|
-          issue_types[issue_type['name']] = issue_type
-        end
-        issue_types['Cancel'] = nil
-        choice = self.io.choose("Select an issue type", issue_types.keys)
-        return issue_types[choice]
+      def assign_parent?
+        return false unless issue_type['subtask']
+        return false if io.no?('Set parent of subtask?')
+        true
       end
 
+      def parent
+        @parent ||= io.ask('Subtask parent:', default: Jira::Core.ticket)
+      end
+
+      def issue_type
+        @issue_type ||= issue_types[
+          io.select("Select an issue type:", issue_types.keys)
+        ]
+      end
+
+      def issue_types
+        @issue_types ||= (
+          issue_types = {}
+          project['issues'].each do |issue_type|
+            issue_types[issue_type['name']] = issue_type
+          end
+          issue_types
+        )
+      end
+
+      def summary
+        @summary ||= io.ask("Summary:")
+      end
+
+      def description
+        @description ||= io.ask("Description:")
+      end
+
+    end
   end
 end