honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/worker/metrics_collection.rb

@@ -0,0 +1,61 @@
+module Honeybadger
+  class Worker
+    # This code comes from batsd
+    class MetricsCollection < Array
+      PERCENTILE_METHOD_SIGNATURE = /\Apercentile_(.+)\z/.freeze
+
+      # Calculates the sum of values in the array
+      def sum
+        inject( nil ) { |sum,x| sum ? sum+x : x };
+      end
+
+      # Calculates the arithmetic mean of values in the array
+      def mean
+        self.sum.to_f / self.length
+      end
+
+      # Calculates the median of values in the array
+      def median
+        self.sort[self.length/2]
+      end
+
+      # Calculates the value of the upper percentile of values
+      # in the array. If only a single value is provided in the array, that is
+      # returned
+      def percentile(threshold)
+        if (count > 1)
+          self.sort!
+          # strip off the top 100-threshold
+          threshold_index = (((100 - threshold).to_f / 100) * count).round
+          self[0..-threshold_index].last
+        else
+          self.first
+        end
+      end
+
+      # Calculates the mean squared error of values in the array
+      def mean_squared
+        m = mean
+        self.class.new(map{|v| (v-m)**2}).sum
+      end
+
+      # Calculates the standard deviatiation of values in the array
+      def standard_dev
+        (mean_squared/(count-1))**0.5
+      end
+
+      # Allow [1,2,3].percentile_90, [1,2,3].percentile(75), etc.
+      def method_missing(method, *args, &block)
+        if method.to_s =~ PERCENTILE_METHOD_SIGNATURE
+          percentile($1.to_i)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        method.to_s =~ PERCENTILE_METHOD_SIGNATURE or super
+      end
+    end
+  end
+end

data/lib/honeybadger/worker/metrics_collector.rb

@@ -0,0 +1,96 @@
+require 'securerandom'
+require 'forwardable'
+
+module Honeybadger
+  class Worker
+    autoload :MetricsCollection, 'honeybadger/worker/metrics_collection'
+
+    class MetricsCollector
+      extend Forwardable
+
+      class Chunk
+        extend Forwardable
+
+        attr_reader :id
+
+        def initialize(id, metrics)
+          @id = SecureRandom.uuid
+          @metrics = metrics
+        end
+
+        def_delegators :@metrics, :to_json, :size
+      end
+
+      def initialize(config, interval = 60, now = now)
+        @id = SecureRandom.uuid
+        @config = config
+        @interval = interval
+        @future = now + interval
+        @mutex = Mutex.new
+        @metrics = { :timing => {}, :counter => {} }
+      end
+
+      attr_reader :id
+
+      def_delegators :@metrics, :[]
+
+      def timing(name, value)
+        add_metric(name, value, :timing)
+      end
+
+      def increment(name, value)
+        add_metric(name, value, :counter)
+      end
+
+      def flush?
+        now >= future
+      end
+
+      def to_a
+        [].tap do |m|
+          metrics[:counter].each do |metric, values|
+            m << "#{metric} #{values.sum}"
+          end
+          metrics[:timing].each do |metric, values|
+            m << "#{metric}:mean #{values.mean}"
+            m << "#{metric}:median #{values.median}"
+            m << "#{metric}:percentile_90 #{values.percentile(90)}"
+            m << "#{metric}:min #{values.min}"
+            m << "#{metric}:max #{values.max}"
+            m << "#{metric}:stddev #{values.standard_dev}" if values.count > 1
+            m << "#{metric} #{values.count}"
+          end
+          m.compact!
+        end
+      end
+
+      def chunk(size)
+        to_a.each_slice(size) do |metrics|
+          yield(Chunk.new(id, as_json(metrics)))
+        end
+      end
+
+      def as_json(metrics = to_a)
+        {metrics: metrics, :environment => config[:env], :hostname => config[:hostname]}
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+
+      private
+
+      attr_reader :config, :future, :metrics, :mutex
+
+      def now
+        Time.now.to_i
+      end
+
+      def add_metric(name, value, kind)
+        mutex.synchronize do
+          (metrics[kind][name] ||= MetricsCollection.new) << value
+        end
+      end
+    end
+  end
+end

data/{lib/honeybadger/capistrano.rb → vendor/capistrano-honeybadger/lib/capistrano/honeybadger.rb}

@@ -1,7 +1,5 @@
-require 'capistrano'
-
 if defined?(Capistrano::Configuration.instance)
   require 'honeybadger/capistrano/legacy'
 else
-  load File.expand_path('../capistrano/tasks.rake', __FILE__)
+  load File.expand_path('../tasks/deploy.cap', __FILE__)
 end

data/vendor/capistrano-honeybadger/lib/capistrano/tasks/deploy.cap

@@ -0,0 +1,76 @@
+namespace :honeybadger do
+  def sshkit_outdated?
+    !::SSHKit.config.command_map.respond_to?(:prefix)
+  end
+
+  desc 'Notify Honeybadger of the deployment.'
+  task :deploy => :env do
+    next if sshkit_outdated?
+    if server = fetch(:honeybadger_server)
+      on server do |host|
+        info 'Notifying Honeybadger of deploy.'
+
+        executable = fetch(:honeybadger, :honeybadger)
+
+        revision = fetch(:current_revision) do
+          within(repo_path) do
+            capture("cd #{repo_path} && git rev-parse --short HEAD")
+          end
+        end
+
+        options = [
+          'deploy',
+          '--environment', fetch(:honeybadger_env, fetch(:rails_env, 'production')),
+          '--revision', revision,
+          '--repository', fetch(:repo_url),
+          '--user', fetch(:honeybadger_user, ENV['USER'] || ENV['USERNAME'])
+        ]
+
+        api_key = fetch(:honeybadger_api_key, ENV['HONEYBADGER_API_KEY'])
+        options += ['--api-key', api_key] if api_key
+
+        if fetch(:honeybadger_async_notify, false)
+          ::SSHKit.config.command_map.prefix[:honeybadger].push(:nohup)
+          options << '>> /dev/null 2>&1 &'
+        end
+
+        within release_path do
+          execute executable, options
+        end
+
+        info 'Honeybadger notification complete.'
+      end
+    end
+  end
+
+  desc 'Setup ENV for Honeybadger deploy rake task.'
+  task :env do
+    if sshkit_outdated?
+      run_locally do
+        warn 'Unable to notify Honeybadger: you are using an outdated version of SSHKIT. Please upgrade to >= 1.2.0.'
+      end
+      next
+    end
+
+    server = fetch(:honeybadger_server) do
+      s = primary(:app)
+      set(:honeybadger_server, s.select?({exclude: :no_release}) ? s : nil)
+    end
+
+    if server
+      on server do |host|
+        rails_env = fetch(:rails_env, 'production')
+        env = ["RAILS_ENV=#{rails_env}"]
+        ::SSHKit.config.command_map.prefix[:honeybadger].unshift(*env)
+      end
+    end
+  end
+end
+
+namespace :load do
+  task :defaults do
+    set :bundle_bins, fetch(:bundle_bins, []).push('honeybadger')
+  end
+end
+
+after 'deploy:finishing', 'honeybadger:deploy'

data/vendor/capistrano-honeybadger/lib/honeybadger/capistrano.rb

@@ -0,0 +1,2 @@
+warn 'DEPRECATED: requiring honeybadger/capistrano has been deprecated. Require capistrano/honeybadger instead.'
+require File.expand_path('../../capistrano/honeybadger', __FILE__)

data/{lib → vendor/capistrano-honeybadger/lib}/honeybadger/capistrano/legacy.rb

@@ -1,9 +1,11 @@
+require 'capistrano'
+
 module Honeybadger
   module Capistrano
     def self.load_into(configuration)
       configuration.load do
-        after "deploy",            "honeybadger:deploy"
-        after "deploy:migrations", "honeybadger:deploy"
+        after 'deploy',            'honeybadger:deploy'
+        after 'deploy:migrations', 'honeybadger:deploy'
 
         namespace :honeybadger do
           desc <<-DESC
@@ -11,28 +13,27 @@ module Honeybadger
               - Run remotely so we use remote API keys, environment, etc.
           DESC
           task :deploy, :except => { :no_release => true } do
-            rails_env = fetch(:rails_env, "production")
-            honeybadger_env = fetch(:honeybadger_env, fetch(:rails_env, "production"))
-            rake_task = fetch(:honeybadger_deploy_task, 'honeybadger:deploy')
+            rails_env = fetch(:rails_env, 'production')
+            honeybadger_env = fetch(:honeybadger_env, fetch(:rails_env, 'production'))
             local_user = ENV['USER'] || ENV['USERNAME']
-            executable = RUBY_PLATFORM.downcase.include?('mswin') ? fetch(:rake, 'rake.bat') : fetch(:rake, 'rake')
+            executable = fetch(:honeybadger, "#{fetch(:bundle_cmd, 'bundle')} exec honeybadger")
             async_notify = fetch(:honeybadger_async_notify, false)
             directory = fetch(:honeybadger_deploy_dir, configuration.current_release)
             notify_options = "cd #{directory};"
-            notify_options << " nohup" if async_notify
-            notify_options << " #{executable} RAILS_ENV=#{rails_env} #{rake_task} TO=#{honeybadger_env} REVISION=#{current_revision} REPO=#{repository} USER=#{local_user}"
-            notify_options << " DRY_RUN=true" if dry_run
-            notify_options << " API_KEY=#{ENV['API_KEY']}" if ENV['API_KEY']
-            notify_options << " >> /dev/null 2>&1 &" if async_notify
+            notify_options << " RAILS_ENV=#{rails_env}"
+            notify_options << ' nohup' if async_notify
+            notify_options << " #{executable} deploy --environment=#{honeybadger_env} --revision=#{current_revision} --repository=#{repository} --user=#{local_user}"
+            notify_options << ' --dry-run' if dry_run
+            notify_options << " --api-key=#{ENV['API_KEY']}" if ENV['API_KEY']
+            notify_options << ' >> /dev/null 2>&1 &' if async_notify
             logger.info "Notifying Honeybadger of Deploy (#{notify_options})"
             if configuration.dry_run
-              logger.info "DRY RUN: Notification not actually run."
+              logger.info 'DRY RUN: Notification not actually run.'
             else
-              result = ""
+              result = ''
               run(notify_options, :once => true, :pty => false) { |ch, stream, data| result << data }
-              # TODO: Check if SSL is active on account via result content.
             end
-            logger.info "Honeybadger Notification Complete."
+            logger.info 'Honeybadger Notification Complete.'
           end
         end
       end

data/vendor/thor/lib/thor.rb

@@ -0,0 +1,484 @@
+require "set"
+require "thor/base"
+
+class Thor # rubocop:disable ClassLength
+  class << self
+    # Allows for custom "Command" package naming.
+    #
+    # === Parameters
+    # name<String>
+    # options<Hash>
+    #
+    def package_name(name, options = {})
+      @package_name = name.nil? || name == "" ? nil : name
+    end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    #
+    def default_command(meth = nil)
+      if meth
+        @default_command = meth == :none ? "help" : meth.to_s
+      else
+        @default_command ||= from_superclass(:default_command, "help")
+      end
+    end
+    alias_method :default_task, :default_command
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options = {})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { |*args| invoke(klass, args) }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next command.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.usage = usage             if usage
+        command.description = description if description
+      else
+        @usage, @desc, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next command.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a command. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list command.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+    #
+    def map(mappings = nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each { |subkey| @map[subkey] = value }
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options = nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    alias_method :options, :method_options
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    def method_option(name, options = {})
+      scope = if options[:for]
+        find_and_refresh_command(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+    alias_method :option, :method_option
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    #
+    def command_help(shell, command_name)
+      meth = normalize_command_name(command_name)
+      command = all_commands[meth]
+      handle_no_command_error(meth) unless command
+
+      shell.say "Usage:"
+      shell.say "  #{banner(command)}"
+      shell.say
+      class_options_help(shell, nil => command.options.map { |_, o| o })
+      if command.long_description
+        shell.say "Description:"
+        shell.print_wrapped(command.long_description, :indent => 2)
+      else
+        shell.say command.description
+      end
+    end
+    alias_method :task_help, :command_help
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+      list.sort! { |a, b| a[0] <=> b[0] }
+
+      if defined?(@package_name) && @package_name
+        shell.say "#{@package_name} commands:"
+      else
+        shell.say "Commands:"
+      end
+
+      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns commands ready to be printed.
+    def printable_commands(all = true, subcommand = false)
+      (all ? all_commands : commands).map do |_, command|
+        next if command.hidden?
+        item = []
+        item << banner(command, false, subcommand)
+        item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : "")
+        item
+      end.compact
+    end
+    alias_method :printable_tasks, :printable_commands
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+    alias_method :subtasks, :subcommands
+
+    def subcommand_classes
+      @subcommand_classes ||= {}
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      subcommand_classes[subcommand.to_s] = subcommand_class
+
+      define_method(subcommand) do |*args|
+        args, opts = Thor::Arguments.split(args)
+        args.unshift("help") if opts.include? "--help" or opts.include? "-h"
+        invoke subcommand_class, args, opts, :invoked_via_subcommand => true, :class_options => options
+      end
+    end
+    alias_method :subtask, :subcommand
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options = {})
+      @check_unknown_options ||= {}
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      command = config[:current_command]
+      return true unless command
+
+      name = command.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the command.
+    # This is useful if you have a command that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a command that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The command itself also accepts some options,
+    # which should be handled by Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    def stop_on_unknown_option!(*command_names)
+      stop_on_unknown_option.merge(command_names)
+    end
+
+    def stop_on_unknown_option?(command) #:nodoc:
+      command && stop_on_unknown_option.include?(command.name.to_sym)
+    end
+
+  protected
+    def stop_on_unknown_option #:nodoc:
+      @stop_on_unknown_option ||= Set.new
+    end
+
+    # The method responsible for dispatching given the args.
+    def dispatch(meth, given_args, given_opts, config) #:nodoc: # rubocop:disable MethodLength
+      meth ||= retrieve_command_name(given_args)
+      command = all_commands[normalize_command_name(meth)]
+
+      if !command && config[:invoked_via_subcommand]
+        # We're a subcommand and our first argument didn't match any of our
+        # commands. So we put it back and call our default command.
+        given_args.unshift(meth)
+        command = all_commands[normalize_command_name(default_command)]
+      end
+
+      if command
+        args, opts = Thor::Options.split(given_args)
+        if stop_on_unknown_option?(command) && !args.empty?
+          # given_args starts with a non-option, so we treat everything as
+          # ordinary arguments
+          args.concat opts
+          opts.clear
+        end
+      else
+        args, opts = given_args, nil
+        command = dynamic_command_class.new(meth)
+      end
+
+      opts = given_opts || opts || []
+      config.merge!(:current_command => command, :command_options => command.options)
+
+      instance = new(args, opts, config)
+      yield instance if block_given?
+      args = instance.args
+      trailing = args[Range.new(arguments.size, -1)]
+      instance.invoke_command(command, trailing || [])
+    end
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner. It receives
+    # the command that is going to be invoked and a boolean which indicates if
+    # the namespace should be displayed as arguments.
+    #
+    def banner(command, namespace = nil, subcommand = false)
+      "#{basename} #{command.formatted_usage(self, $thor_runner, subcommand)}"
+    end
+
+    def baseclass #:nodoc:
+      Thor
+    end
+
+    def dynamic_command_class #:nodoc:
+      Thor::DynamicCommand
+    end
+
+    def create_command(meth) #:nodoc:
+      @usage ||= nil
+      @desc ||= nil
+      @long_desc ||= nil
+
+      if @usage && @desc
+        base_class = @hide ? Thor::HiddenCommand : Thor::Command
+        commands[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+        @usage, @desc, @long_desc, @method_options, @hide = nil
+        true
+      elsif all_commands[meth] || meth == "method_missing"
+        true
+      else
+        puts "[WARNING] Attempted to create command #{meth.inspect} without usage or description. " <<
+             "Call desc if you want this method to be available as command or declare it inside a " <<
+             "no_commands{} block. Invoked from #{caller[1].inspect}."
+        false
+      end
+    end
+    alias_method :create_task, :create_command
+
+    def initialize_added #:nodoc:
+      class_options.merge!(method_options)
+      @method_options = nil
+    end
+
+    # Retrieve the command name from given args.
+    def retrieve_command_name(args) #:nodoc:
+      meth = args.first.to_s unless args.empty?
+      if meth && (map[meth] || meth !~ /^\-/)
+        args.shift
+      else
+        nil
+      end
+    end
+    alias_method :retrieve_task_name, :retrieve_command_name
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    def normalize_command_name(meth) #:nodoc:
+      return default_command.to_s.gsub("-", "_") unless meth
+
+      possibilities = find_command_possibilities(meth)
+      if possibilities.size > 1
+        fail AmbiguousTaskError, "Ambiguous command #{meth} matches [#{possibilities.join(', ')}]"
+      elsif possibilities.size < 1
+        meth = meth || default_command
+      elsif map[meth]
+        meth = map[meth]
+      else
+        meth = possibilities.first
+      end
+
+      meth.to_s.gsub("-", "_") # treat foo-bar as foo_bar
+    end
+    alias_method :normalize_task_name, :normalize_command_name
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    def find_command_possibilities(meth)
+      len = meth.to_s.length
+      possibilities = all_commands.merge(map).keys.select { |n| meth == n[0, len] }.sort
+      unique_possibilities = possibilities.map { |k| map[k] || k }.uniq
+
+      if possibilities.include?(meth)
+        [meth]
+      elsif unique_possibilities.size == 1
+        unique_possibilities
+      else
+        possibilities
+      end
+    end
+    alias_method :find_task_possibilities, :find_command_possibilities
+
+    def subcommand_help(cmd)
+      desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+      class_eval "
+        def help(command = nil, subcommand = true); super; end
+"
+    end
+    alias_method :subtask_help, :subcommand_help
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [COMMAND]", "Describe available commands or one specific command"
+  def help(command = nil, subcommand = false)
+    if command
+      if self.class.subcommands.include? command
+        self.class.subcommand_classes[command].help(shell, true)
+      else
+        self.class.command_help(shell, command)
+      end
+    else
+      self.class.help(shell, subcommand)
+    end
+  end
+end