jira_client 1.0.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+coverage
+*.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jira-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matthew Williams
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# JiraClient::Client
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jira-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jira-client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/jira_client.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jira_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jira_client"
+  spec.version       = JiraClient::VERSION
+  spec.authors       = ["Matthew Williams"]
+  spec.email         = ["m.williams@me.com"]
+  spec.description   = %q{A Ruby client for the Jira 5 REST API}
+  spec.summary       = %q{A Ruby client for the Jira 5 REST API...}
+  spec.homepage      = "https://github.com/mrwillihog/jira_client"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "rest-client"
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "chronic_duration"
+end

data/lib/jira_client.rb

@@ -0,0 +1,121 @@
+require "rest-client"
+require "json"
+
+require "jira_client/base"
+require "jira_client/comment"
+require "jira_client/configuration"
+require "jira_client/issue"
+require "jira_client/project"
+require "jira_client/status"
+require "jira_client/timetracking"
+require "jira_client/user"
+require "jira_client/worklog"
+require "jira_client/api/comments"
+require "jira_client/api/issues"
+require "jira_client/api/projects"
+require "jira_client/api/server"
+require "jira_client/api/statuses"
+require "jira_client/api/users"
+require "jira_client/api/worklogs"
+require "jira_client/core_ext/string"
+require "jira_client/error/configuration_error"
+require "jira_client/error/bad_request"
+require "jira_client/error/issue_error"
+require "jira_client/error/resource_not_found"
+require "jira_client/error/unauthorized"
+
+module JiraClient
+  class << self
+    include JiraClient::API::Comments
+    include JiraClient::API::Issues
+    include JiraClient::API::Projects
+    include JiraClient::API::Server
+    include JiraClient::API::Statuses
+    include JiraClient::API::Users
+    include JiraClient::API::Worklogs
+
+    attr_accessor :configuration
+    def configure
+      self.configuration ||= Configuration.new
+      begin
+        yield(configuration)
+      rescue NoMethodError => e
+        raise JiraClient::Error::ConfigurationError, "Unrecognized configuration option provided #{e.message}"
+      end
+    end
+
+    def reset!
+      self.configuration = nil
+      @resource = nil
+    end
+
+  private
+
+    def get(path, params={})
+      request(:get, path, :params => params)
+    end
+
+    def post(path, params={})
+      request(:post, path, params.to_json)
+    end
+
+    def put(path, params={})
+      request(:put, path, params.to_json)
+    end
+
+    def request(method, path, params={})
+      begin
+        response = resource[URI.encode(path)].send(method.to_sym, params)
+        snake_case!(JSON.parse(response, :symbolize_names => true)) unless response.empty?
+      rescue RestClient::ResourceNotFound => e
+        raise_error JiraClient::Error::ResourceNotFound, e
+      rescue RestClient::BadRequest => e
+        raise_error JiraClient::Error::BadRequest, e
+      rescue RestClient::Unauthorized => e
+        raise_error JiraClient::Error::Unauthorized, e
+      end
+    end
+
+    def raise_error(error_type, message_response)
+      raise error_type, JSON.parse(message_response.response)["errorMessages"].join
+    end
+
+    # Returns a RestClient resource
+    def resource
+      raise JiraClient::Error::ConfigurationError, "No configuration found. Please run JiraClient.configure" if JiraClient.configuration.nil?
+      @resource ||= begin
+        url = JiraClient.configuration.full_url
+        options = {
+          :headers => {:content_type => :json, :accept => :json}
+        }
+
+        RestClient.proxy = JiraClient.configuration.proxy
+
+        unless JiraClient.configuration.certificate.nil?
+          options[:ssl_client_cert] = OpenSSL::X509::Certificate.new File.read(JiraClient.configuration.certificate)
+          options[:ssl_client_key] = OpenSSL::PKey::RSA.new File.read(JiraClient.configuration.certificate), JiraClient.configuration.certificate_passphrase
+          options[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+        else
+          # RestClient will ignore basic auth parameters if nil
+          options[:user] = JiraClient.configuration.username
+          options[:password] = JiraClient.configuration.password
+        end
+
+        RestClient::Resource.new(url, options)
+      end
+    end
+
+    # Convert CamelCaseKeys to snake_case_keys
+    def snake_case!(value)
+      case value
+        when Array
+          value.map {|v| snake_case!(v)}
+        when Hash
+          Hash[value.map {|k, v| [k.to_s.underscore.to_sym, snake_case!(v)] }]
+        else
+          value
+      end
+    end
+
+  end
+end

data/lib/jira_client/api/comments.rb

@@ -0,0 +1,19 @@
+require "jira_client/api/utils"
+
+module JiraClient
+  module API
+    module Comments
+      include JiraClient::API::Utils
+
+      def find_issue_comments(key)
+        response = get("/issue/#{key}/comment")
+        response[:comments].map {|c| JiraClient::Comment.from_response c}
+      end
+
+      def comment_on_issue(key, message)
+        object_from_response(JiraClient::Comment, :post, "/issue/#{key}/comment", {:body => message})
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/issues.rb

@@ -0,0 +1,62 @@
+require "jira_client/api/utils"
+
+module JiraClient
+  module API
+    module Issues
+      include JiraClient::API::Utils
+
+      def find_issues(params={})
+        response = post("/search", params)
+        response[:issues].map {|i| JiraClient::Issue.from_response i}
+      end
+
+      def find_issue_by_key(key, params={})
+        fields = params[:fields].join "," if params.has_key? :fields
+        url = "/issue/#{key}"
+        url << "?fields=#{fields}" if fields
+        object_from_response(JiraClient::Issue, :get, url)
+      end
+
+      def assign_issue(key, username)
+        put("/issue/#{key}/assignee", :name => username)
+      end
+
+      def close_issue(key, params={})
+        transition_to(key, JiraClient::Status::CLOSE, params)
+      end
+
+      def reopen_issue(key, params={})
+        transition_to(key, JiraClient::Status::REOPEN, params)
+      end
+
+      def resolve_issue(key, params={})
+        transition_to(key, JiraClient::Status::RESOLVE, params)
+      end
+
+      def start_progress_on_issue(key, params={})
+        transition_to(key, JiraClient::Status::START_PROGRESS, params)
+      end
+
+    private
+
+      def transition_to(key, transition, params={})
+        opts = {:transition => {:id => transition}}
+        if params.has_key? :as
+          opts[:fields] ||= {}
+          opts[:fields][:resolution] = {:name => params[:as]}
+        end
+        opts[:update] = comment_hash(params[:comment])
+
+        # Remove keys with nil values
+        opts.reject! {|k,v| v.nil?}
+        post("/issue/#{key}/transitions", opts)
+      end
+
+      def comment_hash(comment)
+        return unless comment
+        {:comment => [{:add => {:body => comment}}]}
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/projects.rb

@@ -0,0 +1,19 @@
+require "jira_client/api/utils"
+require "jira_client/project"
+
+module JiraClient
+  module API
+    module Projects
+      include JiraClient::API::Utils
+
+      def find_projects
+        objects_from_response(JiraClient::Project, :get, '/project')
+      end
+
+      def find_project_by_key(key)
+        object_from_response(JiraClient::Project, :get, "/project/#{key.to_s}")
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/server.rb

@@ -0,0 +1,15 @@
+require "jira_client/api/utils"
+require "jira_client/server_info"
+
+module JiraClient
+  module API
+    module Server
+      include JiraClient::API::Utils
+
+      def server_info
+        object_from_response(JiraClient::ServerInfo, :get, "/serverInfo")
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/statuses.rb

@@ -0,0 +1,20 @@
+require 'jira_client/api/utils'
+require "jira_client/status"
+
+module JiraClient
+  module API
+    module Statuses
+      include JiraClient::API::Utils
+
+      def find_statuses
+        objects_from_response(JiraClient::Status, :get, '/status')
+      end
+
+      def find_status_by_id(id)
+        object_from_response(JiraClient::Status, :get, "/status/#{id}")
+      end
+      alias :find_status_by_name :find_status_by_id
+
+    end
+  end
+end

data/lib/jira_client/api/users.rb

@@ -0,0 +1,18 @@
+require "jira_client/api/utils"
+
+module JiraClient
+  module API
+    module Users
+      include JiraClient::API::Utils
+
+      def find_users(username)
+        objects_from_response(JiraClient::User, :get, "/user/search", :username => username)
+      end
+
+      def find_user_by_username(username)
+        object_from_response(JiraClient::User, :get, "/user", :username => username)
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/utils.rb

@@ -0,0 +1,25 @@
+module JiraClient
+  module API
+    module Utils
+
+    private
+
+      def objects_from_response(klass, request_method, path, options={})
+        response = send(request_method.to_sym, path, options)
+        objects_from_array(klass, response)
+      end
+
+      def objects_from_array(klass, array)
+        array.map do |element|
+          klass.from_response(element)
+        end
+      end
+
+      def object_from_response(klass, request_method, path, options={})
+        response = send(request_method.to_sym, path, options)
+        klass.from_response(response)
+      end
+
+    end
+  end
+end

data/lib/jira_client/api/worklogs.rb

@@ -0,0 +1,26 @@
+require "chronic_duration"
+
+module JiraClient
+  module API
+    module Worklogs
+
+      def create_worklog(key, time, opts={})
+        url = "/issue/#{key}/worklog"
+        url += "?adjustEstimate=new&newEstimate=#{opts[:remaining_estimate]}" if opts.has_key? :remaining_estimate
+        url += "?adjustEstimate=manual&reduceBy=#{opts[:reduce_estimate]}" if opts.has_key? :reduce_estimate
+        time_in_seconds = ChronicDuration.parse(time)
+        params = {
+          :timeSpentSeconds => time_in_seconds
+        }
+        params[:comment] = opts[:comment] if opts.has_key? :comment
+        post(url, params)
+      end
+
+      def find_issue_worklogs(key)
+        response = get("/issue/#{key}/worklog")
+        response[:worklogs].map {|w| JiraClient::Worklog.from_response w}
+      end
+
+    end
+  end
+end