coderunner 0.17.11 → 0.18.0

data/lib/coderunner/class_methods.rb

@@ -278,24 +278,14 @@ class CodeRunner
     end
   end
 
+  # Used by the help method defined in interactive_methods.rb
   def self.reference(class_or_method, copts={})
-    code_folders = Dir.recursive_entries(SCRIPT_FOLDER + '/code_modules').grep(/\/ri$/).map{|fold| ['-d', fold]}.flatten
-#     ep code_folders
-
-#     require 'rdoc/ri/driver'
-
-# "
-#     op = @ri_count ? [] : (@ri_count = true; ['--no-use-cache'])
-#     trap(1){puts 'No help available'}
-#     at_exit{raise ""}
-#     p op
     begin
       eputs "Looking up #{class_or_method}"
-      RDoc::RI::Driver.run ['-d', SCRIPT_FOLDER + '/ri', class_or_method.to_s] + code_folders
-    rescue => err
+      RDoc::RI::Driver.run [class_or_method.to_s] 
+    rescue SystemExit => err
       eputs "Unknown class or method or no help available: #{err}"
     end
-#     trap(1){}
   end
 
   def self.directory(id, copts={})

data/lib/coderunner/config.rb

@@ -0,0 +1,87 @@
+#In this file we set up the global coderunner configuration
+#
+
+require 'rubygems'
+require "rubyhacks"
+require 'fileutils'
+
+class CodeRunner
+
+  GLOBAL_OPTIONS = {
+    system: 'generic_linux', # See coderunner/system_modules for more options
+    short_run_name: false, # If true, use simple run_names like v_id_1
+    no_repo: true, # Disable CodeRunner repo, true for now as in development
+    simple_prompt: false, # If true have a less fancy prompt in interactive mode
+    non_interactive: false, # If true, don't prompt for feedback when executing commands. Use with caution.
+  }
+
+  class CodeRunner::ConfigError < StandardError
+  end
+
+
+  def self.global_options(option)
+    raise CodeRunner::ConfigError.new(
+      "Missing value for global option #{option.inspect}. Global options are #{GLOBAL_OPTIONS.inspect}."
+    ) unless GLOBAL_OPTIONS.keys.include?(option)
+    return GLOBAL_OPTIONS[option]
+  end
+
+
+  CONFIG_FOLDER = ENV['HOME'] + "/.coderunner"
+  CONFIG_FILE = CONFIG_FOLDER + '/config.rb'
+  #Create the coderunner config directory if it doesn't exist
+  FileUtils.makedirs(CONFIG_FOLDER)
+  COMMAND_FOLDER = Dir.pwd
+  SCRIPT_FOLDER = File.dirname(File.expand_path(__FILE__))  #i.e. where this script is
+
+
+  if FileTest.exist? CONFIG_FILE
+    load CONFIG_FILE
+  end
+  # Deprecated as insecure
+  if ENV['CODE_RUNNER_OPTIONS']
+    $stderr.puts 'WARNING: CODE_RUNNER_OPTIONS is insecure and deprecated. Please use ~/.coderunner/config instead'
+    begin
+      env_global_options = eval(ENV['CODE_RUNNER_OPTIONS']) # global options are set by the environment but some can be changed.
+      env_global_options.each{|k,v| GLOBAL_OPTIONS[k] = v}
+    rescue
+      raise CodeRunner::ConfigError.new("Environment variable CODE_RUNNER_OPTIONS is not a valid hash")
+    end
+  end
+  GLOBAL_OPTIONS.keys.each do |key|
+    env_string = 'CODE_RUNNER_' + key.to_s.upcase
+    if env_val = ENV[env_string]
+      GLOBAL_OPTIONS[:key] = 
+        case env_val
+        when 'true'
+          true
+        when 'false'
+          false
+        when /\d+/
+          env_val.to_i
+        when /\d[\deE+-\.]*/
+          env_val.to_f
+        else
+          env_val
+        end
+    end
+  end
+
+  SYS = GLOBAL_OPTIONS[:system]
+  require SCRIPT_FOLDER + "/system_modules/#{SYS}.rb"
+  SYSTEM_MODULE = const_get(SYS.variable_to_class_name)
+  include SYSTEM_MODULE
+  class << self
+    include SYSTEM_MODULE
+  end
+  @@sys = SYS
+  def gets #No reading from the command line thank you very much!
+    $stdin.gets
+  end
+  def self.gets
+    $stdin.gets
+  end
+
+  CodeRunner::CODE_RUNNER_VERSION = Version.new(Gem.loaded_specs['coderunner'].version.to_s) rescue "test"
+
+end

data/lib/coderunner/fortran_namelist.rb

@@ -301,10 +301,10 @@ def self.add_code_variable_to_namelist(namelist, var, value)
 	enum = $~ ? $~[:num] : nil
 	return if rcp.namelists[namelist] and rcp.namelists[namelist][:variables].map{|v, h| (h[:code_name] or v).to_s.downcase.to_sym}.include? var
 	namelists = rcp.namelists
-	namelist_file = 'namelists.rb'
+	_namelist_file = 'namelists.rb'
 # 	end
 	raise "This namelist: #{namelist} should have an enumerator and does not have one" if enum and (not rcp.namelists[namelist] or not rcp.namelists[namelist][:enumerator])
-  unless ENV['CR_NON_INTERACTIVE']
+  unless CodeRunner.global_options(:non_interactive)
   	return unless Feedback.get_boolean("An unknown variable has been found in this input file: \n\n\t Namelist: #{namelist}, Name: #{code_name}, Sample Value: #{value.inspect}.\n\nDo you wish to add it to the CodeRunner module? (Recommended: answer yes as long as the variable is not a typo)")
   end
 
@@ -320,7 +320,7 @@ def self.add_code_variable_to_namelist(namelist, var, value)
 	namelists[namelist][:should_include] ||= "true"
 	namelists[namelist][:variables] ||= {}
 	raise "Shouldn't have got here" if namelists[namelist][:variables][var]
-	tst = nil
+	_tst = nil
 
 	case value
 	when Float
@@ -366,7 +366,7 @@ def self.add_code_variable_to_namelist(namelist, var, value)
 		attr_accessor var
 	end
   save_namelists
-	edit_variable_help(namelist, var) unless ENV['CR_NON_INTERACTIVE']
+	edit_variable_help(namelist, var) unless CodeRunner.global_options(:non_interactive)
 # 	folder = File.dirname(__FILE__)
 # 	File.open(folder + '/' + namelist_file, 'w'){|f| f.puts namelists.pretty_inspect}
 end	
@@ -1230,14 +1230,14 @@ def self.process_synchronisation(source, nms, all_variables_in_source, namelist_
 
 	raise "No namelists found" if nms.size == 0
 	eputs nms.keys.zip(nms.values.map{|vs| vs.size})
-	eputs "Namelists to be added to. (Press Enter)"; STDIN.gets unless ENV['CR_NON_INTERACTIVE']
+	eputs "Namelists to be added to. (Press Enter)"; STDIN.gets unless CodeRunner.global_options(:non_interactive)
 	n = 0
   ep nms
 # 	ep nms.values.sum
 	nms.values.sum.each do |var|
 		eputs var if variable_exists? var
 	end
-	eputs "Conflicting Variables. (Press Enter)";; STDIN.gets unless ENV['CR_NON_INTERACTIVE']
+	eputs "Conflicting Variables. (Press Enter)";; STDIN.gets unless CodeRunner.global_options(:non_interactive)
 	nms.each do |namelist, vars|
 		ep namelist
 		ep vars

data/lib/coderunner/interactive_config.rb

@@ -0,0 +1,57 @@
+#############################################
+## Default configuration for interactive mode
+############################################
+
+
+$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 CodeRunner.global_options(:simple_prompt) 
+  #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#{CodeRunner::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
+
+if FileTest.exist? conf = CodeRunner::CONFIG_FOLDER + '/interactive_config.rb'
+  load conf
+end
+
+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

data/lib/coderunner/interactive_methods.rb

@@ -1,22 +1,22 @@
 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
+
+  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
       if @r
         histfile = @r.root_folder + '/.code-runner-irb-save-history'
         if FileTest.exist?(histfile)
@@ -28,13 +28,13 @@ class CodeRunner
         end
       end
 
-		end
-		def pwd
-			puts Dir.pwd
-		end
-		def runs
-			CodeRunner.runner.run_list
-		end
+    end
+    def pwd
+      puts Dir.pwd
+    end
+    def runs
+      CodeRunner.runner.run_list
+    end
     # Change the default root folder(s) for commands. If a runner
     # has not been loaded for a given folder, it will be loaded
     # as subsequently required.
@@ -44,84 +44,27 @@ class CodeRunner
     alias :crf :change_root_folder
 
 
-			
 
-		
-		INTERACTIVE_METHODS = <<EOF
 
 
+    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=>""}
-
+  end # module InteractiveMethods
 
-	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
-	
+  def CodeRunner.interactive_mode(copts={})
+    process_command_options(copts)
+    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
+    exec %[#{RbConfig::CONFIG['bindir']}/irb#{RbConfig::CONFIG['ruby_install_name'].sub(/ruby/, '')} -f -I '#{Dir.pwd}' -I '#{SCRIPT_FOLDER}'   -I '#{ENV['HOME']}'  -r 'coderunner/config' -r 'coderunner/interactive_config' -r 'coderunner' -r .int.tmp ]
+  end
 
-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 %[#{RbConfig::CONFIG['bindir']}/irb#{RbConfig::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
 
@@ -130,343 +73,317 @@ 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
-	
+
+  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
+
+    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}
+    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}"
+      #     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 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)
+        # Array
+        receiver = $1
+        message = Regexp.quote($2)
 
-	candidates = Array.instance_methods.collect{|m| m.to_s}
-	select_message(receiver, message, candidates)
+        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}
+        # 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
+        #         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}
-
-	
+        # 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}
+        # 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 /^(.*-?(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)
+        # 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)
+        regmessage = Regexp.new(Regexp.quote($1))
+        candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
 
-#      when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
+        #      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)
+        # 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)
+        # unknown(maybe String)
 
-	receiver = ""
-	message = Regexp.quote($1)
+        receiver = ""
+        message = Regexp.quote($1)
 
-	candidates = String.instance_methods(true).collect{|m| m.to_s}
-	select_message(receiver, message, candidates)
+        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)}/)
+        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
 
   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
+
+  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
-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
+  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
-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=")
@@ -476,9 +393,9 @@ Readline.completion_append_character = "BB"
 Readline.completion_proc = IRB::InputCompletor::CodeRunnerCompletionProc
 
 begin
-if Readline.respond_to?("basic_quote_characters=")
-  Readline.basic_quote_characters= "\"'`"
-end
+  if Readline.respond_to?("basic_quote_characters=")
+    Readline.basic_quote_characters= "\"'`"
+  end
 rescue NotImplementedError
 end
 
@@ -489,306 +406,35 @@ 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
+class Object
+  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
-#   rescue NotFoundError => e
-#     eputs e
-# 		return
+    CodeRunner.reference("#{self.to_s}#{join}#{meth_or_const}")
   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
+end
 
-      opt.on("--width=WIDTH", "-w", OptionParser::DecimalInteger,
-             "Set the width of the output.") do |value|
-        options[:width] = value
+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
-
-    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
+    CodeRunner.reference("#{self.to_s}#{join}#{meth_or_const}")
   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