   _clean: () =>
     Object.keys(@).forEach((key) =>
       if /^_/.test(key)
-        switch key
-          when '_runCallbacks'
-            null
-          when '_log'
-            null
-          when '_raw'
-            null
-          when '_cooked'
-            null
-          when '_eaten'
-            null
-          else
-            delete this[key])
+        [
+          '_runCallbacks',
+          '_log',
+          '_raw',
+          '_cooked',
+          '_eaten',
+          '_help'
+        ].forEach((target) =>
+          if key isnt target
+            delete @[key]))
     return @
 
   parse: () =>
+    @_makeHelp()
     @_gather()
     @_resolveOpts()
-    @_log(@)
-    @_runCallbacks()
+    #@_runCallbacks()
 
 module.exports = Bebopt

util      = require 'util'
clone     = require 'clone'
deepEqual = require './deep-equal'

class Bebopt
  constructor: (@app) ->
    @app ?= 'bebopt'
    @_long = {}
    @_short = {}
    @_parent = null
    # XXX for the people; lol, that is this is a protected copy of `argv'
    @_raw = process.argv
    @_cooked = []
    @_eaten = {}
    @usage = undefined

  _beatError: (parent, name) ->
    switch parent

    @_parent = null
    return @

  _parentOrChildUsage: (opt) =>
    if typeof opt.usage isnt 'string'
      if opt.parent is null
        if opt.child is null
          return ''
        else
          return @_options[opt.child.index].usage
      else
        return @_options[opt.parent.index].usage
    else
      return opt.usage

  _makeHelp: () =>
    @_options.forEach((opt) =>
      dashes = if opt.list is 'short' then '-' else '--'
      usage = @_parentOrChildUsage(opt)
      if opt.child is null
        if opt.parent is null
          @_help.push("  #{dashes}#{opt.name}#{usage}")
      else
        if opt.parent is null
          if dashes is '--'
            @_help.push("  -#{opt.child.name}, #{dashes}#{opt.name}#{usage}")
          else
            @_help.push("  #{dashes}#{opt.name}, --#{opt.child.name}#{usage}")
    )
    @_log(@)

  printHelp: (fn) =>
    usage = if @usage is undefined then "Usage: #{@app}" else @usage
    if fn is undefined
      console.error(usage)
      @_help.forEach((txt) ->
        console.error(txt))
    else
      fn(usage)
      @_help.forEach((txt) ->
        fn(txt))

  usage: (text) =>
    @usage = text
