terjira 0.1.0

data/lib/terjira/option_support/resource_store.rb

@@ -0,0 +1,45 @@
+require 'singleton'
+
+module Terjira
+  # Store resource or key value of selected options
+  class ResourceStore
+    include Singleton
+
+    attr_accessor :store
+
+    def initialize
+      initialize_store
+    end
+
+    def fetch(resource_name)
+      resouce = get(resource_name)
+      if resouce
+        resouce
+      elsif block_given?
+        resouce = yield
+        set(resource_name, resouce)
+      end
+    end
+
+    def get(resource_name)
+      store[resource_name]
+    end
+
+    def set(resource_name, resource)
+      store[resource_name] = resource
+      resource
+    end
+
+    def exists?(resource_name)
+      store[resource_name].present?
+    end
+
+    def clear
+      initialize_store
+    end
+
+    def initialize_store
+      @store = Thor::CoreExt::HashWithIndifferentAccess.new
+    end
+  end
+end

data/lib/terjira/option_support/shared_options.rb

@@ -0,0 +1,70 @@
+module Terjira
+  module SharedOptions
+    OPTIONS = {
+      'project' => {
+        type: :string,
+        aliases: '-p',
+        desc: 'project key'
+      },
+      'board' => {
+        type: :numeric,
+        aliases: '-b',
+        banner: 'BOARD_ID',
+        lazy_default: 'board'
+      },
+      'sprint' => {
+        type: :numeric,
+        banner: 'SPRINT_ID',
+        lazy_default: 'sprint'
+      },
+      'assignee' => {
+        type: :string,
+        aliases: '-a'
+      },
+      'state' => {
+        type: :array,
+        aliases: '-s',
+        default: %w(Active Future),
+        lazy_default: %w(Active Future),
+        enum: %w(Active Future Closed)
+      },
+      'status' => {
+        type: :string,
+        aliases: '-s',
+        desc: 'status'
+      },
+      'resolution' => {
+        type: :string,
+        aliases: '-r'
+      },
+      'issuetype' => {
+        type: :string,
+        aliases: '-t'
+      },
+      'priority' => {
+        type: :string,
+        aliases: '-P'
+      },
+      'summary' => {
+        type: :string,
+        aliases: '-S'
+      },
+      'description' => {
+        type: :string,
+        aliases: '-d'
+      },
+      'comment' => {
+        type: :string,
+        aliases: '-m'
+      }
+    }.freeze
+
+    def jira_options(*keys)
+      keys.each { |key| jira_option(key) }
+    end
+
+    def jira_option(key, opts = {})
+      method_option(key, (OPTIONS[key.to_s] || {}).merge(opts))
+    end
+  end
+end

data/lib/terjira/option_supportable.rb

@@ -0,0 +1,80 @@
+require_relative 'option_support/option_selector'
+require_relative 'option_support/resource_store'
+require_relative 'option_support/shared_options'
+
+module Terjira
+  # For support CLI options.
+  module OptionSupportable
+    def self.included(klass)
+      klass.class_eval do
+        extend SharedOptions
+        include OptionSelector
+      end
+    end
+
+    OPTION_TO_SELECTOR = {
+      project: :select_project,
+      board: :select_board,
+      summary: :write_summary,
+      description: :write_description,
+      sprint: :select_sprint,
+      issuetype: :select_issuetype,
+      assignee: :select_assignee,
+      status: :select_issue_status,
+      priority: :select_priority,
+      resolution: :select_resolution,
+      comment: :write_comment
+    }.freeze
+
+    # Transforming and clening options
+    # and suggest list of option values
+    def suggest_options(opts = {})
+      origin = options.dup
+
+      if opts[:required].is_a? Array
+        opts[:required].inject(origin) do |memo, opt|
+          memo[opt] ||= opt.to_s
+          memo
+        end
+      end
+
+      # Store assigned options
+      origin.reject { |k, v| k.to_s.casecmp(v.to_s).zero? }.each do |k, v|
+        resource_store.set(k.to_sym, v)
+      end
+
+      # Store given options from arguments
+      (opts[:resources] || {}).each do |k, v|
+        resource_store.set(k.to_sym, v)
+      end
+
+      # Select options that are not assigned value from user
+      default_value_options = origin.select do |k, v|
+        k.to_s.casecmp(v.to_s).zero?
+      end
+
+      # Sort order for suggest option values
+      default_value_options = default_value_options.sort do |hash|
+        OPTION_TO_SELECTOR.keys.index(hash[0].to_sym) || 999
+      end
+      default_value_options = Hash[default_value_options]
+
+      # Suggest option values and save to resource store
+      default_value_options.each do |k, _v|
+        selector_method = OPTION_TO_SELECTOR[k.to_sym]
+        send(selector_method) if selector_method
+      end
+
+      # Fetch selected values from resource store
+      default_value_options.each do |k, _v|
+        default_value_options[k] = resource_store.get(k)
+      end
+
+      origin.merge! default_value_options
+    end
+
+    def resource_store
+      ResourceStore.instance
+    end
+  end
+end

data/lib/terjira/presenters/board_presenter.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Terjira
+  module BoardPresenter
+    def render_boards_summary(boards)
+      pastel = Pastel.new
+
+      header = %w(ID Name Type).map { |title| pastel.bold(title) }
+      rows = []
+      boards.each do |board|
+        rows << [pastel.bold(board.id), board.name, board.type]
+      end
+
+      table = TTY::Table.new header, rows
+      result = table.render(:unicode, padding: [0, 1, 0, 1])
+
+      render(result)
+    end
+  end
+end

data/lib/terjira/presenters/common_presenter.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'tty-table'
+require 'pastel'
+
+module Terjira
+  module CommonPresenter
+    def render(text)
+      if text.is_a? Array
+        puts text.join("\n")
+      else
+        puts text
+      end
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
+
+    def formatted_date(date_str)
+      return nil if date_str.nil? || date_str.empty?
+      Time.parse(date_str).strftime('%c')
+    end
+
+    def username_with_email(user)
+      if user.nil?
+        'None'
+      else
+        title = "#{user.name}, #{user.displayName}"
+        title += " <#{user.emailAddress}>" if user.respond_to?(:emailAddress)
+        title
+      end
+    end
+
+    def screen_width
+      TTY::Screen.width
+    end
+
+    # Insert new line(`\n`)
+    # when string display length is longger than length argument
+    def insert_new_line(str, length)
+      str.split(/\r\n|\n/).map do |line|
+        if line.display_width < 1
+          line
+        else
+          display_length = pastel.strip(line).display_width
+          split_length = (line.length * length / display_length).to_i
+          line.scan(/.{1,#{split_length}}/).join("\n")
+        end
+      end.join("\n")
+    end
+  end
+end

data/lib/terjira/presenters/issue_presenter.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+require 'tty-prompt'
+require 'tty-table'
+require 'pastel'
+
+module Terjira
+  module IssuePresenter
+    def render_issues(issues, opts = {})
+      return render('Empty') if issues.blank?
+
+      header = [pastel.bold('Key'), pastel.bold('Summary')] if opts[:header]
+
+      rows = issues.map do |issue|
+        [pastel.bold(issue.key), summarise_issue(issue)]
+      end
+
+      table = TTY::Table.new header, rows
+      table_opts = { padding: [0, 1, 0, 1], multiline: true }
+      result = table.render(:unicode, table_opts) do |renderer|
+        renderer.border.separator = :each_row
+      end
+
+      render(result)
+    end
+
+    def render_divided_issues_by_status(issues)
+      extract_status_names(issues).each do |name|
+        selected_issues = issues.select { |issue| issue.status.name == name }
+        title = colorize_issue_stastus(selected_issues.first.status)
+        title += "(#{selected_issues.size})"
+        render(title)
+        render_issues(selected_issues, header: false)
+      end
+    end
+
+    def render_issue_detail(issue)
+      header_title = "#{pastel.bold(issue.key)} in #{issue.project.name}"
+      header = [insert_new_line(header_title, screen_width - 10)]
+
+      rows = []
+      rows << pastel.underline.bold(issue.summary)
+      rows << ''
+      rows << issue_sutats_bar(issue)
+      rows << ''
+
+      rows << [pastel.bold('Assignee'), username_with_email(issue.assignee)].join(' ')
+      rows << [pastel.bold('Reporter'), username_with_email(issue.reporter)].join(' ')
+      rows << ''
+      rows << pastel.bold('Description')
+      rows << (issue.description.blank? ? 'None' : issue.description)
+
+      if issue.respond_to?(:environment) && issue.environment.present?
+        rows << pastel.bold('Environment')
+        rows << issue.environment
+      end
+
+      if issue.comments.present?
+        rows << ''
+        rows << pastel.bold('Comments')
+        remain_comments = issue.comments
+        comments = remain_comments.pop(4)
+
+        if comments.size.zero?
+          rows << 'None'
+        elsif remain_comments.empty?
+          rows << pastel.dim("- #{remain_comments.size} previous comments exist -")
+        end
+
+        comments.each do |comment|
+          comment_title = pastel.bold(comment.author['displayName'])
+          comment_title += " #{formatted_date(comment.created)}"
+          rows << comment_title
+          rows << comment.body
+          rows << ''
+        end
+      end
+
+      rows = rows.map { |row| insert_new_line(row, screen_width - 10) }
+
+      table = TTY::Table.new header, rows.map { |r| [r] }
+      result = table.render(:unicode, padding: [0, 1, 0, 1], multiline: true)
+
+      render(result)
+    end
+
+    def summarise_issue(issue)
+      first_line = [colorize_issue_stastus(issue.status),
+                    issue.summary.tr("\t", ' ')].join
+
+      second_line = [colorize_priority(issue.priority),
+                     colorize_issue_type(issue.issuetype),
+                     assign_info(issue)].join(' ')
+
+      lines = [first_line, second_line].map do |line|
+        insert_new_line(line, screen_width - 30)
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    def assign_info(issue)
+      reporter = issue.reporter ? issue.reporter.name : 'None'
+      assignee = issue.assignee ? issue.assignee.name : 'None'
+      "#{reporter} ⇨ #{assignee}"
+    end
+
+    def issue_sutats_bar(issue)
+      bar = ["#{pastel.bold('Type')}: #{colorize_issue_type(issue.issuetype)}",
+             "#{pastel.bold('Status')}: #{colorize_issue_stastus(issue.status)}",
+             "#{pastel.bold('priority')}: #{colorize_priority(issue.priority, title: true)}"]
+      bar.join("\s\s\s")
+    end
+
+    def colorize_issue_type(issue_type)
+      title = " #{issue_type.name} "
+      if title =~ /bug/i
+        pastel.on_red.bold(title)
+      elsif title =~ /task/i
+        pastel.on_blue.bold(title)
+      elsif title =~ /story/i
+        pastel.on_green.bold(title)
+      elsif title =~ /epic/i
+        pastel.on_magenta.bold(title)
+      else
+        pastel.on_cyan.bold(title)
+      end
+    end
+
+    def colorize_issue_stastus(status)
+      title = "#{status.name} "
+      category = title
+      if status.respond_to? :statusCategory
+        category = (status.statusCategory || {})['name'] || ''
+      end
+      if category =~ /to\sdo|open/i
+        pastel.blue.bold(title)
+      elsif category =~ /in\sprogress/i
+        pastel.yellow.bold(title)
+      elsif category =~ /done|close/i
+        pastel.green.bold(title)
+      else
+        pastel.magenta.bold(title)
+      end
+    end
+
+    def colorize_priority(priority, opts = {})
+      return '' unless priority.respond_to? :name
+      name = priority.name
+      info = if name =~ /high|major|critic/i
+               { color: :red, icon: '⬆' }
+             elsif name =~ /medium|default/i
+               { color: :yellow, icon: '⬆' }
+             elsif name =~ /minor|low|trivial/i
+               { color: :green, icon: '⬇' }
+             else
+               { color: :green, icon: '•' }
+             end
+      title = opts[:title] ? "#{info[:icon]} #{name}" : info[:icon]
+      pastel.send(info[:color], title)
+    end
+
+    def extract_status_names(issues)
+      issue_names = issues.sort_by do |issue|
+        status_key = %w(new indeterminate done)
+        idx = if issue.status.respond_to? :statusCategory
+                status_key.index(issue.status.statusCategory['key'])
+              end
+        idx || status_key.size
+      end
+      issue_names.map { |issue| issue.status.name }.uniq
+    end
+  end
+end