jira-ruby 1.2.0 → 2.3.0

data/lib/jira/http_client.rb

@@ -1,14 +1,14 @@
 require 'json'
 require 'net/https'
 require 'cgi/cookie'
+require 'uri'
 
 module JIRA
   class HttpClient < RequestClient
-
     DEFAULT_OPTIONS = {
-      :username           => '',
-      :password           => ''
-    }
+      username: nil,
+      password: nil
+    }.freeze
 
     attr_reader :options
 
@@ -18,18 +18,26 @@ module JIRA
     end
 
     def make_cookie_auth_request
-      body = { :username => @options[:username], :password => @options[:password] }.to_json
-      make_request(:post, '/rest/auth/1/session', body, {'Content-Type' => 'application/json'})
+      body = { username: @options[:username].to_s, password: @options[:password].to_s }.to_json
+      @options.delete(:username)
+      @options.delete(:password)
+      make_request(:post, @options[:context_path] + '/rest/auth/1/session', body, 'Content-Type' => 'application/json')
     end
 
-    def make_request(http_method, path, body='', headers={})
+    def make_request(http_method, url, body = '', headers = {})
+      # When a proxy is enabled, Net::HTTP expects that the request path omits the domain name
+      path = request_path(url)
       request = Net::HTTP.const_get(http_method.to_s.capitalize).new(path, headers)
       request.body = body unless body.nil?
-      add_cookies(request) if options[:use_cookies]
-      request.basic_auth(@options[:username], @options[:password])
-      response = basic_auth_http_conn.request(request)
-      store_cookies(response) if options[:use_cookies]
-      response
+
+      execute_request(request)
+    end
+
+    def make_multipart_request(url, body, headers = {})
+      path = request_path(url)
+      request = Net::HTTP::Post::Multipart.new(path, body, headers)
+
+      execute_request(request)
     end
 
     def basic_auth_http_conn
@@ -38,23 +46,52 @@ module JIRA
 
     def http_conn(uri)
       if @options[:proxy_address]
-          http_class = Net::HTTP::Proxy(@options[:proxy_address], @options[:proxy_port] ? @options[:proxy_port] : 80)
+        http_class = Net::HTTP::Proxy(@options[:proxy_address], @options[:proxy_port] || 80, @options[:proxy_username], @options[:proxy_password])
       else
-          http_class = Net::HTTP
+        http_class = Net::HTTP
       end
       http_conn = http_class.new(uri.host, uri.port)
       http_conn.use_ssl = @options[:use_ssl]
+      if @options[:use_client_cert]
+        http_conn.cert = @options[:ssl_client_cert]
+        http_conn.key = @options[:ssl_client_key]
+      end
       http_conn.verify_mode = @options[:ssl_verify_mode]
+      http_conn.ssl_version = @options[:ssl_version] if @options[:ssl_version]
       http_conn.read_timeout = @options[:read_timeout]
+      http_conn.ca_file = @options[:ca_file] if @options[:ca_file]
       http_conn
     end
 
     def uri
-      uri = URI.parse(@options[:site])
+      URI.parse(@options[:site])
+    end
+
+    def authenticated?
+      @authenticated
     end
 
     private
 
+    def execute_request(request)
+      add_cookies(request) if options[:use_cookies]
+      request.basic_auth(@options[:username], @options[:password]) if @options[:username] && @options[:password]
+
+      response = basic_auth_http_conn.request(request)
+      @authenticated = response.is_a? Net::HTTPOK
+      store_cookies(response) if options[:use_cookies]
+
+      response
+    end
+
+    def request_path(url)
+      parsed_uri = URI(url)
+
+      return url unless parsed_uri.is_a?(URI::HTTP)
+
+      parsed_uri.request_uri
+    end
+
     def store_cookies(response)
       cookies = response.get_fields('set-cookie')
       if cookies
@@ -67,7 +104,8 @@ module JIRA
     end
 
     def add_cookies(request)
-      cookie_array = @cookies.values.map { |cookie| cookie.to_s }
+      cookie_array = @cookies.values.map { |cookie| "#{cookie.name}=#{cookie.value[0]}" }
+      cookie_array += Array(@options[:additional_cookies]) if @options.key?(:additional_cookies)
       request.add_field('Cookie', cookie_array.join('; ')) if cookie_array.any?
       request
     end

data/lib/jira/http_error.rb

@@ -1,16 +1,14 @@
 require 'forwardable'
 module JIRA
-
   class HTTPError < StandardError
     extend Forwardable
 
-    def_instance_delegators :@response, :message, :code
-    attr_reader :response
+    def_instance_delegators :@response, :code
+    attr_reader :response, :message
 
     def initialize(response)
       @response = response
+      @message = response.try(:message).presence || response.try(:body)
     end
-
   end
-
 end

data/lib/jira/jwt_client.rb

@@ -0,0 +1,67 @@
+require 'atlassian/jwt'
+
+module JIRA
+  class JwtClient < HttpClient
+    def make_request(http_method, url, body = '', headers = {})
+      @http_method = http_method
+
+      super(http_method, url, body, headers)
+    end
+
+    def make_multipart_request(url, data, headers = {})
+      @http_method = :post
+
+      super(url, data, headers)
+    end
+
+    class JwtUriBuilder
+      attr_reader :request_url, :http_method, :shared_secret, :site, :issuer
+
+      def initialize(request_url, http_method, shared_secret, site, issuer)
+        @request_url = request_url
+        @http_method = http_method
+        @shared_secret = shared_secret
+        @site = site
+        @issuer = issuer
+      end
+
+      def build
+        uri = URI.parse(request_url)
+        new_query = URI.decode_www_form(String(uri.query)) << ['jwt', jwt_header]
+        uri.query = URI.encode_www_form(new_query)
+
+        return uri.to_s unless uri.is_a?(URI::HTTP)
+
+        uri.request_uri
+      end
+
+      private
+
+      def jwt_header
+        claim = Atlassian::Jwt.build_claims \
+          issuer,
+          request_url,
+          http_method.to_s,
+          site,
+          (Time.now - 60).to_i,
+          (Time.now + 86_400).to_i
+
+        JWT.encode claim, shared_secret
+      end
+    end
+
+    private
+
+    attr_reader :http_method
+
+    def request_path(url)
+      JwtUriBuilder.new(
+        url,
+        http_method.to_s,
+        @options[:shared_secret],
+        @options[:site],
+        @options[:issuer]
+      ).build
+    end
+  end
+end

data/lib/jira/oauth_client.rb

@@ -4,22 +4,21 @@ require 'forwardable'
 
 module JIRA
   class OauthClient < RequestClient
-
     DEFAULT_OPTIONS = {
-      :signature_method   => 'RSA-SHA1',
-      :request_token_path => "/plugins/servlet/oauth/request-token",
-      :authorize_path     => "/plugins/servlet/oauth/authorize",
-      :access_token_path  => "/plugins/servlet/oauth/access-token",
-      :private_key_file   => "rsakey.pem",
-      :consumer_key       => nil,
-      :consumer_secret    => nil
-    }
+      signature_method: 'RSA-SHA1',
+      request_token_path: '/plugins/servlet/oauth/request-token',
+      authorize_path: '/plugins/servlet/oauth/authorize',
+      access_token_path: '/plugins/servlet/oauth/access-token',
+      private_key_file: 'rsakey.pem',
+      consumer_key: nil,
+      consumer_secret: nil
+    }.freeze
 
     # This exception is thrown when the client is used before the OAuth access token
     # has been initialized.
     class UninitializedAccessTokenError < StandardError
       def message
-        "init_access_token must be called before using the client"
+        'init_access_token must be called before using the client'
       end
     end
 
@@ -35,17 +34,19 @@ module JIRA
       @consumer = init_oauth_consumer(@options)
     end
 
-    def init_oauth_consumer(options)
+    def init_oauth_consumer(_options)
       @options[:request_token_path] = @options[:context_path] + @options[:request_token_path]
       @options[:authorize_path] = @options[:context_path] + @options[:authorize_path]
       @options[:access_token_path] = @options[:context_path] + @options[:access_token_path]
-      OAuth::Consumer.new(@options[:consumer_key],@options[:consumer_secret],@options)
+      # proxy_address does not exist in oauth's gem context but proxy does
+      @options[:proxy] = @options[:proxy_address] if @options[:proxy_address]
+      OAuth::Consumer.new(@options[:consumer_key], @options[:consumer_secret], @options)
     end
 
     # Returns the current request token if it is set, else it creates
     # and sets a new token.
     def request_token(options = {}, *arguments, &block)
-      @request_token ||= get_request_token(options, *arguments, block)
+      @request_token ||= get_request_token(options, *arguments, &block)
     end
 
     # Sets the request token from a given token and secret.
@@ -62,23 +63,52 @@ module JIRA
     # Sets the access token from a preexisting token and secret.
     def set_access_token(token, secret)
       @access_token = OAuth::AccessToken.new(@consumer, token, secret)
+      @authenticated = true
+      @access_token
     end
 
     # Returns the current access token. Raises an
     # JIRA::Client::UninitializedAccessTokenError exception if it is not set.
     def access_token
-      raise UninitializedAccessTokenError.new unless @access_token
+      raise UninitializedAccessTokenError unless @access_token
       @access_token
     end
 
-    def make_request(http_method, path, body='', headers={})
+    def make_request(http_method, url, body = '', headers = {})
+      # When using oauth_2legged we need to add an empty oauth_token parameter to every request.
+      if @options[:auth_type] == :oauth_2legged
+        oauth_params_str = 'oauth_token='
+        uri = URI.parse(url)
+        uri.query = if uri.query.to_s == ''
+                      oauth_params_str
+                    else
+                      uri.query + '&' + oauth_params_str
+                    end
+        url = uri.to_s
+      end
+
       case http_method
       when :delete, :get, :head
-        response = access_token.send http_method, path, headers
+        response = access_token.send http_method, url, headers
       when :post, :put
-        response = access_token.send http_method, path, body, headers
+        response = access_token.send http_method, url, body, headers
       end
+      @authenticated = true
       response
     end
+
+    def make_multipart_request(url, data, headers = {})
+      request = Net::HTTP::Post::Multipart.new url, data, headers
+
+      access_token.sign! request
+
+      response = consumer.http.request(request)
+      @authenticated = true
+      response
+    end
+
+    def authenticated?
+      @authenticated
+    end
   end
 end

data/lib/jira/request_client.rb

@@ -1,20 +1,31 @@
 require 'oauth'
 require 'json'
 require 'net/https'
-#require 'pry'
 
 module JIRA
   class RequestClient
-
     # Returns the response if the request was successful (HTTP::2xx) and
     # raises a JIRA::HTTPError if it was not successful, with the response
     # attached.
 
     def request(*args)
       response = make_request(*args)
-      #binding.pry unless response.kind_of?(Net::HTTPSuccess)
-      raise HTTPError.new(response) unless response.kind_of?(Net::HTTPSuccess)
+      raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
+      response
+    end
+
+    def request_multipart(*args)
+      response = make_multipart_request(*args)
+      raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
       response
     end
+
+    def make_request(*args)
+      raise NotImplementedError
+    end
+
+    def make_multipart_request(*args)
+      raise NotImplementedError
+    end
   end
-end
+end

data/lib/jira/resource/agile.rb

@@ -2,32 +2,59 @@ require 'cgi'
 
 module JIRA
   module Resource
-
     class AgileFactory < JIRA::BaseFactory # :nodoc:
     end
 
     class Agile < JIRA::Base
-
-      def self.all(client)
-        response = client.get(path_base(client) + '/board')
+      # @param client [JIRA::Client]
+      # @param options [Hash<Symbol, Object>]
+      # @return [Hash]
+      def self.all(client, options = {})
+        opts = options.empty? ? '' : "?#{hash_to_query_string(options)}"
+        response = client.get(path_base(client) + "/board#{opts}")
         parse_json(response.body)
       end
 
       def self.get_backlog_issues(client, board_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/board/#{board_id}/backlog?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/board/#{board_id}/backlog?#{hash_to_query_string(options)}")
         parse_json(response.body)
       end
 
+      def self.get_board_issues(client, board_id, options = {})
+        response = client.get(path_base(client) + "/board/#{board_id}/issue?#{hash_to_query_string(options)}")
+        json = parse_json(response.body)
+        # To get Issue objects with the same structure as for Issue.all
+        return {} if json['issues'].size.zero?
+        issue_ids = json['issues'].map do |issue|
+          issue['id']
+        end
+        client.Issue.jql("id IN(#{issue_ids.join(', ')})")
+      end
+
       def self.get_sprints(client, board_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/board/#{board_id}/sprint?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/board/#{board_id}/sprint?#{hash_to_query_string(options)}")
         parse_json(response.body)
       end
 
       def self.get_sprint_issues(client, sprint_id, options = {})
         options[:maxResults] ||= 100
-        response = client.get("/rest/agile/1.0/sprint/#{sprint_id}/issue?maxResults=#{options[:maxResults]}")
+        response = client.get(path_base(client) + "/sprint/#{sprint_id}/issue?#{hash_to_query_string(options)}")
+        parse_json(response.body)
+      end
+
+      def self.get_projects_full(client, board_id, _options = {})
+        response = client.get(path_base(client) + "/board/#{board_id}/project/full")
+        parse_json(response.body)
+      end
+
+      def self.get_projects(client, board_id, options = {})
+        options[:maxResults] ||= 100
+        create_meta_url = path_base(client) + "/board/#{board_id}/project"
+        params = hash_to_query_string(options)
+
+        response = client.get("#{create_meta_url}?#{params}")
         parse_json(response.body)
       end
 
@@ -47,8 +74,6 @@ module JIRA
       def path_base(client)
         self.class.path_base(client)
       end
-
     end
-
   end
 end

data/lib/jira/resource/applinks.rb

@@ -1,13 +1,11 @@
 module JIRA
   module Resource
-
     class ApplicationLinkFactory < JIRA::BaseFactory # :nodoc:
       delegate_to_target_class :manifest
     end
 
     class ApplicationLink < JIRA::Base
-
-      REST_BASE_PATH = '/rest/applinks/1.0'
+      REST_BASE_PATH = '/rest/applinks/1.0'.freeze
 
       def self.endpoint_name
         'listApplicationlinks'
@@ -18,7 +16,7 @@ module JIRA
       end
 
       def self.collection_path(client, prefix = '/')
-        self.full_url(client) + prefix + self.endpoint_name
+        full_url(client) + prefix + endpoint_name
       end
 
       def self.all(client, options = {})
@@ -26,17 +24,16 @@ module JIRA
         json = parse_json(response.body)
         json = json['list']
         json.map do |attrs|
-          self.new(client, {:attrs => attrs}.merge(options))
+          new(client, { attrs: attrs }.merge(options))
         end
       end
 
       def self.manifest(client)
-        url = self.full_url(client) + '/manifest'
+        url = full_url(client) + '/manifest'
         response = client.get(url)
         json = parse_json(response.body)
-        JIRA::Base.new(client, {:attrs => json})
+        JIRA::Base.new(client, attrs: json)
       end
-
     end
   end
 end

data/lib/jira/resource/attachment.rb

@@ -1,12 +1,50 @@
+require 'net/http/post/multipart'
+
 module JIRA
   module Resource
-
     class AttachmentFactory < JIRA::BaseFactory # :nodoc:
+      delegate_to_target_class :meta
     end
 
     class Attachment < JIRA::Base
-      has_one :author, :class => JIRA::Resource::User
-    end
+      belongs_to :issue
+      has_one :author, class: JIRA::Resource::User
+
+      def self.endpoint_name
+        'attachments'
+      end
+
+      def self.meta(client)
+        response = client.get(client.options[:rest_base_path] + '/attachment/meta')
+        parse_json(response.body)
+      end
+
+      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'
+
+        headers = { 'X-Atlassian-Token' => 'nocheck' }
+        data = { 'file' => UploadIO.new(file, mime_type, file) }
 
+        response = client.post_multipart(path, data , headers)
+
+        set_attributes(attrs, response)
+
+        @expanded = false
+        true
+      end
+
+      private
+
+      def set_attributes(attributes, response)
+        set_attrs(attributes, false)
+        return if response.body.nil? || response.body.length < 2
+
+        json = self.class.parse_json(response.body)
+        attachment = json[0]
+
+        set_attrs(attachment)
+      end
+    end
   end
 end

data/lib/jira/resource/board.rb

@@ -0,0 +1,91 @@
+require 'cgi'
+
+module JIRA
+  module Resource
+    class BoardFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Board < JIRA::Base
+      def self.all(client)
+        path = path_base(client) + '/board'
+        response = client.get(path)
+        json = parse_json(response.body)
+        results = json['values']
+
+        until json['isLast']
+          params = { 'startAt' => (json['startAt'] + json['maxResults']).to_s }
+          response = client.get(url_with_query_params(path, params))
+          json = parse_json(response.body)
+          results += json['values']
+        end
+
+        results.map do |board|
+          client.Board.build(board)
+        end
+      end
+
+      def self.find(client, key, _options = {})
+        response = client.get(path_base(client) + "/board/#{key}")
+        json = parse_json(response.body)
+        client.Board.build(json)
+      end
+
+      def issues(params = {})
+        path = path_base(client) + "/board/#{id}/issue"
+        response = client.get(url_with_query_params(path, params))
+        json = self.class.parse_json(response.body)
+        results = json['issues']
+
+        while (json['startAt'] + json['maxResults']) < json['total']
+          params['startAt'] = (json['startAt'] + json['maxResults'])
+          response = client.get(url_with_query_params(path, params))
+          json = self.class.parse_json(response.body)
+          results += json['issues']
+        end
+
+        results.map { |issue| client.Issue.build(issue) }
+      end
+
+      def configuration(params = {})
+        path = path_base(client) + "/board/#{id}/configuration"
+        response = client.get(url_with_query_params(path, params))
+        json = self.class.parse_json(response.body)
+        client.BoardConfiguration.build(json)
+      end
+
+      # options
+      #   - state ~ future, active, closed, you can define multiple states separated by commas, e.g. state=active,closed
+      #   - maxResults ~ default: 50 (JIRA API), 1000 (this library)
+      #   - startAt ~ base index, starts at 0
+      def sprints(options = {})
+        # options.reverse_merge!(DEFAULT_OPTIONS)
+        response = client.get(path_base(client) + "/board/#{id}/sprint?#{options.to_query}")
+        json = self.class.parse_json(response.body)
+        json['values'].map do |sprint|
+          sprint['rapidview_id'] = id
+          client.Sprint.build(sprint)
+        end
+      end
+
+      def project
+        response = client.get(path_base(client) + "/board/#{id}/project")
+        json = self.class.parse_json(response.body)
+        json['values'][0]
+      end
+
+      def add_issue_to_backlog(issue)
+        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'
+      end
+
+      def path_base(client)
+        self.class.path_base(client)
+      end
+    end
+  end
+end

data/lib/jira/resource/board_configuration.rb

@@ -0,0 +1,9 @@
+module JIRA
+  module Resource
+    class BoardConfigurationFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class BoardConfiguration < JIRA::Base
+    end
+  end
+end

data/lib/jira/resource/comment.rb

@@ -1,6 +1,5 @@
 module JIRA
   module Resource
-
     class CommentFactory < JIRA::BaseFactory # :nodoc:
     end
 
@@ -9,6 +8,5 @@ module JIRA
 
       nested_collections true
     end
-
   end
 end

data/lib/jira/resource/component.rb

@@ -1,10 +1,8 @@
 module JIRA
   module Resource
-
     class ComponentFactory < JIRA::BaseFactory # :nodoc:
     end
 
-    class Component < JIRA::Base ; end
-
+    class Component < JIRA::Base; end
   end
 end