Module: IRB::InputCompletor

Defined in:
lib/coderunner/interactive_methods.rb

Overview

ep ‘COMMANDS’, COMMANDS

Constant Summary collapse

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

Class Method Summary collapse

Class Method Details

.complete_files(receiver, message) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/coderunner/interactive_methods.rb', line 134

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