jiraMule 0.1.1

data/lib/JiraMule.rb

@@ -0,0 +1,7 @@
+require 'JiraMule/version'
+require 'JiraMule/Config'
+require 'JiraMule/jiraUtils'
+require 'JiraMule/gitUtils'
+require 'JiraMule/Tempo'
+
+require 'JiraMule/commands'

data/lib/jiraMule/Config.rb

@@ -0,0 +1,224 @@
+require 'pathname'
+require 'inifile'
+
+module JiraMule
+  class Config
+    #
+    #  internal    transient this-run-only things (also -c options)
+    #  specified   from --configfile
+    #  env         from ENV['JM_CONFIGFILE']
+    #  project     .jiramulerc at project dir
+    #  user        .jiramulerc at $HOME
+    #  system      .jiramulerc at /etc
+    #  defaults    Internal hardcoded defaults
+    #
+    ConfigFile = Struct.new(:kind, :path, :data) do
+      def load()
+        return if kind == :internal
+        return if kind == :defaults
+        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
+        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        self[:data].restore
+      end
+
+      def write()
+        return if kind == :internal
+        return if kind == :defaults
+        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
+        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        self[:data].save
+        path.chmod(0600)
+      end
+    end
+
+    attr :paths
+    attr_reader :projectDir
+
+    CFG_SCOPES=%w{internal specified env project private user system defaults}.map{|i| i.to_sym}.freeze
+    CFG_FILE_NAME = '.jiramulerc'.freeze
+    CFG_DIR_NAME = '.jiramule'.freeze
+    CFG_ALTRC_NAME = '.jiramule/config'.freeze
+    CFG_SYS_NAME = '/etc/jiramulerc'.freeze
+
+    def initialize
+      @paths = []
+      @paths << ConfigFile.new(:internal, nil, IniFile.new())
+      # :specified --configfile FILE goes here. (see load_specific)
+      unless ENV['JM_CONFIGFILE'].nil? then
+        # if it exists, must be a file
+        # if it doesn't exist, that's ok
+        ep = Pathname.new(ENV['JM_CONFIGFILE'])
+        if ep.file? or not ep.exist? then
+          @paths << ConfigFile.new(:env, ep)
+        end
+      end
+      @projectDir = findProjectDir()
+      unless @projectDir.nil? then
+        @paths << ConfigFile.new(:project, @projectDir + CFG_FILE_NAME)
+        fixModes(@projectDir + CFG_DIR_NAME)
+      end
+      @paths << ConfigFile.new(:user, Pathname.new(Dir.home) + CFG_FILE_NAME)
+      fixModes(Pathname.new(Dir.home) + CFG_DIR_NAME)
+      @paths << ConfigFile.new(:system, Pathname.new(CFG_SYS_NAME))
+      @paths << ConfigFile.new(:defaults, nil, IniFile.new())
+
+
+      set('tool.verbose', false, :defaults)
+      set('tool.debug', false, :defaults)
+      set('tool.dry', false, :defaults)
+
+    end
+
+    ## Find the root of this project Directory.
+    #
+    # The Project dir is the directory between PWD and HOME that has one of (in
+    # order of preference):
+    # - .jiramulerc
+    # - .jiramule/config
+    # - .jiramule/
+    # - .git/
+    def findProjectDir()
+      result=nil
+      fileNames=[CFG_FILE_NAME, CFG_ALTRC_NAME]
+      dirNames=[CFG_DIR_NAME]
+      home = Pathname.new(Dir.home)
+      pwd = Pathname.new(Dir.pwd)
+      return nil if home == pwd
+      pwd.dirname.ascend do |i|
+        break unless result.nil?
+        break if i == home
+        fileNames.each do |f|
+          if (i + f).exist? then
+            result = i
+          end
+        end
+        dirNames.each do |f|
+          if (i + f).directory? then
+            result = i
+          end
+        end
+      end
+
+      # If nothing found, do a last ditch try by looking for .git/
+      if result.nil? then
+        pwd.dirname.ascend do |i|
+          break unless result.nil?
+          break if i == home
+          if (i + '.git').directory? then
+            result = i
+          end
+        end
+      end
+
+      # Now if nothing found, assume it will live in pwd.
+      result = Pathname.new(Dir.pwd) if result.nil?
+      return result
+    end
+    private :findProjectDir
+
+    def fixModes(path)
+      if path.directory? then
+        path.chmod(0700)
+      elsif path.file? then
+        path.chmod(0600)
+      end
+    end
+
+    def file_at(name, scope=:project)
+      case scope
+      when :internal
+        root = nil
+      when :specified
+        root = nil
+      when :project
+        root = @projectDir + CFG_DIR_NAME
+      when :user
+        root = Pathname.new(Dir.home) + CFG_DIR_NAME
+      when :system
+        root = nil
+      when :defaults
+        root = nil
+      end
+      return nil if root.nil?
+      root.mkpath
+      root + name
+    end
+
+    ## Load all of the potential config files
+    def load()
+      # - read/write config file in [Project, User, System] (all are optional)
+      @paths.each { |cfg| cfg.load }
+    end
+
+    ## Load specified file into the config stack
+    # This can be called multiple times and each will get loaded into the config
+    def load_specific(file)
+      spc = ConfigFile.new(:specified, Pathname.new(file))
+      spc.load
+      @paths.insert(1, spc)
+    end
+
+    ## Get a value for key, looking at the specificed scopes
+    # key is <section>.<key>
+    def get(key, scope=CFG_SCOPES)
+      scope = [scope] unless scope.kind_of? Array
+      paths = @paths.select{|p| scope.include? p.kind}
+
+      section, ikey = key.split('.')
+      paths.each do |path|
+        if path.data.has_section?(section) then
+          sec = path.data[section]
+          return sec if ikey.nil?
+          if sec.has_key?(ikey) then
+            return sec[ikey]
+          end
+        end
+      end
+      return nil
+    end
+
+    ## Dump out a combined config
+    def dump()
+      # have a fake, merge all into it, then dump it.
+      base = IniFile.new()
+      @paths.reverse.each do |ini|
+        base.merge! ini.data
+      end
+      base.to_s
+    end
+
+    def set(key, value, scope=:project)
+      section, ikey = key.split('.', 2)
+      raise "Invalid key" if section.nil?
+      if not section.nil? and ikey.nil? then
+        # If key isn't dotted, then assume the tool section.
+        ikey = section
+        section = 'tool'
+      end
+
+      paths = @paths.select{|p| scope == p.kind}
+      raise "Unknown scope" if paths.empty?
+      cfg = paths.first
+      data = cfg.data
+      tomod = data[section]
+      tomod[ikey] = value unless value.nil?
+      tomod.delete(ikey) if value.nil?
+      data[section] = tomod
+      cfg.write
+    end
+
+    # key is <section>.<key>
+    def [](key)
+      get(key)
+    end
+
+    # For setting internal, this-run-only values
+    def []=(key, value)
+      set(key, value, :internal)
+    end
+
+  end
+
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/jiraMule/Passwords.rb

@@ -0,0 +1,81 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'date'
+require 'pathname'
+require 'yaml'
+require 'JiraMule/Config'
+require 'JiraMule/http'
+
+module JiraMule
+  class Passwords
+    def initialize(path)
+      path = Pathname.new(path) unless path.kind_of? Pathname
+      @path = path
+      @data = nil
+    end
+    def load()
+      if @path.exist? then
+        @path.chmod(0600)
+        @path.open('rb') do |io|
+          @data = YAML.load(io)
+        end
+      end
+    end
+    def save()
+      @path.dirname.mkpath unless @path.dirname.exist?
+      @path.open('wb') do |io|
+        io << @data.to_yaml
+      end
+      @path.chmod(0600)
+    end
+    def set(host, user, pass)
+      unless @data.kind_of? Hash then
+        @data = {host=>{user=>pass}}
+        return
+      end
+      hd = @data[host]
+      if hd.nil? or not hd.kind_of?(Hash) then
+        @data[host] = {user=>pass}
+        return
+      end
+      @data[host][user] = pass
+      return
+    end
+    def get(host, user)
+      return nil unless @data.kind_of? Hash
+      return nil unless @data.has_key? host
+      return nil unless @data[host].kind_of? Hash
+      return nil unless @data[host].has_key? user
+      return @data[host][user]
+    end
+  end
+
+  class Account
+    def loginInfo
+      host = $cfg['net.url']
+      user = $cfg['user.name']
+      if user.nil? then
+        say_error("No Jira user account found; please login")
+        user = ask("User name: ")
+        $cfg.set('user.name', user, :user)
+      end
+      pff = $cfg.file_at('passwords', :user)
+      pf = Passwords.new(pff)
+      pf.load
+      pws = pf.get(host, user)
+      if pws.nil? then
+        say_error("Couldn't find password for #{user}")
+        pws = ask("Password:  ") { |q| q.echo = "*" }
+        pf.set(host, user, pws)
+        pf.save
+      end
+      {
+        :email => $cfg['user.name'],
+        :password => pws
+      }
+    end
+  end
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/jiraMule/commands/attach.rb

@@ -0,0 +1,69 @@
+require 'tempfile'
+require 'zip'
+require 'JiraMule/jiraUtils'
+
+command :attach do |c|
+  c.syntax = 'jm attach [options] [key] [file...]'
+  c.summary = 'Attach file to an Issue'
+  c.description = 'Attach a file to an Issue'
+  c.example 'Attach a file', %{jm attach BUG-1 foo.log}
+  c.option '-z', '--zip', 'Zip the file[s] first'
+
+  c.action do |args, options|
+    options.default :zip => false
+
+    jira = JiraMule::JiraUtils.new(args, options)
+    key = args.shift
+
+    # keys can be with or without the project prefix.
+    key = jira.expandKeys([key]).first
+
+    jira.printVars(:key=>key, :files=>args)
+
+    begin
+      if options.zip then
+        tf = Tempfile.new('zipped')
+        begin
+          tf.close
+          Zip::File.open(tf.path, Zip::File::CREATE) do |zipfile|
+            args.each do |file|
+              if File.directory?(file) then
+                Dir[File.join(file, '**', '**')].each do |dfile|
+                  zipfile.add(dfile, dfile)
+                end
+              else
+                zipfile.add(file, file)
+              end
+            end
+          end
+
+          jira.attach(key, tf.path, 'application/zip', "#{Time.new.to_i}.zip")
+
+        ensure
+          tf.unlink
+        end
+
+      else
+        args.each do |file|
+          raise "Cannot send directories! #{file}" if File.directory?(file)
+          raise "No such file! #{file}" unless File.exists? file
+          mime=`file -I -b #{file}`
+          # if mime.nil? use ruby built in.
+          jira.attach(key, file, mime)
+        end
+      end
+
+    rescue JiraMule::JiraUtilsException => e
+      puts "= #{e}"
+      puts "= #{e.request}"
+      puts "= #{e.response}"
+      puts "= #{e.response.inspect}"
+      puts "= #{e.response.body}"
+    rescue Exception => e
+      puts e
+    end
+
+  end
+end
+
+#  vim: set sw=2 ts=2 :

data/lib/jiraMule/commands/config.rb

@@ -0,0 +1,68 @@
+require 'JiraMule/Config'
+
+command :config do |c|
+  c.syntax = %{jm config [options] <key> [<new value>]}
+  c.summary = %{Get and set options}
+  c.description = %{
+  You can get, set, or query config options with this command.  All config
+  options are in a 'section.key' format.  There is also a layer of scopes
+  that the keys can be saved in.
+  }
+
+  c.example %{See what the current combined config is}, 'jm config --dump'
+  c.example %{Query a value}, 'jm config jira.project'
+  c.example %{Set a new value; writing to the project config file}, 'jm config jira.project XXXXXXXX'
+  c.example %{Set a new value; writing to the user config file}, 'jm config --user user.name my@email.address'
+  c.example %{Unset a value in a configfile. (lower scopes will become visible if set)},
+    'jm config diff.cmd --unset'
+
+
+  c.option '--system', 'Use only the system config file. (/etc/jiramulerc)'
+  c.option '--user', 'Use only the config file in $HOME (.jiramulerc)'
+  c.option '--project', 'Use only the config file in the project (.jiramulerc)'
+  c.option '--env', 'Use only the config file from $JM_CONFIGFILE'
+  c.option '--specified', 'Use only the config file from the --config option.'
+
+  c.option '--unset', 'Remove key from config file.'
+  c.option '--dump', 'Dump the current combined view of the config'
+
+  c.action do |args, options|
+
+    if options.dump then
+      puts $cfg.dump()
+    elsif args.count == 0 then
+      say_error "Need a config key"
+    elsif args.count == 1 and not options.unset then
+      options.defaults :system=>false, :user=>false, :project=>false,
+        :specified=>false, :env=>false
+
+      # For read, if no scopes, than all. Otherwise just those specified
+      scopes = []
+      scopes << :system if options.system
+      scopes << :user if options.user
+      scopes << :project if options.project
+      scopes << :env if options.env
+      scopes << :specified if options.specified
+      scopes = JiraMule::Config::CFG_SCOPES if scopes.empty?
+
+      say $cfg.get(args[0], scopes)
+    else
+
+      options.defaults :system=>false, :user=>false, :project=>true,
+        :specified=>false, :env=>false
+      # For write, if scope is specified, only write to that scope.
+      scope = :project
+      scope = :system if options.system
+      scope = :user if options.user
+      scope = :project if options.project
+      scope = :env if options.env
+      scope = :specified if options.specified
+
+      args[1] = nil if options.unset
+      $cfg.set(args[0], args[1], scope)
+    end
+  end
+
+end
+
+#  vim: set ai et sw=2 ts=2 :

data/lib/jiraMule/commands/goto.rb

@@ -0,0 +1,166 @@
+require 'vine'
+require 'pp'
+
+command :goto do |c|
+  c.syntax = 'jm goto [options] [status] [keys]'
+  c.summary = 'Move issue to a status; making multiple transitions if needed'
+  c.description = %{
+Named for the bad command that sometimes there is nothing better to use.
+
+Your issue has a status X, and you need it in Y, and there are multiple steps from
+X to Y.  Why would you do something a computer can do better?  Hence goto.
+
+The down side is there is no good way to automatically get mutli-step transitions.
+So these need to be added to your config.
+}
+  c.example 'Move BUG-4 into the In Progress state.', %{jm goto 'In Progress' BUG-4}
+
+  c.action do |args, options|
+    jira = JiraMule::JiraUtils.new(args, options)
+    to = args.shift
+
+    # keys can be with or without the project prefix.
+    keys = jira.expandKeys(args)
+    jira.printVars(:to=>to, :keys=>keys)
+    raise "No keys to transition" if keys.empty?
+
+    keys.each do |key|
+      # First see if we can just go there.
+      trans = jira.transitionsFor(key)
+      direct = trans.select {|item| jira.fuzzyMatchStatus(item, to) }
+      if not direct.empty? then
+        # We can just go right there.
+        id = direct.first[:id]
+        jira.transition(key, id)
+        # TODO: deal with required field.
+      else
+
+        # where we are.
+        #query = "assignee = #{jira.username} AND project = #{jira.project} AND "
+        query = "key = #{key}"
+        issues = jira.getIssues(query, ["status"])
+        #type = issues.first.access('fields.issuetype.name')
+        at = issues.first.access('fields.status.name')
+
+        if at == to then
+          say "All ready at '#{to}'"
+          exit
+        end
+
+        # Get the
+        transMap = jira.getPath(at, to)
+        if transMap.nil? or transMap.empty? then
+          say "No transision map found between '#{at}' and '#{to}'"
+          y=ask("Would you like to build one? [Yn]")
+          exit if y =~ /^n/i
+          say_warning "This will make changes to the issue as the map is built."
+
+          start_at = at
+          transMap = []
+          loop do
+            issues = jira.getIssues("key = #{key}", ["status"])
+            at = issues.first.access('fields.status.name')
+            break if at == to
+            trans = jira.transitionsFor(key)
+            if trans.length == 1 then
+              id = trans.first[:id]
+              say "Taking single exit: '#{trans.first[:name]}' (#{trans.first[:id]})"
+              transMap << trans.first[:name]
+              jira.transition(key, id)
+            else
+              choose do |menu|
+                menu.prompt = "Follow which transition?"
+                trans.each do |tr|
+                  menu.choice(tr[:name]) do
+                    say "Transitioning #{key} to '#{tr[:name]}' (#{tr[:id]})"
+                    transMap << tr[:name]
+                    jira.transition(key, tr[:id])
+                  end
+                end
+              end
+            end
+          end
+          say "Found the end."
+          say " '#{start_at}' to '#{to}' via: #{transMap.join(', ')}"
+          y=ask("Record this? [Yn]")
+          unless y =~ /^n/ then
+            cfgkey = "goto-maps.#{start_at.gsub(/\W+/,'_')}-#{to.gsub(/\W+/,'_')}"
+            $cfg.set(cfgkey, transMap.join(', '), :project)
+          end
+        else
+
+          # Now move thru
+          jira.printVars(:key=>key, :tm=>transMap)
+          transMap.each do |step|
+            trans = jira.transitionsFor(key)
+            direct = trans.select {|item| jira.fuzzyMatchStatus(item, step) }
+            raise "Broken transition step on #{key} to #{step}" if direct.empty?
+            id = direct.first[:id]
+            jira.transition(key, id)
+            # TODO: deal with required field.
+          end
+        end
+
+      end
+    end
+  end
+end
+alias_command :move, :goto
+
+command :mapGoto do |c|
+  c.syntax = 'jm mapGoto [options]'
+  c.summary = 'Attempt to build a goto map'
+  c.option '--dot', %{Output a dot graph}
+  c.description = %{
+  This command is incomplete.  The goal here is to auto-build the transision maps
+  for multi-step gotos.
+
+  Right now it is just dumping stuff.
+
+  }
+  c.action do |args, options|
+    options.defaults :dot => true
+    jira = JiraMule::JiraUtils.new(args, options)
+
+    # Get all of the states that issues can be in.
+    # Try to find an actual issue in each state, and load the next transitions from
+    # it.
+    #
+    types = jira.statusesFor(jira.project)
+
+    # There is only one workflow for all types it seems.
+
+    # We just need the names, so we'll merge down.
+    statusNames = {}
+
+    types.each do |type|
+      statuses = type[:statuses]
+      next if statuses.nil?
+      next if statuses.empty?
+      statuses.each {|status| statusNames[ status[:name] ] = 1}
+    end
+
+    puts "digraph #{jira.project} {"
+    statusNames.each_key do |status|
+      #puts "    #{status}"
+      query = %{project = #{jira.project} AND status = "#{status}"}
+      issues = jira.getIssues(query, ["key"])
+      if issues.empty? then
+        #?
+        puts %{/* Cannot find transitions for #{status} */}
+      else
+        key = issues.first[:key]
+        # get transisitons.
+        trans = jira.transitionsFor(key)
+        trans.each do |tr|
+          puts %{  "#{status}" -> "#{tr[:to][:name]}" [label="#{tr[:name]}"]} # [#{tr[:id]}]"]}
+        end
+      end
+    end
+    puts "}"
+
+  end
+end
+
+#  vim: set sw=2 ts=2 :
+