jira-ruby 0.0.2 → 0.0.3

data/README.markdown

@@ -1,81 +0,0 @@
-Jira 5 API Gem
-==============
-
-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 application
--------------------------------------
-The JiraApi 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. These two pieces of information are applied globally to your application, with separate JiraApi::Client objects created on a per-user basis.
-
-An example initializer which sets the key and certificate filename in a pair of globals is shown below, myapp/config/initializers/jira\_api.rb:
-
-    $CONSUMER_KEY = 'cbaec507669c65979b6b6eefdb1c5bb0' #Your consumer key. Can be generated by rake jira_api:generate_public_cert 
-    $PUBLIC_CERT_FILE = 'rsakey.pem' #Location of the Private Key File (generated by rake jira_api:generate_public_cert 
-
-This allows acces to the variables when a session is being set up.
-The following sample controller shows how to set up and initialize an access token for a particular user session.
-(Note that the callback url is defined in the Jira application link interface, and can be placed wherever suits you best in your application. The session#callback method is simply an example)
-
-\#TODO cannot pass params hash straight into init\_access\_token method - errors with a missing parameter exception
-
-    class SessionsController < ApplicationController
-      def create
-        session[:client] = JiraApi::Client.new($CONSUMER_KEY, '', :private_key_file => $PUBLIC_CERT_FILE)
-        session[:request_token] = session[:client].request_token #Generate the request token
-        redirect_to session[:request_token].authorize_url   #Redirect to Jira to authorize the token
-      end
-    
-      def callback
-        session[:client].init_access_token(:oauth_verifier => params[:oauth_verifier]) #Initialize the access token
-        redirect_to root_url  #Redirect to the desired page after initializing the access token
-      end
-    end

data/lib/jira/resource/base.rb

@@ -1,148 +0,0 @@
-module Jira
-  module Resource
-
-    class Base
-
-      attr_reader :client
-      attr_accessor :expanded, :deleted, :attrs
-      alias :expanded? :expanded
-      alias :deleted? :deleted
-
-      def initialize(client, options = {})
-        @client   = client
-        @attrs    = options[:attrs] || {}
-        @expanded = options[:expanded] || false
-        @deleted  = false
-      end
-
-      # The class methods are never called directly, they are always
-      # invoked from a BaseFactory subclass instance.
-      def self.all(client)
-        response = client.get(rest_base_path(client))
-        json = parse_json(response.body)
-        json.map do |attrs|
-          self.new(client, :attrs => attrs)
-        end
-      end
-
-      def self.find(client, key)
-        instance = self.new(client)
-        instance.attrs[key_attribute.to_s] = key
-        instance.fetch
-        instance
-      end
-
-      def self.build(client, attrs)
-        self.new(client, :attrs => attrs)
-      end
-
-      def self.rest_base_path(client)
-        client.options[:rest_base_path] + '/' + self.endpoint_name
-      end
-
-      def self.endpoint_name
-        self.name.split('::').last.downcase
-      end
-
-      def self.key_attribute
-        :key
-      end
-
-      def self.parse_json(string)
-        JSON.parse(string)
-      end
-
-      def respond_to?(method_name)
-        if attrs.keys.include? method_name.to_s
-          true
-        else
-          super(method_name)
-        end
-      end
-
-      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
-
-      def rest_base_path
-        # Just proxy this to the class method
-        self.class.rest_base_path(client)
-      end
-
-      def fetch(reload = false)
-        return if expanded? && !reload
-        response = client.get(url)
-        set_attrs_from_response(response)
-        @expanded = true
-      end
-
-      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
-
-      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
-
-      def delete
-        client.delete(url)
-        @deleted = true
-      end
-
-      def url
-        if @attrs['self']
-          @attrs['self']
-        elsif @attrs[self.class.key_attribute.to_s]
-          rest_base_path + "/" + @attrs[self.class.key_attribute.to_s].to_s
-        else
-          rest_base_path
-        end
-      end
-
-      def to_s
-        "#<#{self.class.name}:#{object_id} @attrs=#{@attrs.inspect}>"
-      end
-
-      def to_json
-        attrs.to_json
-      end
-
-      def new_record?
-        @attrs['id'].nil?
-      end
-    end
-
-  end
-end

data/lib/jira/resource/base_factory.rb

@@ -1,44 +0,0 @@
-module Jira
-  module Resource
-
-    # 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 all
-        target_class.all(@client)
-      end
-
-      def find(key)
-        target_class.find(@client, key)
-      end
-
-      def build(attrs={})
-        target_class.build(@client, attrs)
-      end
-    end
-  end
-end

data/lib/jira/resource/http_error.rb

@@ -1,17 +0,0 @@
-require 'forwardable'
-module Jira
-  module Resource
-
-    class HTTPError < StandardError
-      extend Forwardable
-
-      delegate [:message, :code] => :response
-      attr_reader :response
-
-      def initialize(response)
-        @response = response
-      end
-
-    end
-  end
-end

data/spec/jira/resource/base_factory_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Jira::Resource::BaseFactory do
-
-  class Jira::Resource::FooFactory < Jira::Resource::BaseFactory ; end
-  class Jira::Resource::Foo ; end
-
-  let(:client)  { mock() }
-  subject       { Jira::Resource::FooFactory.new(client) }
-
-  it "initializes correctly" do
-    subject.class.should        == Jira::Resource::FooFactory
-    subject.client.should       == client
-    subject.target_class.should == Jira::Resource::Foo
-  end
-
-  it "proxies all to the target class" do
-    Jira::Resource::Foo.should_receive(:all).with(client)
-    subject.all
-  end
-
-  it "proxies find to the target class" do
-    Jira::Resource::Foo.should_receive(:find).with(client, 'FOO')
-    subject.find('FOO')
-  end
-
-  it "returns the target class" do
-    subject.target_class.should == Jira::Resource::Foo
-  end
-
-  it "proxies build to the target class" do
-    attrs = mock()
-    Jira::Resource::Foo.should_receive(:build).with(client, attrs)
-    subject.build(attrs)
-  end
-end

data/spec/jira/resource/base_spec.rb

@@ -1,292 +0,0 @@
-require 'spec_helper'
-
-describe Jira::Resource::Base do
-
-  class Jira::Resource::Deadbeef < Jira::Resource::Base ; end
-
-  let(:client)  { mock() }
-  let(:attrs)   { mock() }
-
-  subject { Jira::Resource::Deadbeef.new(client, :attrs => attrs) }
-
-  it "assigns the client and attrs" do
-    subject.client.should == client
-    subject.attrs.should  == attrs
-  end
-
-  it "returns all the deadbeefs" do
-    response = mock()
-    response.should_receive(:body).and_return('[{"self":"http://deadbeef/","key":"FOO"}]')
-    client.should_receive(:get).with('/jira/rest/api/2/deadbeef').and_return(response)
-    Jira::Resource::Deadbeef.should_receive(:rest_base_path).and_return('/jira/rest/api/2/deadbeef')
-    deadbeefs = Jira::Resource::Deadbeef.all(client)
-    deadbeefs.length.should == 1
-    first = deadbeefs.first
-    first.class.should == Jira::Resource::Deadbeef
-    first.attrs['self'].should  == 'http://deadbeef/'
-    first.attrs['key'].should   == 'FOO'
-    first.expanded?.should be_false
-  end
-
-  it "finds a deadbeef by key" do
-    response = mock()
-    response.stub(:body).and_return('{"self":"http://deadbeef/","key":"FOO"}')
-    client.should_receive(:get).with('/jira/rest/api/2/deadbeef/FOO').and_return(response)
-    Jira::Resource::Deadbeef.should_receive(:rest_base_path).and_return('/jira/rest/api/2/deadbeef')
-    deadbeef = Jira::Resource::Deadbeef.find(client, 'FOO')
-    deadbeef.client.should == client
-    deadbeef.attrs['self'].should  == 'http://deadbeef/'
-    deadbeef.attrs['key'].should   == 'FOO'
-    deadbeef.expanded?.should be_true
-  end
-
-  it "builds a deadbeef" do
-    deadbeef = Jira::Resource::Deadbeef.build(client, 'key' => "FOO" )
-    deadbeef.expanded?.should be_false
-
-    deadbeef.client.should == client
-    deadbeef.attrs['key'].should   == 'FOO'
-  end
-
-  it "returns the endpoint name" do
-    subject.class.endpoint_name.should == 'deadbeef'
-  end
-
-
-  describe "rest_base_path" do
-
-    before(:each) do
-      client.should_receive(:options).and_return(:rest_base_path => '/deadbeef/bar')
-    end
-
-    it "returns the rest_base_path" do
-      subject.rest_base_path.should == '/deadbeef/bar/deadbeef'
-    end
-
-    it "has a class method that returns the rest_base_path" do
-      subject.class.rest_base_path(client).should == '/deadbeef/bar/deadbeef'
-    end
-  end
-
-  it "parses json" do
-    described_class.parse_json('{"foo":"bar"}').should == {"foo" => "bar"}
-  end
-
-  describe "dynamic instance methods" do
-
-    let(:attrs) { {'foo' => 'bar', 'flum' => 'goo', 'object_id' => 'dummy'} }
-    subject     { Jira::Resource::Deadbeef.new(client, :attrs => attrs) }
-
-    it "responds to each of the top level attribute names" do
-      subject.should respond_to(:foo)
-      subject.should respond_to('flum')
-      subject.should respond_to(:object_id)
-
-      subject.foo.should  == 'bar'
-      subject.flum.should == 'goo'
-
-      # Should not override existing method names, but should still allow
-      # access to their values via the attrs[] hash
-      subject.object_id.should_not == 'dummy'
-      subject.attrs['object_id'].should == 'dummy'
-    end
-  end
-
-  describe "fetch" do
-
-    subject     { Jira::Resource::Deadbeef.new(client, :attrs => {'key' => 'FOO'}) }
-
-    describe "not cached" do
-
-      before(:each) do
-        response = mock()
-        response.stub(:body).and_return('{"self":"http://deadbeef/","key":"FOO"}')
-        client.should_receive(:get).with('/jira/rest/api/2/deadbeef/FOO').and_return(response)
-        Jira::Resource::Deadbeef.should_receive(:rest_base_path).and_return('/jira/rest/api/2/deadbeef')
-      end
-
-      it "sets expanded to true after fetch" do
-        subject.expanded?.should be_false
-        subject.fetch
-        subject.expanded?.should be_true
-      end
-
-      it "performs a fetch" do
-        subject.expanded?.should be_false
-        subject.fetch
-        subject.self.should == "http://deadbeef/"
-        subject.key.should  == "FOO"
-      end
-
-      it "performs a fetch if already fetched and force flag is true" do
-        subject.expanded = true
-        subject.fetch(true)
-      end
-
-    end
-
-    describe "cached" do
-      it "doesn't perform a fetch if already fetched" do
-        subject.expanded = true
-        client.should_not_receive(:get)
-        subject.fetch
-      end
-    end
-
-  end
-
-  describe "save" do
-
-    let(:response) { mock() }
-
-    subject { Jira::Resource::Deadbeef.new(client) }
-
-    before(:each) do
-      subject.should_receive(:url).and_return('/foo/bar')
-    end
-
-    it "POSTs a new record" do
-      response.stub(:body => '{"id":"123"}')
-      subject.stub(:new_record? => true)
-      client.should_receive(:post).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save("foo" => "bar").should be_true
-      subject.id.should == "123"
-      subject.expanded.should be_false
-    end
-
-    it "PUTs an existing record" do
-      response.stub(:body => nil)
-      subject.stub(:new_record? => false)
-      client.should_receive(:put).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save("foo" => "bar").should be_true
-      subject.expanded.should be_false
-    end
-
-    it "merges attrs on save" do
-      response.stub(:body => nil)
-      client.should_receive(:post).with('/foo/bar','{"foo":{"fum":"dum"}}').and_return(response)
-      subject.attrs = {"foo" => {"bar" => "baz"}}
-      subject.save({"foo" => {"fum" => "dum"}})
-      subject.foo.should == {"bar" => "baz", "fum" => "dum"}
-    end
-
-  end
-
-  describe "set_attrs" do
-    it "merges hashes correctly when clobber is true (default)" do
-      subject.attrs = {"foo" => {"bar" => "baz"}}
-      subject.set_attrs({"foo" => {"fum" => "dum"}})
-      subject.foo.should == {"fum" => "dum"}
-    end
-
-    it "merges hashes correctly when clobber is false" do
-      subject.attrs = {"foo" => {"bar" => "baz"}}
-      subject.set_attrs({"foo" => {"fum" => "dum"}}, false)
-      subject.foo.should == {"bar" => "baz", "fum" => "dum"}
-    end
-  end
-
-  describe "delete" do
-
-    before(:each) do
-      client.should_receive(:delete).with('/foo/bar')
-      subject.stub(:url => '/foo/bar')
-    end
-
-    it "flags itself as deleted" do
-      subject.deleted?.should be_false
-      subject.delete
-      subject.deleted?.should be_true
-    end
-
-    it "sends a DELETE request" do
-      subject.delete
-    end
-
-  end
-
-  describe "new_record?" do
-
-    it "returns true for new_record? when new object" do
-      subject.attrs.stub(:[]).with('id').and_return(nil)
-      subject.new_record?.should be_true
-    end
-
-    it "returns false for new_record? when id is set" do
-      subject.attrs.stub(:[]).with('id').and_return('123')
-      subject.new_record?.should be_false
-    end
-
-  end
-
-  describe 'url' do
-    it "returns self as the URL if set" do
-      attrs.stub(:[]).with('self').and_return('http://foo/bar')
-      subject.url.should == "http://foo/bar"
-    end
-
-    it "generates the URL from key if self not set" do
-      attrs.stub(:[]).with('self').and_return(nil)
-      attrs.stub(:[]).with('key').and_return('FOO')
-      subject.stub(:rest_base_path => 'http://foo/bar')
-      subject.url.should == "http://foo/bar/FOO"
-    end
-
-    it "generates the URL from rest_base_path if self and key not set" do
-      attrs.stub(:[]).with('self').and_return(nil)
-      attrs.stub(:[]).with('key').and_return(nil)
-      subject.stub(:rest_base_path => 'http://foo/bar')
-      subject.url.should == "http://foo/bar"
-    end
-  end
-
-  it "returns the formatted attrs from to_s" do
-    subject.attrs.stub(:[]).with('foo').and_return('bar')
-    subject.attrs.stub(:[]).with('dead').and_return('beef')
-
-    subject.to_s.should match(/#<Jira::Resource::Deadbeef:\d+ @attrs=#{attrs.inspect}>/)
-  end
-
-  it "returns the key attribute" do
-    subject.class.key_attribute.should == :key
-  end
-
-  it "converts to json" do
-    subject.attrs.stub(:to_json => '{"foo":"bar","dead":"beef"}')
-
-    subject.to_json.should == '{"foo":"bar","dead":"beef"}'
-  end
-
-  describe "extract attrs from response" do
-
-    subject { Jira::Resource::Deadbeef.new(client, :attrs => {}) }
-
-    it "sets the attrs from a response" do
-      response = mock()
-      response.stub(:body).and_return('{"foo":"bar"}')
-
-      subject.set_attrs_from_response(response).should == {'foo' => 'bar'}
-      subject.foo.should == "bar"
-    end
-
-    it "doesn't clobber existing attrs not in response" do
-      response = mock()
-      response.stub(:body).and_return('{"foo":"bar"}')
-
-      subject.attrs = {'flum' => 'flar'}
-      subject.set_attrs_from_response(response).should == {'foo' => 'bar'}
-      subject.foo.should == "bar"
-      subject.flum.should == "flar"
-    end
-
-    it "handles nil response body" do
-      response = mock()
-      response.stub(:body).and_return(nil)
-
-      subject.attrs = {'flum' => 'flar'}
-      subject.set_attrs_from_response(response).should be_nil
-      subject.flum.should == 'flar'
-    end
-  end
-
-end