vim/runtime/autoload/rubycomplete.vim

" Vim completion script
" Language:				Ruby
" Maintainer:			Mark Guzman ( segfault AT hasno DOT info )
" Info:					$Id$
" URL:					http://vim-ruby.rubyforge.org
" Anon CVS:				See above site
" Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
" ----------------------------------------------------------------------------
"
" Ruby IRB/Complete author: Keiju ISHITSUKA(keiju@ishitsuka.com)
" ----------------------------------------------------------------------------

if !has('ruby')
    echo "Error: Required vim compiled with +ruby"
    finish
endif

if version < 700
    echo "Error: Required vim >= 7.0"
    finish
endif

func! GetRubyVarType(v)
	let stopline = 1
	let vtp = ''
	let pos = getpos('.')
	let [lnum,lcol] = searchpos('^\s*#\s*@var\s*'.a:v.'\>\s\+[^ \t]\+\s*$','nb',stopline)
	if lnum != 0 && lcol != 0
		call setpos('.',pos)
		let str = getline(lnum)
		let vtp = substitute(str,'^\s*#\s*@var\s*'.a:v.'\>\s\+\([^ \t]\+\)\s*$','\1','')
		return vtp
	endif
	call setpos('.',pos)
	let [lnum,lcol] = searchpos(''.a:v.'\>\s*[+\-*/]*=\s*\([^ \t]\+.\(now\|new\|open\|get_instance\)\>\|[\[{"'']\)','nb',stopline)
	if lnum != 0 && lcol != 0
		let str = matchstr(getline(lnum),'=\s*\([^ \t]\+.\(now\|new\|open\|get_instance\)\>\|[\[{"'']\)',lcol)
		let str = substitute(str,'^=\s*','','')
		call setpos('.',pos)
		if str == '"' || str == ''''
			return 'String'
		elseif str == '['
			return 'Array'
		elseif str == '{'
			return 'Hash'
		elseif strlen(str) > 4
            let l = stridx(str,'.')
			return str[0:l-1]
		end
		return ''
	endif
	call setpos('.',pos)
    return ''
endf

function! rubycomplete#Complete(findstart, base)
     "findstart = 1 when we need to get the text length
    if a:findstart
        let line = getline('.')
        let idx = col('.')
        while idx > 0
            let idx -= 1
            let c = line[idx-1]
            if c =~ '\w'
                continue
            elseif ! c =~ '\.'
                idx = -1
                break
            else
                break
            endif
        endwhile

        return idx
    "findstart = 0 when we need to return the list of completions
    else
        execute "ruby get_completions('" . a:base . "')"
        return g:rbcomplete_completions
    endif
endfunction


function! s:DefRuby()
ruby << RUBYEOF
ReservedWords = [
      "BEGIN", "END",
      "alias", "and",
      "begin", "break",
      "case", "class",
      "def", "defined", "do",
      "else", "elsif", "end", "ensure",
      "false", "for",
      "if", "in",
      "module",
      "next", "nil", "not",
      "or",
      "redo", "rescue", "retry", "return",
      "self", "super",
      "then", "true",
      "undef", "unless", "until",
      "when", "while",
      "yield",
    ]

Operators = [ "%", "&", "*", "**", "+",  "-",  "/",
      "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
      "[]", "[]=", "^", ]

def identify_type(var)
    @buf = VIM::Buffer.current
    enum = @buf.line_number
    snum = (enum-10).abs
    nums = Range.new( snum, enum )
    regxs = '/.*(%s)\s*=(.*)/' % var
    regx = Regexp.new( regxs )
    nums.each do |x|
        ln = @buf[x]
        #print $~ if regx.match( ln )
    end
end

def load_requires
    @buf = VIM::Buffer.current
    enum = @buf.line_number
    nums = Range.new( 1, enum )
    nums.each do |x|
        ln = @buf[x]
        begin
            eval( "require %s" % $1 ) if /.*require\s*(.*)$/.match( ln )
        rescue Exception
            #ignore?
        end
    end
end

def get_completions(base)
    load_requires
    input = VIM::evaluate('expand("<cWORD>")')
    input += base
    message = nil


    case input
      when /^(\/[^\/]*\/)\.([^.]*)$/
        # Regexp
        receiver = $1
        message = Regexp.quote($2)

        candidates = Regexp.instance_methods(true)
        select_message(receiver, message, candidates)

      when /^([^\]]*\])\.([^.]*)$/
        # Array
        receiver = $1
        message = Regexp.quote($2)

        candidates = Array.instance_methods(true)
        select_message(receiver, message, candidates)

      when /^([^\}]*\})\.([^.]*)$/
        # Proc or Hash
        receiver = $1
        message = Regexp.quote($2)

        candidates = Proc.instance_methods(true) | Hash.instance_methods(true)
        select_message(receiver, message, candidates)

      when /^(:[^:.]*)$/
        # Symbol
        if Symbol.respond_to?(:all_symbols)
          sym = $1
          candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
          candidates.grep(/^#{sym}/)
        else
          []
        end

      when /^::([A-Z][^:\.\(]*)$/
        # Absolute Constant or class methods
        receiver = $1
        candidates = Object.constants
        candidates.grep(/^#{receiver}/).collect{|e| "::" + e}

      when /^(((::)?[A-Z][^:.\(]*)+)::?([^:.]*)$/
        # Constant or class methods
        receiver = $1
        message = Regexp.quote($4)
        begin
          candidates = eval("#{receiver}.constants | #{receiver}.methods")
        rescue Exception
          candidates = []
        end
        candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}

      when /^(:[^:.]+)\.([^.]*)$/
        # Symbol
        receiver = $1
        message = Regexp.quote($2)

        candidates = Symbol.instance_methods(true)
        select_message(receiver, message, candidates)

      when /^([0-9_]+(\.[0-9_]+)?(e[0-9]+)?)\.([^.]*)$/
        # Numeric
        receiver = $1
        message = Regexp.quote($4)

        begin
          candidates = eval(receiver).methods
        rescue Exception
          candidates
        end
        select_message(receiver, message, candidates)

      when /^(\$[^.]*)$/
	      candidates = global_variables.grep(Regexp.new(Regexp.quote($1)))

#      when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
      when /^((\.?[^.]+)+)\.([^.]*)$/
        # variable
        receiver = $1
        message = Regexp.quote($3)

        cv = eval("self.class.constants")

        vartype = VIM::evaluate("GetRubyVarType('%s')" % receiver)
        if vartype != ''
          candidates = eval("#{vartype}.instance_methods")
        elsif (cv).include?(receiver)
          # foo.func and foo is local var.
          candidates = eval("#{receiver}.methods")
        elsif /^[A-Z]/ =~ receiver and /\./ !~ receiver
          # Foo::Bar.func
          begin
            candidates = eval("#{receiver}.methods")
          rescue Exception
            candidates = []
          end
        else
          # func1.func2
          candidates = []
          ObjectSpace.each_object(Module){|m|
            next if m.name != "IRB::Context" and
              /^(IRB|SLex|RubyLex|RubyToken)/ =~ m.name
            candidates.concat m.instance_methods(false)
          }
          candidates.sort!
          candidates.uniq!
        end
        #identify_type( receiver )
        select_message(receiver, message, candidates)

    #when /^((\.?[^.]+)+)\.([^.]*)\(\s*\)*$/
        #function call
        #obj = $1
        #func = $3

      when /^\.([^.]*)$/
	# unknown(maybe String)

        receiver = ""
        message = Regexp.quote($1)

        candidates = String.instance_methods(true)
        select_message(receiver, message, candidates)

    else
      candidates = eval("self.class.constants")

      (candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
    end

    #print candidates
    if message != nil && message.length > 0
        rexp = '^%s' % message.downcase
        candidates.delete_if do |c|
            c.downcase.match( rexp )
            $~ == nil
        end
    end

    outp = ""
    #    tags = VIM::evaluate("taglist('^%s$')" %
    (candidates-Object.instance_methods).each { |c| outp += "{'word':'%s','item':'%s'}," % [ c, c ] }
    outp.sub!(/,$/, '')
    VIM::command("let g:rbcomplete_completions = [%s]" % outp)
end


def select_message(receiver, message, candidates)
  candidates.grep(/^#{message}/).collect do |e|
    case e
      when /^[a-zA-Z_]/
        receiver + "." + e
      when /^[0-9]/
      when *Operators
        #receiver + " " + e
    end
  end
  candidates.delete_if { |x| x == nil }
  candidates.uniq!
  candidates.sort!
end
RUBYEOF
endfunction

call s:DefRuby()
" vim: set et ts=4: