RubyGems - ruby-bugzilla - Versions diffs - 0.4.0 → 0.4.1 - Mend

ruby-bugzilla 0.4.0 → 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

data/bin/bzconsole CHANGED Viewed

@@ -890,7 +890,7 @@ begin
     opt.on('-t', '--timeout=SEC', 'Set XMLRPC timeout in a second.') {|v| opts[:timeout] = v.to_i}
     opt.on('-h', '--help', 'show this message') {|x| opts[:help] = true}
-    cmds = BzConsole.constants.sort.map {|x| (k = eval("BzConsole::#{x}")).class == Class && x != :CommandTemplate ? x.downcase : nil}.compact
+    cmds = BzConsole.constants.sort.map {|x| (k = eval("BzConsole::#{x}")).class == Class && x != :CommandTemplate ? x.downcase.to_sym : nil}.compact
     subargv = opt.order(ARGV);
@@ -899,7 +899,7 @@ begin
     if subargv.length > 0 then
       n = cmds.index(command.to_sym)
       unless n.nil? then
-        opts[:instance] = eval("BzConsole::#{cmds[n].capitalize}.new(Bugzilla::Plugin::Template.new)")
+        opts[:instance] = eval("BzConsole::#{cmds[n].to_s.capitalize}.new(Bugzilla::Plugin::Template.new)")
         subargv = opts[:instance].parse(opt, subargv[1..-1], opts[:command])
       else
         STDERR.printf("E: Unknown command: %s\n", subargv[0])

data/lib/bugzilla/version.rb CHANGED Viewed

@@ -28,6 +28,6 @@
 module Bugzilla
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end # module Bugzilla

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-bugzilla
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-08-07 00:00:00.000000000 Z
+date: 2012-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -97,7 +97,6 @@ email:
 - akira@tagoh.org
 executables:
 - bzconsole
-- bzconsole~
 extensions: []
 extra_rdoc_files: []
 files:
@@ -121,7 +120,6 @@ files:
 - README.rdoc
 - COPYING
 - bin/bzconsole
-- bin/bzconsole~
 homepage: http://github.com/tagoh/ruby-bugzilla
 licenses: []
 post_install_message:

data/bin/bzconsole~ DELETED Viewed

@@ -1,836 +0,0 @@
-#! /usr/bin/env ruby
-# bzconsole.rb
-# Copyright (C) 2010-2012 Red Hat, Inc.
-#
-# Authors:
-#   Akira TAGOH  <tagoh@redhat.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the
-# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-# Boston, MA 02111-1307, USA.
-require 'optparse'
-require 'time'
-require 'yaml'
-require 'rubygems'
-require 'pp'
-require 'gruff'
-require 'uri'
-require 'highline/import'
-begin
-  require 'bugzilla'
-rescue LoadError
-  $:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
-  require 'bugzilla'
-end
-$KCODE = 'u'
-module BzConsole
-  class CommandTemplate
-    def initialize(plugin)
-      @n_args = 0
-      @defaultyamlfile = File.join(ENV['HOME'], ".bzconsole.yml")
-      @plugin = plugin
-    end # def initialize
-    attr_reader :n_args
-    def parse(parser, argv, opts)
-      raise RuntimeError, sprintf("No implementation for %s", self.class) if self.class =~ /CommandTemplate/
-      parser.on('-h', '--help', 'show this message') {|x| opts[:help] = true}
-      read_config(opts)
-      @plugin.run(:parser, nil, parser, argv, opts)
-      parser.order(argv)
-    end # def parse
-    def do(argv)
-      raise RuntimeError, sprintf("No implementation for %s", self.class)
-    end # def do
-    protected
-    def read_config(opts)
-      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
-      begin
-        conf = YAML.load(File.open(fname).read)
-      rescue Errno::ENOENT
-        conf = {}
-      end
-      conf.each do |k, v|
-        if v.kind_of?(Hash) && v.include?(:Plugin) then
-          load(v[:Plugin])
-        end
-      end
-      conf
-    end # def read_config
-    def save_config(opts, conf)
-      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
-      if File.exist?(fname) then
-        st = File.lstat(fname)
-        if st.mode & 0600 != 0600 then
-          raise RuntimeError, sprintf("The permissions of %s has to be 0600", fname)
-        end
-      end
-      File.open(fname, "w") {|f| f.chmod(0600); f.write(conf.to_yaml)}
-    end # def save_config
-    private
-    def get_proxy(info)
-      uri = info[:Proxy] || ENV["http_proxy"]
-      proxy_uri = uri.nil? ? nil : URI.parse(uri)
-      proxy_host = proxy_uri.nil? ? nil : proxy_uri.host
-      proxy_port = proxy_uri.nil? ? nil : proxy_uri.port
-      return proxy_host, proxy_port
-    end
-  end # class CommandTemplate
-  class Setup < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 0
-    end # def initialize
-    def parse(parser, argv, opts)
-      parser.banner = sprintf("Usage: %s [global options] setup", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Command options:"
-      super
-    end # def parse
-    def do(argv, opts)
-      template = {
-        "rhbz"=>{
-          :Name=>"Red Hat Bugzilla",
-          :URL=>"https://bugzilla.redhat.com",
-          :User=>"account@example.com",
-          :Password=>"blahblahblah",
-          :ProductAliases=>{
-            'RHEL3'=>'Red Hat Enterprise Linux 3',
-            'RHEL4'=>'Red Hat Enterprise Linux 4',
-            'RHEL5'=>'Red Hat Enterprise Linux 5',
-            'RHEL6'=>'Red Hat Enterprise Linux 6'
-          },
-          :Plugin=>"ruby-bugzilla/rhbugzilla.rb"
-        },
-        "gnbz"=>{
-          :Name=>"GNOME Bugzilla",
-          :URL=>"https://bugzilla.gnome.org",
-          :User=>"account@example.com",
-          :Password=>"blahblahblah",
-        },
-        "fdobz"=>{
-          :Name=>"FreeDesktop Bugzilla",
-          :URL=>"https://bugs.freedesktop.org",
-          :User=>"account@example.com",
-          :Password=>"blahblahblah",
-        },
-        "mzbz"=>{
-          :Name=>"Mozilla Bugzilla",
-          :URL=>"https://bugzilla.mozilla.org",
-          :User=>"account@example.com",
-          :Password=>"blahblahblah",
-        }
-      }
-      template.each do |k, v|
-        @plugin.run(:pre, v[:URL].sub(/\Ahttps?:\/\//, '').sub(/\/\Z/, ''), :setup, v)
-      end
-      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
-      if File.exist?(fname) then
-        raise RuntimeError, ".bzconsole.yml already exists. please remove it first to proceed to the next step."
-      end
-      File.open(fname, File::CREAT|File::WRONLY, 0600) do |f|
-        f.write(template.to_yaml)
-      end
-      printf("%s has been created. please modify your account information before operating.\n", fname)
-    end # def do
-  end # class Setup
-  class Login < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 1
-    end # def initialize
-    def parse(parser, argv, opts)
-      opts[:output] = File.join(ENV['HOME'], '.ruby-bugzilla-cookie.yml')
-      parser.banner = sprintf("Usage: %s [global options] login [command options] <prefix> ...", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Command options:"
-      parser.on('-o', '--output=FILE', 'FILE to store the cookie') {|v| opts[:output] = v}
-      super
-    end # def parse
-    def do(argv, opts)
-      conf = read_config(opts)
-      conf.freeze
-      cconf = read_config({:config=>opts[:command][:output]})
-      argv.each do |prefix|
-        if prefix.nil? then
-          raise ArgumentError, "No prefix to log in"
-        end
-        unless conf.include?(prefix) then
-          raise RuntimeError, sprintf("No host information for %s", prefix)
-        end
-        info = conf[prefix]
-        uri = URI.parse(info[:URL])
-        host = uri.host
-        port = uri.port
-        path = uri.path.empty? ? nil : uri.path
-        login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
-        pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
-        proxy_host, proxy_port = get_proxy(info)
-        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
-        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout)
-        user = Bugzilla::User.new(xmlrpc)
-        begin
-          result = user.login({'login'=>login, 'password'=>pass, 'remember'=>true})
-          cconf[host] = xmlrpc.cookie
-          save_config({:config=>opts[:command][:output]}, cconf)
-        rescue XMLRPC::FaultException => e
-          printf("E: %s\n", e.message)
-        end
-      end
-    end # def do
-   end # class Login
-  class Getbug < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 1
-    end # def initialize
-    def parse(parser, argv, opts)
-      parser.banner = sprintf("Usage: %s [global options] getbug [command options] <prefix:bug number> ...", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Command options:"
-      parser.on('-s', '--summary', 'Displays bugs summary only') {opts[:summary] = true}
-      parser.on('-d', '--details', 'Displays detailed bugs information') {opts[:details] = true}
-      parser.on('-a', '--all', 'Displays the whole data in bugs') {opts[:all] = true}
-      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
-      super
-    end # def parse
-    def do(argv, opts)
-      real_do(argv, opts) do |result|
-        if opts[:command][:summary] == true then
-          printf("Bug#%s, %s, %s[%s, %s] %s\n",
-                 result['id'],
-                 result['product'],
-                 result['component'],
-                 result['status'],
-                 result['severity'],
-                 result['summary'])
-        elsif opts[:command][:details] == true then
-          printf("Bug#%s, %s, %s, %s[%s, %s, %s, %s] %s\n",
-                 result['id'],
-                 result['product'],
-                 result['assigned_to'],
-                 result['component'],
-                 result['status'],
-                 result['resolution'],
-                 result['priority'],
-                 result['severity'],
-                 result['summary'])
-        else
-          printf("Bug#%s - %s\n", result['id'], result['summary'])
-          printf("Status:\t\t%s%s\n", result['status'], !result['resolution'].empty? ? sprintf("[%s]", result['resolution']) : "")
-          printf("Product:\t%s\n", result['product'])
-          printf("Component:\t%s\n", result['component'])
-          printf("Assinged To:\t%s\n", result['assigned_to'])
-          printf("Priority:\t%s\n", result['priority'])
-          printf("Severity:\t%s\n", result['severity'])
-          printf("Comments:\t%d\n\n", result['comments'].length)
-          i = 0
-          result['comments'].each do |c|
-            printf("Comment#%d%s %s  %s\n", i, c['is_private'] == true ? "[private]" : "", c['author'], c['time'].to_time)
-            printf("\n  %s\n\n", c['text'].split("\n").join("\n  "))
-            i += 1
-          end
-        end
-      end
-    end # def do
-    private
-    def real_do(argv, opts)
-      conf = read_config(opts)
-      conf.freeze
-      argv.each do |bugn|
-        bugn =~ /(.*):(.*)/
-        prefix = $1
-        nnn = $2
-        if prefix.nil? then
-          raise ArgumentError, sprintf("No prefix specified for Bug#%s", bugn)
-        end
-        unless conf.include?(prefix) then
-          raise RuntimeError, sprintf("No host information for %s", prefix)
-        end
-        info = conf[prefix]
-        uri = URI.parse(info[:URL])
-        host = uri.host
-        port = uri.port
-        path = uri.path.empty? ? nil : uri.path
-        login = opts[:command][:anonymous] == true ? nil : info[:User]
-        pass = opts[:command][:anonymous] == true ? nil : info[:Password]
-        proxy_host, proxy_port = get_proxy(info)
-        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
-        @plugin.run(:pre, host, :getbug, opts)
-        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout)
-        user = Bugzilla::User.new(xmlrpc)
-        user.session(login, pass) do
-          bug = Bugzilla::Bug.new(xmlrpc)
-          result = nil
-          if opts[:command][:summary] == true then
-            result = bug.get_bugs(nnn.split(','))
-          elsif opts[:command][:details] == true then
-            result = bug.get_bugs(nnn.split(','), ::Bugzilla::Bug::FIELDS_DETAILS)
-          else
-            result = bug.get_bugs(nnn.split(','), nil)
-          end
-          @plugin.run(:post, host, :getbug, result)
-          result.each do |r|
-            yield r
-          end
-        end
-      end
-    end # def real_do
-  end # class Getbug
-  class Search < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 1
-    end # def initialize
-    def parse(parser, argv, opts)
-      opts[:query] ||= {}
-      parser.banner = sprintf("Usage: %s [global options] search [command options] <prefix> ...", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Search options:"
-      parser.on('--alias=ALIASES', 'filter out the result by the alias') {|v| opts[:query][:alias] ||= []; opts[:query][:alias].push(*v.split(','))}
-      parser.on('-a', '--assignee=ASSIGNEES', 'filter out the result by the specific assignees') {|v| opts[:query][:assigned_to] ||= []; opts[:query][:assigned_to].push(*v.split(','))}
-      parser.on('--bug=BUGS', 'filter out the result by the specific bug number') {|v| opts[:query][:id] ||= []; opts[:query][:id].push(*v.split(','))}
-      parser.on('-c', '--component=COMPONENTS', 'filter out the result by the specific components') {|v| opts[:query][:component] ||= []; opts[:query][:component].push(*v.split(','))}
-      parser.on('--create-time=TIME', 'Searches for bugs that were created at this time or later') {|v| opts[:query][:creation_time] = Time.parse(v)}
-      parser.on('--creator=CREATER', 'filter out the result by the specific user who reported bugs') {|v| opts[:query][:creator] ||= []; opts[:query][:creator].push(*v.split(','))}
-      parser.on('--last-change-time=TIME', 'Searches for bugs that were modified at this time or later') {|v| opts[:query][:last_change_time] = Time.parse(v)}
-      parser.on('--op-sys=NAMES', 'filter out the result by the operating system') {|v| opts[:query][:op_sys] ||= []; opts[:query][:op_sys].push(*v.split(','))}
-      parser.on('--platform=PLATFORMS', 'filter out the result by the platform') {|v| opts[:query][:platform] ||= []; opts[:query][:platform].push(*v.split(','))}
-      parser.on('--priority=PRIORITY', 'filter out the result by the priority') {|v| opts[:query][:priority] ||= []; opts[:query][:priority].push(*v.split(','))}
-      parser.on('-p', '--product=PRODUCTS', 'filter out the result by the specific products') {|v| opts[:query][:product] ||= []; opts[:query][:product].push(*v.split(','))}
-      parser.on('--resolution=RESOLUSIONS', 'filter out the result by the resolusions') {|v| opts[:query][:resolution] ||= []; opts[:query][:resolusion].push(*v.split(','))}
-      parser.on('--severity=SEVERITY', 'filter out the result by the severity') {|v| opts[:query][:severity] ||= []; opts[:query][:severity].push(*v.split(','))}
-      parser.on('-s', '--status=STATUSES', 'filter out the result by the status') {|v| opts[:query][:status] ||= []; opts[:query][:status].push(*v.split(','))}
-      parser.on('--summary=SUMMARY', 'filter out the result by the summary') {|v| opts[:query][:summary] ||= []; opts[:query][:summary] << v}
-      parser.on('--milestone=MILESTONE', 'filter out the result by the target milestone') {|v| opts[:query][:target_milestone] ||= []; opts[:query][:target_milestone].push(*v.split(','))}
-      parser.on('--whiteboard=STRING', 'filter out the result by the specific words in the status whiteboard') {|v| opts[:query][:whiteboard] ||= []; opts[:query][:whiteboard] << v}
-      parser.separator ""
-      parser.separator "Command options:"
-      parser.on('--short-list', 'Displays bugs summary only') {opts[:summary] = true}
-      parser.on('--detailed-list', 'Displays detailed bugs information') {opts[:details] = true}
-      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
-      super
-    end # def parse
-    def do(argv, opts)
-      c = 0
-      real_do(argv, opts) do |result|
-        if opts[:command][:summary] == true then
-          printf("Bug#%s, %s, %s[%s, %s] %s\n",
-                 result['id'] || result['bug_id'],
-                 result['product'],
-                 result['component'],
-                 result['status'],
-                 result['severity'],
-                 result['summary'])
-        elsif opts[:command][:details] == true then
-          printf("Bug#%s, %s, %s, %s[%s, %s, %s, %s] %s\n",
-                 result['id'],
-                 result['product'],
-                 result['assigned_to'],
-                 result['component'],
-                 result['status'],
-                 result['resolution'],
-                 result['priority'],
-                 result['severity'],
-                 result['summary'])
-        end
-        c += 1
-      end
-      printf("\n%d bug(s) found\n", c)
-    end # def do
-    private
-    def real_do(argv, opts)
-      conf = read_config(opts)
-      conf.freeze
-      argv.each do |prefix|
-        unless conf.include?(prefix) then
-          raise RuntimeError, sprintf("No host information for %s", prefix)
-        end
-        info = conf[prefix]
-        uri = URI.parse(info[:URL])
-        host = uri.host
-        port = uri.port
-        path = uri.path.empty? ? nil : uri.path
-        login = opts[:command][:anonymous] == true ? nil : info[:User]
-        pass = opts[:command][:anonymous] == true ? nil : info[:Password]
-        proxy_host, proxy_port = get_proxy(info)
-        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
-        @plugin.run(:pre, host, :search, opts[:command][:query])
-        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout)
-        user = Bugzilla::User.new(xmlrpc)
-        user.session(login, pass) do
-          bug = Bugzilla::Bug.new(xmlrpc)
-          opts[:command][:query][:product].map! {|x| info.include?(:ProductAliases) && info[:ProductAliases].include?(x) ? info[:ProductAliases][x] : x} if opts[:command][:query].include?(:product)
-          result = bug.search(opts[:command][:query])
-          @plugin.run(:post, host, :search, result)
-          if result.include?('bugs') then
-            result['bugs'].each do |r|
-              yield r
-            end
-          end
-        end
-      end
-    end # def real_do
-  end # class Search
-  class Show < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 1
-    end # def initialize
-    def parse(parser, argv, opts)
-      opts[:show] ||= {}
-      opts[:show][:mode] = :component
-      opts[:show][:field] = []
-      parser.banner = sprintf("Usage: %s [global options] show [command options] <prefix> ...", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Command options:"
-      parser.on('-f', '--field', 'Displays available field informations') {|v| opts[:show][:mode] = :field}
-      parser.on('--field-name=NAME', 'Displays NAME field information') {|v| opts[:show][:field] << v.split(',')}
-      parser.on('-p', '--product', 'Displays available product names') {|v| opts[:show][:mode] = :product}
-      parser.on('-c', '--component', 'Displays available component names (default)') {|v| opts[:show][:mode] = :component}
-      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
-      super
-    end # def parse
-    def do(argv, opts)
-      real_do(argv, opts) do |*result|
-        if opts[:command][:show][:mode] == :product then
-          printf("%s\n", result[0])
-        elsif opts[:command][:show][:mode] == :component then
-          printf("%s:\n", result[0])
-          printf("  %s\n", result[1].join("\n  "))
-        end
-      end
-    end # def do
-    private
-    def real_do(argv, opts)
-      conf = read_config(opts)
-      conf.freeze
-      argv.each do |prefix|
-        unless conf.include?(prefix) then
-          raise RuntimeError, sprintf("No host information for %s", prefix)
-        end
-        info = conf[prefix]
-        uri = URI.parse(info[:URL])
-        host = uri.host
-        port = uri.port
-        path = uri.path.empty? ? nil : uri.path
-        login = opts[:command][:anonymous] == true ? nil : info[:User]
-        pass = opts[:command][:anonymous] == true ? nil : info[:Password]
-        proxy_host, proxy_port = get_proxy(info)
-        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
-        @plugin.run(:pre, host, :show, opts)
-        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout)
-        user = Bugzilla::User.new(xmlrpc)
-        user.session(login, pass) do
-          if opts[:command][:show][:mode] == :field then
-            bug = Bugzilla::Bug.new(xmlrpc)
-            result = bug.fields(opts[:command][:show][:field].flatten)
-            @plugin.run(:post, host, :show, result)
-            pp result
-          else
-            product = Bugzilla::Product.new(xmlrpc)
-            result = product.selectable_products
-            @plugin.run(:post, host, :show, result)
-            products = result.keys.sort
-            products.each do |p|
-              if opts[:command][:show][:mode] == :product then
-                yield p
-              elsif opts[:command][:show][:mode] == :component then
-                yield p, result[p][0].sort
-              end
-            end
-          end
-        end
-      end
-    end # def real_do
-  end # class Show
-  class Metrics < CommandTemplate
-    def initialize(plugin)
-      super
-      @n_args = 1
-    end # def initialize
-    def parse(parser, argv, opts)
-      opts[:metrics] = {}
-      opts[:query] = {}
-      opts[:metrics][:output] = 'bz-metrics.png'
-      opts[:metrics][:x_coordinate] = :monthly
-      parser.banner = sprintf("Usage: %s [global options] metrics [command options] <prefix> ...", File.basename(__FILE__))
-      parser.separator ""
-      parser.separator "Search options:"
-      parser.on('--alias=ALIASES', 'filter out the result by the alias') {|v| opts[:query][:alias] ||= []; opts[:query][:alias].push(*v.split(','))}
-      parser.on('-a', '--assignee=ASSIGNEES', 'filter out the result by the specific assignees') {|v| opts[:query][:assigned_to] ||= []; opts[:query][:assigned_to].push(*v.split(','))}
-      parser.on('--bug=BUGS', 'filter out the result by the specific bug number') {|v| opts[:query][:id] ||= []; opts[:query][:id].push(*v.split(','))}
-      parser.on('-c', '--component=COMPONENTS', 'filter out the result by the specific components') {|v| opts[:query][:component] ||= []; opts[:query][:component].push(*v.split(','))}
-      parser.on('--creator=CREATER', 'filter out the result by the specific user who reported bugs') {|v| opts[:query][:creator] ||= []; opts[:query][:creator].push(*v.split(','))}
-      parser.on('--op-sys=NAMES', 'filter out the result by the operating system') {|v| opts[:query][:op_sys] ||= []; opts[:query][:op_sys].push(*v.split(','))}
-      parser.on('--platform=PLATFORMS', 'filter out the result by the platform') {|v| opts[:query][:platform] ||= []; opts[:query][:platform].push(*v.split(','))}
-      parser.on('--priority=PRIORITY', 'filter out the result by the priority') {|v| opts[:query][:priority] ||= []; opts[:query][:priority].push(*v.split(','))}
-      parser.on('-p', '--product=PRODUCTS', 'filter out the result by the specific products') {|v| opts[:query][:product] ||= []; opts[:query][:product].push(*v.split(','))}
-      parser.on('--resolution=RESOLUSIONS', 'filter out the result by the resolusions') {|v| opts[:query][:resolution] ||= []; opts[:query][:resolusion].push(*v.split(','))}
-      parser.on('--severity=SEVERITY', 'filter out the result by the severity') {|v| opts[:query][:severity] ||= []; opts[:query][:severity].push(*v.split(','))}
-      parser.on('--summary=SUMMARY', 'filter out the result by the summary') {|v| opts[:query][:summary] ||= []; opts[:query][:summary] << v}
-      parser.on('--milestone=MILESTONE', 'filter out the result by the target milestone') {|v| opts[:query][:target_milestone] ||= []; opts[:query][:target_milestone].push(*v.split(','))}
-      parser.on('--whiteboard=STRING', 'filter out the result by the specific words in the status whiteboard') {|v| opts[:query][:whiteboard] ||= []; opts[:query][:whiteboard] << v}
-      parser.separator ""
-      parser.separator "Command options:"
-      parser.on('-t', '--title=TITLE', 'add TITLE to the graph') {|v| opts[:metrics][:title] = v}
-      parser.on('--begin-date=DATE', 'generate the graph since the beginning of month of DATE.') {|v| x = Time.parse(v); opts[:metrics][:begin_date] = Time.utc(x.year, x.month, 1, 0, 0, 0)}
-      parser.on('--end-date=DATE', 'generate the graph until the end of month of DATE.') {|v| x = Time.parse(v); opts[:metrics][:end_date] = Time.utc(x.year, x.month + 1, 1, 0, 0, 0) - 1}
-      parser.on('-o', '--output=FILE', 'generate the graph to FILE') {|v| opts[:metrics][:output] = v}
-      parser.on('--anonymous', 'access to Bugzilla anonymously') {|v| opts[:anonymous] = true}
-      parser.on('--weekly', 'genereate the graph with weekly X-coordinate') {|v| opts[:metrics][:x_coordinate] = :weekly}
-      parser.on('--monthly', 'genereate the graph with monthly X-coordinate (default)') {|v| opts[:metrics][:x_coordinate] = :monthly}
-      super
-    end # def parse
-    def do(argv, opts)
-      data = {
-        :label=>[],
-        'NEW'=>[],
-        'ASSIGNED'=>[],
-        'MODIFIED'=>[],
-        'ON_QA'=>[],
-        'CLOSED'=>[],
-        'OPEN'=>[]
-      }
-      last_label = nil
-      real_do(argv, opts) do |t, new, assigned, modified, on_qa, closed, open|
-        printf("%s, new: %d, assigned: %d, modified %d, on_qa %d, closed %d / open %d\n",
-               opts[:command][:metrics][:x_coordinate] == :weekly ? sprintf("week %d", Date.new(t.year, t.month, t.day).cweek) : t.strftime("%Y-%m"), new, assigned, modified, on_qa, closed, open)
-        data['NEW'] << new
-        data['ASSIGNED'] << assigned
-        data['MODIFIED'] << modified
-        data['ON_QA'] << on_qa
-        data['CLOSED'] << closed
-        data['OPEN'] << open
-        label = t.strftime("%Y/%m")
-        if last_label != label then
-          data[:label] << label
-          last_label = label
-        else
-          data[:label] << nil
-        end
-      end
-      timeline = data[:label]
-      data.delete(:label)
-      def timeline.to_hash
-	ret = {}
-        (0..self.length-1).each do |i|
-          ret[i] = self[i] unless self[i].nil?
-        end
-        ret
-      end # def timeline.to_hash
-      # output the trend graph
-      g = Gruff::Line.new
-      g.title = sprintf("Trend: %s", opts[:command][:metrics][:title])
-      g.labels = timeline.to_hash
-      data.each do |k, v|
-        next unless k == 'NEW' || k == 'OPEN' || k == 'CLOSED'
-        g.data(k, v)
-      end
-      g.write(sprintf("trend-%s", opts[:command][:metrics][:output]))
-      # output the activity graph
-      g = Gruff::StackedBar.new
-      g.title = sprintf("Activity: %s", opts[:command][:metrics][:title])
-      g.labels = timeline.to_hash
-      g.data('Resolved', data['CLOSED'])
-      x = []
-      (0..data['ASSIGNED'].length-1).each do |i|
-        x[i] = data['ASSIGNED'][i] + data['MODIFIED'][i] + data['ON_QA'][i]
-      end
-      g.data('Unresolved', x)
-      a = []
-      (0..data['OPEN'].length-1).each do |i|
-        a[i] = data['OPEN'][i] - x[i]
-      end
-      g.data('non-activity bugs', a)
-      g.write(sprintf("activity-%s", opts[:command][:metrics][:output]))
-    end # def do
-    private
-    def real_do(argv, opts)
-      conf = read_config(opts)
-      conf.freeze
-      argv.each do |prefix|
-        unless conf.include?(prefix) then
-          raise RuntimeError, sprintf("No host information for %s", prefix)
-        end
-        info = conf[prefix]
-        uri = URI.parse(info[:URL])
-        host = uri.host
-        port = uri.port
-        path = uri.path.empty? ? nil : uri.path
-        login = opts[:command][:anonymous] == true ? nil : info[:User]
-        pass = opts[:command][:anonymous] == true ? nil : info[:Password]
-        proxy_host, proxy_port = get_proxy(info)
-        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
-        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout)
-        user = Bugzilla::User.new(xmlrpc)
-        user.session(login, pass) do
-          bug = Bugzilla::Bug.new(xmlrpc)
-          opts[:command][:query][:product].map! {|x| info.include?(:ProductAliases) && info[:ProductAliases].include?(x) ? info[:ProductAliases][x] : x} if opts[:command][:query].include?(:product)
-          ts = opts[:command][:metrics][:begin_date] || Time.utc(Time.new.year, 1, 1)
-          te = opts[:command][:metrics][:end_date] || Time.utc(Time.new.year+1, 1, 1) - 1
-          if opts[:command][:metrics][:x_coordinate] == :weekly then
-            # align to the week
-            d = Date.new(ts.year, ts.month, ts.day)
-            ds = Date.commercial(d.year, d.cweek, 1)
-            d = Date.new(te.year, te.month, te.day)
-            de = Date.commercial(d.year, d.cweek, 7)
-            ts = Time.utc(ds.year, ds.month, ds.day)
-            te = Time.utc(de.year, de.month, de.day)
-          end
-          searchopts = opts[:command][:query].clone
-          @plugin.run(:pre, host, :metrics, searchopts, opts[:metrics])
-          if searchopts == opts[:command][:query] then
-            raise NoMethodError, "No method to deal with the query"
-          end
-          while ts < te do
-            searchopts = opts[:command][:query].clone
-            # don't rely on the status to deal with NEW bugs.
-            # unable to estimate the case bugs closed quickly
-            if opts[:command][:metrics][:x_coordinate] == :weekly then
-              d = Date.new(ts.year, ts.month, ts.day)
-              de = Date.commercial(d.year, d.cweek, 7)
-              drange = [ts, Time.utc(de.year, de.month, de.day, 23, 59, 59)]
-            else
-              drange = [ts, Time.utc(ts.year, ts.month + 1, 1) - 1]
-            end
-            searchopts[:creation_time] = drange
-            @plugin.run(:pre, host, :metrics, searchopts)
-            result = bug.search(searchopts)
-            @plugin.run(:post, host, :search, result)
-            new = result.include?('bugs') ? result['bugs'].length : 0
-            # for open bugs
-            # what we are interested in here would be how many bugs still keeps open.
-            searchopts = opts[:command][:query].clone
-            searchopts[:last_change_time] = drange
-            searchopts[:status] = '__open__'
-            @plugin.run(:pre, host, :metrics, searchopts)
-            result = bug.search(searchopts)
-            @plugin.run(:post, host, :search, result)
-            assigned = result.include?('bugs') ? result['bugs'].map{|x| x['status'] == 'ASSIGNED' ? x : nil}.compact.length : 0
-            modified = result.include?('bugs') ? result['bugs'].map{|x| x['status'] == 'MODIFIED' ? x : nil}.compact.length : 0
-            on_qa = result.include?('bugs') ? result['bugs'].map{|x| x['status'] == 'ON_QA' ? x : nil}.compact.length : 0
-            # send a separate query for closed.
-            # just counting CLOSED the above is meaningless.
-            # what we are interested in here would be how much bugs are
-            # actually closed, but not how many closed bugs one worked on.
-            searchopts = opts[:command][:query].clone
-            searchopts[:last_change_time] = drange
-            searchopts[:status] = 'CLOSED'
-            @plugin.run(:pre, host, :metrics, searchopts)
-            result = bug.search(searchopts)
-            @plugin.run(:post, host, :search, result)
-            closed = result.include?('bugs') ? result['bugs'].length : 0
-            # obtain the information for open bugs that closed now
-            searchopts = opts[:command][:query].clone
-            searchopts[:status] = 'CLOSED'
-            searchopts[:metrics_closed_after] = drange[1] + 1
-            @plugin.run(:pre, host, :metrics, searchopts)
-            result = bug.search(searchopts)
-            @plugin.run(:post, host, :search, result)
-            open_bugs = result.include?('bugs') ? result['bugs'].length : 0
-            # obtain the information for open bugs
-            searchopts = opts[:command][:query].clone
-            searchopts[:metrics_not_closed] = drange[1]
-            @plugin.run(:pre, host, :metrics, searchopts)
-            result = bug.search(searchopts)
-            @plugin.run(:post, host, :search, result)
-            open_bugs += result.include?('bugs') ? result['bugs'].length : 0
-            yield ts, new, assigned, modified, on_qa, closed, open_bugs
-            ts = drange[1] + 1
-          end
-        end
-      end
-    end # def real_do
-  end # class Metrics
-end # module BzConsole
-begin
-  opts = {}
-  opts[:command] = {}
-  subargv = []
-  o = ARGV.options do |opt|
-    opt.banner = sprintf("Usage: %s [global options] <command> ...", File.basename(__FILE__))
-    opt.separator ""
-    opt.separator "Global options:"
-    opt.on('-c', '--config=FILE', 'read FILE as the configuration file.') {|v| opts[:config] = v}
-    opt.on('-t', '--timeout=SEC', 'Set XMLRPC timeout in a second.') {|v| opts[:timeout] = v.to_i}
-    opt.on('-h', '--help', 'show this message') {|x| opts[:help] = true}
-    cmds = BzConsole.constants.sort.map {|x| (k = eval("BzConsole::#{x}")).class == Class && x != "CommandTemplate" ? x.downcase : nil}.compact
-    subargv = opt.order(ARGV);
-    command = subargv[0]
-    if subargv.length > 0 then
-      n = cmds.index(command)
-      unless n.nil? then
-        opts[:instance] = eval("BzConsole::#{cmds[n].capitalize}.new(Bugzilla::Plugin::Template.new)")
-        subargv = opts[:instance].parse(opt, subargv[1..-1], opts[:command])
-      else
-        STDERR.printf("E: Unknown command: %s\n", subargv[0])
-        STDERR.printf("   Available commands: %s\n", cmds.join(' '))
-        exit 1
-      end
-    else
-      opt.separator ""
-      opt.separator "Available commands:"
-      opt.separator sprintf("  %s", cmds.join(' '))
-    end
-    if opts[:instance].nil? && subargv.length == 0 ||
-        opts[:help] == true ||
-        subargv.length < opts[:instance].n_args then
-      puts opt.help
-      exit
-    end
-  end
-  opts[:instance].do(subargv, opts)
-end