rubycom 0.2.5 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmZkNDU1NjY2ZGU2MmM0ZGE4OTEyNTkwYTBkMzVhMjhiYWIzOWVhNA==
+    NDQwZWY1MzUyMTk1MGQ1OTc2YTEzYzNhOWRlNTZjZTkzMjU3MzliNw==
   data.tar.gz: !binary |-
-    NWI4NWMxNjJiN2RhZTA2MWJiNjZhZjZiNTVhMmMzMTMwMWRkN2FkYQ==
+    OWVkOTI4MjY3ODhlODM1M2FhMTAxZTc2YjQxYTVkN2JmZDg2ZGE1Yg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MjI1NjA5YjZiMDdhNzQ3M2YzNjVmYTYwYWQyMjMxZmIzZDYwZmMyNWMwM2Jm
-    MjAwNTQ3NDI0NjMzOWVjMGUzNDAyZjVjZDVjZmZkNzk3MjM5YzJlY2M3NDU3
-    NzhlNjI2NzNlNjQ4ZTZkYjljNjQ2ZDVmZGE3YjJlNWUxNmI3NDc=
+    Nzc5NWUyZTczZWMzZjUxM2UwMmEyNGQxYTZlZTEyYmI1MmViYmUwZDE0NmRm
+    ZTYzM2Y0N2Q1MjhkOThjZTdiN2Q5OWIyODEyMmVkMjdiMjQ3OTc0ZWQ2MTcx
+    NzUwZTAzMzZjOWMwN2FlZjk1NjUzMTFlM2EzZTdkZTk3NjI5ZGQ=
   data.tar.gz: !binary |-
-    MjUwMmNmYjVjMDc0ZDI2YzE5MzMyYTY0ZDNmNmJiOTdkZDQ4YTVlMGE0Yjlj
-    YTRkOTM5ZTM3NTQyNjcxNGE2ZTY0ODAyYTNmZjFmN2JiNGJkYTFmYjQ3YjVi
-    Yzk0YjFkMWIxNGViNDlmNDUzNWM4ODdjNWE0MDE1ZmY0ZjczOTQ=
+    YzVlZTBiODM0MzU0MmQzNTg1YWI1NDg0MTE0ZGRhOWMyMDA2M2Y5NTIxZTY1
+    NTFmM2Y3NDM5MDU5ZmRhYmI2Y2FlMDc1YjdiNzA3OWIzYWVlNGYxNTRhMjU3
+    MzZjYzNjMmQ2NzUwZmIxNDM2MzcxODU4OGUzMWYyZGNmOGVjNGY=

data/README.md

@@ -20,6 +20,8 @@ by simply including Rubycom at the bottom.
 * Method parameters become required CLI arguments. Optional (defaulted) parameters become CLI options.
 * Command consoles can be built up by including other modules before including Rubycom.
 * Included modules become commands, their public singleton methods become sub-commands.
+* Built in tab completion support for all commands.
+    * Users may call `./path/to/my_command.rb register_completions` then `source ~/.bash_profile` to register completions.
 
 Usage
 ---------------
@@ -131,11 +133,13 @@ If a set of functions needs to be accessible from the terminal, just `include Ru
 * Usage documentation is pulled from method comments.
 * Method parameters become required CLI arguments.
 * Optional (defaulted) parameters become CLI options.
+* Tab completion support if the user has registered it for the file.
 
 The result is a function library which can be consumed easily from other classes/modules and which is accessible from the command line.
 
 Coming Soon
 ---------------
+* Support for piping.
 * Build a job yaml by running each command in sequence with a special option --job_add <path_to_yaml>[:step_number]
 * Edit job files from the command line using special options.
     * --job_update <path_to_yaml>[:step_number]

data/Rakefile

@@ -1,4 +1,5 @@
 require 'yard'
+require 'rake/testtask'
 
 task :default => [:package]
 
@@ -9,19 +10,19 @@ task :clean do
   FileUtils.rm(Dir.glob('./rubycom-*.gem'))
 end
 
-task :test do
-  test_files = Dir.glob("**/test/*/test_*.rb")
-  test_files.each { |test_case|
-    ruby test_case rescue SystemExit
-    if $?.exitstatus != 0;
-      raise "Error during test phase\n Test: #{test_case}\n Error: #{$!}\n#{$@}" unless $!.nil?
-    end
-  }
+task :bundle do
+  system("bundle install")
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*/*_test.rb']
+  t.verbose = true
 end
 
 YARD::Rake::YardocTask.new
 
-task :package => [:clean, :test, :yard] do
+task :package => [:clean, :bundle, :test, :yard] do
   gem_specs = Dir.glob("**/*.gemspec")
   gem_specs.each { |gem_spec|
     system("gem build #{gem_spec}")
@@ -34,7 +35,15 @@ task :install => :package do
   system("gem install #{File.expand_path(File.dirname(__FILE__))}/rubycom-#{Rubycom::VERSION}.gem")
 end
 
+task :upgrade => :package do
+  system("gem uninstall rubycom -a")
+  load "#{File.expand_path(File.dirname(__FILE__))}/lib/rubycom/version.rb"
+  system("gem install #{File.expand_path(File.dirname(__FILE__))}/rubycom-#{Rubycom::VERSION}.gem")
+end
+
 task :version_set, [:version] do |t, args|
+  raise "Must provide a version.\n If you called 'rake version_set 1.2.3', try 'rake version_set[1.2.3]'" if args[:version].nil? || args[:version].empty?
+
   version_file = <<-END.gsub(/^ {4}/, '')
     module Rubycom
       VERSION = "#{args[:version]}"

data/lib/rubycom.rb

@@ -1,7 +1,9 @@
-require "#{File.expand_path(File.dirname(__FILE__))}/rubycom/version.rb"
+require "#{File.dirname(__FILE__)}/rubycom/arguments.rb"
+require "#{File.dirname(__FILE__)}/rubycom/commands.rb"
+require "#{File.dirname(__FILE__)}/rubycom/documentation.rb"
+require "#{File.dirname(__FILE__)}/rubycom/version.rb"
+
 require 'yaml'
-require 'find'
-require 'method_source'
 
 # Upon inclusion in another Module, Rubycom will attempt to call a method in the including module by parsing
 # ARGV for a method name and a list of arguments.
@@ -35,59 +37,78 @@ module Rubycom
       command = args[0] || nil
       arguments = args[1..-1] || []
 
-      if command == 'help'
-        help_topic = arguments[0]
-        if help_topic.nil?
-          usage = self.get_usage(base)
-          puts usage
-          return usage
-        else
-          cmd_usage = self.get_command_usage(base, help_topic, arguments[1..-1])
-          puts cmd_usage
-          return cmd_usage
-        end
-      elsif command == 'job'
-        begin
-          raise CLIError, 'No job specified' if arguments[0].nil? || arguments[0].empty?
-          job_hash = YAML.load_file(arguments[0])
-          job_hash = {} if job_hash.nil?
-          STDOUT.sync = true
-          if arguments.delete('-test') || arguments.delete('--test')
-            puts "[Test Job #{arguments[0]}]"
-            job_hash['steps'].each { |step, step_hash|
-              step = "[Step: #{step}/#{job_hash['steps'].length}]"
-              context = step_hash.select{|key| key!="cmd"}.map{|key,val| "[#{key}: #{val}]"}.join(' ')
-              env = job_hash['env'] || {}
-              env.map { |key, val| step_hash['cmd'].gsub!("env[#{key}]", "#{((val.class == String)&&(val.match(/\w+/))) ? "\"#{val}\"" : val}") }
-              cmd = "[cmd: #{step_hash['cmd']}]"
-              puts "#{[step,context,cmd].join(' ')}"
-            }
+      case command
+        when 'register_completions'
+          puts self.register_completions(base)
+        when 'tab_complete'
+          puts self.tab_complete(base, args)
+        when 'help'
+          help_topic = arguments[0]
+          if help_topic.nil?
+            usage = Documentation.get_usage(base)
+            default_usage = Documentation.get_default_commands_usage
+            puts usage
+            puts default_usage
+            return usage+"\n"+default_usage
+          elsif help_topic == 'job'
+            usage = Documentation.get_job_usage(base)
+            puts usage
+            return usage
+          elsif help_topic == 'register_completions'
+            usage = Documentation.get_register_completions_usage(base)
+            puts usage
+            return usage
+          elsif help_topic == 'tab_complete'
+            usage = Documentation.get_tab_complete_usage(base)
+            puts usage
+            return usage
           else
-            puts "[Job #{arguments[0]}]"
-            job_hash['steps'].each { |step, step_hash|
-              step = "[Step: #{step}/#{job_hash['steps'].length}]"
-              context = step_hash.select{|key| key!="cmd"}.map{|key,val| "[#{key}: #{val}]"}.join(' ')
-              env = job_hash['env'] || {}
-              env.map { |key, val| step_hash['cmd'].gsub!("env[#{key}]", "#{((val.class == String)&&(val.match(/\w+/))) ? "\"#{val}\"" : val}") }
-              cmd = "[cmd: #{step_hash['cmd']}]"
-              puts "#{[step,context,cmd].join(' ')}"
-              system(step_hash['cmd'])
-            }
+            cmd_usage = Documentation.get_command_usage(base, help_topic, arguments[1..-1])
+            puts cmd_usage
+            return cmd_usage
           end
-        rescue CLIError => e
-          $stderr.puts e
-        end
-      else
-        output = self.run_command(base, command, arguments)
-        std_output = nil
-        std_output = output.to_yaml unless [String, NilClass, TrueClass, FalseClass, Fixnum, Float, Symbol].include?(output.class)
-        puts std_output || output
-        return output
+        when 'job'
+          begin
+            raise CLIError, 'No job specified' if arguments[0].nil? || arguments[0].empty?
+            job_hash = YAML.load_file(arguments[0])
+            job_hash = {} if job_hash.nil?
+            STDOUT.sync = true
+            if arguments.delete('-test') || arguments.delete('--test')
+              puts "[Test Job #{arguments[0]}]"
+              job_hash['steps'].each { |step, step_hash|
+                step = "[Step: #{step}/#{job_hash['steps'].length}]"
+                context = step_hash.select { |key| key!="cmd" }.map { |key, val| "[#{key}: #{val}]" }.join(' ')
+                env = job_hash['env'] || {}
+                env.each { |key, val| step_hash['cmd'].gsub!("env[#{key}]", "#{((val.class == String)&&(val.match(/\w+/))) ? "\"#{val}\"" : val}") }
+                cmd = "[cmd: #{step_hash['cmd']}]"
+                puts "#{[step, context, cmd].join(' ')}"
+              }
+            else
+              puts "[Job #{arguments[0]}]"
+              job_hash['steps'].each { |step, step_hash|
+                step = "[Step: #{step}/#{job_hash['steps'].length}]"
+                context = step_hash.select { |key| key!="cmd" }.map { |key, val| "[#{key}: #{val}]" }.join(' ')
+                env = job_hash['env'] || {}
+                env.each { |key, val| step_hash['cmd'].gsub!("env[#{key}]", "#{((val.class == String)&&(val.match(/\w+/))) ? "\"#{val}\"" : val}") }
+                cmd = "[cmd: #{step_hash['cmd']}]"
+                puts "#{[step, context, cmd].join(' ')}"
+                system(step_hash['cmd'])
+              }
+            end
+          rescue CLIError => e
+            $stderr.puts e
+          end
+        else
+          output = self.run_command(base, command, arguments)
+          std_output = nil
+          std_output = output.to_yaml unless [String, NilClass, TrueClass, FalseClass, Fixnum, Float, Symbol].include?(output.class)
+          puts std_output || output
+          return output
       end
 
     rescue CLIError => e
       $stderr.puts e
-      $stderr.puts self.get_summary(base)
+      $stderr.puts Documentation.get_summary(base)
     end
   end
 
@@ -100,314 +121,81 @@ module Rubycom
     arguments = [] if arguments.nil?
     raise CLIError, 'No command specified.' if command.nil? || command.length == 0
     begin
-      raise CLIError, "Invalid Command: #{command}" unless self.get_top_level_commands(base).include? command.to_sym
+      raise CLIError, "Invalid Command: #{command}" unless Commands.get_top_level_commands(base).include? command.to_sym
       if base.included_modules.map { |mod| mod.name.to_sym }.include?(command.to_sym)
         self.run_command(eval(command), arguments[0], arguments[1..-1])
       else
         method = base.public_method(command.to_sym)
         raise CLIError, "No public method found for symbol: #{command.to_sym}" if method.nil?
-        param_defs = self.get_param_definitions(method)
-        args = self.parse_arguments(param_defs, arguments)
+        param_defs = Arguments.get_param_definitions(method)
+        args = Arguments.parse_arguments(param_defs, arguments)
         flatten = false
-        params = method.parameters.map { |arr| flatten = true if arr[0]==:rest; args[arr[1]]}
+        params = method.parameters.map { |arr| flatten = true if arr[0]==:rest; args[arr[1]] }
         if flatten
           rest_arr = params.delete_at(-1)
-          rest_arr.each{|arg| params << arg}
+          rest_arr.each { |arg| params << arg }
         end
         (arguments.nil? || arguments.empty?) ? method.call : method.call(*params)
       end
     rescue CLIError => e
       $stderr.puts e
-      $stderr.puts self.get_command_usage(base, command, arguments)
-    end
-  end
-
-  # Parses the given arguments and matches them to the given parameters
-  #
-  # @param [Hash] parameters a Hash representing the parameters to match.
-  #         Entries should match :param_name => { type: :req||:opt||:rest,
-  #                                               def:(source_definition),
-  #                                               default:(default_value || :nil_rubycom_required_param)
-  #                                              }
-  # @param [Array] arguments an Array of Strings representing the arguments to be parsed
-  # @return [Hash] a Hash mapping the defined parameters to their matching argument values
-  def self.parse_arguments(parameters={}, arguments=[])
-    raise CLIError, 'parameters may not be nil' if parameters.nil?
-    raise CLIError, 'arguments may not be nil' if arguments.nil?
-    sorted_args = arguments.map { |arg|
-      Rubycom.parse_arg(arg)
-    }.group_by { |hsh|
-      hsh.keys.first
-    }.map { |key, arr|
-      (key == :rubycom_non_opt_arg) ? Hash[key, arr.map { |hsh| hsh.values }.flatten(1)] : Hash[key, arr.map { |hsh| hsh.values.first }.reduce(&:merge)]
-    }.reduce(&:merge) || {}
-
-    sorted_arg_count = sorted_args.map{|key,val| val}.flatten(1).length
-    types = parameters.values.group_by { |hsh| hsh[:type] }.map { |type, defs_arr| Hash[type, defs_arr.length] }.reduce(&:merge) || {}
-    raise CLIError, "Wrong number of arguments. Expected at least #{types[:req]}, received #{sorted_arg_count}" if sorted_arg_count < (types[:req]||0)
-    raise CLIError, "Wrong number of arguments. Expected at most #{(types[:req]||0) + (types[:opt]||0)}, received #{sorted_arg_count}" if types[:rest].nil? && (sorted_arg_count > ((types[:req]||0) + (types[:opt]||0)))
-
-    parameters.map { |param_sym, def_hash|
-      if def_hash[:type] == :req
-        raise CLIError, "No argument available for #{param_sym}" if sorted_args[:rubycom_non_opt_arg].nil? || sorted_args[:rubycom_non_opt_arg].length == 0
-        Hash[param_sym, sorted_args[:rubycom_non_opt_arg].shift]
-      elsif def_hash[:type] == :opt
-        if sorted_args[param_sym].nil?
-          arg = (sorted_args[:rubycom_non_opt_arg].nil? || sorted_args[:rubycom_non_opt_arg].empty?) ? parameters[param_sym][:default] : sorted_args[:rubycom_non_opt_arg].shift
-        else
-          arg = sorted_args[param_sym]
-        end
-        Hash[param_sym, arg]
-      elsif def_hash[:type] == :rest
-        ret = Hash[param_sym, ((!sorted_args[param_sym].nil?) ? sorted_args[param_sym] : sorted_args[:rubycom_non_opt_arg])]
-        sorted_args[:rubycom_non_opt_arg] = []
-        ret
-      end
-    }.reduce(&:merge)
-  end
-
-  # Uses YAML.load to parse the given String
-  #
-  # @param [String] arg a String representing the argument to be parsed
-  # @return [Object] the result of parsing the given arg with YAML.load
-  def self.parse_arg(arg)
-    return Hash[:rubycom_non_opt_arg, nil] if arg.nil?
-    if arg.is_a?(String) && ((arg.match(/^[-]{3,}\w+/) != nil) || ((arg.match(/^[-]{1,}\w+/) == nil) && (arg.match(/^\w+=/) != nil)))
-      raise CLIError, "Improper option specification, options must start with one or two dashes. Received: #{arg}"
-    elsif arg.is_a?(String) && arg.match(/^(-|--)\w+[=|\s]{1}/) != nil
-      k, v = arg.partition(/^(-|--)\w+[=|\s]{1}/).select { |part|
-        !part.empty?
-      }.each_with_index.map { |part, index|
-        index == 0 ? part.chomp('=').gsub(/^--/, '').gsub(/^-/, '').strip.to_sym : (YAML.load(part) rescue "#{part}")
-      }
-      Hash[k, v]
-    else
-      begin
-        parsed_arg = YAML.load("#{arg}")
-      rescue Exception
-        parsed_arg = "#{arg}"
-      end
-      Hash[:rubycom_non_opt_arg, parsed_arg]
+      $stderr.puts Documentation.get_command_usage(base, command, arguments)
     end
   end
 
-  # Retrieves the summary for each command method in the given Module
+  # Inserts a tab completion into the current user's .bash_profile with a command entry to register the function for
+  # the current running ruby file
   #
   # @param [Module] base the module which invoked 'include Rubycom'
-  # @return [String] the summary for each command method in the given Module
-  def self.get_summary(base)
-    self.get_top_level_commands(base).each_with_index.map { |sym, index|
-      "#{"Commands:\n" if index == 0}" << self.get_command_summary(base, sym, self.get_separator(sym, self.get_longest_command_name(base).length))
-    }.reduce(:+) or "No Commands found for #{base}."
-  end
-
-  # Creates a separator with the appropriate spacing to line up a command/description pair in a command list
-  #
-  # @param [Symbol] sym
-  # @param [Integer] spacer_length
-  # @return [String] a spaced separator String for use in a command/description list
-  def self.get_separator(sym, spacer_length=0)
-    [].unshift(" " * (spacer_length - sym.to_s.length)).join << "  -  "
-  end
+  # @return [String] a message indicating the result of the command
+  def self.register_completions(base)
+    completion_function = <<-END.gsub(/^ {4}/, '')
+
+    _#{base}_complete() {
+      COMPREPLY=()
+      local completions="$(ruby #{File.absolute_path($0)} tab_complete ${COMP_WORDS[*]} 2>/dev/null)"
+      COMPREPLY=( $(compgen -W "$completions") )
+    }
+    complete -o bashdefault -o default -o nospace -F _#{base}_complete #{$0.split('/').last}
+    END
 
-  # Retrieves the summary for the given command_name
-  #
-  # @param [Module] base the module which invoked 'include Rubycom'
-  # @param [String] command_name the command to retrieve usage for
-  # @return [String] a summary of the given command_name
-  def self.get_command_summary(base, command_name, separator = '  -  ')
-    raise CLIError, "Can not get usage for #{command_name} with base: #{base||"nil"}" if base.nil? || !base.respond_to?(:included_modules)
-    return 'No command specified.' if command_name.nil? || command_name.length == 0
-    if base.included_modules.map { |mod| mod.name.to_sym }.include?(command_name.to_sym)
-      begin
-      mod_const = Kernel.const_get(command_name.to_sym)
-      desc = File.read(mod_const.public_method(mod_const.singleton_methods().first).source_location.first).split(//).reduce(""){|str,c|
-        unless str.gsub("\n",'').gsub(/\s+/,'').include?("module#{mod_const}")
-          str << c
-          end
-          str
-      }.split("\n").select{|line| line.strip.match(/^#/)}.map{|line| line.strip.gsub(/^#+/,'')}.join("\n")
-      rescue
-        desc = ""
-      end
+    already_registered = File.readlines("#{Dir.home}/.bash_profile").map { |line| line.include?("_#{base}_complete()") }.reduce(:|) rescue false
+    if already_registered
+      "Completion function for #{base} already registered."
     else
-      raise CLIError, "Invalid command for #{base}, #{command_name}" unless base.public_methods.include?(command_name.to_sym)
-      desc = self.get_doc(base.public_method(command_name.to_sym))[:desc].join("\n") rescue ""
+      File.open("#{Dir.home}/.bash_profile", 'a+') { |file|
+        file.write(completion_function)
+      }
+      "Registration complete, run 'source #{Dir.home}/.bash_profile' to enable auto-completion."
     end
-    (desc.nil?||desc=='nil'||desc.length==0) ? "#{command_name}\n" : self.get_formatted_summary(command_name, desc, separator)
-  end
-
-  # Arranges the given command_name and command_description with the separator in a standard format
-  #
-  # @param [String] command_name the command format
-  # @param [String] command_description the description for the given command
-  # @param [String] separator optional separator to use
-  def self.get_formatted_summary(command_name, command_description, separator = '  -  ')
-    width = 95
-    prefix = command_name.to_s.split(//).map { " " }.join + separator.split(//).map { " " }.join
-    line_width = width - prefix.length
-    description_msg = command_description.gsub(/(.{1,#{line_width}})(?: +|$)\n?|(.{#{line_width}})/, "#{prefix}"+'\1\2'+"\n")
-    "#{command_name}#{separator}#{description_msg.lstrip}"
   end
 
-  # Retrieves the usage description for the given Module with a list of command methods
+  # Discovers a list of possible matches to the given arguments
+  # Intended for use with bash tab completion
   #
   # @param [Module] base the module which invoked 'include Rubycom'
-  # @return [String] the usage description for the module with a list of command methods
-  def self.get_usage(base)
-    return '' if base.nil? || !base.respond_to?(:included_modules)
-    return '' if self.get_top_level_commands(base).size == 0
-    "Usage:\n    #{base} <command> [args]\n\n" << self.get_summary(base)
-  end
-
-  # Retrieves the usage description for the given command_name
-  #
-  # @param [Module] base the module which invoked 'include Rubycom'
-  # @param [String] command_name the command to retrieve usage for
-  # @param [Array] args the remaining args other than the command_name, used of sub-command look-ups
-  # @return [String] the detailed usage description for the given command_name
-  def self.get_command_usage(base, command_name, args=[])
-    raise CLIError, "Can not get usage for #{command_name} with base: #{base||"nil"}" if base.nil? || !base.respond_to?(:included_modules)
-    return 'No command specified.' if command_name.nil? || command_name.length == 0
-    if base.included_modules.map { |mod| mod.name.to_sym }.include?(command_name.to_sym)
-      if args.empty?
-        self.get_usage(eval(command_name.to_s))
-      else
-        self.get_command_usage(eval(command_name.to_s), args[0], args[1..-1])
-      end
-    else
-      raise CLIError, "Invalid command for #{base}, #{command_name}" unless base.public_methods.include?(command_name.to_sym)
-      m = base.public_method(command_name.to_sym)
-      method_doc = self.get_doc(m) || {}
-
-      msg = "Usage: #{m.name} #{self.get_param_usage(m)}\n"
-      msg << "#{"Parameters:"}\n" unless m.parameters.empty?
-      msg << "#{method_doc[:param].join("\n    ")}\n" unless method_doc[:param].nil?
-      msg << "#{"Returns:"}\n"  unless method_doc[:return].nil?
-      msg << "#{method_doc[:return].join("\n    ")}\n" unless method_doc[:return].nil?
-      msg
-    end
-  end
-
-  # Discovers the given Method's parameters and uses them to build a formatted usage string
-  #
-  # @param [Method] method the Method object to generate usage for
-  def self.get_param_usage(method)
-    return "" if method.parameters.nil? || method.parameters.empty?
-    method.parameters.map { |type, param| {type => param}
-    }.group_by { |entry| entry.keys.first
-    }.map { |key, val| Hash[key, val.map { |param| param.values.first }]
-    }.reduce(&:merge).map { |type, arr|
-      if type == :req
-        Hash[type, arr.map { |param| " <#{param.to_s}>" }.reduce(:+)]
-      elsif type == :opt
-        Hash[type, "[#{arr.map { |param| "-#{param}=val" }.join("|")}]"]
-      else
-        Hash[type, "[&#{arr.join(',')}]"]
+  # @param [Array] arguments a String Array representing the arguments to be matched
+  # @return [Array] a String Array including the possible matches for the given arguments
+  def self.tab_complete(base, arguments)
+    arguments = [] if arguments.nil?
+    args = (arguments.include?("tab_complete")) ? arguments[2..-1] : arguments
+    matches = ['']
+    if args.nil? || args.empty?
+      matches = Rubycom::Commands.get_top_level_commands(base).map { |sym| sym.to_s }
+    elsif args.length == 1
+      matches = Rubycom::Commands.get_top_level_commands(base).map { |sym| sym.to_s }.select { |word| !word.match(/^#{args[0]}/).nil? }
+      if matches.size == 1 && matches[0] == args[0]
+        matches = self.tab_complete(Kernel.const_get(args[0].to_sym), args[1..-1])
       end
-    }.reduce(&:merge).values.join(" ")
-  end
-
-  # Builds a hash mapping parameter names (as symbols) to their
-  # :type (:req,:opt,:rest), :def (source_definition), :default (default_value || :nil_rubycom_required_param)
-  # for each parameter defined by the given method.
-  #
-  # @param [Method] method the Method who's parameter hash should be built
-  # @return [Hash] a Hash representing the given Method's parameters
-  def self.get_param_definitions(method)
-    raise CLIError, 'method must be an instance of the Method class' unless method.class == Method
-    method.parameters.map { |param|
-      param[1].to_s
-    }.map { |param_name|
-      {param_name.to_sym => method.source.split("\n").select { |line| line.include?(param_name) }.first}
-    }.map { |param_hash|
-      param_def = param_hash.flatten[1].gsub(/(def\s+self\.#{method.name.to_s}|def\s+#{method.name.to_s})/, '').lstrip.chomp.chomp(')').reverse.chomp('(').reverse.split(',').map { |param_n| param_n.lstrip }.select { |candidate| candidate.include?(param_hash.flatten[0].to_s) }.first
-      Hash[
-          param_hash.flatten[0],
-          Hash[
-              :def, param_def,
-              :type, method.parameters.select { |arr| arr[1] == param_hash.flatten[0] }.flatten[0],
-              :default, (param_def.include?('=') ? YAML.load(param_def.split('=')[1..-1].join('=')) : :nil_rubycom_required_param)
-          ]
-      ]
-    }.reduce(&:merge) || {}
-  end
-
-  # Retrieves the given method's documentation from it's source code
-  #
-  # @param [Method] method the Method who's documentation should be retrieved
-  # @return [Hash] a Hash representing the given Method's documentation, documentation parsed as follows:
-  #                :desc = the first general method comment lines,
-  #                :word = each @word comment (i.e.- a line starting with @param will be saved as :param => ["line"])
-  def self.get_doc(method)
-    method.comment.split("\n").map { |line|
-      line.gsub(/#\s*/, '') }.group_by { |doc|
-      if doc.match(/^@\w+/).nil?
-        :desc
-      else
-        doc.match(/^@\w+/).to_s.gsub('@', '').to_sym
+    elsif args.length > 1
+      begin
+        matches = self.tab_complete(Kernel.const_get(args[0].to_sym), args[1..-1])
+      rescue Exception
+        matches = ['']
       end
-    }.map { |key, val|
-      Hash[key, val.map { |val_line| val_line.gsub(/^@\w+/, '').lstrip }.select { |line| line != '' }]
-    }.reduce(&:merge)
-  end
-
-  # Looks up the commands which will be available on the given base Module and returns the longest command name
-  # Used in arranging the command list format
-  #
-  # @param [Module] base the base Module to look up
-  # @return [String] the longest command name which will show in a list of commands for the given base Module
-  def self.get_longest_command_name(base)
-    return '' if base.nil?
-    self.get_commands(base, false).map { |_, mod_hash|
-      mod_hash[:commands] + mod_hash[:inclusions].flatten }.flatten.max_by(&:size) or ''
-  end
-
-  # Retrieves the singleton methods in the given base and included Modules
-  #
-  # @param [Module] base the module which invoked 'include Rubycom'
-  # @param [Boolean] all if true recursively search for included modules' commands, if false return only top level commands
-  # @return [Hash] a Hash of Symbols representing the command methods in the given base and it's included modules (if all=true)
-  def self.get_commands(base, all=true)
-    return {} if base.nil? || !base.respond_to?(:singleton_methods) || !base.respond_to?(:included_modules)
-    {
-        base.name.to_sym => {
-            commands: base.singleton_methods(true).select { |sym| ![:included, :extended].include?(sym) },
-            inclusions: base.included_modules.select { |mod|
-              ![:Rubycom].include?(mod.name.to_sym)
-            }.map { |mod|
-              all ? self.get_commands(mod) : mod.name.to_sym
-            }
-        }
-    }
-  end
-
-  # Discovers the commands specified in the given base without considering the commands contained in sub-modules
-  #
-  # @param [Module] base the base Module to search
-  # @return [Array] a list of command name symbols which are defined in the given Module
-  def self.get_top_level_commands(base)
-    return {} if base.nil? || !base.respond_to?(:singleton_methods) || !base.respond_to?(:included_modules)
-    excluded_commands = [:included, :extended]
-    excluded_modules = [:Rubycom]
-    base.singleton_methods(true).select { |sym| !excluded_commands.include?(sym) } +
-        base.included_modules.select { |mod| !excluded_modules.include?(mod.name.to_sym) }.map { |mod| mod.name.to_sym }.flatten
-  end
-
-  # Discovers the commands specified in the given base and included Modules
-  #
-  # @param [Module] base the base Module to search
-  # @return [Hash] a set of command name symbols mapped to containing Modules
-  def self.index_commands(base)
-    excluded_commands = [:included, :extended]
-    excluded_modules = [:Rubycom]
-    Hash[base.singleton_methods(true).select { |sym| !excluded_commands.include?(sym) }.map { |sym|
-      [sym, base]
-    }].merge(
-        base.included_modules.select { |mod| !excluded_modules.include?(mod.name.to_sym) }.map { |mod|
-          self.index_commands(mod)
-        }.reduce(&:merge) || {}
-    )
+    end unless base.nil?
+    matches = [''] if matches.nil? || matches.include?(args[0])
+    matches
   end
 
 end