jira-ruby 0.1.17 → 1.0.0

data/lib/jira/resource/createmeta.rb

@@ -0,0 +1,52 @@
+module JIRA
+  module Resource
+
+    class CreatemetaFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Createmeta < JIRA::Base
+      def self.endpoint_name
+        '/issue/createmeta'
+      end
+
+      def self.all(client, params={})
+
+        if params.has_key?(:projectKeys)
+          values = Array(params[:projectKeys]).map{|i| (i.is_a?(JIRA::Resource::Project) ? i.key : i)}
+          params[:projectKeys] = values.join(',')
+        end
+
+        if params.has_key?(:projectIds)
+          values = Array(params[:projectIds]).map{|i| (i.is_a?(JIRA::Resource::Project) ? i.id : i)}
+          params[:projectIds] = values.join(',')
+        end
+
+        if params.has_key?(:issuetypeNames)
+          values = Array(params[:issuetypeNames]).map{|i| (i.is_a?(JIRA::Resource::Issuetype) ? i.name : i)}
+          params[:issuetypeNames] = values.join(',')
+        end
+
+        if params.has_key?(:issuetypeIds)
+          values = Array(params[:issuetypeIds]).map{|i| (i.is_a?(JIRA::Resource::Issuetype) ? i.id : i)}
+          params[:issuetypeIds] = values.join(',')
+        end
+
+        create_meta_url = client.options[:rest_base_path] + self.endpoint_name
+        params = hash_to_query_string(params)
+
+        response = params.empty? ? client.get("#{create_meta_url}") : client.get("#{create_meta_url}?#{params}")
+
+        json = parse_json(response.body)
+        self.new(client, {:attrs => json['projects']})
+      end
+
+      def self.hash_to_query_string(query_params)
+        query_params.map do |k,v|
+          CGI.escape(k.to_s) + '=' + CGI.escape(v.to_s)
+        end.join('&')
+      end
+
+    end
+
+  end
+end

data/lib/jira/resource/field.rb

@@ -2,9 +2,82 @@ module JIRA
   module Resource
 
     class FieldFactory < JIRA::BaseFactory # :nodoc:
+       delegate_to_target_class :map_fields, :name_to_id, :field_map
     end
 
-    class Field < JIRA::Base ; end
+    class Field < JIRA::Base
 
+      #translate a custom field description to a method-safe name
+      def self.safe_name(description)
+        description.gsub(/[^a-zA-Z0-9]/,'_')
+      end
+
+      # safe_name plus disambiguation if it fails it uses the original jira id (customfield_#####)
+      def self.safer_name(description, jira_id)
+        "#{safe_name(description)}_#{jira_id.split('_')[1]}" rescue jira_id
+      end
+
+      def self.map_fields(client)
+        field_map = {}
+        field_map_reverse = {}
+        fields = client.Field.all
+
+        # two pass approach, so that a custom field with the same name
+        # as a system field can't take precedence
+        fields.each do |f|
+          next if f.custom
+          name = safe_name(f.name)
+          field_map_reverse[f.id] = [f.name, name] # capture both the official name, and the mapped name
+          field_map[name] = f.id
+        end
+
+        fields.each do |f|
+          next unless f.custom
+          name = if field_map.key? f.name
+            renamed = safer_name(f.name, f.id)
+            warn "Duplicate Field name #{f.name} #{f.id} - renaming as #{renamed}"
+            renamed
+          else
+            safe_name(f.name)
+          end
+          field_map_reverse[f.id] = [f.name, name] # capture both the official name, and the mapped name
+          field_map[name] = f.id
+        end
+
+        client.cache.field_map_reverse = field_map_reverse   # not sure where this will be used yet, but sure to be useful
+        client.cache.field_map = field_map
+      end
+
+      def self.field_map(client)
+        client.cache.field_map
+      end
+
+      def self.name_to_id(client, field_name)
+        field_name = field_name.to_s
+        return field_name unless client.cache.field_map && client.cache.field_map[field_name]
+        client.cache.field_map[field_name]
+      end
+
+      def respond_to?(method_name, include_all=false)
+        if [method_name.to_s, client.Field.name_to_id(method_name)].any? {|k| attrs.key?(k)}
+          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
+            official_name=client.Field.name_to_id(method_name)
+            if attrs.keys.include?(official_name)
+              attrs[official_name]
+            else
+              super(method_name, *args, &block)
+            end
+          end
+      end
+    end
   end
 end

data/lib/jira/resource/issue.rb

@@ -51,7 +51,7 @@ module JIRA
       def self.jql(client, jql, options = {fields: nil, start_at: nil, max_results: nil, expand: nil})
         url = client.options[:rest_base_path] + "/search?jql=" + CGI.escape(jql)
 
-        url << "&fields=#{options[:fields].map{ |value| CGI.escape(value.to_s) }.join(',')}" if options[:fields]
+        url << "&fields=#{options[:fields].map{ |value| CGI.escape(client.Field.name_to_id(value)) }.join(',')}" if options[:fields]
         url << "&startAt=#{CGI.escape(options[:start_at].to_s)}" if options[:start_at]
         url << "&maxResults=#{CGI.escape(options[:max_results].to_s)}" if options[:max_results]
 
@@ -67,8 +67,16 @@ module JIRA
         end
       end
 
+      def editmeta
+        editmeta_url = client.options[:rest_base_path] + "/#{self.class.endpoint_name}/#{key}/editmeta"
+
+        response = client.get(editmeta_url)
+        json = self.class.parse_json(response.body)
+        json['fields']
+      end
+
       def respond_to?(method_name, include_all=false)
-        if attrs.keys.include?('fields') && attrs['fields'].keys.include?(method_name.to_s)
+        if attrs.keys.include?('fields') && [method_name.to_s, client.Field.name_to_id(method_name)].any? {|k| attrs['fields'].key?(k)}
           true
         else
           super(method_name)
@@ -76,10 +84,19 @@ module JIRA
       end
 
       def method_missing(method_name, *args, &block)
-        if attrs.keys.include?('fields') && attrs['fields'].keys.include?(method_name.to_s)
-          attrs['fields'][method_name.to_s]
+        if attrs.keys.include?('fields')
+          if attrs['fields'].keys.include?(method_name.to_s)
+            attrs['fields'][method_name.to_s]
+          else
+            official_name=client.Field.name_to_id(method_name)
+            if attrs['fields'].keys.include?(official_name)
+              attrs['fields'][official_name]
+            else
+              super(method_name, *args, &block)
+            end
+          end
         else
-          super(method_name)
+          super(method_name, *args, &block)
         end
       end
 

data/lib/jira/resource/resolution.rb

@@ -0,0 +1,10 @@
+module JIRA
+  module Resource
+
+    class ResolutionFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Resolution < JIRA::Base ; end
+
+  end
+end

data/lib/jira/resource/sprint.rb

@@ -0,0 +1,36 @@
+require 'cgi'
+
+module JIRA
+  module Resource
+
+    class SprintFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Sprint < JIRA::Base
+
+      def self.all(client, key)
+        response = client.get(path_base(client) + '/sprintquery/' + key.to_s)
+        parse_json(response.body)
+      end
+
+      def self.find(client, key, options = {})
+        options[:maxResults] ||= 100
+        fields = options[:fields].join(',') unless options[:fields].nil?
+        response = client.get("/rest/api/latest/search?jql=sprint=#{key}&fields=#{fields}&maxResults=#{options[:maxResults]}")
+        parse_json(response.body)
+      end
+
+      private
+
+      def self.path_base(client)
+        client.options[:context_path] + '/rest/greenhopper/1.0'
+      end
+
+      def path_base(client)
+        self.class.path_base(client)
+      end
+
+    end
+
+  end
+end

data/lib/jira/resource/user.rb

@@ -2,6 +2,12 @@ module JIRA
   module Resource
 
     class UserFactory < JIRA::BaseFactory # :nodoc:
+      def myself
+        instance = build
+        response = client.get("#{client.options[:rest_base_path]}/myself")
+        instance.set_attrs_from_response(response)
+        instance
+      end
     end
 
     class User < JIRA::Base

data/lib/jira/resource/webhook.rb

@@ -0,0 +1,40 @@
+module JIRA
+  module Resource
+
+    class WebhookFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Webhook < JIRA::Base
+
+      REST_BASE_PATH = '/rest/webhooks/1.0'
+
+      def self.endpoint_name
+        'webhook'
+      end
+
+      def self.full_url(client)
+        client.options[:context_path] + REST_BASE_PATH
+      end
+
+      def self.collection_path(client, prefix = '/')
+        self.full_url(client) + prefix + self.endpoint_name
+      end
+
+      def self.all(client, options = {})
+        response = client.get(collection_path(client))
+        json = parse_json(response.body)
+        json.map do |attrs|
+          self.new(client, {:attrs => attrs}.merge(options))
+        end
+      end
+
+      # def self.save(options={})
+      # end
+
+      # def self.delete(options={})
+
+      # end
+
+    end
+  end
+end

data/lib/jira/version.rb

@@ -1,3 +1,3 @@
 module JIRA
-  VERSION = "0.1.17"
+  VERSION = "1.0.0"
 end

data/spec/integration/resolution_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Resolution do
+
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+
+    let(:key) { "1" }
+
+    let(:expected_attributes) do
+      {
+        'self' => "http://www.example.com/jira/rest/api/2/resolution/1",
+        'id' => key,
+        'name' => 'Fixed',
+        'description' => 'A fix for this issue is checked into the tree and tested.', 
+        'iconUrl' => 'http://www.example.com/jira/images/icons/status_resolved.gif'
+      }
+    end
+
+    let(:expected_collection_length) { 2 }
+
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a collection GET endpoint"
+    it_should_behave_like "a resource with a singular GET endpoint"
+
+  end
+end

data/spec/integration/webhook.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Webhook do
+
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+
+    let(:key) { "2" }
+
+    let(:expected_attributes) do
+     {"name"=>"from API", "url"=>"http://localhost:3000/webhooks/1", "excludeBody"=>false, "filters"=>{"issue-related-events-section"=>""}, "events"=>[], "enabled"=>true, "self"=>"http://localhost:2990/jira/rest/webhooks/1.0/webhook/2", "lastUpdatedUser"=>"admin", "lastUpdatedDisplayName"=>"admin", "lastUpdated"=>1453306520188}
+    end
+
+    let(:expected_collection_length) { 1 }
+
+    it_should_behave_like "a resource"
+    it_should_behave_like "a resource with a collection GET endpoint"
+    it_should_behave_like "a resource with a singular GET endpoint"
+
+    
+
+    it "returns a collection of components" do
+
+      stub_request(:get, site_url + described_class.singular_path(client, key)).
+        to_return(:status => 200, :body => get_mock_response('webhook/webhook.json'))
+
+
+      
+
+    end
+  end
+end

data/spec/jira/base_spec.rb

@@ -427,9 +427,12 @@ describe JIRA::Base do
   end
 
   it "converts to json" do
-    subject.attrs = {"foo" => "bar","dead" => "beef"}
-
+    subject.attrs = { 'foo' => 'bar', 'dead' => 'beef' }
     expect(subject.to_json).to eq(subject.attrs.to_json)
+
+    h       = { 'key' => subject }
+    h_attrs = { 'key' => subject.attrs }
+    expect(h.to_json).to eq(h_attrs.to_json)
   end
 
   describe "extract attrs from response" do

data/spec/jira/resource/createmeta_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Createmeta do
+  let(:client) {
+    double(
+      'client',
+      :options => {
+        :rest_base_path => '/jira/rest/api/2'
+      }
+    )
+  }
+
+  let(:response) {
+    double(
+      'response',
+      :body => '{"expand":"projects","projects":[{"self":"http://localhost:2029/rest/api/2/project/TST"}]}'
+    )
+  }
+
+  describe 'general' do
+    it 'should query correct url without parameters' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta').and_return(response)
+      JIRA::Resource::Createmeta.all(client)
+    end
+
+    it 'should query correct url with `expand` parameter' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?expand=projects.issuetypes.fields').and_return(response)
+      JIRA::Resource::Createmeta.all(client, :expand => 'projects.issuetypes.fields')
+    end
+
+    it 'should query correct url with `foo` parameter' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?foo=bar').and_return(response)
+      JIRA::Resource::Createmeta.all(client, :foo => 'bar')
+    end
+
+  end
+
+
+  describe 'projectKeys' do
+    it 'should query correct url when only one `projectKeys` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectKeys => 'PROJECT_1',
+      )
+    end
+
+    it 'should query correct url when multiple `projectKeys` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1%2CPROJECT_2').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectKeys => ['PROJECT_1', 'PROJECT_2'],
+      )
+    end
+
+    it 'should query correct url when only one `projectKeys` given as Project' do
+      prj = JIRA::Resource::Project.new(client)
+      allow(prj).to receive(:key).and_return('PRJ')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PRJ').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectKeys => prj,
+      )
+    end
+
+    it 'should query correct url when multiple `projectKeys` given as Project' do
+      prj_1 = JIRA::Resource::Project.new(client)
+      allow(prj_1).to receive(:key).and_return('PRJ_1')
+      prj_2 = JIRA::Resource::Project.new(client)
+      allow(prj_2).to receive(:key).and_return('PRJ_2')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PRJ_2%2CPRJ_1').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectKeys => [prj_2, prj_1],
+      )
+    end
+
+    it 'should query correct url when multiple `projectKeys` given as different types' do
+      prj_5 = JIRA::Resource::Project.new(client)
+      allow(prj_5).to receive(:key).and_return('PRJ_5')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectKeys=PROJECT_1%2CPRJ_5').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectKeys => ['PROJECT_1', prj_5],
+      )
+    end
+  end
+
+
+  describe 'projectIds' do
+    it 'should query correct url when only one `projectIds` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectIds => '10101',
+      )
+    end
+
+    it 'should query correct url when multiple `projectIds` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101%2C20202').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectIds => ['10101', '20202'],
+      )
+    end
+
+    it 'should query correct url when only one `projectIds` given as Project' do
+      prj = JIRA::Resource::Project.new(client)
+      allow(prj).to receive(:id).and_return('30303')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=30303').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectIds => prj,
+      )
+    end
+
+    it 'should query correct url when multiple `projectIds` given as Project' do
+      prj_1 = JIRA::Resource::Project.new(client)
+      allow(prj_1).to receive(:id).and_return('30303')
+      prj_2 = JIRA::Resource::Project.new(client)
+      allow(prj_2).to receive(:id).and_return('50505')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=50505%2C30303').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectIds => [prj_2, prj_1],
+      )
+    end
+
+    it 'should query correct url when multiple `projectIds` given as different types' do
+      prj_5 = JIRA::Resource::Project.new(client)
+      allow(prj_5).to receive(:id).and_return('60606')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?projectIds=10101%2C60606').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :projectIds => ['10101', prj_5],
+      )
+    end
+  end
+
+
+  describe 'issuetypeNames' do
+    it 'should query correct url when only one `issuetypeNames` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeNames => 'Feature',
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeNames` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature%2CBug').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeNames => ['Feature', 'Bug'],
+      )
+    end
+
+    it 'should query correct url when only one `issuetypeNames` given as Issuetype' do
+      issue_type = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type).to receive(:name).and_return('Epic')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Epic').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeNames => issue_type,
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeNames` given as Issuetype' do
+      issue_type_1 = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type_1).to receive(:name).and_return('Epic')
+      issue_type_2 = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type_2).to receive(:name).and_return('Sub-Task')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Sub-Task%2CEpic').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeNames => [issue_type_2, issue_type_1],
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeNames` given as different types' do
+      issue_type = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type).to receive(:name).and_return('Epic')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeNames=Feature%2CEpic').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeNames => ['Feature', issue_type],
+      )
+    end
+  end
+
+
+  describe 'issuetypeIds' do
+    it 'should query correct url when only one `issuetypeIds` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeIds => '10101',
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeIds` given as string' do
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101%2C20202').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeIds => ['10101', '20202'],
+      )
+    end
+
+    it 'should query correct url when only one `issuetypeIds` given as Issuetype' do
+      issue_type = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type).to receive(:id).and_return('30303')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=30303').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeIds => issue_type,
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeIds` given as Issuetype' do
+      issue_type_1 = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type_1).to receive(:id).and_return('30303')
+      issue_type_2 = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type_2).to receive(:id).and_return('50505')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=50505%2C30303').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeIds => [issue_type_2, issue_type_1],
+      )
+    end
+
+    it 'should query correct url when multiple `issuetypeIds` given as different types' do
+      issue_type = JIRA::Resource::Issuetype.new(client)
+      allow(issue_type).to receive(:id).and_return('30303')
+
+      expect(client).to receive(:get).with('/jira/rest/api/2/issue/createmeta?issuetypeIds=10101%2C30303').and_return(response)
+      JIRA::Resource::Createmeta.all(
+        client,
+        :issuetypeIds => ['10101', issue_type],
+      )
+    end
+  end
+end