terjira 0.1.0

data/lib/terjira/client/rapid_view.rb

@@ -0,0 +1,8 @@
+require_relative 'base'
+
+module Terjira
+  module Client
+    class RapidView < Base
+    end
+  end
+end

data/lib/terjira/client/resolution.rb

@@ -0,0 +1,14 @@
+require_relative 'base'
+
+module Terjira
+  module Client
+    class Resolution < Base
+      class << self
+        def all
+          resp = api_get("resolution")
+          resp.map { |resolution| build(resolution) }
+        end
+      end
+    end
+  end
+end

data/lib/terjira/client/sprint.rb

@@ -0,0 +1,28 @@
+require_relative 'base'
+
+module Terjira
+  module Client
+    class Sprint < Base
+      class << self
+        delegate :build, to: :resource
+
+        def all(board, options = {})
+          params = options.slice(:state, :maxResults)
+          resp = agile_api_get "board/#{board.key_value}/sprint", params
+          resp['values'].map { |value| build(value) }
+        end
+
+        def find(sprint)
+          resp = agile_api_get "sprint/#{sprint.key_value}"
+          build resp
+        end
+
+        def find_active(board)
+          params = { state: 'active' }
+          resp = agile_api_get "board/#{board.key_value}/sprint", params
+          resp['values'].map { |value| build(value) }
+        end
+      end
+    end
+  end
+end

data/lib/terjira/client/status.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+module Terjira
+  module Client
+    class Status < Base
+      class << self
+        def all(project)
+          resp = api_get "project/#{project.key_value}/statuses"
+          statuses_json = resp.map { |issuetype| issuetype["statuses"] }.flatten.uniq
+          statuses_json.map { |status| build(status) }
+        end
+      end
+    end
+  end
+end

data/lib/terjira/client/user.rb

@@ -0,0 +1,44 @@
+require_relative 'base'
+
+module Terjira
+  module Client
+    class User < Base
+      class << self
+        def assignables_by_project(project)
+          if project.is_a? Array
+            keys = project.map(&:key_value).join(",")
+            fetch_assignables "user/assignable/multiProjectSearch", {projectKeys: keys }
+          else
+            fetch_assignables "user/assignable/search", { project: project.key_value }
+          end
+        end
+
+        def assignables_by_board(board)
+          projects = Client::Project.all_by_board(board)
+          assignables_by_project(projects)
+        end
+
+        def assignables_by_sprint(sprint)
+          board_id = if sprint.respond_to? :originBoardId
+                       sprint.originBoardId
+                     else
+                       Client::Sprint.find(sprint).originBoardId
+                     end
+          assignables_by_board(board_id)
+        end
+
+        def assignables_by_issue(issue)
+          fetch_assignables "user/assignable/search", {issueKey: issue.key_value }
+        end
+
+        private
+
+        def fetch_assignables(path, params)
+          resp = api_get(path, params)
+          resp.map { |user| build(user) }.
+            reject { |user| user.key_value =~ /^addon/ }
+        end
+      end
+    end
+  end
+end

data/lib/terjira/ext/jira_ruby.rb

@@ -0,0 +1,70 @@
+require 'jira-ruby'
+require 'tty-screen'
+require 'tty-spinner'
+require 'pastel'
+
+module JIRA
+  # Extend jira-ruby for command line interface.
+  class HttpClient
+    alias origin_make_request make_request
+
+    def make_request(http_method, path, body = '', headers = {})
+      title = http_method.to_s.upcase
+      title = Pastel.new.dim(title)
+      spinner = TTY::Spinner.new ":spinner #{title}", format: :dots, clear: true
+      result = nil
+
+      spinner.run do
+        result = origin_make_request(http_method, path, body, headers)
+      end
+
+      result
+    end
+  end
+
+  # Board model is not defined in jira-ruby gem
+  class Base
+    def key_with_key_value
+      [self.class.key_attribute, key_value]
+    end
+  end
+
+  module Resource
+    class BoardFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Board < JIRA::Base
+      def self.key_attribute; :id; end
+    end
+
+    class User
+      def self.key_attribute; :name; end
+    end
+
+    class Issue
+      def self.key_attribute; :key; end
+    end
+
+    class Issuetype
+      def self.key_attribute; :name; end
+    end
+
+    class Resolution
+      def self.key_attribute; :name; end
+    end
+  end
+
+  class Client
+    def Board # :nodoc:
+      JIRA::Resource::BoardFactory.new(self)
+    end
+  end
+end
+
+class String
+  def key_value; self.strip; end
+end
+
+class Integer
+  def key_value; self.to_s; end
+end

data/lib/terjira/ext/tty_prompt.rb

@@ -0,0 +1,34 @@
+require 'tty-prompt'
+# Fix some unexpected result
+module TTY
+  class Prompt
+    class Question
+      # Decide how to handle input from user
+      #
+      # @api private
+      def process_input
+        @input = read_input
+        if Utils.blank?(@input)
+          @input = default? ? default : nil
+        end
+
+        if @input.is_a? String
+          @input = encode_input(@input)
+        elsif @input.is_a? Array
+          @input = @input.map { |input| encode_input(input) }
+        end
+
+        @evaluator.(@input)
+      end
+
+      # Encod input
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def encode_input(line)
+        line.codepoints.to_a.pack('C*').force_encoding('utf-8')
+      end
+    end
+  end
+end

data/lib/terjira/issue_cli.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+require_relative 'base_cli'
+
+module Terjira
+  class IssueCLI < BaseCLI
+    no_commands do
+      def client_class
+        Client::Issue
+      end
+    end
+
+    default_task :show
+
+    desc '[ISSUE_KEY]', 'Show detail of the issue'
+    def show(issue_key = nil)
+      return invoke(:help) unless issue_key
+      issue = client_class.find(issue_key)
+      render_issue_detail(issue)
+    end
+
+    desc '( ls | list )', 'List of issues'
+    jira_options :assignee, :status, :project, :issuetype, :priority
+    map ls: :list
+    def list
+      opts = suggest_options
+      opts[:statusCategory] ||= %w(To\ Do In\ Progress) unless opts[:status]
+      opts[:assignee] ||= current_username
+      opts.delete(:assignee) if opts[:assignee] =~ /^all/i
+
+      issues = client_class.all(opts)
+      render_issues(issues)
+    end
+
+    desc 'trans [ISSUE_KEY] ([STATUS])', 'Do Transition'
+    jira_options :comment, :assignee, :resolution
+    def trans(*args)
+      issue = args.shift
+      raise 'must pass issue key or id' unless issue
+      status = args.join(' ') if args.present?
+      issue = client_class.find(issue, expand: 'transitions.fields')
+
+      transitions = issue.transitions
+      transition = transitions.find { |t| t.name.casecmp(status.to_s).zero? }
+
+      resources = if transition
+                    { status: transition, issue: issue }
+                  else
+                    { statuses: transitions, issue: issue }
+                  end
+
+      opts = suggest_options(required: [:status], resources: resources)
+      issue = client_class.trans(issue, opts)
+      render_issue_detail(issue)
+    end
+
+    desc 'new', 'Create issue'
+    jira_options :summary, :description, :project, :issuetype,
+                 :priority, :assignee
+    def new
+      opts = suggest_options(required: [:project, :summary, :issuetype])
+
+      if opts[:issuetype].key_value.casecmp('epic').zero?
+        epic_name_field = Client::Field.epic_name
+        opts[epic_name_field.key] = write_epic_name
+      end
+
+      issue = client_class.create(opts)
+      render_issue_detail(issue)
+    end
+
+    desc 'edit', 'Edit issue'
+    jira_options :summary, :description, :project, :issuetype,
+                 :priority, :assignee
+    def edit(issue)
+      return if options.blank?
+      issue = client_class.find(issue)
+      opts = suggest_options(resources: { issue: issue })
+      issue = client_class.update(issue, opts)
+      render_issue_detail(issue)
+    end
+
+    desc 'comment', 'Write comment on the issue'
+    jira_options :comment
+    def comment(issue)
+      opts = suggest_options(required: [:comment])
+      issue = client_class.write_comment(issue, opts[:comment])
+      render_issue_detail(issue)
+    end
+
+    desc 'take [ISSUE_KEY]', 'Assign issue to self'
+    def take(issue)
+      assign(issue, current_username)
+    end
+
+    desc 'assign [ISSUE_KEY] ([ASSIGNEE])', 'Assing issue to user'
+    def assign(*keys)
+      issue = keys[0]
+      assignee = keys[1]
+      if assignee.nil?
+        issue = client_class.find(issue)
+        opts = suggest_options(required: [:assignee],
+                               resouces: { issue: issue })
+        assignee = opts[:assignee]
+      end
+      client_class.assign(issue, assignee)
+      show(issue.key_value)
+    end
+  end
+end

data/lib/terjira/option_support/option_selector.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+
+require 'tty-prompt'
+require_relative 'resource_store'
+
+module Terjira
+  module OptionSelector
+    delegate :get, :set, :fetch, to: :resource_store
+
+    def select_project
+      fetch :project do
+        projects = fetch(:projects) { Client::Project.all }
+        option_prompt.select('Choose project?') do |menu|
+          projects.each { |project| menu.choice project_choice_title(project), project }
+        end
+      end
+    end
+
+    def select_board(type = nil)
+      fetch(:board) do
+        boards = fetch(:boards) { Client::Board.all(type: type) }
+        option_prompt.select('Choose board?') do |menu|
+          boards.sort_by(&:id).each do |board|
+            menu.choice "#{board.key_value} - #{board.name}", board
+          end
+        end
+      end
+    end
+
+    def select_sprint
+      fetch(:sprint) do
+        board = select_board('scrum')
+        sprints = fetch(:sprints) { Client::Sprint.all(board) }
+        option_prompt.select('Choose sprint?') do |menu|
+          sort_sprint_by_state(sprints).each do |sprint|
+            menu.choice sprint_choice_title(sprint), sprint
+          end
+        end
+      end
+    end
+
+    def select_assignee
+      fetch(:assignee) do
+        users = fetch(:users) do
+          if issue = get(:issue)
+            Client::User.assignables_by_issue(issue)
+          elsif board = get(:board)
+            Client::User.assignables_by_board(board)
+          elsif sprint = get(:sprint)
+            Client::User.assignables_by_sprint(sprint)
+          else
+            users = Client::User.assignables_by_project(select_project)
+          end
+        end
+
+        option_prompt.select('Choose assignee?') do |menu|
+          users.each { |user| menu.choice user_choice_title(user), user }
+        end
+      end
+    end
+
+    def select_issuetype
+      fetch(:issuetype) do
+        project = select_project
+        if project.is_a? String
+          project = Client::Project.find(project)
+          set(:project, project)
+        end
+
+        option_prompt.select('Choose isseu type?') do |menu|
+          project.issuetypes.each do |issuetype|
+            menu.choice issuetype.name, issuetype
+          end
+        end
+      end
+    end
+
+    def select_issue_status
+      fetch(:status) do
+        statuses = fetch(:statuses) do
+          project = if issue = get(:issue)
+            if issue.respond_to?(:project)
+              issue.project
+            else
+              set(:issue, Client::Issue.find(issue)).project
+            end
+          else
+            select_project
+          end
+          Client::Status.all(project)
+        end
+
+        option_prompt.select('Choose status?') do |menu|
+          statuses.each do |status|
+            menu.choice status.name, status
+          end
+        end
+      end
+    end
+
+    def select_priority
+      fetch(:priority) do
+        priorities = fetch(:priorities) { Terjira::Client::Priority.all }
+        option_prompt.select('Choose priority?') do |menu|
+          priorities.each do |priority|
+            menu.choice priority.name, priority
+          end
+        end
+      end
+    end
+
+    def select_resolution
+      fetch(:resolution) do
+        resolutions = fetch(:resolutions) { Terjira::Client::Resolution.all }
+        option_prompt.select('Choose resolution?') do |menu|
+          resolutions.each do |resolution|
+            menu.choice resolution.name, resolution
+          end
+        end
+      end
+    end
+
+    def write_epic_name
+      option_prompt.ask('Epic name?')
+    end
+
+    def write_comment
+      fetch(:comment) do
+        comment = option_prompt.multiline("Comment? (Return empty line for finish)\n")
+        comment.join("\n") if comment
+      end
+    end
+
+    def write_description
+      fetch(:description) do
+        desc = option_prompt.multiline("Description? (Return empty line for finish)\n")
+        desc.join("\n") if desc
+      end
+    end
+
+    def write_summary
+      fetch(:summary) { option_prompt.ask('Summary?') }
+    end
+
+    private
+
+    def sprint_choice_title(sprint)
+      "#{sprint.key_value} - #{sprint.name} (#{sprint.state.capitalize})"
+    end
+
+    def user_choice_title(user)
+      "#{user.key_value} - #{user.displayName}"
+    end
+
+    def project_choice_title(project)
+      "#{project.key_value} - #{project.name}"
+    end
+
+    def resource_store
+      ResourceStore.instance
+    end
+
+    def option_prompt
+      @option_prompt ||= TTY::Prompt.new
+    end
+  end
+end