jira-ruby 0.0.2 → 0.0.3

data/README.rdoc

@@ -0,0 +1,259 @@
+= JIRA 5 API Gem
+
+This gem provides access to the Atlassian JIRA version 5 REST API (a.k.a REST
+API version 2).
+
+== Example usage
+
+  client = JIRA::Client.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+  project = client.Project.find('SAMPLEPROJECT')
+
+  project.issues.each do |issue|
+    puts "#{issue.id} - #{issue.summary}"
+  end
+
+  issue.comments.each {|comment| ... }
+
+  comment = issue.comments.build({'body':'My new comment'})
+  comment.save
+  comment.delete
+
+== Links to JIRA REST API documentation
+
+* {Overview}[https://developer.atlassian.com/display/JIRADEV/JIRA+REST+APIs]
+* {Reference}[http://docs.atlassian.com/jira/REST/5.0-rc1/]
+
+
+== Setting up the JIRA SDK
+
+On Mac OS,
+
+    brew install atlassian-plugin-sdk
+
+Otherwise:
+
+* Download the SDK from https://developer.atlassian.com/ (You will need
+  an Atlassian login for this)
+* Unpack the dowloaded archive
+* From within the archive directory, run:
+
+    ./bin/atlas-run-standalone --product jira --version 5.0-rc2
+
+Once this is running, you should be able to connect to
+http://localhost:2990/ and login to the JIRA admin system using `admin:admin`
+
+You'll need to create a dummy project and probably some issues to test using
+this library.
+
+== Configuring JIRA to use OAuth
+
+From the JIRA API tutorial
+
+  The first step is to register a new consumer in JIRA. This is done through
+  the Application Links administration screens in JIRA. Create a new
+  Application Link.
+  {Administration/Plugins/Application Links}[http://localhost:2990/jira/plugins/servlet/applinks/listApplicationLinks]
+
+  When creating the Application Link use a placeholder URL or the correct URL
+  to your client (e.g. `http://localhost:3000`), if your client can be reached
+  via HTTP and choose the Generic Application type. After this Application Link
+  has been created, edit the configuration and go to the incoming
+  authentication configuration screen and select OAuth. Enter in this the
+  public key and the consumer key which your client will use when making
+  requests to JIRA.
+
+This public key and consumer key will need to be generated by the Gem user, using OpenSSL
+or similar to generate the public key and the provided rake task to generate the consumer
+key.
+
+  After you have entered all the information click OK and ensure OAuth authentication is
+  enabled.
+
+== Using the API Gem in your Rails application
+
+The gem requires the consumer key and public certificate file (which
+are generated in their respective rake tasks) to initialize an access token for
+using the JIRA API.
+
+Below is an example for setting up a rails application for OAuth authorization.
+
+  # app/controllers/application_controller.rb
+  class ApplicationController < ActionController::Base
+    protect_from_forgery
+
+    rescue_from JIRA::Client::UninitializedAccessTokenError do
+      redirect_to new_jira_session_url
+    end
+
+    private
+
+    def get_jira_client
+      options = {
+        :private_key_file => "rsakey.pem"
+      }
+      @jira_client = JIRA::Client.new('test', '', options)
+
+      # Add AccessToken if authorised previously.
+      if session[:jira_auth]
+        @jira_client.set_access_token(
+          session[:jira_auth][:access_token],
+          session[:jira_auth][:access_key]
+        )
+      end
+    end
+  end
+
+Create a controller for handling the OAuth conversation.
+
+  # app/controllers/jira_sessions_controller.rb
+  require 'jira'
+
+  class JiraSessionsController < ApplicationController
+
+    before_filter :get_jira_client
+
+    def new
+      request_token = @jira_client.request_token
+      session[:request_token] = request_token.token
+      session[:request_secret] = request_token.secret
+
+      redirect_to request_token.authorize_url
+    end
+
+    def authorize
+      request_token = @jira_client.set_request_token(
+        session[:request_token], session[:request_secret]
+      )
+      access_token = @jira_client.init_access_token(
+        :oauth_verifier => params[:oauth_verifier]
+      )
+
+      session[:jira_auth] = {
+        :access_token => access_token.token,
+        :access_key => access_token.secret
+      }
+
+      session.delete(:request_token)
+      session.delete(:request_secret)
+
+      redirect_to projects_path
+    end
+
+    def destroy
+      session.data.delete(:jira_auth)
+    end
+  end
+
+Create your own controllers for the JIRA resources you wish to access.
+
+  # app/controllers/issues_controller.rb
+  class IssuesController < ApplicationController
+    before_filter :get_jira_client
+    def index
+      @issues = @jira_client.Issue.all
+    end
+
+    def show
+      @issue = @jira_client.Issue.find(params[:id])
+    end
+  end
+
+== Using the API Gem in your Sinatra application
+
+Here's the same example as a Sinatra application:
+
+  require 'jira'
+  class App < Sinatra::Base
+    enable :sessions
+
+    # This section gets called before every request. Here, we set up the
+    # OAuth consumer details including the consumer key, private key,
+    # site uri, and the request token, access token, and authorize paths
+    before do
+      options = {
+        :site               => 'http://localhost:2990',
+        :signature_method   => 'RSA-SHA1',
+        :request_token_path => "/jira/plugins/servlet/oauth/request-token",
+        :authorize_path     => "/jira/plugins/servlet/oauth/authorize",
+        :access_token_path  => "/jira/plugins/servlet/oauth/access-token",
+        :private_key_file   => "rsakey.pem",
+        :rest_base_path     => "/jira/rest/api/2"
+      }
+
+      @jira_client = JIRA::Client.new('jira-ruby-example', '', options)
+      @jira_client.consumer.http.set_debug_output($stderr)
+
+      # Add AccessToken if authorised previously.
+      if session[:jira_auth]
+        @jira_client.set_access_token(
+          session[:jira_auth][:access_token],
+          session[:jira_auth][:access_key]
+        )
+      end
+    end
+
+
+    # Starting point: http://<yourserver>/
+    # This will serve up a login link if you're not logged in. If you are, it'll show some user info and a
+    # signout link
+    get '/' do
+      if !session[:jira_auth]
+        # not logged in
+        <<-eos
+          <h1>jira-ruby (JIRA 5 Ruby Gem) demo </h1>You're not signed in. Why don't you 
+          <a href=/signin>sign in</a> first.
+        eos
+      else
+        #logged in
+        @issues = @jira_client.Issue.all
+
+        # HTTP response inlined with bind data below...
+        <<-eos
+          You're now signed in. There #{@issues.count == 1 ? "is" : "are"} #{@issues.count} 
+          issue#{@issues.count == 1 ? "" : "s"} in this JIRA instance. <a href='/signout'>Signout</a>
+        eos
+      end
+    end
+
+    # http://<yourserver>/signin
+    # Initiates the OAuth dance by first requesting a token then redirecting to 
+    # http://<yourserver>/auth to get the @access_token
+    get '/signin' do
+      request_token = @jira_client.request_token
+      session[:request_token] = request_token.token
+      session[:request_secret] = request_token.secret
+
+      redirect request_token.authorize_url    
+    end
+
+    # http://<yourserver>/callback
+    # Retrieves the @access_token then stores it inside a session cookie. In a real app, 
+    # you'll want to persist the token in a datastore associated with the user.
+    get "/callback/" do
+      request_token = @jira_client.set_request_token(
+        session[:request_token], session[:request_secret]
+      )
+      access_token = @jira_client.init_access_token(
+        :oauth_verifier => params[:oauth_verifier]
+      )
+
+      session[:jira_auth] = {
+        :access_token => access_token.token,
+        :access_key => access_token.secret
+      }
+
+      session.delete(:request_token)
+      session.delete(:request_secret)
+
+      redirect "/"
+    end
+
+    # http://<yourserver>/signout
+    # Expires the session
+    get "/signout" do
+      session.delete(:jira_auth)
+      redirect "/"
+    end
+  end
+

data/Rakefile

@@ -2,8 +2,17 @@ require "bundler/gem_tasks"
 
 require 'rubygems'
 require 'rspec/core/rake_task'
+require 'rake/rdoctask'
+
+Dir.glob('lib/tasks/*.rake').each { |r| import r }
 
 task :default => [:spec]
 
 desc "Run RSpec tests"
 RSpec::Core::RakeTask.new(:spec)
+
+Rake::RDocTask.new(:doc) do |rd|
+  rd.main       = 'README.rdoc'
+  rd.rdoc_dir   = 'doc'
+  rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
+end

data/example.rb

@@ -7,7 +7,7 @@ options = {
 
 CONSUMER_KEY = 'test'
 
-client = Jira::Client.new(CONSUMER_KEY, '', options)
+client = JIRA::Client.new(CONSUMER_KEY, '', options)
 
 if ARGV.length == 0
   # If not passed any command line arguments, open a browser and prompt the
@@ -42,6 +42,15 @@ pp issue
 # # ------------------------------
 # project = client.Project.find('SAMPLEPROJECT')
 # pp project
+# project.issues.each do |issue|
+#   puts "#{issue.id} - #{issue.fields['summary']}"
+# end
+#
+# # List all Issues
+# # ---------------
+# client.Issue.all.each do |issue|
+#   puts "#{issue.id} - #{issue.fields['summary']}"
+# end
 #
 # # Delete an issue
 # # ---------------
@@ -58,9 +67,43 @@ pp issue
 # issue.save({"fields"=>{"summary"=>"blarg from in example.rb","project"=>{"id"=>"10001"},"issuetype"=>{"id"=>"3"}}})
 # issue.fetch
 # pp issue
-# 
-# Update an issue
-# ---------------
+#
+# # Update an issue
+# # ---------------
 # issue = client.Issue.find("10002")
 # issue.save({"fields"=>{"summary"=>"EVEN MOOOOOOARRR NINJAAAA!"}})
 # pp issue
+#
+# # Find a user
+# # -----------
+# user = client.User.find('admin')
+# pp user
+#
+# # Get all issue types
+# # -------------------
+# issuetypes = client.Issuetype.all
+# pp issuetypes
+#
+# # Get a single issue type
+# # -----------------------
+# issuetype = client.Issuetype.find('5')
+# pp issuetype
+#
+# #  Get all comments for an issue
+# #  -----------------------------
+# issue.comments.each do |comment|
+#   pp comment
+# end
+#
+# # Build and Save a comment
+# # ------------------------
+# comment = issue.comments.build
+# comment.save!(:body => "New comment from example script")
+#
+# # Delete a comment from the collection
+# # ------------------------------------
+# issue.comments.last.delete
+#
+# # Update an existing comment
+# # --------------------------
+# issue.comments.first.save({"body" => "an updated comment frome example.rb"})

data/jira-ruby.gemspec

@@ -4,11 +4,11 @@ require "jira/version"
 
 Gem::Specification.new do |s|
   s.name        = "jira-ruby"
-  s.version     = Jira::VERSION
+  s.version     = JIRA::VERSION
   s.authors     = ["Trineo Ltd"]
   s.homepage    = "http://trineo.co.nz"
-  s.summary     = %q{Ruby Gem for use with the Atlassian Jira 5 REST API}
-  s.description = %q{API for Jira 5}
+  s.summary     = %q{Ruby Gem for use with the Atlassian JIRA 5 REST API}
+  s.description = %q{API for JIRA 5}
 
   s.rubyforge_project = "jira-ruby"
 
@@ -24,5 +24,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "oauth"
   s.add_runtime_dependency "railties"
   s.add_development_dependency "railties"
+  s.add_runtime_dependency "activesupport"
+  s.add_development_dependency "activesupport"
   s.add_development_dependency "webmock"
 end

data/lib/jira.rb

@@ -1,12 +1,26 @@
-Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f } if defined?(Rake)
-
 $: << File.expand_path(File.dirname(__FILE__))
-require 'jira/resource/base'
-require 'jira/resource/base_factory'
-require 'jira/resource/http_error'
 
-require 'jira/resource/issue'
-require 'jira/resource/project'
+require 'active_support/inflector'
+ActiveSupport::Inflector.inflections do |inflector|
+  inflector.singular 'status', 'status'
+end
+
+require 'jira/base'
+require 'jira/base_factory'
+require 'jira/has_many_proxy'
+require 'jira/http_error'
+
+require 'jira/resource/user'
+require 'jira/resource/attachment'
 require 'jira/resource/component'
+require 'jira/resource/issuetype'
+require 'jira/resource/version'
+require 'jira/resource/project'
+require 'jira/resource/priority'
+require 'jira/resource/status'
+require 'jira/resource/comment'
+require 'jira/resource/worklog'
+require 'jira/resource/issue'
 
 require 'jira/client'
+

data/lib/jira/base.rb

@@ -0,0 +1,466 @@
+require 'active_support/core_ext/string'
+require 'active_support/inflector'
+
+module JIRA
+
+  # This class provides the basic object <-> REST mapping for all JIRA::Resource subclasses,
+  # i.e. the Create, Retrieve, Update, Delete lifecycle methods.
+  #
+  # == Lifecycle methods
+  #
+  # Note that not all lifecycle
+  # methods are available for all resources, for example some resources cannot be updated
+  # or deleted.
+  #
+  # === Retrieving all resources
+  #
+  #   client.Resource.all
+  #
+  # === Retrieving a single resource
+  #
+  #   client.Resource.find(id)
+  #
+  # === Creating a resource
+  #
+  #   resource = client.Resource.build({'name' => '')
+  #   resource.save
+  #
+  # === Updating a resource
+  #
+  #   resource = client.Resource.find(id)
+  #   resource.save('updated_attribute' => 'new value')
+  #
+  # === Deleting a resource
+  #
+  #   resource = client.Resource.find(id)
+  #   resource.delete
+  #
+  # == Nested resources
+  #
+  # Some resources are not defined in the top level of the URL namespace
+  # within the JIRA API, but are always nested under the context of another
+  # resource.  For example, a JIRA::Resource::Comment always belongs to a
+  # JIRA::Resource::Issue.
+  #
+  # These resources must be indexed and built from an instance of the class
+  # they are nested under:
+  #
+  #   issue = client.Issue.find(id)
+  #   comments = issue.comments
+  #   new_comment = issue.comments.build
+  #
+  class Base
+
+    # A reference to the JIRA::Client used to initialize this resource.
+    attr_reader :client
+
+    # Returns true if this instance has been fetched from the server
+    attr_accessor :expanded
+
+    # Returns true if this instance has been deleted from the server
+    attr_accessor :deleted
+
+    # The hash of attributes belonging to this instance.  An exact
+    # representation of the JSON returned from the JIRA API
+    attr_accessor :attrs
+
+    alias :expanded? :expanded
+    alias :deleted? :deleted
+
+    def initialize(client, options = {})
+      @client   = client
+      @attrs    = options[:attrs] || {}
+      @expanded = options[:expanded] || false
+      @deleted  = false
+
+      # If this class has any belongs_to relationships, a value for
+      # 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)
+        elsif options["#{relation}_id".to_sym]
+          instance_variable_set("@#{relation.to_s}_id", options["#{relation}_id".to_sym])
+        else
+          raise ArgumentError.new("Required option #{relation.inspect} missing") unless options[relation]
+        end
+      end
+    end
+
+    # The class methods are never called directly, they are always
+    # invoked from a BaseFactory subclass instance.
+    def self.all(client, options = {})
+      response = client.get(collection_path(client))
+      json = parse_json(response.body)
+      puts collection_attributes_are_nested
+      if collection_attributes_are_nested
+        json = json[endpoint_name.pluralize]
+      end
+      json.map do |attrs|
+        self.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.attrs[key_attribute.to_s] = key
+      instance.fetch
+      instance
+    end
+
+    # 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)
+    end
+
+    # Returns the name of this resource for use in URL components.
+    # E.g.
+    #   JIRA::Resource::Issue.endpoint_name
+    #     # => issue
+    def self.endpoint_name
+      self.name.split('::').last.downcase
+    end
+
+    # Returns the full path for a collection of this resource.
+    # E.g.
+    #   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
+    end
+
+    # Returns the singular path for the resource with the given key.
+    # E.g.
+    #   JIRA::Resource::Issue.singular_path('123')
+    #     # => /jira/rest/api/2/issue/123
+    #
+    # If a prefix parameter is provided it will be injected between the base
+    # path and the endpoint.
+    # E.g.
+    #   JIRA::Resource::Comment.singular_path('456','/issue/123/')
+    #     # => /jira/rest/api/2/issue/123/comment/456
+    def self.singular_path(client, key, prefix = '/')
+      collection_path(client, prefix) + '/' + key
+    end
+
+    # Returns the attribute name of the attribute used for find.
+    # Defaults to :id unless overridden.
+    def self.key_attribute
+      :id
+    end
+
+    def self.parse_json(string) # :nodoc:
+      JSON.parse(string)
+    end
+
+    # Declares that this class contains a singular instance of another resource
+    # within the JSON returned from the JIRA API.
+    #
+    #   class Example < JIRA::Base
+    #     has_one :child
+    #   end
+    #
+    #   example = client.Example.find(1)
+    #   example.child # Returns a JIRA::Resource::Child
+    #
+    # The following options can be used to override the default behaviour of the
+    # relationship:
+    #
+    # [:attribute_key]  The relationship will by default reference a JSON key on the
+    #                   object with the same name as the relationship.
+    #
+    #                     has_one :child # => {"id":"123",{"child":{"id":"456"}}}
+    #
+    #                   Use this option if the key in the JSON is named differently.
+    #
+    #                     # Respond to resource.child, but return the value of resource.attrs['kid']
+    #                     has_one :child, :attribute_key => 'kid' # => {"id":"123",{"kid":{"id":"456"}}}
+    #
+    # [:class]          The class of the child instance will be inferred from the name of the
+    #                   relationship. E.g. <tt>has_one :child</tt> will return a <tt>JIRA::Resource::Child</tt>.
+    #                   Use this option to override the inferred class.
+    #
+    #                     has_one :child, :class => JIRA::Resource::Kid
+    # [:nested_under]   In some cases, the JSON return from JIRA is nested deeply for particular
+    #                   relationships.  This option allows the nesting to be specified.
+    #
+    #                     # Specify a single depth of nesting.
+    #                     has_one :child, :nested_under => 'foo'
+    #                       # => Looks for {"foo":{"child":{}}}
+    #                     # Specify deeply nested JSON
+    #                     has_one :child, :nested_under => ['foo', 'bar', 'baz']
+    #                       # => Looks for {"foo":{"bar":{"baz":{"child":{}}}}}
+    def self.has_one(resource, options = {})
+      attribute_key = options[:attribute_key] || resource.to_s
+      child_class = options[:class] || ('JIRA::Resource::' + resource.to_s.classify).constantize
+      define_method(resource) do
+        attribute = maybe_nested_attribute(attribute_key, options[:nested_under])
+        return nil unless attribute
+        child_class.new(client, :attrs => attribute)
+      end
+    end
+
+    # Declares that this class contains a collection of another resource
+    # within the JSON returned from the JIRA API.
+    #
+    #   class Example < JIRA::Base
+    #     has_many :children
+    #   end
+    #
+    #   example = client.Example.find(1)
+    #   example.children # Returns an instance of Jira::Resource::HasManyProxy,
+    #                    # which behaves exactly like an array of
+    #                    # Jira::Resource::Child
+    #
+    # The following options can be used to override the default behaviour of the
+    # relationship:
+    #
+    # [:attribute_key]  The relationship will by default reference a JSON key on the
+    #                   object with the same name as the relationship.
+    #
+    #                     has_many :children # => {"id":"123",{"children":[{"id":"456"},{"id":"789"}]}}
+    #
+    #                   Use this option if the key in the JSON is named differently.
+    #
+    #                     # Respond to resource.children, but return the value of resource.attrs['kids']
+    #                     has_many :children, :attribute_key => 'kids' # => {"id":"123",{"kids":[{"id":"456"},{"id":"789"}]}}
+    #
+    # [:class]          The class of the child instance will be inferred from the name of the
+    #                   relationship. E.g. <tt>has_many :children</tt> will return an instance
+    #                   of <tt>JIRA::Resource::HasManyProxy</tt> containing the collection of
+    #                   <tt>JIRA::Resource::Child</tt>.
+    #                   Use this option to override the inferred class.
+    #
+    #                     has_many :children, :class => JIRA::Resource::Kid
+    # [:nested_under]   In some cases, the JSON return from JIRA is nested deeply for particular
+    #                   relationships.  This option allows the nesting to be specified.
+    #
+    #                     # Specify a single depth of nesting.
+    #                     has_many :children, :nested_under => 'foo'
+    #                       # => Looks for {"foo":{"children":{}}}
+    #                     # Specify deeply nested JSON
+    #                     has_many :children, :nested_under => ['foo', 'bar', 'baz']
+    #                       # => Looks for {"foo":{"bar":{"baz":{"children":{}}}}}
+    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
+      define_method(collection) do
+        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))
+        end
+        HasManyProxy.new(self, child_class, collection)
+      end
+    end
+
+    def self.belongs_to_relationships
+      @belongs_to_relationships ||= []
+    end
+
+    def self.belongs_to(resource)
+      belongs_to_relationships.push(resource)
+      attr_reader resource
+      attr_reader "#{resource}_id"
+    end
+
+    def self.collection_attributes_are_nested
+      @collection_attributes_are_nested ||= false
+    end
+
+    def self.nested_collections(value)
+      @collection_attributes_are_nested = value
+    end
+
+    # Returns a symbol for the given instance, for example
+    # JIRA::Resource::Issue returns :issue
+    def to_sym
+      self.class.endpoint_name.to_sym
+    end
+
+    # 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)
+      if attrs.keys.include? method_name.to_s
+        true
+      else
+        super(method_name)
+      end
+    end
+
+    # 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
+        attrs[method_name.to_s]
+      else
+        super(method_name)
+      end
+    end
+
+    # Each resource has a unique key attribute, this method returns the value
+    # of that key for this instance.
+    def key_value
+      @attrs[self.class.key_attribute.to_s]
+    end
+
+    def collection_path(prefix = "/")
+      # Just proxy this to the class method
+      self.class.collection_path(client, prefix)
+    end
+
+    # This returns the URL path component that is specific to this instance,
+    # for example for Issue id 123 it returns '/issue/123'.  For an unsaved
+    # issue it returns '/issue'
+    def path_component
+      path_component = "/#{self.class.endpoint_name}"
+      if key_value
+        path_component += '/' + key_value
+      end
+      path_component
+    end
+
+    # Fetches the attributes for the specified resource from JIRA unless
+    # the resource is already expanded and the optional force reload flag 
+    # is not set
+    def fetch(reload = false)
+      return if expanded? && !reload
+      response = client.get(url)
+      set_attrs_from_response(response)
+      @expanded = true
+    end
+
+    # Saves the specified resource attributes by sending either a POST or PUT
+    # request to JIRA, depending on resource.new_record?
+    #
+    # 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)
+      http_method = new_record? ? :post : :put
+      response = client.send(http_method, url, attrs.to_json)
+      set_attrs(attrs, false)
+      set_attrs_from_response(response)
+      @expanded = false
+      true
+    end
+
+    # Saves the specified resource attributes by sending either a POST or PUT
+    # request to JIRA, depending on resource.new_record?
+    #
+    # Accepts an attributes hash of the values to be saved. Will return false
+    # if the request fails.
+    def save(attrs)
+      begin
+        save_status = save!(attrs)
+      rescue JIRA::HTTPError => exception
+        set_attrs_from_response(exception.response) rescue JSON::ParserError  # Merge error status generated by JIRA REST API
+        save_status = false
+      end
+      save_status
+    end
+
+    # 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
+        json = self.class.parse_json(response.body)
+        set_attrs(json)
+      end
+    end
+
+    # Set the current attributes from a hash.  If clobber is true, any existing
+    # 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)
+      target ||= @attrs
+      if clobber
+        target.merge!(hash)
+        hash
+      else
+        hash.each do |k, v|
+          if v.is_a?(Hash)
+            set_attrs(v, clobber, target[k])
+          else
+            target[k] = v
+          end
+        end
+      end
+    end
+
+    # Sends a delete request to the JIRA Api and sets the deleted instance
+    # variable on the object to true.
+    def delete
+      client.delete(url)
+      @deleted = true
+    end
+
+    def has_errors?
+      respond_to?('errors')
+    end
+
+    def url
+      prefix = '/'
+      unless self.class.belongs_to_relationships.empty?
+        prefix = self.class.belongs_to_relationships.inject(prefix) do |prefix_so_far, relationship|
+          prefix_so_far + relationship.to_s + "/" + self.send("#{relationship.to_s}_id") + '/'
+        end
+      end
+      if @attrs['self']
+        @attrs['self']
+      elsif key_value
+        self.class.singular_path(client, key_value.to_s, prefix)
+      else
+        self.class.collection_path(client, prefix)
+      end
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{object_id} @attrs=#{@attrs.inspect}>"
+    end
+
+    # Returns a JSON representation of the current attributes hash.
+    def to_json
+      attrs.to_json
+    end
+
+    # Determines if the resource is newly created by checking whether its
+    # key_value is set. If it is nil, the record is new and the method
+    # will return true.
+    def new_record?
+      key_value.nil?
+    end
+
+    protected
+
+    # This allows conditional lookup of possibly nested attributes.  Example usage:
+    #
+    #   maybe_nested_attribute('foo')                 # => @attrs['foo']
+    #   maybe_nested_attribute('foo', 'bar')          # => @attrs['bar']['foo']
+    #   maybe_nested_attribute('foo', ['bar', 'baz']) # => @attrs['bar']['baz']['foo']
+    #
+    def maybe_nested_attribute(attribute_name, nested_under = nil)
+      self.class.maybe_nested_attribute(@attrs, attribute_name, nested_under)
+    end
+
+    def self.maybe_nested_attribute(attributes, attribute_name, nested_under = nil)
+      return attributes[attribute_name] if nested_under.nil?
+      if nested_under.instance_of? Array
+        final = nested_under.inject(attributes) do |parent, key|
+          break if parent.nil?
+          parent[key]
+        end
+        return nil if final.nil?
+        final[attribute_name]
+      else
+        return attributes[nested_under][attribute_name]
+      end
+    end
+
+  end
+end