jiraMule 0.1.1

data/lib/jiraMule/http.rb

@@ -0,0 +1,147 @@
+require 'uri'
+require 'net/http'
+require 'json'
+
+module JiraMule
+  module Http
+
+    def json_opts
+      return @json_opts unless not defined?(@json_opts) or @json_opts.nil?
+      @json_opts = {
+        :allow_nan => true,
+        :symbolize_names => true,
+        :create_additions => false
+      }
+    end
+
+    def curldebug(request)
+      if $cfg['tool.curldebug'] then
+        a = []
+        a << %{curl -s }
+        if request.key?('Authorization') then
+          a << %{-H 'Authorization: #{request['Authorization']}'}
+        end
+        a << %{-H 'User-Agent: #{request['User-Agent']}'}
+        a << %{-H 'Content-Type: #{request.content_type}'}
+        a << %{-X #{request.method}}
+        a << %{'#{request.uri.to_s}'}
+        a << %{-d '#{request.body}'} unless request.body.nil?
+        puts a.join(' ')
+      end
+    end
+
+    def http
+      uri = URI($cfg['net.url'])
+      if not defined?(@http) or @http.nil? then
+        @http = Net::HTTP.new(uri.host, uri.port)
+        @http.use_ssl = true
+        @http.start
+      end
+      @http
+    end
+    def http_reset
+      @http = nil
+    end
+
+    def set_def_headers(request)
+      request.content_type = 'application/json'
+      request.basic_auth(username(), password())
+      request['User-Agent'] = "JiraMule/#{JiraMule::VERSION}"
+      request
+    end
+
+    def isJSON(data)
+      begin
+        return true, JSON.parse(data, json_opts)
+      rescue
+        return false, data
+      end
+    end
+
+    def showHttpError(request, response)
+      if $cfg['tool.debug'] then
+        puts "Sent #{request.method} #{request.uri.to_s}"
+        request.each_capitalized{|k,v| puts "> #{k}: #{v}"}
+        if request.body.nil? then
+        else
+          puts " > #{request.body[0..156]}"
+        end
+        puts "Got #{response.code} #{response.message}"
+        response.each_capitalized{|k,v| puts "< #{k}: #{v}"}
+      end
+      isj, jsn = isJSON(response.body)
+      resp = "Request Failed: #{response.code}: "
+      if isj then
+        if $cfg['tool.fullerror'] then
+          resp << JSON.pretty_generate(jsn)
+        else
+          resp << "[#{jsn[:statusCode]}] " if jsn.has_key? :statusCode
+          resp << jsn[:message] if jsn.has_key? :message
+        end
+      else
+        resp << jsn
+      end
+      say_error resp
+    end
+
+    def workit(request, &block)
+      curldebug(request)
+      if block_given? then
+        return yield request, http()
+      else
+        response = http().request(request)
+        case response
+        when Net::HTTPSuccess
+          return {} if response.body.nil?
+          begin
+            return JSON.parse(response.body, json_opts)
+          rescue
+            return response.body
+          end
+        else
+          showHttpError(request, response)
+          raise response
+        end
+      end
+    end
+
+    def get(path='', query=nil, &block)
+      uri = endPoint(path)
+      uri.query = URI.encode_www_form(query) unless query.nil?
+      req = Net::HTTP::Get.new(uri)
+      workit(set_def_headers(req), &block)
+    end
+
+    def post(path='', body={}, &block)
+      uri = endPoint(path)
+      req = Net::HTTP::Post.new(uri)
+      set_def_headers(req)
+      req.body = JSON.generate(body)
+      workit(req, &block)
+    end
+
+    def postf(path='', form={}, &block)
+      uri = endPoint(path)
+      req = Net::HTTP::Post.new(uri)
+      set_def_headers(req)
+      req.content_type = 'application/x-www-form-urlencoded; charset=utf-8'
+      req.form_data = form
+      workit(req, &block)
+    end
+
+    def put(path='', body={}, &block)
+      uri = endPoint(path)
+      req = Net::HTTP::Put.new(uri)
+      set_def_headers(req)
+      req.body = JSON.generate(body)
+      workit(req, &block)
+    end
+
+    def delete(path='', &block)
+      uri = endPoint(path)
+      workit(set_def_headers(Net::HTTP::Delete.new(uri)), &block)
+    end
+
+  end
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/jiraMule/jiraUtils.rb

@@ -0,0 +1,288 @@
+require 'uri'
+require 'net/http'
+require 'net/http/post/multipart'
+require 'json'
+require 'date'
+require 'pp'
+require 'mime/types'
+require 'JiraMule/Config'
+require 'JiraMule/Passwords'
+require 'JiraMule/http'
+require 'JiraMule/verbosing'
+
+module JiraMule
+    class JiraUtilsException < Exception
+        attr_accessor :request, :response
+    end
+
+    class JiraUtils
+        include Verbose
+        include Http
+
+        # TODO: all params are now optional.
+        def initialize(args=nil, options=nil, cfg=nil)
+            acc = Account.new
+            up = acc.loginInfo
+            @username = up[:email]
+            @password = up[:password]
+        end
+        attr_reader :username, :password
+
+        def jiraEndPoint
+            endPoint()
+        end
+
+        def endPoint(path='')
+          URI($cfg['net.url'] + '/rest/api/2/' + path.to_s)
+        end
+
+        def project
+            return @project unless @project.nil?
+            @project = $cfg['jira.project']
+            return @project
+        end
+
+        ##
+        # Given an array of issues keys that may or may not have the project prefixed
+        # Return an array with the project prefixed.
+        #
+        # So on project APP, from %w{1 56 BUG-78} you get %w{APP-1 APP-56 BUG-78}
+        def expandKeys(keys)
+            return keys.map do |k|
+                k.match(/([a-zA-Z]+-)?(\d+)/) do |m|
+                    if m[1].nil? then
+                        "#{project}-#{m[2]}"
+                    else
+                        m[0]
+                    end
+                end
+            end.compact
+        end
+
+        ##
+        # Allow for some sloppy matching.
+        # +transition+:: The transition hash to match against
+        # +couldBe+:: The string from a human to match for
+        def fuzzyMatchStatus(transition, couldBe)
+            return transition[:id] == couldBe if couldBe =~ /^\d+$/
+
+            # Build a regexp for all sorts of variations.
+
+            # Replace whitespace with a rex for dashes, whitespace, or nospace.
+            cb = couldBe.gsub(/\s+/, '[-_\s]*')
+
+            matcher = Regexp.new(cb, Regexp::IGNORECASE)
+            debug "Fuzzing: #{transition[:name]} =~ #{cb}"
+            return transition[:name] =~ matcher
+        end
+
+        ##
+        # Lookup a path from one state to another in a map
+        # +at+:: The starting state
+        # +to+:: The stopping state
+        def getPath(at, to)
+            verbose "Getting path from '#{at}' to '#{to}'"
+
+            # [goto-map]
+            # at-to: each, step, to, end
+            tr = $cfg["goto-maps.#{at.gsub(/\W+/,'_')}-#{to.gsub(/\W+/,'_')}"]
+            (tr or "").split(/,/).map{|p| p.strip}
+        end
+
+        ##
+        # Run a JQL query and get issues with the selected fields
+        def getIssues(query, fields=[ 'key', 'summary' ])
+            verbose "Get keys: #{query}"
+            data = post('search', {:jql=>query, :fields=>fields})
+            data[:issues]
+        end
+
+        ##
+        # make sure #user is an actual user in the system.
+        def checkUser(user, keyMatch=true)
+            verbose "Get user: #{user}"
+            users = get("user/search", {:username=>user})
+            return [] if users.empty?
+            userKeys = users.map{|i| i[:key]}
+            return [user] if keyMatch and userKeys.index(user)
+            return userKeys
+        end
+
+        ##
+        # Create a new version for release.
+        # TODO: test this.
+        def createVersion(project, version)
+            verbose "Creating #{request.body}"
+            unless $cfg['tool.dry'] then
+                data = post('version', {
+                    'name' => version,
+                    'archived' => false,
+                    'released' => true,
+                    'releaseDate' => DateTime.now.strftime('%Y-%m-%d'),
+                    'project' => project,
+                })
+                unless data[:released] then
+                    # Sometimes setting released on create doesn't work.
+                    # So modify it.
+                    put("version/#{data[:id]}", {:released=>true})
+                end
+            end
+        end
+
+        ##
+        # Create a new issue
+        # +type+:: The type of issue this is
+        # +summary+:: Short title text
+        # +description+:: Full details.
+        def createIssue(type, summary, description)
+            verbose "Creating #{type} issue for #{summary}"
+            unless $cfg['tool.dry'] then
+                post('issue', {
+                    :fields=>{
+                        :issuetype=>{:name=>type},
+                        :project=>{:key=>project},
+                        :summary=>summary,
+                        :description=>description,
+                        :labels=>['auto-imported'],
+                    }
+                })
+            else
+                {:key=>'_'}
+            end
+        end
+
+        ##
+        # Check this issue type in current project
+        def checkIssueType(type='bug')
+            rt = Regexp.new(type.gsub(/\s+/, '[-_\s]*'), Regexp::IGNORECASE)
+            cmeta = get('issue/createmeta')
+            prj = cmeta[:projects].select{|p| p[:key] == project}.first
+            prj[:issuetypes].select{|it| it[:name] =~ rt}
+        end
+
+        # Update fields on a key
+        # +keys+:: Array of keys to update
+        # +update+:: Hash of fields to update. (see https://docs.atlassian.com/jira/REST/6.4.7/#d2e261)
+        def updateKeys(keys, update)
+            keys = [keys] unless keys.kind_of? Array
+            keys.each do |key|
+                verbose "Updating key #{key} with #{update}"
+                put("issue/#{key}", {:update=>update}) unless $cfg['tool.dry']
+            end
+        end
+
+        # Transition key into a new status
+        # +key+:: The key to transition
+        # +toID+:: The ID of the transition to make
+        def transition(key, toID)
+            verbose "Transitioning key #{key} to #{toID}"
+            post('issue/' + key + '/transitions', {:transition=>{:id=>toID}}) unless $cfg['tool.dry']
+        end
+
+        # Get the transitions that a key can move to.
+        # +key+:: The issue
+        def transitionsFor(key)
+            verbose "Fetching transitions for #{key}"
+            data = get('issue/' + key + '/transitions')
+            data[:transitions]
+        end
+
+        # Get the status for a project
+        # +project+:: The project to fetch status from
+        def statusesFor(project)
+            verbose "Fetching statuses for #{project}"
+            get('project/' + project + '/statuses')
+        end
+
+        # Assign issues to a user
+        # +keys+:: Array of keys to assign
+        # +to+:: The user to assign to (or -1 for default)
+        def assignTo(keys, to="-1")
+            keys = [keys] unless keys.kind_of? Array
+            r=[]
+            keys.each do |key|
+                verbose "Assigning #{key} to #{to}"
+                r << put("issue/#{key}/assignee", {:name=>to}) unless $cfg['tool.dry']
+            end
+            r
+        end
+
+        # Log a work entry to Jira
+        # +key+:: The issue to log work on
+        # +timespend+:: The time spent in seconds
+        # +notes+:: Any notes to add.
+        # +on+:: When this work happened. (default is now)
+        def logWork(key, timespent, notes="", on=nil)
+            body = {
+                :comment => notes,
+                :timeSpentSeconds => timespent,
+            }
+            body[:started] = on.to_time.strftime('%FT%T.%3N%z') unless on.nil?
+
+            verbose "Logging #{timespent} of work to #{key} with note \"#{notes}\""
+            post('issue/' + key + '/worklog', body) unless $cfg['tool.dry']
+        end
+
+        # Get the work log for an Issue
+        # +key+:: The issue to retrive the work log for
+        def workLogs(key)
+            verbose "Fetching work logs for #{key}"
+            get('issue/' + key + '/worklog')
+        end
+
+        ## Get links on an issue
+        # +key+:: The issue to retrive the remote links for
+        def remote_links(key)
+            get("issue/#{key}/remotelink")
+        end
+
+        ## Attach a URL to an issue
+        # +key+:: The issue to set a remote link on
+        # +url+:: The URL to link to
+        # +title+:: The title of the link
+        def linkTo(key, url, title)
+            verbose "Attaching [#{title}](#{url}) to #{key}"
+            unless $cfg['tool.dry'] then
+                post("issue/#{key}/remotelink", {
+                    :object=>{
+                        :url=>url,
+                        :title=>title,
+                    }
+                })
+            # XXX Lookup favicon for site and include?
+            end
+        end
+
+        def linkKeys(key, toKey, relation='related to')
+        end
+
+        # Attach a file to an issue.
+        # +key+:: The issue to attach to
+        # +file+:: Full path to the file to be attached
+        # +type+:: MIME type of the fiel data
+        # +name+:: Aternate name of file being uploaded
+        def attach(key, file, type=nil, name=nil)
+            file = Pathname.new(file) unless file.kind_of? Pathname
+
+            name = file.basename if name.nil?
+
+            if type.nil? then
+                mime = MIME::Types.type_for(file.to_s)[0] || MIME::Types["application/octet-stream"][0]
+                type = mime.simplified
+            end
+
+            verbose "Going to upload #{file} [#{type}] to #{key}"
+
+            uri = endPoint('issue/' + key + '/attachments')
+            fuio = UploadIO.new(file.open, type, name)
+            req = Net::HTTP::Post::Multipart.new(uri, 'file'=> fuio )
+            req.basic_auth(username(), password())
+            req['User-Agent'] = "JiraMule/#{JiraMule::VERSION}"
+            #set_def_headers(req)
+            req['X-Atlassian-Token'] = 'nocheck'
+            workit(req) unless $cfg['tool.dry']
+        end
+
+    end
+end
+#  vim: set sw=4 ts=4 :

data/lib/jiraMule/verbosing.rb

@@ -0,0 +1,28 @@
+require 'pp'
+
+module JiraMule
+  module Verbose
+
+    def verbose(msg)
+      if $cfg['tool.verbose'] then
+        say "\033[1m=#\033[0m #{msg}"
+      end
+    end
+
+    def debug(msg)
+      if $cfg['tool.debug'] then
+        say "\033[1m=#\033[0m #{msg}"
+      end
+    end
+
+    def printVars(map)
+      $stdout.print("\033[1m=:\033[0m ")
+      map.each {|k,v|
+        $stdout.print("\033[1m#{k}:\033[0m #{v}  ")
+      }
+      $stdout.print("\n")
+    end
+
+  end
+end
+#  vim: set ai et sw=2 ts=2 :

data/lib/jiraMule/version.rb

@@ -0,0 +1,3 @@
+module JiraMule
+  VERSION = '0.1.1'
+end