jira-ruby 2.3.0 → 3.2.0

data/lib/jira/resource/attachment.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'net/http/post/multipart'
+require 'open-uri'
 
 module JIRA
   module Resource
@@ -6,27 +9,153 @@ module JIRA
       delegate_to_target_class :meta
     end
 
+    # This class provides the Attachment object <-> REST mapping for JIRA::Resource::Attachment derived class,
+    # i.e. the Create, Retrieve, Update, Delete lifecycle methods.
+    #
+    # == Lifecycle methods
+    #
+    # === Retrieving a single attachment by Issue and attachment id
+    #
+    #     # Find attachment with id 30076 on issue SUP-3000.
+    #     issue =  JIRA::Resource::Issue.find(client, 'SUP-3000', { fields: 'attachment' } )
+    #     attachment = issue.attachments.find do |attachment_curr|
+    #         30076 == attachment_curr.id.to_i
+    #     end
+    #
+    # === Retrieving meta information for an attachments
+    #
+    #     attachment.meta
+    #
+    # === Retrieving file contents of attachment
+    #
+    #     content = URI.open(attachment.content).read
+    #     content = attachment.download_contents
+    #     content = attachment.download_file { |file| file.read }
+    #
+    # === Adding an attachment to an issue
+    #
+    #     Dir.mktmpdir do |dir|
+    #       path = File.join(dir, filename)
+    #       IO.copy_stream(file.path, path)
+    #
+    #       issue =  JIRA::Resource::Issue.find(client, 'SUP-3000', { fields: 'attachment' } )
+    #       attachment = issue.attachments.build
+    #       attachment.save!( { file: path, mimeType: content_type } )
+    #     end
+    #
+    # === Deleting an attachment
+    #
+    #   attachment.delete
+    #
+    # @!method save(attrs, path = url)
+    #   Uploads a file as an attachment to its issue.
+    #
+    #   Filename used will be the basename of the given file.
+    #
+    #   @param [Hash] attrs the options to create a message with.
+    #   @option attrs [IO,String] :file The file to upload, either a file object or a file path to find the file.
+    #   @option attrs [String] :mimeType The MIME type of the file.
+    #   @return [Boolean] True if successful, false if failed.
+    #
+    # @!attribute [r] self
+    #   @return [String] URL to JSON of this attachment
+    # @!attribute [r] filename
+    #   @return [String] the filename
+    # @!attribute [r] author
+    #   @return [JIRA::Resource::User] the user who created the attachment
+    # @!attribute [r] created
+    #   @return [String] timestamp when the attachment was created
+    # @!attribute [r] size
+    #   @return [Integer] the file size
+    # @!attribute [r] mimeType
+    #   @return [String] MIME of the content type
+    # @!attribute [r] content
+    #   @return [String] URL (not the contents) to download the contents of the attachment
+    # @!attribute [r] thumbnail
+    #   @return [String] URL to download the thumbnail of the attachment
+    #
     class Attachment < JIRA::Base
       belongs_to :issue
       has_one :author, class: JIRA::Resource::User
 
+      # @private
       def self.endpoint_name
         'attachments'
       end
 
+      # Gets metadata about attachments on the server.
+      # @example Return metadata
+      #   Attachment.meta(client)
+      #   =>  { "enabled" => true, "uploadLimit" => 1000000 }
+      # @return [Hash] The metadata for attachments.  (See example.)
       def self.meta(client)
-        response = client.get(client.options[:rest_base_path] + '/attachment/meta')
+        response = client.get("#{client.options[:rest_base_path]}/attachment/meta")
         parse_json(response.body)
       end
 
+      # Opens a file streaming the download of the attachment.
+      # @example Write file contents to a file.
+      #   File.open('some-filename', 'wb') do |output|
+      #     download_file do |file|
+      #       IO.copy_stream(file, output)
+      #     end
+      #   end
+      # @example Stream file contents for an HTTP response.
+      #   response.headers[ "Content-Type" ] = "application/octet-stream"
+      #   download_file do |file|
+      #     chunk = file.read(8000)
+      #     while chunk.present? do
+      #       response.stream.write(chunk)
+      #       chunk = file.read(8000)
+      #     end
+      #   end
+      #   response.stream.close
+      # @param [Hash] headers Any additional headers to call Jira.
+      # @yield |file|
+      # @yieldparam [IO] file The IO object streaming the download.
+      def download_file(headers = {}, &)
+        default_headers = client.options[:default_headers]
+        URI.parse(content).open(default_headers.merge(headers), &)
+      end
+
+      # Downloads the file contents as a string object.
+      #
+      # Note that this reads the contents into a ruby string in memory.
+      # A file might be very large so it is recommended to avoid this unless you are certain about doing so.
+      # Use the download_file method instead and avoid calling the read method without a limit.
+      #
+      # @example Save file contents to a string.
+      #   content = download_contents
+      # @param [Hash] headers Any additional headers to call Jira.
+      # @return [String,NilClass] The file contents.
+      def download_contents(headers = {})
+        download_file(headers, &:read)
+      end
+
+      # Uploads a file as an attachment to its issue.
+      #
+      # Filename used will be the basename of the given file.
+      #
+      # @example Save a file as an attachment
+      #   issue =  JIRA::Resource::Issue.find(client, 'SUP-3000', { fields: 'attachment' } )
+      #   attachment = issue.attachments.build
+      #   attachment.save!( { file: path, mimeType: 'text/plain' } )
+      # @param [Hash] attrs the options to create a message with.
+      # @option attrs [IO,String] :file The file to upload, either a file object or a file path to find the file.
+      # @option attrs [String] :mimeType The MIME type of the file.
+      # @raise [JIRA::HTTPError] if failed
       def save!(attrs, path = url)
         file = attrs['file'] || attrs[:file] # Keep supporting 'file' parameter as a string for backward compatibility
-        mime_type = attrs[:mimeType] || 'application/binary'
+        # If :filename does not exist or is nil, that is fine as it will force
+        # Upload to determine the filename automatically from file.
+        # Breaking the filename out allows this to support any IO-based file parameter.
+        fname = attrs['filename'] || attrs[:filename]
+        mime_type = attrs['mimeType'] || attrs[:mimeType] || 'application/binary'
 
         headers = { 'X-Atlassian-Token' => 'nocheck' }
-        data = { 'file' => UploadIO.new(file, mime_type, file) }
+        data = { 'file' => Multipart::Post::UploadIO.new(file, mime_type, fname) }
 
-        response = client.post_multipart(path, data , headers)
+        response = client.post_multipart(path, data, headers)
 
         set_attributes(attrs, response)
 
@@ -34,6 +163,17 @@ module JIRA
         true
       end
 
+      def http_download
+        # Actually fetch the attachment
+        # Note: Jira handles attachment's weird!
+        # Typically, they respond with a redirect location that should not have the same authentication
+        client.get(attrs['content'])
+      rescue JIRA::HTTPError => e
+        raise e unless e.response.code =~ /\A3\d\d\z/ && e.response['location'].present?
+
+        Net::HTTP.get_response(URI(e.response['location']))
+      end
+
       private
 
       def set_attributes(attributes, response)

data/lib/jira/resource/board.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cgi'
 
 module JIRA
@@ -7,7 +9,7 @@ module JIRA
 
     class Board < JIRA::Base
       def self.all(client)
-        path = path_base(client) + '/board'
+        path = "#{path_base(client)}/board"
         response = client.get(path)
         json = parse_json(response.body)
         results = json['values']
@@ -74,13 +76,13 @@ module JIRA
       end
 
       def add_issue_to_backlog(issue)
-        client.post(path_base(client) + '/backlog/issue', { issues: [issue.id] }.to_json)
+        client.post("#{path_base(client)}/backlog/issue", { issues: [issue.id] }.to_json)
       end
 
       private
 
       def self.path_base(client)
-        client.options[:context_path] + '/rest/agile/1.0'
+        "#{client.options[:context_path]}/rest/agile/1.0"
       end
 
       def path_base(client)

data/lib/jira/resource/board_configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class BoardConfigurationFactory < JIRA::BaseFactory # :nodoc:

data/lib/jira/resource/comment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class CommentFactory < JIRA::BaseFactory # :nodoc:
@@ -7,6 +9,18 @@ module JIRA
       belongs_to :issue
 
       nested_collections true
+
+      def self.all(client, options = {})
+        issue = options[:issue]
+        raise ArgumentError, 'parent issue is required' unless issue
+
+        response = client.get("#{issue.url}/#{endpoint_name}")
+        json = parse_json(response.body)
+        json = json[endpoint_name.pluralize]
+        json.map do |attrs|
+          new(client, { attrs: }.merge(options))
+        end
+      end
     end
   end
 end

data/lib/jira/resource/component.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class ComponentFactory < JIRA::BaseFactory # :nodoc:

data/lib/jira/resource/createmeta.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class CreatemetaFactory < JIRA::BaseFactory # :nodoc:
@@ -10,22 +12,22 @@ module JIRA
 
       def self.all(client, params = {})
         if params.key?(:projectKeys)
-          values = Array(params[:projectKeys]).map { |i| (i.is_a?(JIRA::Resource::Project) ? i.key : i) }
+          values = Array(params[:projectKeys]).map { |i| i.is_a?(JIRA::Resource::Project) ? i.key : i }
           params[:projectKeys] = values.join(',')
         end
 
         if params.key?(:projectIds)
-          values = Array(params[:projectIds]).map { |i| (i.is_a?(JIRA::Resource::Project) ? i.id : i) }
+          values = Array(params[:projectIds]).map { |i| i.is_a?(JIRA::Resource::Project) ? i.id : i }
           params[:projectIds] = values.join(',')
         end
 
         if params.key?(:issuetypeNames)
-          values = Array(params[:issuetypeNames]).map { |i| (i.is_a?(JIRA::Resource::Issuetype) ? i.name : i) }
+          values = Array(params[:issuetypeNames]).map { |i| i.is_a?(JIRA::Resource::Issuetype) ? i.name : i }
           params[:issuetypeNames] = values.join(',')
         end
 
         if params.key?(:issuetypeIds)
-          values = Array(params[:issuetypeIds]).map { |i| (i.is_a?(JIRA::Resource::Issuetype) ? i.id : i) }
+          values = Array(params[:issuetypeIds]).map { |i| i.is_a?(JIRA::Resource::Issuetype) ? i.id : i }
           params[:issuetypeIds] = values.join(',')
         end
 
@@ -36,7 +38,7 @@ module JIRA
 
         json = parse_json(response.body)
         json['projects'].map do |attrs|
-          new(client, attrs: attrs)
+          new(client, attrs:)
         end
       end
     end

data/lib/jira/resource/field.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class FieldFactory < JIRA::BaseFactory # :nodoc:
@@ -19,43 +21,42 @@ module JIRA
 
       def self.map_fields(client)
         field_map = {}
-        field_map_reverse = {}
         fields = client.Field.all
 
         # two pass approach, so that a custom field with the same name
         # as a system field can't take precedence
         fields.each do |f|
           next if f.custom
+
           name = safe_name(f.name)
-          field_map_reverse[f.id] = [f.name, name] # capture both the official name, and the mapped name
           field_map[name] = f.id
         end
 
-        fields.each do |f|
+        fields.each do |f| # rubocop:disable Style/CombinableLoops
           next unless f.custom
+
           name = if field_map.key? f.name
                    renamed = safer_name(f.name, f.id)
                    warn "Duplicate Field name #{f.name} #{f.id} - renaming as #{renamed}"
                    renamed
                  else
                    safe_name(f.name)
-          end
-          field_map_reverse[f.id] = [f.name, name] # capture both the official name, and the mapped name
+                 end
           field_map[name] = f.id
         end
 
-        client.cache.field_map_reverse = field_map_reverse # not sure where this will be used yet, but sure to be useful
-        client.cache.field_map = field_map
+        client.field_map_cache = field_map
       end
 
       def self.field_map(client)
-        client.cache.field_map
+        client.field_map_cache
       end
 
       def self.name_to_id(client, field_name)
         field_name = field_name.to_s
-        return field_name unless client.cache.field_map && client.cache.field_map[field_name]
-        client.cache.field_map[field_name]
+        return field_name unless client.field_map_cache && client.field_map_cache[field_name]
+
+        client.field_map_cache[field_name]
       end
 
       def respond_to?(method_name, _include_all = false)
@@ -66,7 +67,7 @@ module JIRA
         end
       end
 
-      def method_missing(method_name, *args, &block)
+      def method_missing(method_name, *args, &)
         if attrs.key?(method_name.to_s)
           attrs[method_name.to_s]
         else
@@ -74,7 +75,7 @@ module JIRA
           if attrs.key?(official_name)
             attrs[official_name]
           else
-            super(method_name, *args, &block)
+            super
           end
         end
       end

data/lib/jira/resource/filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class FilterFactory < JIRA::BaseFactory # :nodoc:

data/lib/jira/resource/issue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cgi'
 require 'json'
 
@@ -6,100 +8,168 @@ module JIRA
     class IssueFactory < JIRA::BaseFactory # :nodoc:
     end
 
+    # This class provides the Issue object <-> REST mapping for JIRA::Resource::Issue derived class,
+    # i.e. the Create, Retrieve, Update, Delete lifecycle methods.
+    #
+    # == Lifecycle methods
+    #
+    # === Retrieving all issues
+    #
+    #   client.Issue.all
+    #
+    # === Retrieving a single issue
+    #
+    #   options = { expand: 'editmeta' }
+    #   issue = client.Issue.find("SUP-3000", options)
+    #
+    # === Creating a new issue
+    #
+    #   issue = client.Issue.build(fields: { summary: 'New issue', project: { key: 'SUP' }, issuetype: { name: 'Bug' } })
+    #   issue.save
+    #
+    # === Updating an issue
+    #
+    #   issue = client.Issue.find("SUP-3000")
+    #   issue.save(fields: { summary: 'Updated issue' })
+    #
+    # === Deleting an issue
+    #
+    #   issue = client.Issue.find("SUP-3000")
+    #   issue.delete
+    #
     class Issue < JIRA::Base
-      has_one :reporter,  class: JIRA::Resource::User,
-                          nested_under: 'fields'
-      has_one :assignee,  class: JIRA::Resource::User,
-                          nested_under: 'fields'
-      has_one :project,   nested_under: 'fields'
-
+      has_one :reporter, class: JIRA::Resource::User, nested_under: 'fields'
+      has_one :assignee, class: JIRA::Resource::User, nested_under: 'fields'
+      has_one :project, nested_under: 'fields'
       has_one :issuetype, nested_under: 'fields'
-
-      has_one :priority,  nested_under: 'fields'
-
-      has_one :status,    nested_under: 'fields'
-
+      has_one :priority, nested_under: 'fields'
+      has_one :status, nested_under: 'fields'
+      has_one :resolution, nested_under: 'fields'
       has_many :transitions
-
       has_many :components, nested_under: 'fields'
-
       has_many :comments, nested_under: %w[fields comment]
-
-      has_many :attachments, nested_under: 'fields',
-                             attribute_key: 'attachment'
-
-      has_many :versions,    nested_under: 'fields'
-      has_many :fixVersions, class: JIRA::Resource::Version,
-                             nested_under: 'fields'
-
+      has_many :attachments, nested_under: 'fields', attribute_key: 'attachment'
+      has_many :versions, nested_under: 'fields'
+      has_many :fixVersions, class: JIRA::Resource::Version, nested_under: 'fields'
       has_many :worklogs, nested_under: %w[fields worklog]
-      has_one :sprint, class: JIRA::Resource::Sprint,
-                       nested_under: 'fields'
-
-      has_many :closed_sprints, class: JIRA::Resource::Sprint,
-                                nested_under: 'fields', attribute_key: 'closedSprints'
-
+      has_one :sprint, class: JIRA::Resource::Sprint, nested_under: 'fields'
+      has_many :closed_sprints, class: JIRA::Resource::Sprint, nested_under: 'fields', attribute_key: 'closedSprints'
       has_many :issuelinks, nested_under: 'fields'
-
       has_many :remotelink, class: JIRA::Resource::Remotelink
+      has_many :watchers, attribute_key: 'watches', nested_under: %w[fields watches]
+      has_many :properties, class: JIRA::Resource::Properties
 
-      has_many :watchers,   attribute_key: 'watches',
-                            nested_under: %w[fields watches]
-
+      # Get collection of issues.
+      # @param client [JIRA::Client]
+      # @return [Array<JIRA::Resource::Issue>]
       def self.all(client)
         start_at = 0
         max_results = 1000
         result = []
         loop do
           url = client.options[:rest_base_path] +
-                "/search?expand=transitions.fields&maxResults=#{max_results}&startAt=#{start_at}"
+                "/search/jql?expand=transitions.fields&maxResults=#{max_results}&startAt=#{start_at}"
           response = client.get(url)
           json = parse_json(response.body)
           json['issues'].map do |issue|
             result.push(client.Issue.build(issue))
           end
           break if json['issues'].empty?
+
           start_at += json['issues'].size
         end
         result
       end
 
-      def self.jql(client, jql, options = { fields: nil, start_at: nil, max_results: nil, expand: nil, validate_query: true })
-        url = client.options[:rest_base_path] + "/search?jql=#{CGI.escape(jql)}"
+      # Get issues using JQL query.
+      # @param client [JIRA::Client]
+      # @param jql [String] the JQL query string to search with
+      # @param options [Hash] Jira API options for the search
+      # @return [Array<JIRA::Resource::Issue>] or [Integer] total count if max_results is 0
+      def self.jql(client, jql, options = { fields: nil, max_results: nil, expand: nil, reconcile_issues: nil })
+        issues = []
+        total = nil
+        next_page_token = nil
+        is_last = false
+
+        until is_last
+          result = jql_paged(client, jql, options.merge(next_page_token:))
+
+          issues.concat(result[:issues])
+          total = result[:total]
+          next_page_token = result[:next_page_token]
+          is_last = next_page_token.nil?
+        end
+        options[:max_results]&.zero? ? total : issues
+      end
+
+      # Get paged issues using JQL query.
+      # @param jql [String] the JQL query string to search with
+      # @param options [Hash] Jira API options for the search, including next_page_token
+      # @return [Hash] with format { issues: [JIRA::Resource::Issue], next_page_token: [String], total: [Integer] }
+      def self.jql_paged(client, jql, options = { fields: nil, max_results: nil, expand: nil, reconcile_issues: nil, next_page_token: nil })
+        url = jql_url(client, jql, options)
+        next_page_token = options[:next_page_token]
+        max_results = options[:max_results]
+
+        issues = []
 
-        url << "&fields=#{options[:fields].map { |value| CGI.escape(client.Field.name_to_id(value)) }.join(',')}" if options[:fields]
-        url << "&startAt=#{CGI.escape(options[:start_at].to_s)}" if options[:start_at]
+        page_url = url.dup
+        page_url << "&nextPageToken=#{next_page_token}" if next_page_token
+
+        response = client.get(page_url)
+        json = parse_json(response.body)
+        total = json['total']
+
+        unless max_results&.zero?
+          next_page_token = json['nextPageToken']
+          json['issues'].map do |issue|
+            issues << client.Issue.build(issue)
+          end
+        end
+
+        { issues:, next_page_token:, total: }
+      end
+
+      def self.jql_url(client, jql, options)
+        url = client.options[:rest_base_path] + "/search/jql?jql=#{CGI.escape(jql)}"
+
+        if options[:fields]
+          url << "&fields=#{options[:fields].map do |value|
+                              CGI.escape(client.Field.name_to_id(value))
+                            end.join(',')}"
+        end
         url << "&maxResults=#{CGI.escape(options[:max_results].to_s)}" if options[:max_results]
-        url << '&validateQuery=false' if options[:validate_query] === false
+        url << "&reconcileIssues=#{CGI.escape(options[:reconcile_issues].to_s)}" if options[:reconcile_issues]
 
         if options[:expand]
           options[:expand] = [options[:expand]] if options[:expand].is_a?(String)
           url << "&expand=#{options[:expand].to_a.map { |value| CGI.escape(value.to_s) }.join(',')}"
         end
-
-        response = client.get(url)
-        json = parse_json(response.body)
-        if options[:max_results] && (options[:max_results] == 0)
-          return json['total']
-        end
-        json['issues'].map do |issue|
-          client.Issue.build(issue)
-        end
+        url
       end
 
       # Fetches the attributes for the specified resource from JIRA unless
       # the resource is already expanded and the optional force reload flag
       # is not set
+      # @param [Boolean] reload
+      # @param [Hash] query_params
+      # @option query_params [String] :fields
+      # @option query_params [String] :expand
+      # @option query_params [Integer] :startAt
+      # @option query_params [Integer] :maxResults
+      # @return [void]
       def fetch(reload = false, query_params = {})
         return if expanded? && !reload
+
         response = client.get(url_with_query_params(url, query_params))
         set_attrs_from_response(response)
-        if @attrs && @attrs['fields'] && @attrs['fields']['worklog'] && (@attrs['fields']['worklog']['total'] > @attrs['fields']['worklog']['maxResults'])
+        if @attrs && @attrs['fields'] &&
+           @attrs['fields']['worklog'] &&
+           (@attrs['fields']['worklog']['total'] > @attrs['fields']['worklog']['maxResults'])
           worklog_url = client.options[:rest_base_path] + "/#{self.class.endpoint_name}/#{id}/worklog"
           response = client.get(worklog_url)
-          unless response.body.nil? || (response.body.length < 2)
-            set_attrs({ 'fields' => { 'worklog' => self.class.parse_json(response.body) } }, false)
-          end
+          set_attrs({ 'fields' => { 'worklog' => self.class.parse_json(response.body) } }, false) unless response.body.nil? || (response.body.length < 2)
         end
         @expanded = true
       end
@@ -112,15 +182,19 @@ module JIRA
         json['fields']
       end
 
+      # @private
       def respond_to?(method_name, _include_all = false)
-        if attrs.key?('fields') && [method_name.to_s, client.Field.name_to_id(method_name)].any? { |k| attrs['fields'].key?(k) }
+        if attrs.key?('fields') && [method_name.to_s, client.Field.name_to_id(method_name)].any? do |k|
+             attrs['fields'].key?(k)
+           end
           true
         else
           super(method_name)
         end
       end
 
-      def method_missing(method_name, *args, &block)
+      # @private
+      def method_missing(method_name, *args, &)
         if attrs.key?('fields')
           if attrs['fields'].key?(method_name.to_s)
             attrs['fields'][method_name.to_s]
@@ -129,13 +203,33 @@ module JIRA
             if attrs['fields'].key?(official_name)
               attrs['fields'][official_name]
             else
-              super(method_name, *args, &block)
+              super
             end
           end
         else
-          super(method_name, *args, &block)
+          super
         end
       end
+
+      # @!method self.find(client, key, options = {})
+      #   Gets/fetches an issue from JIRA.
+      #
+      #   Note: attachments are not fetched by default.
+      #
+      #   @param [JIRA::Client] client
+      #   @param [String] key the key of the issue to find
+      #   @param [Hash] options the options to find the issue with
+      #   @option options [String] :fields the fields to include in the response
+      #   @return [JIRA::Resource::Issue] the found issue
+      #   @example Find an issue
+      #   JIRA::Resource::Issue.find(client, "SUP-3000", { fields: %w[summary description attachment created ] } )
+      #
+      # @!method self.build(attrs = {})
+      #   Constructs a new issue object.
+      #   @param [Hash] attrs the attributes to initialize the issue with
+      #   @return [JIRA::Resource::Issue] the new issue
+      #
+      # .
     end
   end
 end

data/lib/jira/resource/issue_picker_suggestions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JIRA
   module Resource
     class IssuePickerSuggestionsFactory < JIRA::BaseFactory # :nodoc:
@@ -6,7 +8,8 @@ module JIRA
     class IssuePickerSuggestions < JIRA::Base
       has_many :sections, class: JIRA::Resource::IssuePickerSuggestionsIssue
 
-      def self.all(client, query = '', options = { current_jql: nil, current_issue_key: nil, current_project_id: nil, show_sub_tasks: nil, show_sub_tasks_parent: nil })
+      def self.all(client, query = '', options = { current_jql: nil, current_issue_key: nil, current_project_id: nil,
+                                                   show_sub_tasks: nil, show_sub_tasks_parent: nil })
         url = client.options[:rest_base_path] + "/issue/picker?query=#{CGI.escape(query)}"
 
         url << "&currentJQL=#{CGI.escape(options[:current_jql])}" if options[:current_jql]