jira-ruby 1.2.0 → 2.3.0

data/lib/jira/base.rb

@@ -3,7 +3,6 @@ require 'active_support/inflector'
 require 'set'
 
 module JIRA
-
   # This class provides the basic object <-> REST mapping for all JIRA::Resource subclasses,
   # i.e. the Create, Retrieve, Update, Delete lifecycle methods.
   #
@@ -51,8 +50,8 @@ module JIRA
   #   new_comment = issue.comments.build
   #
   class Base
-    QUERY_PARAMS_FOR_SINGLE_FETCH = Set.new [:expand, :fields]
-    QUERY_PARAMS_FOR_SEARCH = Set.new [:expand, :fields, :startAt, :maxResults]
+    QUERY_PARAMS_FOR_SINGLE_FETCH = Set.new %i[expand fields]
+    QUERY_PARAMS_FOR_SEARCH = Set.new %i[expand fields startAt maxResults]
 
     # A reference to the JIRA::Client used to initialize this resource.
     attr_reader :client
@@ -67,8 +66,8 @@ module JIRA
     # representation of the JSON returned from the JIRA API
     attr_accessor :attrs
 
-    alias :expanded? :expanded
-    alias :deleted? :deleted
+    alias expanded? expanded
+    alias deleted? deleted
 
     def initialize(client, options = {})
       @client   = client
@@ -80,12 +79,12 @@ module JIRA
       # each of them must be passed in to the initializer.
       self.class.belongs_to_relationships.each do |relation|
         if options[relation]
-          instance_variable_set("@#{relation.to_s}", options[relation])
-          instance_variable_set("@#{relation.to_s}_id", options[relation].key_value)
+          instance_variable_set("@#{relation}", options[relation])
+          instance_variable_set("@#{relation}_id", options[relation].key_value)
         elsif options["#{relation}_id".to_sym]
-          instance_variable_set("@#{relation.to_s}_id", options["#{relation}_id".to_sym])
+          instance_variable_set("@#{relation}_id", options["#{relation}_id".to_sym])
         else
-          raise ArgumentError.new("Required option #{relation.inspect} missing") unless options[relation]
+          raise ArgumentError, "Required option #{relation.inspect} missing" unless options[relation]
         end
       end
     end
@@ -95,17 +94,15 @@ module JIRA
     def self.all(client, options = {})
       response = client.get(collection_path(client))
       json = parse_json(response.body)
-      if collection_attributes_are_nested
-        json = json[endpoint_name.pluralize]
-      end
+      json = json[endpoint_name.pluralize] if collection_attributes_are_nested
       json.map do |attrs|
-        self.new(client, {:attrs => attrs}.merge(options))
+        new(client, { attrs: attrs }.merge(options))
       end
     end
 
     # Finds and retrieves a resource with the given ID.
     def self.find(client, key, options = {})
-      instance = self.new(client, options)
+      instance = new(client, options)
       instance.attrs[key_attribute.to_s] = key
       instance.fetch(false, query_params_for_single_fetch(options))
       instance
@@ -114,7 +111,7 @@ module JIRA
     # Builds a new instance of the resource with the given attributes.
     # These attributes will be posted to the JIRA Api if save is called.
     def self.build(client, attrs)
-      self.new(client, :attrs => attrs)
+      new(client, attrs: attrs)
     end
 
     # Returns the name of this resource for use in URL components.
@@ -122,7 +119,7 @@ module JIRA
     #   JIRA::Resource::Issue.endpoint_name
     #     # => issue
     def self.endpoint_name
-      self.name.split('::').last.downcase
+      name.split('::').last.downcase
     end
 
     # Returns the full path for a collection of this resource.
@@ -130,7 +127,7 @@ module JIRA
     #   JIRA::Resource::Issue.collection_path
     #     # => /jira/rest/api/2/issue
     def self.collection_path(client, prefix = '/')
-      client.options[:rest_base_path] + prefix + self.endpoint_name
+      client.options[:rest_base_path] + prefix + endpoint_name
     end
 
     # Returns the singular path for the resource with the given key.
@@ -200,7 +197,7 @@ module JIRA
       define_method(resource) do
         attribute = maybe_nested_attribute(attribute_key, options[:nested_under])
         return nil unless attribute
-        child_class.new(client, :attrs => attribute)
+        child_class.new(client, attrs: attribute)
       end
     end
 
@@ -248,12 +245,12 @@ module JIRA
     def self.has_many(collection, options = {})
       attribute_key = options[:attribute_key] || collection.to_s
       child_class = options[:class] || ('JIRA::Resource::' + collection.to_s.classify).constantize
-      self_class_basename = self.name.split('::').last.downcase.to_sym
+      self_class_basename = name.split('::').last.downcase.to_sym
       define_method(collection) do
-        child_class_options = {self_class_basename => self}
+        child_class_options = { self_class_basename => self }
         attribute = maybe_nested_attribute(attribute_key, options[:nested_under]) || []
         collection = attribute.map do |child_attributes|
-          child_class.new(client, child_class_options.merge(:attrs => child_attributes))
+          child_class.new(client, child_class_options.merge(attrs: child_attributes))
         end
         HasManyProxy.new(self, child_class, collection)
       end
@@ -290,8 +287,8 @@ module JIRA
     # Checks if method_name is set in the attributes hash
     # and returns true when found, otherwise proxies the
     # call to the superclass.
-    def respond_to?(method_name, include_all=false)
-      if attrs.keys.include? method_name.to_s
+    def respond_to?(method_name, _include_all = false)
+      if attrs.key?(method_name.to_s)
         true
       else
         super(method_name)
@@ -301,8 +298,8 @@ module JIRA
     # Overrides method_missing to check the attribute hash
     # for resources matching method_name and proxies the call
     # to the superclass if no match is found.
-    def method_missing(method_name, *args, &block)
-      if attrs.keys.include? method_name.to_s
+    def method_missing(method_name, *_args)
+      if attrs.key?(method_name.to_s)
         attrs[method_name.to_s]
       else
         super(method_name)
@@ -315,7 +312,7 @@ module JIRA
       @attrs[self.class.key_attribute.to_s]
     end
 
-    def collection_path(prefix = "/")
+    def collection_path(prefix = '/')
       # Just proxy this to the class method
       self.class.collection_path(client, prefix)
     end
@@ -325,9 +322,7 @@ module JIRA
     # issue it returns '/issue'
     def path_component
       path_component = "/#{self.class.endpoint_name}"
-      if key_value
-        path_component += '/' + key_value
-      end
+      path_component += '/' + key_value if key_value
       path_component
     end
 
@@ -346,9 +341,10 @@ module JIRA
     #
     # Accepts an attributes hash of the values to be saved.  Will throw a
     # JIRA::HTTPError if the request fails (response is not HTTP 2xx).
-    def save!(attrs)
+    def save!(attrs, path = nil)
+      path ||= new_record? ? url : patched_url
       http_method = new_record? ? :post : :put
-      response = client.send(http_method, new_record? ? url : patched_url, attrs.to_json)
+      response = client.send(http_method, path, attrs.to_json)
       set_attrs(attrs, false)
       set_attrs_from_response(response)
       @expanded = false
@@ -360,21 +356,20 @@ module JIRA
     #
     # Accepts an attributes hash of the values to be saved. Will return false
     # if the request fails.
-    def save(attrs)
+    def save(attrs, path = url)
       begin
-        save_status = save!(attrs)
+        save_status = save!(attrs, path)
       rescue JIRA::HTTPError => exception
-        puts ">>>>>>>>> Exception response: #{exception.response.body}"
         begin
           set_attrs_from_response(exception.response) # Merge error status generated by JIRA REST API
         rescue JSON::ParserError => parse_exception
-          set_attrs("exception" => {
-                        "class" => exception.response.class.name,
-                        "code" => exception.response.code,
-                        "message" => exception.response.message
-                    }
-          )
+          set_attrs('exception' => {
+                      'class' => exception.response.class.name,
+                      'code' => exception.response.code,
+                      'message' => exception.response.message
+                    })
         end
+        # raise exception
         save_status = false
       end
       save_status
@@ -383,7 +378,7 @@ module JIRA
     # Sets the attributes hash from a HTTPResponse object from JIRA if it is
     # not nil or is not a json response.
     def set_attrs_from_response(response)
-      unless response.body.nil? or response.body.length < 2
+      unless response.body.nil? || (response.body.length < 2)
         json = self.class.parse_json(response.body)
         set_attrs(json)
       end
@@ -393,7 +388,7 @@ module JIRA
     # hash values will be clobbered by the new hash, otherwise the hash will
     # be deeply merged into attrs.  The target paramater is for internal use only
     # and should not be used.
-    def set_attrs(hash, clobber=true, target = nil)
+    def set_attrs(hash, clobber = true, target = nil)
       target ||= @attrs
       if clobber
         target.merge!(hash)
@@ -424,12 +419,12 @@ module JIRA
       prefix = '/'
       unless self.class.belongs_to_relationships.empty?
         prefix = self.class.belongs_to_relationships.inject(prefix) do |prefix_so_far, relationship|
-          prefix_so_far.to_s + relationship.to_s + "/" + self.send("#{relationship.to_s}_id").to_s + '/'
+          prefix_so_far.to_s + relationship.to_s + '/' + send("#{relationship}_id").to_s + '/'
         end
       end
       if @attrs['self']
-        the_url = @attrs['self'].sub(@client.options[:site],'')
-        the_url = "/#{the_url}" if (the_url =~ /^\//).nil?
+        the_url = @attrs['self']
+        the_url = the_url.sub(@client.options[:site].chomp('/'), '') if @client.options[:site]
         the_url
       elsif key_value
         self.class.singular_path(client, key_value.to_s, prefix)
@@ -447,7 +442,7 @@ module JIRA
     # [07/Jun/2015:15:17:18 +0400] "PUT /jira/rest/api/2/issue/10111 HTTP/1.1" 204 -
     def patched_url
       result = url
-      return result if result.start_with?('/')
+      return result if result.start_with?('/', 'http')
       "/#{result}"
     end
 
@@ -494,9 +489,15 @@ module JIRA
     end
 
     def url_with_query_params(url, query_params)
-      uri = URI.parse(url)
-      uri.query = uri.query.nil? ? "#{hash_to_query_string query_params}" : "#{uri.query}&#{hash_to_query_string query_params}" unless query_params.empty?
-      uri.to_s
+      self.class.url_with_query_params(url, query_params)
+    end
+
+    def self.url_with_query_params(url, query_params)
+      if !query_params.empty?
+        "#{url}?#{hash_to_query_string query_params}"
+      else
+        url
+      end
     end
 
     def hash_to_query_string(query_params)
@@ -504,19 +505,19 @@ module JIRA
     end
 
     def self.hash_to_query_string(query_params)
-      query_params.map do |k,v|
+      query_params.map do |k, v|
         CGI.escape(k.to_s) + '=' + CGI.escape(v.to_s)
       end.join('&')
     end
 
     def self.query_params_for_single_fetch(options)
-      Hash[options.select do |k,v|
+      Hash[options.select do |k, _v|
         QUERY_PARAMS_FOR_SINGLE_FETCH.include? k
       end]
     end
 
     def self.query_params_for_search(options)
-      Hash[options.select do |k,v|
+      Hash[options.select do |k, _v|
         QUERY_PARAMS_FOR_SEARCH.include? k
       end]
     end

data/lib/jira/base_factory.rb

@@ -1,15 +1,13 @@
 module JIRA
-
   # This is the base class for all the JIRA resource factory instances.
   class BaseFactory
-
     attr_reader :client
 
     def initialize(client)
       @client = client
     end
 
-    # Return the name of the class which this factory generates, i.e. 
+    # Return the name of the class which this factory generates, i.e.
     # JIRA::Resource::FooFactory creates JIRA::Resource::Foo instances.
     def target_class
       # Need to do a little bit of work here as Module.const_get doesn't work
@@ -38,12 +36,11 @@ module JIRA
     # The principle purpose of this class is to delegate methods to the corresponding
     # non-factory class and automatically prepend the client argument to the argument
     # list.
-    delegate_to_target_class :all, :find, :collection_path, :singular_path, :jql, :get_backlog_issues, :get_sprints, :get_sprint_issues
+    delegate_to_target_class :all, :find, :collection_path, :singular_path, :jql, :get_backlog_issues, :get_board_issues, :get_sprints, :get_sprint_issues, :get_projects, :get_projects_full
 
     # This method needs special handling as it has a default argument value
-    def build(attrs={})
+    def build(attrs = {})
       target_class.build(@client, attrs)
     end
-
   end
 end

data/lib/jira/client.rb

@@ -3,11 +3,10 @@ require 'forwardable'
 require 'ostruct'
 
 module JIRA
-
   # This class is the main access point for all JIRA::Resource instances.
   #
   # The client must be initialized with an options hash containing
-  # configuration options.  The available options are:
+  # configuration options. The available options are:
   #
   #   :site               => 'http://localhost:2990',
   #   :context_path       => '/jira',
@@ -15,23 +14,38 @@ module JIRA
   #   :request_token_path => "/plugins/servlet/oauth/request-token",
   #   :authorize_path     => "/plugins/servlet/oauth/authorize",
   #   :access_token_path  => "/plugins/servlet/oauth/access-token",
+  #   :private_key        => nil,
   #   :private_key_file   => "rsakey.pem",
   #   :rest_base_path     => "/rest/api/2",
   #   :consumer_key       => nil,
   #   :consumer_secret    => nil,
   #   :ssl_verify_mode    => OpenSSL::SSL::VERIFY_PEER,
+  #   :ssl_version        => nil,
   #   :use_ssl            => true,
   #   :username           => nil,
   #   :password           => nil,
-  #   :auth_type          => :oauth
-  #   :proxy_address      => nil
-  #   :proxy_port         => nil
+  #   :auth_type          => :oauth,
+  #   :proxy_address      => nil,
+  #   :proxy_port         => nil,
+  #   :proxy_username     => nil,
+  #   :proxy_password     => nil,
+  #   :use_cookies        => nil,
+  #   :additional_cookies => nil,
+  #   :default_headers    => {},
+  #   :use_client_cert    => false,
+  #   :read_timeout       => nil,
+  #   :http_debug         => false,
+  #   :shared_secret      => nil,
+  #   :cert_path          => nil,
+  #   :key_path           => nil,
+  #   :ssl_client_cert    => nil,
+  #   :ssl_client_key     => nil
+  #   :ca_file            => nil
   #
   # See the JIRA::Base class methods for all of the available methods on these accessor
   # objects.
 
   class Client
-
     extend Forwardable
 
     # The OAuth::Consumer instance returned by the OauthClient
@@ -43,27 +57,79 @@ module JIRA
     # The configuration options for this client instance
     attr_reader :options
 
-    def_delegators :@request_client, :init_access_token, :set_access_token, :set_request_token, :request_token, :access_token
+    def_delegators :@request_client, :init_access_token, :set_access_token, :set_request_token, :request_token, :access_token, :authenticated?
+
+    DEFINED_OPTIONS = [
+      :site,
+      :context_path,
+      :signature_method,
+      :request_token_path,
+      :authorize_path,
+      :access_token_path,
+      :private_key,
+      :private_key_file,
+      :rest_base_path,
+      :consumer_key,
+      :consumer_secret,
+      :ssl_verify_mode,
+      :ssl_version,
+      :use_ssl,
+      :username,
+      :password,
+      :auth_type,
+      :proxy_address,
+      :proxy_port,
+      :proxy_username,
+      :proxy_password,
+      :use_cookies,
+      :additional_cookies,
+      :default_headers,
+      :use_client_cert,
+      :read_timeout,
+      :http_debug,
+      :issuer,
+      :base_url,
+      :shared_secret,
+      :cert_path,
+      :key_path,
+      :ssl_client_cert,
+      :ssl_client_key
+    ].freeze
 
     DEFAULT_OPTIONS = {
-      :site               => 'http://localhost:2990',
-      :context_path       => '/jira',
-      :rest_base_path     => "/rest/api/2",
-      :ssl_verify_mode    => OpenSSL::SSL::VERIFY_PEER,
-      :use_ssl            => true,
-      :auth_type          => :oauth,
-      :http_debug         => false
-    }
-
-    def initialize(options={})
+      site: 'http://localhost:2990',
+      context_path: '/jira',
+      rest_base_path: '/rest/api/2',
+      ssl_verify_mode: OpenSSL::SSL::VERIFY_PEER,
+      use_ssl: true,
+      use_client_cert: false,
+      auth_type: :oauth,
+      http_debug: false,
+      default_headers: {}
+    }.freeze
+
+    def initialize(options = {})
       options = DEFAULT_OPTIONS.merge(options)
       @options = options
       @options[:rest_base_path] = @options[:context_path] + @options[:rest_base_path]
 
+      unknown_options = options.keys.reject { |o| DEFINED_OPTIONS.include?(o) }
+      raise ArgumentError, "Unknown option(s) given: #{unknown_options}" unless unknown_options.empty?
+
+      if options[:use_client_cert]
+        @options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(@options[:cert_path])) if @options[:cert_path]
+        @options[:ssl_client_key] = OpenSSL::PKey::RSA.new(File.read(@options[:key_path])) if @options[:key_path]
+
+        raise ArgumentError, 'Options: :cert_path or :ssl_client_cert must be set when :use_client_cert is true' unless @options[:ssl_client_cert]
+        raise ArgumentError, 'Options: :key_path or :ssl_client_key must be set when :use_client_cert is true' unless @options[:ssl_client_key]
+      end
+
       case options[:auth_type]
-      when :oauth
+      when :oauth, :oauth_2legged
         @request_client = OauthClient.new(@options)
         @consumer = @request_client.consumer
+      when :jwt
+        @request_client = JwtClient.new(@options)
       when :basic
         @request_client = HttpClient.new(@options)
       when :cookie
@@ -71,8 +137,10 @@ module JIRA
         @options[:use_cookies] = true
         @request_client = HttpClient.new(@options)
         @request_client.make_cookie_auth_request
+        @options.delete(:username)
+        @options.delete(:password)
       else
-        raise ArgumentError, 'Options: ":auth_type" must be ":oauth", ":cookie" or ":basic"'
+        raise ArgumentError, 'Options: ":auth_type" must be ":oauth",":oauth_2legged", ":cookie" or ":basic"'
       end
 
       @http_debug = @options[:http_debug]
@@ -142,10 +210,26 @@ module JIRA
       JIRA::Resource::FieldFactory.new(self)
     end
 
+    def Board
+      JIRA::Resource::BoardFactory.new(self)
+    end
+
+    def BoardConfiguration
+      JIRA::Resource::BoardConfigurationFactory.new(self)
+    end
+
     def RapidView
       JIRA::Resource::RapidViewFactory.new(self)
     end
 
+    def Sprint
+      JIRA::Resource::SprintFactory.new(self)
+    end
+
+    def SprintReport
+      JIRA::Resource::SprintReportFactory.new(self)
+    end
+
     def ServerInfo
       JIRA::Resource::ServerInfoFactory.new(self)
     end
@@ -158,6 +242,10 @@ module JIRA
       JIRA::Resource::ApplicationLinkFactory.new(self)
     end
 
+    def Watcher
+      JIRA::Resource::WatcherFactory.new(self)
+    end
+
     def Webhook
       JIRA::Resource::WebhookFactory.new(self)
     end
@@ -170,12 +258,12 @@ module JIRA
       JIRA::Resource::IssuelinktypeFactory.new(self)
     end
 
-    def Remotelink
-      JIRA::Resource::RemotelinkFactory.new(self)
+    def IssuePickerSuggestions
+      JIRA::Resource::IssuePickerSuggestionsFactory.new(self)
     end
 
-    def Sprint
-      JIRA::Resource::SprintFactory.new(self)
+    def Remotelink
+      JIRA::Resource::RemotelinkFactory.new(self)
     end
 
     def Agile
@@ -197,27 +285,36 @@ module JIRA
 
     # HTTP methods with a body
     def post(path, body = '', headers = {})
-      headers = {'Content-Type' => 'application/json'}.merge(headers)
+      headers = { 'Content-Type' => 'application/json' }.merge(headers)
       request(:post, path, body, merge_default_headers(headers))
     end
 
+    def post_multipart(path, file, headers = {})
+      puts "post multipart: #{path} - [#{file}]" if @http_debug
+      @request_client.request_multipart(path, file, headers)
+    end
+
     def put(path, body = '', headers = {})
-      headers = {'Content-Type' => 'application/json'}.merge(headers)
+      headers = { 'Content-Type' => 'application/json' }.merge(headers)
       request(:put, path, body, merge_default_headers(headers))
     end
 
     # Sends the specified HTTP request to the REST API through the
     # appropriate method (oauth, basic).
-    def request(http_method, path, body = '', headers={})
+    def request(http_method, path, body = '', headers = {})
       puts "#{http_method}: #{path} - [#{body}]" if @http_debug
       @request_client.request(http_method, path, body, headers)
     end
 
-    protected
+    # Stops sensitive client information from being displayed in logs
+    def inspect
+      "#<JIRA::Client:#{object_id}>"
+    end
 
-      def merge_default_headers(headers)
-        {'Accept' => 'application/json'}.merge(headers)
-      end
+    protected
 
+    def merge_default_headers(headers)
+      { 'Accept' => 'application/json' }.merge(@options[:default_headers]).merge(headers)
+    end
   end
 end

data/lib/jira/has_many_proxy.rb

@@ -7,7 +7,6 @@
 # In practice, instances of this class behave exactly like an Array.
 #
 class JIRA::HasManyProxy
-
   attr_reader :target_class, :parent
   attr_accessor :collection