jiralicious 0.1.0 → 0.2.0

data/lib/jiralicious/issue/comment.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Jiralicious
+  class Issue
+    class Comment < Jiralicious::Base
+
+      attr_accessor :jira_key
+
+      def initialize(decoded_json = nil, default = nil, &blk)
+        if (decoded_json != nil)
+          properties_from_hash(decoded_json)
+          super(decoded_json)
+          parse!(decoded_json)
+        end
+      end
+
+      class << self
+        def find_by_key(key, options = {})
+          response = fetch({:parent => parent_name, :parent_key => key})
+          a = new(response)
+          a.jira_key = key
+          return a
+        end
+
+        def find_by_key_and_id(key, id, options = {})
+          response = fetch({:parent => parent_name, :parent_key => key, :key => id})
+          a = new(response)
+          a.jira_key = key
+          return a
+        end
+
+        def add(comment, key)
+          fetch({:method => :post, :body => comment, :parent => parent_name, :parent_key => key})
+        end
+
+        def edit(comment, key, id)
+          fetch({:method => :put, :key => id, :body => comment, :parent => parent_name, :parent_key => key})
+        end
+
+        def remove(key, id)
+          fetch({:method => :delete, :body_to_params => true, :key => id, :parent => parent_name, :parent_key => key})
+
+        end
+      end
+
+      def find_by_id(id, options = {})
+        self.class.find_by_key_and_id(@jira_key, id)
+      end
+
+      def add(comment)
+        self.class.add(comment, @jira_key)
+      end
+
+      def edit(comment)
+        self.class.edit(comment, @jira_key, self.id)
+      end
+
+      def remove(id = self.id)
+        self.class.remove(@jira_key, id)
+      end
+    end
+  end
+end

data/lib/jiralicious/issue/fields.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+module Jiralicious
+  class Issue
+    class Fields
+      attr_accessor :fields_update
+      attr_accessor :fields_current
+
+      def initialize(fc = nil)
+        @fields_current = (fc == nil) ? Hash.new : fc
+        @fields_update = Hash.new
+      end
+
+      def count
+        return @fields_update.count
+      end
+
+      def length
+        return @fields_update.length
+      end
+
+      def add_comment(comment)
+        if !(@fields_update['comment'].type == Array)
+          @fields_update['comment'] = Array.new
+        end
+        @fields_update['comment'].push({"add" => {"body" => comment}})
+      end
+
+      def append_s(field, value)
+        if (@fields_update[field] == nil)
+          @fields_update[field] = @fields_current[field] unless @fields_current.nil?
+          @fields_update[field] ||= ""
+        end
+        @fields_update[field] += " " + value.to_s
+      end
+
+      def append_a(field, value)
+        @fields_update[field] = @fields_current[field] if (@fields_update[field] == nil)
+        @fields_update[field] = Array.new if !(@fields_update[field].is_a? Array)
+        if value.is_a? String
+          @fields_update[field].push(value)
+        else
+          @fields_update[field] = @fields_update[field].concat(value)
+        end
+      end
+
+      def append_h(field, hash)
+        @fields_update[field] = @fields_current[field] if (@fields_update[field] == nil)
+        @fields_update[field] = Hash.new if !(@fields_update[field].is_a? Hash)
+        @fields_update[field].merge!(hash)
+      end
+
+      def set(field, value)
+        @fields_update[field] = value
+      end
+
+      def set_name(field, value)
+        @fields_update[field] = {"name" => value}
+      end
+
+      def set_id(field, value)
+        @fields_update[field] = {"id" => value}
+      end
+
+      def set_current(fc)
+        @fields_current = fc if fc.type == Hash
+      end
+
+      def current
+        return @fields_current
+      end
+
+      def updated
+        return @fields_update
+      end
+
+      def format_for_update
+        up = Hash.new
+        @fields_update.each do |k, v|
+          if k == "comment"
+            up[k] = v
+          else
+            up[k] = [{"set" => v}]
+          end
+        end
+        return {"update" => up}
+      end
+
+      def format_for_create
+        return {"fields" => @fields_update}
+      end
+    end
+  end
+end

data/lib/jiralicious/issue/transitions.rb

@@ -0,0 +1,92 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+module Jiralicious
+  class Issue
+    class Transitions < Jiralicious::Base
+
+      attr_accessor :meta
+
+      def initialize(decoded_json, default = nil, &blk)
+        @loaded = false
+        @meta = nil
+        if decoded_json.is_a? Hash
+          properties_from_hash(decoded_json)
+          super(decoded_json)
+          parse!(decoded_json)
+          @loaded = true
+        else
+          self.class.property :jira_key
+          self.jira_key = default
+          decoded_json.each do |list|
+            self.class.property :"id_#{list['id']}"
+            self.merge!({"id_#{list['id']}" => self.class.new(list)})
+          end
+        end
+      end
+
+      class << self
+
+        def find(key, options = {})
+          response = fetch({:parent => parent_name, :parent_key => key})
+          response.parsed_response['transitions'].each do |t|
+            t['jira_key'] = key
+          end
+          a = new(response.parsed_response['transitions'], key)
+          return a
+        end
+
+        def find_by_key_and_id(key, id, options = {})
+          response = fetch({:key => id, :parent => parent_name, :parent_key => key})
+          response.parsed_response['jira_key'] = key
+          a = new(response.parsed_response['transitions'])
+          return a
+        end
+
+        def go(key, id, options = {})
+          transition = {"transition" => {"id" => id}}
+          if options[:comment].is_a? String
+            transition.merge!({"update" => {"comment" => [{"add" => {"body" => options[:comment].to_s}}]}})
+          elsif options[:comment].is_a? Jiralicious::Issue::Fields
+            transition.merge!(options[:comment].format_for_update)
+          elsif options[:comment].is_a? Hash
+            transition.merge!({"update" => options[:comment]})
+          end
+          if options[:fields].is_a? Jiralicious::Issue::Fields
+            transition.merge!(options[:fields].format_for_create)
+          elsif options[:fields].is_a? Hash
+            transition.merge!({"fields" => options[:fields]})
+          end
+          fetch({:method => :post, :parent => parent_name, :parent_key => key, :body => transition})
+        end
+
+        def meta(key, id, options = {})
+          response = fetch({:method => :get, :parent => parent_name, :parent_key => key, :body_to_params => true,
+              :body => {"transitionId" => id, "expand" => "transitions.fields"}})
+          response.parsed_response['transitions'].each do |t|
+            t['jira_key'] = key
+          end
+          a = (options[:return].nil?) ?  new(response.parsed_response['transitions'], key) : response
+          return a
+        end
+
+        alias :find_all :find
+      end
+
+      def all
+        self.class.all(self.jira_key) if self.jira_key
+      end
+
+      def go(options = {})
+        self.class.go(self.jira_key, self.id, options)
+      end
+
+      def meta
+        if @meta.nil?
+          l = self.class.meta(self.jira_key, self.id, {:return => true})
+          @meta = Field.new(l.parsed_response['transitions'].first)
+        end
+        @meta
+      end
+    end
+  end
+end

data/lib/jiralicious/issue/watchers.rb

@@ -0,0 +1,47 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+module Jiralicious
+  class Issue
+    class Watchers < Jiralicious::Base
+
+      attr_accessor :jira_key
+
+      def initialize(decoded_json = nil, default = nil, &blk)
+        if (decoded_json != nil)
+          properties_from_hash(decoded_json)
+          super(decoded_json)
+          parse!(decoded_json)
+        end
+      end
+
+      class << self
+        def find_by_key(key)
+          response = fetch({:parent => parent_name, :parent_key => key})
+          a = new(response)
+          a.jira_key = key
+          return a
+        end
+
+        def add(name, key)
+          fetch({:method => :post, :body => name, :body_override => true, :parent => parent_name, :parent_key => key})
+        end
+
+        def remove(name, key)
+          fetch({:method => :delete, :body_to_params => true, :body => {:username => name}, :parent => parent_name, :parent_key => key})
+        end
+      end
+
+      def find
+        self.class.find_by_key(@jira_key)
+      end
+
+      def add(name)
+        self.class.add(name, @jira_key)
+      end
+
+      def remove(name)
+        self.class.remove(name, @jira_key)
+      end
+    end
+  end
+end

data/lib/jiralicious/parsers/field_parser.rb

@@ -34,8 +34,8 @@ module Jiralicious
 
       def normalize(name)
         name.gsub(/(\w+)([A-Z].*)/, '\1_\2').
-              gsub(/\W/, "_").
-              downcase
+          gsub(/\W/, "_").
+          downcase
       end
 
       def mashify(data)

data/lib/jiralicious/project.rb

@@ -0,0 +1,44 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+module Jiralicious
+  class Project < Jiralicious::Base
+    
+    attr_accessor :issues
+
+    ### Initialization ###
+    def initialize(decoded_json, default = nil, &blk)
+      @loaded = false
+      if decoded_json.is_a? Hash
+        properties_from_hash(decoded_json)
+        super(decoded_json)
+        parse!(decoded_json)
+        @loaded = true
+      else
+        decoded_json.each do |list|
+          self.class.property :"#{list['key']}"
+          self.merge!({list['key'] => self.class.find(list['key'])})
+        end
+      end
+    end
+
+    class << self
+      def issue_list(key)
+        response = Jiralicious.search("project=#{key}", {:fields => ["id", "key"]})
+        i_out = Issue.new
+        response.issues_raw.each do |issue|
+          i_out.class.property :"#{issue["key"].gsub("-", "_")}"
+          t = Issue.new
+          i_out[issue["key"].gsub("-", "_")] = t.load(issue, true)
+        end
+        i_out
+      end
+    end
+
+    def issues
+      if @issues == nil
+        @issues = self.class.issue_list(self.key)
+      end
+      return @issues
+    end
+  end
+end

data/lib/jiralicious/search.rb

@@ -3,11 +3,14 @@ module Jiralicious
   def search(jql, options = {})
     options[:start_at] ||= 0
     options[:max_results] ||= 50
+    options[:fields] = [options[:fields]] if options[:fields].is_a? String
+    options[:fields] ||= ["*navigable"]
 
     request_body = {
       :jql => jql,
       :startAt => options[:start_at],
-      :maxResults => options[:max_results]
+      :maxResults => options[:max_results],
+      :fields => options[:fields]
     }.to_json
 
     handler = Proc.new do |response|

data/lib/jiralicious/search_result.rb

@@ -13,5 +13,9 @@ module Jiralicious
         Jiralicious::Issue.find(issue["key"])
       end
     end
+
+    def issues_raw
+      @issues
+    end
   end
 end

data/lib/jiralicious/version.rb

@@ -1,3 +1,3 @@
 module Jiralicious
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/basic_session_spec.rb

@@ -2,10 +2,10 @@
 require "spec_helper"
 
 describe  "performing a request" do
-    before :each do
-      FakeWeb.register_uri(:get,
-                           Jiralicious.uri + '/ok',
-                           :status => "200")
+  before :each do
+    FakeWeb.register_uri(:get,
+      Jiralicious.uri + '/ok',
+      :status => "200")
   end
 
   let(:session) { Jiralicious::BasicSession.new }

data/spec/comment_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Jiralicious, "search" do
+
+  before :each do
+    Jiralicious.configure do |config|
+      config.username = "jstewart"
+      config.password = "topsecret"
+      config.uri = "http://localhost"
+      config.auth_type = :cookie
+      config.api_version = "latest"
+    end
+
+    FakeWeb.register_uri(:get,
+      "#{Jiralicious.rest_path}/issue/EX-1/comment/",
+      :status => "200",
+      :body => comment_json)
+    FakeWeb.register_uri(:post,
+      "#{Jiralicious.rest_path}/issue/EX-1/comment/",
+      :status => "201",
+      :body => comment_json)
+    FakeWeb.register_uri(:get,
+      "#{Jiralicious.rest_path}/issue/EX-1/comment/10000",
+      :status => "200",
+      :body => comment_single_json)
+    FakeWeb.register_uri(:put,
+      "#{Jiralicious.rest_path}/issue/EX-1/comment/10000",
+      :status => "200",
+      :body => comment_single_json)
+    FakeWeb.register_uri(:delete,
+      "#{Jiralicious.rest_path}/issue/EX-1/comment/10000",
+      :status => "204")
+  end
+
+  it "finds by isusse key" do
+    comments = Jiralicious::Issue::Comment.find_by_key("EX-1")
+    comments.should be_instance_of(Jiralicious::Issue::Comment)
+    comments.comments.count.should == 1
+    comments.comments[0]['id'].should == "10000"
+  end
+
+  it "finds by isusse key and comment id" do
+    comments = Jiralicious::Issue::Comment.find_by_key_and_id("EX-1", "10000")
+    comments.should be_instance_of(Jiralicious::Issue::Comment)
+    comments.id.should == "10000"
+  end
+
+  it "posts a new comment" do
+    response = Jiralicious::Issue::Comment.add({:body => "this is a test"}, "EX-1")
+    response.class.should == HTTParty::Response
+    response.parsed_response['comments'][0]['id'].to_f.should > 0
+  end
+
+  it "updates a comment" do
+    response = Jiralicious::Issue::Comment.edit("this is a test", "EX-1", "10000")
+  end
+
+  it "deletes a comment" do
+    comment = Jiralicious::Issue::Comment.find_by_key_and_id("EX-1", "10000")
+    response = comment.remove
+    response.response.class.should == Net::HTTPNoContent
+  end
+end