sclemmer-jira-ruby 0.1.12

data/lib/jira/base_factory.rb

@@ -0,0 +1,49 @@
+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 componenets.  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 priciple 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
+
+    # 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,165 @@
+require 'json'
+require 'forwardable'
+
+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_file   => "rsakey.pem",
+  #   :rest_base_path     => "/rest/api/2",
+  #   :consumer_key       => nil,
+  #   :consumer_secret    => nil,
+  #   :ssl_verify_mode    => OpenSSL::SSL::VERIFY_PEER,
+  #   :use_ssl            => true,
+  #   :username           => nil,
+  #   :password           => nil,
+  #   :auth_type          => :oauth
+  #   :proxy_address      => nil
+  #   :proxy_port         => 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
+
+    # 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
+
+    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
+    }
+
+    def initialize(options={})
+      options = DEFAULT_OPTIONS.merge(options)
+      @options = options
+      @options[:rest_base_path] = @options[:context_path] + @options[:rest_base_path]
+
+      case options[:auth_type]
+      when :oauth
+        @request_client = OauthClient.new(@options)
+        @consumer = @request_client.consumer
+      when :basic
+        @request_client = HttpClient.new(@options)
+      end
+
+      @options.freeze
+    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 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
+
+    # 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 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={})
+      @request_client.request(http_method, path, body, headers)
+    end
+
+    protected
+
+      def merge_default_headers(headers)
+        {'Accept' => 'application/json'}.merge(headers)
+      end
+
+  end
+end

data/lib/jira/has_many_proxy.rb

@@ -0,0 +1,43 @@
+#
+# 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,69 @@
+require 'json'
+require 'net/https'
+require 'cgi/cookie'
+
+module JIRA
+  class HttpClient < RequestClient
+
+    DEFAULT_OPTIONS = {
+      :username           => '',
+      :password           => ''
+    }
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @cookies = {}
+    end
+
+    def make_request(http_method, path, body='', headers={})
+      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
+    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] ? @options[:proxy_port] : 80)
+      else
+          http_class = Net::HTTP
+      end
+      http_conn = http_class.new(uri.host, uri.port)
+      http_conn.use_ssl = @options[:use_ssl]
+      http_conn.verify_mode = @options[:ssl_verify_mode]
+      http_conn
+    end
+
+    def uri
+      uri = URI.parse(@options[:site])
+    end
+
+    private
+
+    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.to_s }
+      request.add_field('Cookie', cookie_array.join('; ')) if cookie_array.any?
+      request
+    end
+  end
+end

data/lib/jira/http_error.rb

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

data/lib/jira/oauth_client.rb

@@ -0,0 +1,84 @@
+require 'oauth'
+require 'json'
+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
+    }
+
+    # 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"
+      end
+    end
+
+    extend Forwardable
+
+    attr_accessor :consumer
+    attr_reader :options
+
+    def_instance_delegators :@consumer, :key, :secret, :get_request_token
+
+    def initialize(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @consumer = init_oauth_consumer(@options)
+    end
+
+    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)
+    end
+
+    # Returns the current request token if it is set, else it creates
+    # and sets a new token.
+    def request_token
+      @request_token ||= get_request_token
+    end
+
+    # Sets the request token from a given token and secret.
+    def set_request_token(token, secret)
+      @request_token = OAuth::RequestToken.new(@consumer, token, secret)
+    end
+
+    # Initialises and returns a new access token from the params hash
+    # returned by the OAuth transaction.
+    def init_access_token(params)
+      @access_token = request_token.get_access_token(params)
+    end
+
+    # Sets the access token from a preexisting token and secret.
+    def set_access_token(token, secret)
+      @access_token = OAuth::AccessToken.new(@consumer, token, secret)
+    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
+      @access_token
+    end
+
+    def make_request(http_method, path, body='', headers={})
+      case http_method
+      when :delete, :get, :head
+        response = access_token.send http_method, path, headers
+      when :post, :put
+        response = access_token.send http_method, path, body, headers
+      end
+      response
+    end
+  end
+end

data/lib/jira/railtie.rb

@@ -0,0 +1,10 @@
+require 'jira'
+require 'rails'
+
+module JIRA
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/generate.rake'
+    end
+  end
+end

data/lib/jira/request_client.rb

@@ -0,0 +1,18 @@
+require 'oauth'
+require 'json'
+require 'net/https'
+
+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)
+      raise HTTPError.new(response) unless response.kind_of?(Net::HTTPSuccess)
+      response
+    end
+  end
+end