ruby-jira-cli 0.0.3

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

@@ -0,0 +1,89 @@
+module Jira
+  class Log < Thor
+
+    desc 'update', 'Updates work logged on the input ticket'
+    def update(ticket=Jira::Core.ticket)
+      Command::Log::Update.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Log
+      class Update < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket=Jira::Core.ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return unless logs?
+          api.patch endpoint,
+            params:  params,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def params
+          { timeSpent: updated_time_spent }
+        end
+
+        def updated_time_spent
+          io.ask('Updated time spent?')
+        end
+
+        def logs?
+          if json.empty?
+            puts "Ticket #{ticket} has no work logged."
+            return false
+          end
+          true
+        end
+
+        def endpoint
+          "issue/#{ticket}/worklog/#{to_update['id']}"
+        end
+
+        def on_success
+          ->{ puts "Successfully updated #{to_update['timeSpent']}." }
+        end
+
+        def on_failure
+          ->{ puts "No logged work updated." }
+        end
+
+        def to_update
+          @to_delete ||= logs[
+            io.select("Select a worklog to update:", 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.rb

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

data/lib/jira/commands/new.rb

@@ -0,0 +1,174 @@
+module Jira
+  class CLI < Thor
+
+    desc "new", "Creates a new ticket in JIRA and checks out the git branch"
+    method_option :project, aliases: "-p", type: :string, default: nil, banner: "PROJECT"
+    method_option :components, aliases: "-c", type: :array, default: nil, lazy_default: [], banner: "COMPONENTS"
+    method_option :issuetype, aliases: "-i", type: :string, default: nil, banner: "ISSUETYPE"
+    method_option :parent, type: :string, default: nil, lazy_default: "", banner: "PARENT"
+    method_option :summary, aliases: "-s", type: :string, default: nil, banner: "SUMMARY"
+    method_option :description, aliases: "-d", type: :string, default: nil, lazy_default: "", banner: "DESCRIPTION"
+    method_option :assignee, aliases: "-a", type: :string, default: nil, lazy_default: "auto", banner: "ASSIGNEE"
+    def new
+      Command::New.new(options).run
+    end
+
+  end
+
+  module Command
+    class New < Base
+
+      attr_accessor :options
+
+      def initialize(options)
+        self.options = options
+      end
+
+      def run
+        return if metadata.empty?
+        return if project.nil? || project.empty?
+        return if project_metadata.empty?
+        components # Select components if any after a project
+        return if issue_type.nil? || issue_type.empty?
+        return if assign_parent? && parent.empty?
+        return if summary.empty?
+
+        api.post 'issue',
+          params: params,
+          success: on_success,
+          failure: on_failure
+      end
+
+    private
+
+      attr_accessor :ticket
+
+      def params
+        {
+          fields: {
+            project:     { id: project['id'] },
+            issuetype:   { id: issue_type['id'] },
+            summary:     summary,
+            description: description,
+            parent:      @parent.nil? ? {} : { key: @parent },
+            components:  @components.nil? ? [] : @components
+          }
+        }
+      end
+
+      def on_success
+        ->(json) do
+          self.ticket = json['key']
+          io.say("Ticket #{ticket} created.")
+          assign? if options.empty? || !options['assignee'].nil?
+          create_branch? && checkout_branch? if options.empty?
+        end
+      end
+
+      def assign?
+        Command::Assign.new(ticket, options).run if !options['assignee'].nil? || 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[
+          options['project'] || io.select("Select a project:", projects.keys)
+        ]
+      end
+
+      def projects
+        @projects ||= (
+          projects = {}
+          metadata['projects'].each do |project|
+            projects[project['name']] = {
+              'id'     => project['id'],
+              'issues' => project['issuetypes']
+            }
+          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
+          unless components.empty?
+            if options['components'].nil?
+              components = io.multi_select("Select component(s):", components)
+            else
+              components.select! { |k| options['components'].include?(k) }
+              components = components.values
+            end
+          end
+          components.to_a
+        )
+      end
+
+      def assign_parent?
+        return false unless issue_type['subtask']
+        return false if options['parent'].nil? && io.no?('Set parent of subtask?')
+        true
+      end
+
+      def parent
+        @parent ||= options['parent'] || io.ask('Subtask parent:', default: Jira::Core.ticket)
+      end
+
+      def issue_type
+        @issue_type ||= issue_types[
+            options['issuetype'] || 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 ||= options['summary'] || io.ask("Summary:", default: '')
+      end
+
+      def description
+        @description ||= (
+          description = options['description'] || (io.ask("Description:", default: '') if options['summary'].nil?)
+          description ||= ""
+        )
+      end
+
+    end
+  end
+end

data/lib/jira/commands/rename.rb

@@ -0,0 +1,53 @@
+module Jira
+  class CLI < Thor
+
+    desc "rename", "Updates the summary of the input ticket"
+    method_option :summary, aliases: "-s", type: :string, default: nil, lazy_default: "", banner: "SUMMARY"
+    def rename(ticket=Jira::Core.ticket)
+      Command::Rename.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    class Rename < Base
+
+      attr_accessor :ticket, :options
+
+      def initialize(ticket, options)
+        self.ticket = ticket
+        self.options = options
+      end
+
+      def run
+        return if ticket.empty?
+        return if summary.empty?
+        api.patch "issue/#{ticket}",
+          params:  params,
+          success: on_success,
+          failure: on_failure
+      end
+
+      def params
+        {
+          fields: {
+            summary: summary
+          }
+        }
+      end
+
+      def on_success
+        ->{ puts "Successfully updated ticket #{ticket}'s summary." }
+      end
+
+      def on_failure
+        ->{ puts "No change made to ticket #{ticket}." }
+      end
+
+      def summary
+        @summary ||= options['summary'] || io.ask("New summary for ticket #{ticket}:", default: '')
+      end
+
+    end
+  end
+end

data/lib/jira/commands/sprint.rb

@@ -0,0 +1,109 @@
+module Jira
+  class CLI < Thor
+
+    desc "sprint", "Lists sprint info"
+    def sprint(active = false)
+      Command::Sprint.new(active).run
+    end
+
+  end
+
+  module Command
+    class Sprint < Base
+
+      attr_accessor :active
+
+      def initialize(active)
+        self.active = active
+      end
+
+
+      def run
+        return if rapid_view.empty?
+        return if no_sprints?
+        return if sprint.empty?
+        if active == active
+          sprint_id = info['sprint']['id']
+          jql = "sprint = #{sprint_id}"
+          Command::Tickets.new(jql).run
+        else
+          render_table(
+            [ 'Sprint', 'State' ],
+            [ [ info['sprint']['name'], info['sprint']['state'] ] ]
+          )
+        end
+      end
+
+    private
+
+      def no_sprints?
+        if sprints.empty?
+          puts "The #{rapid_view['name']} board has no sprints."
+          return true
+        end
+        false
+      end
+
+      def info
+        @info ||= sprint_api.sprint(rapid_view['id'], sprint['id'])
+      end
+
+      def sprint
+        @sprint ||= active_sprint || sprints[
+          io.select("Select a sprint:", sprints.keys[-10..-1])
+        ]
+      end
+
+      def sprints
+        @sprints ||= (
+          sprints = {}
+          sprint_api.sprints(rapid_view['id'])['sprints'].each do |sprint|
+            sprints["#{sprint['name']}"] = {
+              'id'   => sprint['id'],
+              'name' => sprint['name'],
+              'state' => sprint['state']
+            }
+          end
+          sprints
+        )
+      end
+
+      def active_sprint
+        sprints = {}
+        sprint_api.sprints(rapid_view['id'])['sprints'].each do |sprint|
+          if sprint['state'] == "ACTIVE"
+            sprints = {
+              'id'   => sprint['id'],
+              'name' => sprint['name'],
+              'state' => sprint['state']
+            }
+          end
+        end
+        sprints
+      end
+
+      def rapid_view
+        keys = rapid_views.keys
+        return '' if keys.empty?
+        # @rapid_view ||= rapid_views[
+        #   io.select("Select a rapid view:", keys)
+        # ]
+        @rapid_view = {"id"=>15, "name"=>"Ruby Team"}
+      end
+
+      def rapid_views
+        @rapid_views ||= (
+          rapid_views = {}
+          sprint_api.rapid_views.each do |rapid_view|
+            rapid_views[rapid_view['name']] = {
+              'id'   => rapid_view['id'],
+              'name' => rapid_view['name']
+            }
+          end
+          rapid_views
+        )
+      end
+
+    end
+  end
+end

data/lib/jira/commands/tickets.rb

@@ -0,0 +1,55 @@
+module Jira
+  class CLI < Thor
+
+    desc "tickets [jql]", "List the tickets of the input jql"
+    def tickets(jql="assignee=#{Jira::Core.username} AND status = \"In Progress\"")
+      Command::Tickets.new(jql).run
+    end
+
+  end
+
+  module Command
+    class Tickets < Base
+
+      attr_accessor :jql
+
+      def initialize(jql)
+        self.jql = jql
+      end
+
+      def run
+        return if jql.empty?
+        return if metadata.empty?
+        return unless metadata['errorMessages'].nil?
+
+        if rows.empty?
+          puts "There are no tickets for jql=#{jql}."
+          return
+        end
+        render_table(header, rows)
+      end
+
+    private
+
+      def header
+        [ 'Ticket', 'Assignee', 'Status', 'Summary']
+      end
+
+      def rows
+        metadata['issues'].map do |issue|
+          [
+            issue['key'],
+            (issue['fields']['assignee']['name'] unless issue['fields']['assignee'].nil?) || 'Unassigned',
+            (issue['fields']['status']['name'] unless issue['fields']['status'].nil?) || 'Unknown',
+            truncate(issue['fields']['summary'] || '', 45)
+          ]
+        end
+      end
+
+      def metadata
+        @metadata ||= api.get("search?jql=#{jql}")
+      end
+
+    end
+  end
+end

data/lib/jira/commands/transition.rb

@@ -0,0 +1,97 @@
+module Jira
+  class CLI < Thor
+
+    desc "transition", "Transitions the input ticket to the next state"
+    method_option :transition, aliases: "-t", type: :string, default: nil, lazy_default: "", banner: "TRANSITION"
+    method_option :resolution, aliases: "-r", type: :string, default: nil, lazy_default: "", banner: "RESOLUTION"
+    def transition(ticket=Jira::Core.ticket)
+      Command::Transition.new(ticket, options).run
+    end
+
+  end
+
+  module Command
+    class Transition < Base
+
+      attr_accessor :ticket, :options
+
+      def initialize(ticket, options)
+        self.ticket = ticket
+        self.options = options
+      end
+
+      def run
+        return if ticket.empty?
+        return if metadata.empty?
+        return unless metadata['errorMessages'].nil?
+        return if transition.nil? || transition.empty?
+
+        api.post "issue/#{ticket}/transitions",
+          params:  params,
+          success: on_success,
+          failure: on_failure
+      end
+
+    private
+
+      def params
+        {
+          transition: { id: transition[:id] },
+          fields: transition[:resolution?] ? { resolution: { name: resolution } } : {}
+        }
+      end
+
+      def on_success
+        ->{ puts "Transitioned ticket #{ticket} to #{transition_name}." }
+      end
+
+      def on_failure
+        ->{ puts "Failed to transition ticket #{ticket}." }
+      end
+
+      def transition_name
+        transitions.invert[transition]
+      end
+
+      def transition
+        @transition ||= transitions[
+          options['transition'] || io.select("Transition #{ticket} to:", transitions.keys)
+        ]
+      end
+
+      def transitions
+        @transitions ||= (
+          transitions = {}
+          metadata['transitions'].each do |transition|
+            transitions[transition['to']['name']] = {
+              id: transition['id'],
+              resolution?: !!transition['fields'].fetch('resolution', {})['required']
+            }
+          end
+          transitions
+        )
+      end
+
+      def metadata
+        @metadata ||= api.get("issue/#{ticket}/transitions?expand=transitions.fields")
+      end
+
+      def resolution
+        @resolution ||= resolutions[
+          options['resolution'] || io.select("Resolve #{ticket} as:", resolutions.keys)
+        ]
+      end
+
+      def resolutions
+        @resolutions ||= (
+          resolutions = {}
+          api.get("resolution").each do |resolution|
+            resolutions[resolution['name']] = resolution['name']
+          end
+          resolutions
+        )
+      end
+
+    end
+  end
+end

data/lib/jira/commands/version.rb

@@ -0,0 +1,10 @@
+module Jira
+  class CLI < Thor
+
+    desc "version", "Displays the version"
+    def version
+      say "jira #{Jira::VERSION}"
+    end
+
+  end
+end

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

@@ -0,0 +1,43 @@
+module Jira
+  class Vote < Thor
+
+    desc 'add', 'Vote for the input ticket'
+    def add(ticket=Jira::Core.ticket)
+      Command::Vote::Add.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Vote
+      class Add < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return if ticket.empty?
+
+          api.post "issue/#{ticket}/votes",
+            params:  "\"#{Jira::Core.username}\"",
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def on_success
+          ->{ puts "Successfully voted for ticket #{ticket}" }
+        end
+
+        def on_failure
+          ->{ puts "No vote cast." }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Jira
+  class Vote < Thor
+
+    desc 'delete', 'Delete vote for the input ticket'
+    def delete(ticket=Jira::Core.ticket)
+      Command::Vote::Delete.new(ticket).run
+    end
+
+  end
+
+  module Command
+    module Vote
+      class Delete < Base
+
+        attr_accessor :ticket
+
+        def initialize(ticket)
+          self.ticket = ticket
+        end
+
+        def run
+          return if ticket.empty?
+
+          api.delete endpoint,
+            success: on_success,
+            failure: on_failure
+        end
+
+      private
+
+        def endpoint
+          "issue/#{ticket}/votes?username=#{Jira::Core.username}"
+        end
+
+        def on_success
+          ->{ puts "Successfully removed vote from ticket #{ticket}" }
+        end
+
+        def on_failure
+          ->{ puts "No unvote." }
+        end
+
+      end
+    end
+  end
+end