coderunner 0.11.0

data/lib/coderunner/interactive_methods.rb

@@ -0,0 +1,776 @@
+class CodeRunner
+	
+	module InteractiveMethods
+		COMMANDS.each do |command|
+			eval("def #{command[1]}(*args) 
+# 			     if args[-1].kind_of? 
+					CodeRunner.send(#{command[0].to_sym.inspect}, *args)
+						end")
+		end
+		def up
+			ObjectSpace.each_object{|obj| obj.update if obj.class.to_s =~ /CodeRunner$/}
+			nil
+		end
+		def cd(dirct)
+			Dir.chdir(dirct)
+		end
+		def setup_interactive
+			@runner = CodeRunner.fetch_runner(CodeRunner::DEFAULT_COMMAND_OPTIONS.dup) unless CodeRunner::DEFAULT_COMMAND_OPTIONS[:q]
+			@r = @runner
+		end
+		def pwd
+			puts Dir.pwd
+		end
+		def runs
+			CodeRunner.runner.run_list
+		end
+
+
+			
+
+		
+		INTERACTIVE_METHODS = <<EOF
+
+
+include CodeRunner::InteractiveMethods
+setup_interactive
+module Kernel
+
+		alias_method(:shell_do, "`".to_sym)
+	def `(cmd)
+		c =caller
+		if c[0] =~ /irb_binding/
+			system(cmd)
+		else
+			shell_do(cmd)
+		end
+	end
+end
+EOF
+
+	end # module InteractiveMethods
+
+  	def CodeRunner.interactive_mode(copts={})
+		process_command_options(copts)
+	  			unless false and FileTest.exist? (ENV['HOME'] + '/code_runner_interactive_options.rb')
+				File.open(ENV['HOME'] + '/.code_runner_interactive_options.rb', 'w') do |file|
+					file.puts <<EOF
+	$has_put_startup_message_for_code_runner = true #please leave!
+	$code_runner_interactive_mode = true #please leave!
+	require 'yaml'
+
+	def reset
+	  Dispatcher.reset_application!
+	end
+	  
+	IRB.conf[:AUTO_INDENT] = true
+	IRB.conf[:USE_READLINE] = true
+	IRB.conf[:LOAD_MODULES] = []  unless IRB.conf.key?(:LOAD_MODULES)
+	unless IRB.conf[:LOAD_MODULES].include?('irb/completion')
+	  IRB.conf[:LOAD_MODULES] << 'irb/completion'
+	end      
+
+				
+	require 'irb/completion'
+	require 'irb/ext/save-history'
+	require 'socket'
+unless ENV['CODE_RUNNER_SYSTEM'] == 'macosx'
+	prompt_start = "\001#{Terminal::LIGHT_GREEN}\002CodeRunner\001#{Terminal::RESET}\002 v#{CODE_RUNNER_VERSION} - \001#{Terminal::CYAN}\002#\{ENV['USER']\}@#\{Socket::gethostname\}:#\{File.basename(Dir.pwd)}\001#{Terminal::RESET}\002 timemarker\n"
+	prompt_start = "\001#{Terminal::LIGHT_GREEN}\002CodeRunner\001#{Terminal::RESET}\002 v#{CODE_RUNNER_VERSION} - \001#{Terminal::CYAN}\002#\{Socket::gethostname\}:#\{File.basename(Dir.pwd)}\001#{Terminal::RESET}\002 timemarker %02n,%i \n"
+else
+		prompt_start = "CodeRunner #\{File.basename(Dir.pwd)}"
+end
+  IRB.conf[:PROMPT][:CODE_RUNNER] = {:PROMPT_I=>"#\{prompt_start}>> %02n,%i >> ", :PROMPT_N=>"#\{prompt_start}>> %02n:%i > ", :PROMPT_S=>"#\{prompt_start}>> %02n:%i (%l)> ", :PROMPT_C=>"#\{prompt_start}>> %02n:%i >>  ", :RETURN=>""}
+  IRB.conf[:PROMPT][:CODE_RUNNER] = {:PROMPT_I=>"#\{prompt_start}>> ", :PROMPT_N=>"#\{prompt_start}> ", :PROMPT_S=>"#\{prompt_start}(%l)> ", :PROMPT_C=>"#\{prompt_start}>>  ", :RETURN=>""}
+#   IRB.conf[:PROMPT][:CODE_RUNNER] = {:PROMPT_I=>"#\{prompt_start} %02n,%i>> ", :PROMPT_N=>"#\{prompt_start} %02n:%i> ", :PROMPT_S=>"#\{prompt_start} %02n:%i (%l)> ", :PROMPT_C=>"#\{prompt_start} %02n:%i>>  ", :RETURN=>""}
+
+
+	IRB.conf[:PROMPT_MODE] = :CODE_RUNNER
+	IRB.conf[:SAVE_HISTORY] = 400
+	IRB.conf[:HISTORY_FILE] = "\#\{Dir.pwd}/.code-runner-irb-save-history"
+	IRB.conf[:INSPECT_MODE] = false
+	
+
+EOF
+				end # File.open
+			end # unless
+			File.open(".int.tmp.rb", 'w')do |file|
+				file.puts "#{copts.inspect}.each do |key, val|
+					CodeRunner::DEFAULT_COMMAND_OPTIONS[key] = val
+				end"
+				file.puts CodeRunner::InteractiveMethods::INTERACTIVE_METHODS
+			end
+# 			asdfa
+			exec %[#{Config::CONFIG['bindir']}/irb#{Config::CONFIG['ruby_install_name'].sub(/ruby/, '')} -f -I '#{Dir.pwd}' -I '#{SCRIPT_FOLDER}'   -I '#{ENV['HOME']}' -r '.code_runner_interactive_options' -r 'coderunner' -r .int.tmp ]
+	end
+		
+
+end
+
+
+require "readline"
+
+
+module IRB
+	
+	COMMANDS = ENV['PATH'].split(':').inject([]) do |comms,dir|
+# 		ep dir
+		begin
+			dir = dir.sub(/~/, ENV['HOME'])
+			Dir.entries(dir).each do |file|
+				file = "#{dir}/#{file}"
+	# 			ep file
+				comms.push(File.basename(file)) if FileTest.executable? file #and File.file? file
+			end
+		rescue
+		end
+		comms
+	end
+	COMMANDS.delete_if{|com| com =~ /^\./}
+# 	ep 'COMMANDS', COMMANDS
+	
+  module InputCompletor
+		
+		def self.complete_files(receiver, message)
+# 			files = message.split(/\s+/)
+# 			message = files.pop
+			dir = message.sub(/[^\/]*$/, '')
+			message = message.sub(Regexp.new("#{Regexp.escape(dir)}"), '')
+			dir.sub!(/^~/, ENV['HOME'])
+			short_dir = dir
+			dir = Dir.pwd + '/' + dir unless dir =~ /^\//
+			#$stderr.puts "Dir to scan: #{dir}"
+
+			files = Dir.entries(dir)
+
+			#$stderr.puts "entries", files
+		  Dir.chdir(dir){files= files.map{|file| FileTest.directory?(file) ? file + "/" : file}}
+			#$stderr.puts "entries - directories", files
+
+		  candidates = message.size > 0 ? files.find_all{|com| com[0...message.size] == message} : files
+			return candidates.map{|com| receiver + short_dir + com}
+			
+			
+			old_dir = message.sub(/[^\/]*$/, '')
+			dir = old_dir.chomp("/")
+			message = message.sub(Regexp.new("#{Regexp.escape(dir)}\\/"), '')
+			if dir.size > 0
+# 			eputs 'dir', dir
+# 				unless old_dir ~= /^\//
+					dir = Dir.pwd + '/' + dir
+# 				end
+# 				eputs 'dir', dir, FileTest.directory?(dir)
+				if FileTest.directory? dir
+					files = Dir.entries(dir)
+				else
+					files = []
+				end
+			else
+				dir = Dir.pwd
+				files = Dir.entries(dir)
+			end
+# 			ep files
+# 			ep 'mess', message
+			Dir.chdir(dir){files= files.map{|file| FileTest.directory?(file) ? file + "/" : file}}
+# 			ep dir, files
+			candidates = message.size > 0 ? files.find_all{|com| com[0...message.size] == message} : files
+			candidates.map{|com| receiver + old_dir + com}
+		rescue 
+			return []
+		end
+
+    @RCS_ID='-$Id: completion.rb 23233 2009-04-19 13:35:47Z yugui $-'
+
+      
+    CodeRunnerCompletionProc = proc do |input|
+      bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+      Readline.completion_append_character = nil
+#     eputs "\n\ninput: #{input}"
+
+
+      case input
+			when Regexp.new("^(#{/\w+\b.*(?:\s|,)(?::p\s+\=\>|p:)\s+\[?\s*/}(?:#{Regexp.quoted_string}\\s*,\\s*)*#{/'\{(?:[^}]*\s)?:?/})(\\w+)$")
+				# matches CodeRunner parameter list.... command [stuff] p: '{var: value, var
+				receiver = $1
+				message = $2
+# 				ep 'mess', message
+				if CodeRunner.runner and CodeRunner.runner.run_class
+					candidates = CodeRunner.runner.run_class.rcp.variables.map{|var| var.to_s}.find_all{|var| var[0...message.size] == message}.map{|var| receiver + var}
+				else
+					candidates = []
+				end
+			when /^('(?:(?:\\ |[^'\s])*\s+)*)((?:\\ |[^'\s])*)$/, Regexp.new("^((?:[^']|#{Regexp.quoted_string})*')([^']*)$")
+				#filename in a single quoted string
+						                      	receiver = "#$1" # "`" #$~[1]
+			message = "#$2" #Regexp.quote($~[2]) # $2 #Regexp.quote($2)
+# 			ep 'mess', message
+			complete_files(receiver, message)
+			
+
+				
+			when /^(\`\w+\s+(?:\S+\s+)*)([^`\s]*)$/, /^([^`]*`\w+\s+)([^`]*)$/
+		#shell command with an executable
+		                      	receiver = $1 # "`" #$~[1]
+	message = $2 #Regexp.quote($~[2]) # $2 #Regexp.quote($2)
+			complete_files(receiver, message)
+# 			files = Dir.entries(File.dirname(message))
+# 			candidates = message.size > 0 ? files.find_all{|com| com[0...message.size] == message} : files
+# 			candidates.map{|com| receiver + com}
+
+			when /^(\`)([^`]*)$/, /^([^`]*`)([^`]*)$/
+		#shell command without an excutable
+		                      
+# 				p $~
+		                      	receiver = $1 # "`" #$~[1]
+	message = $2 #Regexp.quote($~[2]) # $2 #Regexp.quote($2)
+# 	ep "message is", message
+# 	ep COMMANDS.grep(//)
+	candidates = message.size > 0 ? COMMANDS.find_all{|com| com[0...message.size] == message} : COMMANDS
+	candidates.map{|com| receiver + com}
+	#.grep(Regexp.new("^#{message}")) #("^#{Regexp.escape(message)}")) #.map{|com| "#{com}"} #.map{|com| receiver + com}
+# 	ep candidates
+# 	select_message(receiver, message, COMMANDS)
+
+			     when /^([^\/]*\/[^\/]*\/)\.([^.]*)$/
+	# Regexp
+	receiver = $1
+	message = Regexp.quote($2)
+
+	candidates = Regexp.instance_methods.collect{|m| m.to_s}
+	select_message(receiver, message, candidates)
+
+      when /^([^\]]*\])\.([^.]*)$/
+	# Array
+	receiver = $1
+	message = Regexp.quote($2)
+
+	candidates = Array.instance_methods.collect{|m| m.to_s}
+	select_message(receiver, message, candidates)
+
+      when /([^\}]*\})\.([^.]*)$/
+	# Proc or Hash
+	receiver = $1
+	message = Regexp.quote($2)
+
+	candidates = Proc.instance_methods.collect{|m| m.to_s}
+	candidates |= Hash.instance_methods.collect{|m| m.to_s}
+	select_message(receiver, message, candidates)
+	
+		
+ 		when /^((?:(::)?[A-Z][^:.(]*)+)\.help :(\w*)$/
+			# CodeRunner help method
+			receiver = $1
+			message = Regexp.quote($3)
+			begin
+					candidates = eval("(#{receiver}.constants - Object.constants).collect{|m| m.to_s}", bind)
+					candidates |= eval("(#{receiver}.methods - Object.methods).collect{|m| m.to_s}", bind)
+					begin
+						candidates |= eval("(#{receiver}.instance_methods - Object.instance_methods).collect{|m| m.to_s}", bind)
+					rescue
+					end
+				rescue Exception
+					candidates = []
+				end
+			candidates.grep(/^#{message}/).collect{|e| receiver + '.help :' + e}
+
+      when /^((?:.*[^:])?:[^:.]*)$/
+# 				eputs 'found symbol'
+ 	# Symbol
+	if Symbol.respond_to?(:all_symbols)
+	  sym = $1
+	  candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+	  candidates.grep(/^#{sym}/)
+	else
+	  []
+	end
+
+      when /^(.*\s)?(((::)?[A-Z][^:.(]*)+)(::|\.)([^:.]*)$/
+	# Constant or class methods
+# 				p "CCC"
+	start = $1
+	receiver = $2
+	message = Regexp.quote($6)
+	joiner = "#$5"
+	begin
+	  candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
+	  candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
+	rescue Exception
+	  candidates = []
+	end
+	candidates.grep(/^#{message}/).collect{|e| (start or "") + receiver + (joiner or "::") + e}
+
+	
+      when /^(.*)(\b[A-Z][^:\.\(]*)$/
+	# Absolute Constant or class methods
+	receiver = $1
+	message = $2
+	candidates = Object.constants.collect{|m| m.to_s}
+	candidates.grep(/^#{message}/).collect{|e| receiver + e}
+
+	
+
+      when /^(.*-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+	# Numeric
+	receiver = $1
+	message = Regexp.quote($5)
+
+	begin
+	  candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+	rescue Exception
+	  candidates = []
+	end
+	select_message(receiver, message, candidates)
+
+      when /^(.*-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+	# Numeric(0xFFFF)
+	receiver = $1
+	message = Regexp.quote($2)
+
+	begin
+	  candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+	rescue Exception
+	  candidates = []
+	end
+	select_message(receiver, message, candidates)
+
+      when /^(.*[\s\{\[])?(\$[^.]*)$/
+	regmessage = Regexp.new(Regexp.quote($1))
+	candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+
+#      when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
+      when /^((\.?[^.]+)+)\.([^.]*)$/
+	# variable
+	receiver = $1
+	message = Regexp.quote($3)
+
+	gv = eval("global_variables", bind).collect{|m| m.to_s}
+	lv = eval("local_variables", bind).collect{|m| m.to_s}
+	cv = eval("self.class.constants", bind).collect{|m| m.to_s}
+	
+	if (gv | lv | cv).include?(receiver)
+	  # foo.func and foo is local var.
+	  candidates = eval("#{receiver}.methods", bind).collect{|m| m.to_s}
+	elsif /^[A-Z]/ =~ receiver and /\./ !~ receiver
+	  # Foo::Bar.func
+	  begin
+	    candidates = eval("#{receiver}.methods", bind).collect{|m| m.to_s}
+	  rescue Exception
+	    candidates = []
+	  end
+	else
+	  # func1.func2
+	  candidates = []
+	  ObjectSpace.each_object(Module){|m|
+	    begin
+	      name = m.name
+	    rescue Exception
+	      name = ""
+	    end
+	    next if name != "IRB::Context" and 
+	      /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+	    candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+	  }
+	  candidates.sort!
+	  candidates.uniq!
+	end
+	select_message(receiver, message, candidates)
+
+      when /^\.([^.]*)$/
+	# unknown(maybe String)
+
+	receiver = ""
+	message = Regexp.quote($1)
+
+	candidates = String.instance_methods(true).collect{|m| m.to_s}
+	select_message(receiver, message, candidates)
+
+      else
+	candidates = eval("methods | private_methods | local_variables | self.class.constants", bind).collect{|m| m.to_s}
+			  
+	(candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
+
+      end
+			end
+
+  end
+	
+	    def self.select_message(receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect do |e|
+	if receiver =~ /^.*`/
+		receiver + e
+	else
+		case e
+		when /^[a-zA-Z_]/
+			receiver + "." + e
+		when /^[0-9]/
+		when *Operators
+		
+			
+			#receiver + " " + e
+		end
+	end
+      end
+    end
+class InputMethod
+end
+class ReadlineInputMethod < InputMethod
+      include Readline 
+			 def gets
+        Readline.input = @stdin
+        Readline.output = @stdout
+				prompt_end = Time.now.to_s[11...16]
+				begin
+					memsize = `ps ax -o pid,rss | grep -E "^[[:space:]]*#{Process::pid}"`.chomp.split(/\s+/).map {|s| s.strip.to_i}[1].to_i/1000
+					prompt_end += " #{memsize}k"
+				rescue
+				end
+				prompt_end +=" (#{CodeRunner::SETUP_RUN_CLASSES.join(",")})"
+	if l = readline(@prompt.gsub(/timemarker/, prompt_end) , false)
+	  #HISTORY.push(l) if !l.empty? and (HISTORY.size ==0 or l != HISTORY[-1])
+	  HISTORY.push(l) if !l.empty? and (HISTORY.size ==0 or l != HISTORY[-1])
+
+		i = 0
+		loop do
+			break if HISTORY.size == 1
+			(HISTORY.delete_at(i); i-=1) if HISTORY[i] == l
+			i+=1
+			#ep "i: #{i}, HS: #{HISTORY.size}"
+			break if i >= HISTORY.size - 1
+		end
+		#HISTORY.reverse!
+		#HISTORY.uniq!
+		#HISTORY.reverse!
+	  #HISTORY.push(l) if !l.empty? and (HISTORY.size ==0 or !HISTORY.include? l)
+	  @line[@line_no += 1] = l + "\n"
+	else
+	  @eof = true
+	  l
+	end
+      end
+end
+		
+end #module IRB
+
+if Readline.respond_to?("basic_word_break_characters=")
+  Readline.basic_word_break_characters= "\t\n><=;|&("
+end
+Readline.completion_append_character = "BB"
+Readline.completion_proc = IRB::InputCompletor::CodeRunnerCompletionProc
+
+begin
+if Readline.respond_to?("basic_quote_characters=")
+  Readline.basic_quote_characters= "\"'`"
+end
+rescue NotImplementedError
+end
+
+module Kernel
+
+end
+
+require 'rdoc'
+require 'rdoc/ri/driver'
+
+class RDoc::RI::Driver
+  def run
+    if(@list_doc_dirs)
+      puts @doc_dirs.join("\n")
+    elsif @names.empty? then
+      @display.list_known_classes class_cache.keys.sort
+    else
+	
+			@names.each do |name|
+        if class_cache.key? name then
+          method_map = display_class name
+          if(@interactive)
+            method_name = @display.get_class_method_choice(method_map)
+
+            if(method_name != nil)
+              method = lookup_method "#{name}#{method_name}", name
+              display_method method
+            end
+          end
+        elsif name =~ /::|\#|\./ then
+          klass, = parse_name name
+
+          orig_klass = klass
+          orig_name = name
+
+          loop do
+            method = lookup_method name, klass
+
+            break method if method
+
+            ancestor = lookup_ancestor klass, orig_klass
+
+            break unless ancestor
+
+            name = name.sub klass, ancestor
+            klass = ancestor
+          end
+					
+# 					return unless method
+
+          raise NotFoundError, orig_name unless method
+
+          display_method method
+        else
+          methods = select_methods(/#{name}/)
+
+          if methods.size == 0
+          return  
+						raise NotFoundError, name
+          elsif methods.size == 1
+            display_method methods[0]
+          else
+            if(@interactive)
+              @display.display_method_list_choice methods
+            else
+              @display.display_method_list methods
+            end
+          end
+        end
+      end
+    end
+#   rescue NotFoundError => e
+#     eputs e
+# 		return
+  end
+	
+	 def self.process_args(argv)
+    options = default_options
+
+    opts = OptionParser.new do |opt|
+      opt.program_name = File.basename $0
+      opt.version = RDoc::VERSION
+      opt.release = nil
+      opt.summary_indent = ' ' * 4
+
+      directories = [
+        RDoc::RI::Paths::SYSDIR,
+        RDoc::RI::Paths::SITEDIR,
+        RDoc::RI::Paths::HOMEDIR
+      ]
+
+      if RDoc::RI::Paths::GEMDIRS then
+        Gem.path.each do |dir|
+          directories << "#{dir}/doc/*/ri"
+        end
+      end
+
+      opt.banner = <<-EOT
+Usage: #{opt.program_name} [options] [names...]
+
+Where name can be:
+
+  Class | Class::method | Class#method | Class.method | method
+
+All class names may be abbreviated to their minimum unambiguous form. If a name
+is ambiguous, all valid options will be listed.
+
+The form '.' method matches either class or instance methods, while #method
+matches only instance and ::method matches only class methods.
+
+For example:
+
+    #{opt.program_name} Fil
+    #{opt.program_name} File
+    #{opt.program_name} File.new
+    #{opt.program_name} zip
+
+Note that shell quoting may be required for method names containing
+punctuation:
+
+    #{opt.program_name} 'Array.[]'
+    #{opt.program_name} compact\\!
+
+By default ri searches for documentation in the following directories:
+
+    #{directories.join "\n    "}
+
+Specifying the --system, --site, --home, --gems or --doc-dir options will
+limit ri to searching only the specified directories.
+
+Options may also be set in the 'RI' environment variable.
+      EOT
+
+      opt.separator nil
+      opt.separator "Options:"
+      opt.separator nil
+
+      opt.on("--fmt=FORMAT", "--format=FORMAT", "-f",
+             RDoc::RI::Formatter::FORMATTERS.keys,
+             "Format to use when displaying output:",
+             "   #{RDoc::RI::Formatter.list}",
+             "Use 'bs' (backspace) with most pager",
+             "programs. To use ANSI, either disable the",
+             "pager or tell the pager to allow control",
+             "characters.") do |value|
+        options[:formatter] = RDoc::RI::Formatter.for value
+      end
+
+      opt.separator nil
+
+      opt.on("--doc-dir=DIRNAME", "-d", Array,
+             "List of directories from which to source",
+             "documentation in addition to the standard",
+             "directories.  May be repeated.") do |value|
+        value.each do |dir|
+          unless File.directory? dir then
+            raise OptionParser::InvalidArgument, "#{dir} is not a directory"
+          end
+
+          options[:extra_doc_dirs] << File.expand_path(dir)
+        end
+      end
+
+      opt.separator nil
+
+      opt.on("--[no-]use-cache",
+             "Whether or not to use ri's cache.",
+             "True by default.") do |value|
+        options[:use_cache] = value
+      end
+
+      opt.separator nil
+
+      opt.on("--no-standard-docs",
+             "Do not include documentation from",
+             "the Ruby standard library, site_lib,",
+             "installed gems, or ~/.rdoc.",
+             "Equivalent to specifying",
+             "the options --no-system, --no-site, --no-gems,",
+             "and --no-home") do
+        options[:use_system] = false
+        options[:use_site] = false
+        options[:use_gems] = false
+        options[:use_home] = false
+      end
+
+      opt.separator nil
+
+      opt.on("--[no-]system",
+             "Include documentation from Ruby's standard",
+             "library.  Defaults to true.") do |value|
+        options[:use_system] = value
+      end
+
+      opt.separator nil
+
+      opt.on("--[no-]site",
+             "Include documentation from libraries",
+             "installed in site_lib.",
+             "Defaults to true.") do |value|
+        options[:use_site] = value
+      end
+
+      opt.separator nil
+
+      opt.on("--[no-]gems",
+             "Include documentation from RubyGems.",
+             "Defaults to true.") do |value|
+        options[:use_gems] = value
+      end
+
+      opt.separator nil
+
+      opt.on("--[no-]home",
+             "Include documentation stored in ~/.rdoc.",
+             "Defaults to true.") do |value|
+        options[:use_home] = value
+      end
+
+      opt.separator nil
+
+      opt.on("--list-doc-dirs",
+             "List the directories from which ri will",
+             "source documentation on stdout and exit.") do
+        options[:list_doc_dirs] = true
+      end
+
+      opt.separator nil
+
+      opt.on("--no-pager", "-T",
+             "Send output directly to stdout,",
+             "rather than to a pager.") do
+        options[:use_stdout] = true
+      end
+
+      opt.on("--interactive", "-i",
+             "This makes ri go into interactive mode.",
+             "When ri is in interactive mode it will",
+             "allow the user to disambiguate lists of",
+             "methods in case multiple methods match",
+             "against a method search string.  It also",
+             "will allow the user to enter in a method",
+             "name (with auto-completion, if readline",
+             "is supported) when viewing a class.") do
+        options[:interactive] = true
+      end
+
+      opt.separator nil
+
+      opt.on("--width=WIDTH", "-w", OptionParser::DecimalInteger,
+             "Set the width of the output.") do |value|
+        options[:width] = value
+      end
+    end
+
+    argv = ENV['RI'].to_s.split.concat argv
+
+    opts.parse! argv
+
+    options[:names] = argv
+
+    options[:formatter] ||= RDoc::RI::Formatter.for('plain')
+    options[:use_stdout] ||= !$stdout.tty?
+    options[:use_stdout] ||= options[:interactive]
+    options[:width] ||= 72
+
+    options
+
+  rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+    puts opts
+    puts
+    puts e
+#     exit 1
+  end
+
+end
+
+
+	class Object
+# 		def help
+# 			CodeRunner.ri(self.to_s)
+# 		end
+		def self.help(meth_or_const=nil)
+			join = ""
+			if meth_or_const
+				if self.constants.include? meth_or_const.to_sym
+					join = "::"
+				elsif self.methods.include? meth_or_const.to_sym
+					join = "."
+				elsif self.instance_methods.include? meth_or_const.to_sym
+					join = "#"
+				end
+			end
+			CodeRunner.reference("#{self.to_s}#{join}#{meth_or_const}")
+		end
+	end
+	
+	class Module
+
+		def help(meth_or_const=nil)
+			join = ""
+			if meth_or_const
+				if self.constants.include? meth_or_const.to_sym
+					join = "::"
+				elsif self.methods.include? meth_or_const.to_sym
+					join = "."
+				elsif self.instance_methods.include? meth_or_const.to_sym
+					join = "#"
+				end
+			end
+			CodeRunner.reference("#{self.to_s}#{join}#{meth_or_const}")
+		end
+	end