jira-ruby 2.1.3

data/lib/jira/base_factory.rb

@@ -0,0 +1,46 @@
+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.
+    # 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
+      # with nested class names, i.e. JIRA::Resource::Foo.
+      #
+      # So create a method chain from the class components.  This code will
+      # unroll to:
+      #   Module.const_get('JIRA').const_get('Resource').const_get('Foo')
+      #
+      target_class_name = self.class.name.sub(/Factory$/, '')
+      class_components = target_class_name.split('::')
+
+      class_components.inject(Module) do |mod, const_name|
+        mod.const_get(const_name)
+      end
+    end
+
+    def self.delegate_to_target_class(*method_names)
+      method_names.each do |method_name|
+        define_method method_name do |*args|
+          target_class.send(method_name, @client, *args)
+        end
+      end
+    end
+
+    # 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_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 = {})
+      target_class.build(@client, attrs)
+    end
+  end
+end

data/lib/jira/client.rb

@@ -0,0 +1,308 @@
+require 'json'
+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:
+  #
+  #   :site               => 'http://localhost:2990',
+  #   :context_path       => '/jira',
+  #   :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        => 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,
+  #   :proxy_username     => nil,
+  #   :proxy_password     => 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
+  #
+  # 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
+    #
+    # The authenticated client instance returned by the respective client type
+    # (Oauth, Basic)
+    attr_accessor :consumer, :request_client, :http_debug, :cache
+
+    # 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, :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,
+      :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,
+      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, :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
+        raise ArgumentError, 'Options: :use_cookies must be true for :cookie authorization type' if @options.key?(:use_cookies) && !@options[:use_cookies]
+        @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",":oauth_2legged", ":cookie" or ":basic"'
+      end
+
+      @http_debug = @options[:http_debug]
+
+      @options.freeze
+
+      @cache = OpenStruct.new
+    end
+
+    def Project # :nodoc:
+      JIRA::Resource::ProjectFactory.new(self)
+    end
+
+    def Issue # :nodoc:
+      JIRA::Resource::IssueFactory.new(self)
+    end
+
+    def Filter # :nodoc:
+      JIRA::Resource::FilterFactory.new(self)
+    end
+
+    def Component # :nodoc:
+      JIRA::Resource::ComponentFactory.new(self)
+    end
+
+    def User # :nodoc:
+      JIRA::Resource::UserFactory.new(self)
+    end
+
+    def Issuetype # :nodoc:
+      JIRA::Resource::IssuetypeFactory.new(self)
+    end
+
+    def Priority # :nodoc:
+      JIRA::Resource::PriorityFactory.new(self)
+    end
+
+    def Status # :nodoc:
+      JIRA::Resource::StatusFactory.new(self)
+    end
+
+    def Resolution # :nodoc:
+      JIRA::Resource::ResolutionFactory.new(self)
+    end
+
+    def Comment # :nodoc:
+      JIRA::Resource::CommentFactory.new(self)
+    end
+
+    def Attachment # :nodoc:
+      JIRA::Resource::AttachmentFactory.new(self)
+    end
+
+    def Worklog # :nodoc:
+      JIRA::Resource::WorklogFactory.new(self)
+    end
+
+    def Version # :nodoc:
+      JIRA::Resource::VersionFactory.new(self)
+    end
+
+    def Transition # :nodoc:
+      JIRA::Resource::TransitionFactory.new(self)
+    end
+
+    def Field # :nodoc:
+      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
+
+    def Createmeta
+      JIRA::Resource::CreatemetaFactory.new(self)
+    end
+
+    def ApplicationLink
+      JIRA::Resource::ApplicationLinkFactory.new(self)
+    end
+
+    def Watcher
+      JIRA::Resource::WatcherFactory.new(self)
+    end
+
+    def Webhook
+      JIRA::Resource::WebhookFactory.new(self)
+    end
+
+    def Issuelink
+      JIRA::Resource::IssuelinkFactory.new(self)
+    end
+
+    def Issuelinktype
+      JIRA::Resource::IssuelinktypeFactory.new(self)
+    end
+
+    def Remotelink
+      JIRA::Resource::RemotelinkFactory.new(self)
+    end
+
+    def Agile
+      JIRA::Resource::AgileFactory.new(self)
+    end
+
+    # HTTP methods without a body
+    def delete(path, headers = {})
+      request(:delete, path, nil, merge_default_headers(headers))
+    end
+
+    def get(path, headers = {})
+      request(:get, path, nil, merge_default_headers(headers))
+    end
+
+    def head(path, headers = {})
+      request(:head, path, nil, merge_default_headers(headers))
+    end
+
+    # HTTP methods with a body
+    def post(path, body = '', 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)
+      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 = {})
+      puts "#{http_method}: #{path} - [#{body}]" if @http_debug
+      @request_client.request(http_method, path, body, 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

@@ -0,0 +1,42 @@
+#
+# Whenever a collection from a has_many relationship is accessed, an instance
+# of this class is returned.  This instance wraps the Array of instances in
+# the collection with an extra build method, which allows new instances to be
+# built on the collection with the correct properties.
+#
+# In practice, instances of this class behave exactly like an Array.
+#
+class JIRA::HasManyProxy
+  attr_reader :target_class, :parent
+  attr_accessor :collection
+
+  def initialize(parent, target_class, collection = [])
+    @parent       = parent
+    @target_class = target_class
+    @collection   = collection
+  end
+
+  # Builds an instance of this class with the correct parent.
+  # For example, issue.comments.build(attrs) will initialize a
+  # comment as follows:
+  #
+  #   JIRA::Resource::Comment.new(issue.client,
+  #                               :attrs => attrs,
+  #                               :issue => issue)
+  def build(attrs = {})
+    resource = target_class.new(parent.client, :attrs => attrs, parent.to_sym => parent)
+    collection << resource
+    resource
+  end
+
+  # Forces an HTTP request to fetch all instances of the target class that
+  # are associated with the parent
+  def all
+    target_class.all(parent.client, parent.to_sym => parent)
+  end
+
+  # Delegate any missing methods to the collection that this proxy wraps
+  def method_missing(method_name, *args, &block)
+    collection.send(method_name, *args, &block)
+  end
+end

data/lib/jira/http_client.rb

@@ -0,0 +1,112 @@
+require 'json'
+require 'net/https'
+require 'cgi/cookie'
+require 'uri'
+
+module JIRA
+  class HttpClient < RequestClient
+    DEFAULT_OPTIONS = {
+      username: nil,
+      password: nil
+    }.freeze
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @cookies = {}
+    end
+
+    def make_cookie_auth_request
+      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, 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?
+
+      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
+      http_conn(uri)
+    end
+
+    def http_conn(uri)
+      if @options[:proxy_address]
+        http_class = Net::HTTP::Proxy(@options[:proxy_address], @options[:proxy_port] || 80, @options[:proxy_username], @options[:proxy_password])
+      else
+        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
+    end
+
+    def uri
+      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
+        cookies.each do |cookie|
+          data = CGI::Cookie.parse(cookie)
+          data.delete('Path')
+          @cookies.merge!(data)
+        end
+      end
+    end
+
+    def add_cookies(request)
+      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
+  end
+end