'lib-subpaths': ['/', True],

'object-methods': ['.', False],

'literal-methods': ['.', False],

'available-modules': [' ', False],

'available-modules-and-classes': ['<', False],

'module-names': [':', False],

'instance-vars': ['@', True],

'class-vars': ['@', True],

'global-vars': ['$', True],

lang = "Ruby"

def __init__(self):

self._properties = SilverCity.PropertySet()

self._lexer = SilverCity.find_lexer_module_by_id(SCLEX_RUBY)

self._keyword_lists = [

SilverCity.WordList(ruby_keywords)

def __init__(self, ctlr, buf, trg, expr, line, converted_dot_new=None):

CitadelEvaluator.__init__(self, ctlr, buf, trg, expr, line)

self.converted_dot_new = converted_dot_new

def post_process_calltips(self, calltips):

if self.converted_dot_new:

# "Foo.new(" is really using "Foo.initialize(". We swapped

# that for calltip evaluation, now swap it back.

for i, c in enumerate(calltips):

if c.startswith("initialize"):

calltips[i] = "new" + c[len("initialize"):]

return calltips

def post_process_cplns(self, cplns):

"""Skip operator-typical methods like "+", "===", etc.

cplns = [c for c in cplns if isident(c[1][0])]

cplns.sort(key=lambda c: c[1].upper())

def __init__(self, ctlr, buf, trg, import_handler, prefix):

Evaluator.__init__(self, ctlr, buf, trg)

self.import_handler = import_handler

self.prefix = prefix

def __str__(self):

return "Ruby subimports of '%s'" % self.prefix

def eval(self, mgr):

self.ctlr.set_desc("subimports of '%s'" % self.prefix)

cwd = dirname(self.buf.path) # XXX Should eventually use relevant env

# TODO:XXX Update to use the newer `find_importables_in_dir`.

# `findSubImportsOnDisk` is deprecated.

subimports = self.import_handler.findSubImportsOnDisk(

self.prefix, cwd)

if subimports:

cplns = []

for subimport in subimports:

if subimport[-1] == '/':

cplns.append(("directory", subimport[:-1]))

else:

cplns.append(("module", subimport))

cplns.sort(key=lambda c: c[1].upper())

self.ctlr.set_cplns(cplns)

lang = "Ruby"

sce_prefixes = ["SCE_RB_"]

cb_show_if_empty = True

# Characters that should automatically invoke the current completion item:

# XXX Figure out the appropriate set (get Eric to help).

# - Cannot be '!' or '?' or '=' (I think) because those can be part of a

# method name.

# - Cannot be "'" or '"' because that can get in the way. E.g.:

# require 'cgi<|>

# At this point the selected item can be "cgi-lib". Filling up

# with a quote would select "cgi-lib" instead of the possibly

# intended "cgi".

# - Cannot be '.' because of '..' operator for ranges. E.g.:

# 1..1000

# would result in (or whatever the first Fixnum method is):

# 1.abs.1000

cpln_fillup_chars = "~`@#$%^&*(+}[]|\\;:,<>/ "

cpln_stop_chars = cpln_fillup_chars + "'\"."

def __init__(self, mgr, accessor, env=None, path=None, *args, **kwargs):

CitadelBuffer.__init__(self, mgr, accessor, env, path, *args, **kwargs)

self.check_for_rails_app_path(path)

# Skip styles are a bit different for Ruby:

# - for *some* cases autocomplete *is* automatically triggered

# in a string

# - you *can* trigger on a number

self.implicit_completion_skip_styles = dict(

(s, True) for s in self.comment_styles())

self.completion_skip_styles = self.implicit_completion_skip_styles.copy(

)

self.completion_skip_styles[SCE_RB_REGEX] = True

@property

def libs(self):

def __init__(self, buf):

self.buf = buf

@property

def ignore_styles(self):

# This class delegates mostly to its Buffer object.

# class-specific methods first...

def is_ruby_style_at_pos(self, pos):

# All chars are in Ruby code in pure Ruby buffers,

# no need to get the style at position pos

return True

def is_identifier_or_word_style(self, style):

return style == SCE_RB_IDENTIFIER or style == SCE_RB_WORD

def is_identifier_style(self, style):

return style == SCE_RB_IDENTIFIER

def is_operator_style(self, style):

return style == SCE_RB_OPERATOR

def is_default_style(self, style):

return style == SCE_RB_DEFAULT

def is_identifier_or_definition_style(self, style):

""" Check if a style is either a identifier reference or a definition

return style in (SCE_RB_IDENTIFIER, SCE_RB_CLASSNAME,

SCE_RB_DEFNAME, SCE_RB_MODULE_NAME)

def __getattr__(self, name):

return getattr(self.buf, name)

def __init__(self, buf):

_CommonStyleClassifier.__init__(self, buf)

self._implicit_completion_skip_styles = None

self._completion_skip_styles = None

def is_ruby_style_at_pos(self, pos):

style = self.buf.accessor.style_at_pos(pos)

return SCE_UDL_SSL_DEFAULT <= style <= SCE_UDL_SSL_VARIABLE

@property

def implicit_completion_skip_styles(self):

if self._implicit_completion_skip_styles is None:

# XXX - do we have access to the language info?

self._implicit_completion_skip_styles = {

ScintillaConstants.SCE_UDL_SSL_COMMENT: True,

ScintillaConstants.SCE_UDL_SSL_COMMENTBLOCK: True,

}

return self._implicit_completion_skip_styles

@property

def completion_skip_styles(self):

if self._completion_skip_styles is None:

self._completion_skip_styles = {

ScintillaConstants.SCE_UDL_SSL_COMMENT: True,

ScintillaConstants.SCE_UDL_SSL_COMMENTBLOCK: True,

ScintillaConstants.SCE_UDL_SSL_REGEX: True,

}

return self._completion_skip_styles

def is_identifier_or_word_style(self, style):

return style == SCE_UDL_SSL_IDENTIFIER or style == SCE_UDL_SSL_WORD

def is_identifier_style(self, style):

return style == SCE_UDL_SSL_IDENTIFIER

def is_identifier_or_definition_style(self, style):

return style == SCE_UDL_SSL_IDENTIFIER

def is_operator_style(self, style):

return style == SCE_UDL_SSL_OPERATOR

# These aren't properties in buffer.py, so they can't be here either.

def comment_styles(self):

return (ScintillaConstants.SCE_UDL_SSL_COMMENT,)

def number_styles(self):

return (ScintillaConstants.SCE_UDL_SSL_NUMBER,)

def string_styles(self):

return (ScintillaConstants.SCE_UDL_SSL_STRING, )

def is_default_style(self, style):

return style == SCE_UDL_SSL_DEFAULT

ignoreStyles = (ScintillaConstants.SCE_UDL_SSL_DEFAULT,

ParenStyleCalltipIntelMixin,

ProgLangTriggerIntelMixin):

lang = "Ruby"

calltip_region_terminators = tuple(']});\r\n')

# newlines are for ending calltips triggered on a space

def libs_from_buf(self, buf):

env = buf.env

# A buffer's libs depend on its env and the buf itself so

# we cache it on the env and key off the buffer.

if "ruby-buf-libs" not in env.cache:

env.cache["ruby-buf-libs"] = weakref.WeakKeyDictionary()

cache = env.cache["ruby-buf-libs"] # <buf-weak-ref> -> <libs>

if buf not in cache:

libs = self._buf_indep_libs_from_env(env)[:]

# - curdirlib (in Ruby '.' is *last* in the import path)

cwd = dirname(buf.path)

if cwd != "<Unsaved>":

libs.append(self.mgr.db.get_lang_lib(

"Ruby", "curdirlib", [cwd]))

cache[buf] = libs

return cache[buf]

def _ruby_from_env(self, env):

import which

path = [d.strip()

for d in env.get_envvar("PATH", "").split(os.pathsep)

if d.strip()]

try:

return which.which("ruby", path=path)

except which.WhichError:

return None

_gem_ver_ptn = re.compile(r'(.+?)(-[\d+\.]+)$')

def _ruby_info_from_ruby(self, ruby, env):

"""Call the given Ruby and return:

import process

# Ruby 1.5.2 does not support sys.version_info.

info_cmd = "puts RUBY_VERSION; puts $:"

argv = [ruby, "-e", info_cmd]

log.debug("run `%s -e ...'", ruby)

p = process.ProcessOpen(argv, env=env.get_all_envvars(), stdin=None)

stdout, stderr = p.communicate()

stdout_lines = stdout.splitlines(0)

retval = p.returncode

if retval:

log.warn("failed to determine Ruby info:\n"

" path: %s\n"

" retval: %s\n"

" stdout:\n%s\n"

" stderr:\n%s\n",

ruby, retval, indent('\n'.join(stdout_lines)),

indent(stderr))

ruby_ver = stdout_lines[0]

_ver_parts = ruby_ver.split('.', 2)

short_ver = '.'.join(_ver_parts[:2])

if len(_ver_parts) >= 3:

sub_minor_ver = int(_ver_parts[2])

else:

sub_minor_ver = 0

prefix = dirname(dirname(ruby))

libdir = join(prefix, "lib", "ruby", short_ver)

sitelibdir = join(prefix, "lib", "ruby", "site_ruby")

# Need to normpath() these because they come out, e.g.:

# c:/ruby184/lib/ruby/site_ruby/1.8

# on Windows.

import_path = [normpath(p) for p in stdout_lines[1:]]

def get_first_gem_dir_candidate():

gems_dir_part1 = join(prefix, "lib", "ruby", "gems")

gems_dir_version = join(gems_dir_part1, short_ver)

if exists(gems_dir_version):

return join(gems_dir_version, "gems")

for i in range(sub_minor_ver + 1):

cand_ver = "%s.%d" % (gems_dir_version, i)

if exists(cand_ver):

return join(cand_ver, "gems")

return None

# Get the list of relevant Gem lib dirs.

def gem_ver_from_ver_str(ver_str):

parts = ver_str.split('.')

try:

parts = list(map(int, parts))

except ValueError:

return ver_str

else:

return tuple(parts)

gems_dir = get_first_gem_dir_candidate()

gem_ver_and_dir_from_name = {

# "actionmailer": ((1,2,5), ".../actionmailer-1.2.5"),

}

if gems_dir:

for dir in glob(join(gems_dir, "*-*")):

if not isdir(dir):

continue

m = self._gem_ver_ptn.match(basename(dir))

if not m:

continue

name, ver_str = m.groups()

gem_ver = gem_ver_from_ver_str(ver_str)

if name in gem_ver_and_dir_from_name:

if gem_ver > gem_ver_and_dir_from_name[name][0]:

gem_ver_and_dir_from_name[name] = (gem_ver, dir)

else:

gem_ver_and_dir_from_name[name] = (gem_ver, dir)

log.debug("ruby gem dir info: %s", pformat(gem_ver_and_dir_from_name))

gem_lib_dirs = []

for name, (gem_ver, dir) in sorted(gem_ver_and_dir_from_name.items()):

gem_lib_dir = join(dir, "lib")

if isdir(gem_lib_dir):

gem_lib_dirs.append(gem_lib_dir)

return ruby_ver, libdir, sitelibdir, import_path, gem_lib_dirs

#def _extra_dirs_from_env(self, env):

# extra_dirs = set()

# for pref in env.get_all_prefs("rubyExtraPaths"):

# if not pref:

# continue

# # TODO: need to support Gems specially?

# extra_dirs.update(d.strip() for d in pref.split(os.pathsep) if exists(d.strip()))

# return tuple(extra_dirs)

def _buf_indep_libs_from_env(self, env):

"""Create the buffer-independent list of libs."""

cache_key = "ruby-libs"

if cache_key not in env.cache:

env.add_pref_observer("ruby", self._invalidate_cache)

env.add_pref_observer("rubyExtraPaths",

self._invalidate_cache_and_rescan_extra_dirs)

env.add_pref_observer("codeintel_selected_catalogs",

self._invalidate_cache)

db = self.mgr.db

# Gather information about the current ruby.

ruby = None

if env.has_pref("ruby"):

ruby = env.get_pref("ruby").strip() or None

if not ruby or not exists(ruby):

ruby = self._ruby_from_env(env)

if not ruby:

log.warn("no Ruby was found from which to determine the "

"import path")

ver, libdir, sitelibdir, import_path, gem_lib_dirs \

= None, None, None, [], []

else:

ver, libdir, sitelibdir, import_path, gem_lib_dirs \

= self._ruby_info_from_ruby(ruby, env)

libs = []

# - extradirslib

extra_dirs = self._extra_dirs_from_env(env)

if extra_dirs:

log.debug("Ruby extra lib dirs: %r", extra_dirs)

libs.append(db.get_lang_lib("Ruby", "extradirslib",

extra_dirs))

# Figure out which sys.path dirs belong to which lib.

paths_from_libname = {"sitelib": [], "envlib": [], "stdlib": []}

STATE = "envlib"

canon_libdir = libdir and normcase(libdir) or None

canon_sitelibdir = sitelibdir and normcase(sitelibdir) or None

for dir in import_path:

canon_dir = normcase(dir)

if dir == ".": # -> curdirlib (handled separately)

continue

# TODO: need to support gems specially?

elif dir.startswith(sitelibdir):

STATE = "sitelib"

elif dir.startswith(libdir):

STATE = "stdlib"

if not exists(dir):

continue

paths_from_libname[STATE].append(dir)

log.debug("Ruby %s paths for each lib:\n%s", ver, indent(

pformat(paths_from_libname)))

# - envlib, sitelib, gemlib, cataloglib, stdlib

if paths_from_libname["envlib"]:

libs.append(db.get_lang_lib("Ruby", "envlib",

paths_from_libname["envlib"]))

if paths_from_libname["sitelib"]:

libs.append(db.get_lang_lib("Ruby", "sitelib",

paths_from_libname["sitelib"]))

if gem_lib_dirs:

libs.append(db.get_lang_lib("Ruby", "gemlib", gem_lib_dirs))

catalog_selections = env.get_pref("codeintel_selected_catalogs")

libs += [

db.get_catalog_lib("Ruby", catalog_selections),

db.get_stdlib("Ruby", ver)

]

env.cache[cache_key] = libs

return env.cache[cache_key]

def _invalidate_cache(self, env, pref_name):

for key in ("ruby-buf-libs", "ruby-libs"):

if key in env.cache:

log.debug("invalidate '%s' cache on %r", key, env)

del env.cache[key]

def _invalidate_cache_and_rescan_extra_dirs(self, env, pref_name):

self._invalidate_cache(env, pref_name)

extra_dirs = self._extra_dirs_from_env(env)

if extra_dirs:

extradirslib = self.mgr.db.get_lang_lib(

"Ruby", "extradirslib", extra_dirs)

request = PreloadLibRequest(extradirslib)

self.mgr.idxr.stage_request(request, 1.0)

# All Ruby trigger points occur at one of these characters:

# '.' (period) [eval implemented]

# ' ' (space)

# '(' (open paren) [eval implemented]

# ':' (colon) "::" actually [eval implemented]

# '@' (at-sign) "@..." for instance var,

# "@@..." for class vars

# '$' (dollar sign)

# "'" (single-quote) [eval implemented]

# '"' (double-quote) [eval implemented]

# '/' (slash) [eval implemented]

#

# At least three characters into an identifier (\w_)+

#

# spaces -- for class inheritance, include, & call-tips

#

trg_chars = tuple('. (:@$"\'/') # the full set

calltip_trg_chars = tuple('( ')

RUBY_KEYWORDS = dict((k, True) for k in ruby_keywords.split())

def _get_prev_token_skip_ws(self, pos, accessor, styleClassifier):

prev_start_pos, prev_end_pos = accessor.contiguous_style_range_from_pos(

pos - 1)

if prev_start_pos == 0 or not styleClassifier.is_ruby_style_at_pos(prev_start_pos):

return prev_start_pos, prev_end_pos

prev_style = accessor.style_at_pos(prev_start_pos)

if styleClassifier.is_default_style(prev_style):

prev_start_pos, prev_end_pos = accessor.contiguous_style_range_from_pos(

prev_start_pos - 1)

return prev_start_pos, prev_end_pos

def _get_token_before_namelist(self, pos, accessor, styleClassifier, lim=-1):

""" Walk backwards skipping (name, comma) pairs.

while True:

prev_start_pos, prev_end_pos = self._get_prev_token_skip_ws(

pos, accessor, styleClassifier)

if prev_start_pos == 0 or not styleClassifier.is_ruby_style_at_pos(prev_start_pos):

return 0, 0

prev_style = accessor.style_at_pos(prev_start_pos)

if not styleClassifier.is_identifier_or_word_style(prev_style):

return 0, 0

prev_start_pos, prev_end_pos = self._get_prev_token_skip_ws(

prev_start_pos, accessor, styleClassifier)

if prev_start_pos == 0 or not styleClassifier.is_ruby_style_at_pos(prev_start_pos):

return 0, 0

elif not styleClassifier.is_operator_style(prev_style):

return 0, 0

op = accessor.text_range(prev_start_pos, prev_end_pos)

if op != ",":

return prev_start_pos, prev_end_pos

lim -= 1

if lim == 0:

return 0, 0

def _is_completable_name(self, pos, accessor, styleClassifier):

"""

if pos == 0:

return True

prev_start_pos, prev_end_pos = self._get_prev_token_skip_ws(

pos, accessor, styleClassifier)

if prev_start_pos == 0 or not styleClassifier.is_ruby_style_at_pos(prev_start_pos):

return True

prev_style = accessor.style_at_pos(prev_start_pos)

if not styleClassifier.is_operator_style(prev_style):

return True

op = accessor.text_range(prev_start_pos, prev_end_pos)

if op in (".", "::"):

return False

if op == ",":

prev_start_pos, prev_end_pos = self._get_token_before_namelist(

prev_start_pos,

accessor, styleClassifier,

lim=5)

if prev_start_pos <= 0:

return False

prev_style = accessor.style_at_pos(prev_start_pos)

if not styleClassifier.is_operator_style(prev_style):

return True

op = accessor.text_range(prev_start_pos, prev_end_pos)

if op[-1] != "|": # last character

return True

elif op == "{|":

# Special case due to the way the accessor combines tokens of same

# style

return False

# Now look back for either a brace or a 'do'

prev_start_pos, prev_end_pos = self._get_prev_token_skip_ws(

prev_start_pos, accessor, styleClassifier)

if prev_start_pos == 0 or not styleClassifier.is_ruby_style_at_pos(prev_start_pos):

return False

op = accessor.text_range(prev_start_pos, prev_end_pos)

return op not in ("{", "do")

def trg_from_pos(self, buf, pos, implicit=True, DEBUG=False):

"""If the given position is a _likely_ trigger point, return the

if pos <= 0:

return None

styleClassifier = (isinstance(buf, UDLBuffer) and _UDLStyleClassifier

or _RubyStyleClassifier)(buf)

DEBUG = False # not using 'logging' system, because want to be fast

if DEBUG:

print(banner("Ruby trg_from_pos(pos=%r, implicit=%r)"

% (pos, implicit)))

accessor = buf.accessor

last_pos = pos - 1

last_ch = accessor.char_at_pos(last_pos)

if DEBUG:

print(" last_pos: %s" % last_pos)

print(" last_ch: %r" % last_ch)

# All Ruby trigger points occur at one of the trg_chars.

# Also some require specific two (or more) character combos that

# we can use to filter quickly.

if last_ch not in self.trg_chars:

# Can we do a complete-names?

last_style = accessor.style_at_pos(last_pos)

if last_ch.isalnum() or last_ch == '_':

# Gather as long as they're identifier or word chars

MIN_LENGTH = 3

if styleClassifier.is_identifier_or_word_style(last_style):

start_pos, end_pos = accessor.contiguous_style_range_from_pos(

last_pos)

# XXX Is end_pos pointing one past the end?

if pos - start_pos == MIN_LENGTH or not implicit:

ident = accessor.text_range(start_pos, end_pos)

prefix = ident[:pos - start_pos]

if self._is_completable_name(start_pos, accessor, styleClassifier):

return Trigger("Ruby", TRG_FORM_CPLN,

"names",

start_pos, implicit, length=0, prefix=prefix)

if DEBUG:

print("no: %r is not in %r"\

% (last_ch, self.trg_chars))

return None

elif last_ch == ' ':

if last_pos <= 0:

return None

penultimate_ch = accessor.char_at_pos(last_pos-1)

prev_style = accessor.style_at_pos(last_pos - 1)

# Complex conditions, so express them this way to simplify

if styleClassifier.is_operator_style(prev_style) and penultimate_ch == "<":

pass

elif styleClassifier.is_identifier_or_word_style(prev_style):

# XXX Reject keywords

pass

else:

if DEBUG:

print("no: %r is not '< ' or ending a word"\

"(i.e. 'include ')" % (penultimate_ch+last_ch))

return None

elif last_ch == ':' \

and not (last_pos > 0

and accessor.char_at_pos(last_pos-1) == ':'):

if DEBUG:

penultimate_ch = (last_pos > 0

and accessor.char_at_pos(last_pos-1) or '')

print("no: %r is not '::'"\

% (penultimate_ch+last_ch))

return None

# Suppress triggering in some styles.

TRIGGER_IN_STRING_CHARS = tuple('\'"/')

last_style = accessor.style_at_pos(last_pos)

if DEBUG:

style_names = buf.style_names_from_style_num(last_style)

print(" style: %s %s" % (last_style, style_names))

suppress = False

if implicit:

if last_style in styleClassifier.implicit_completion_skip_styles:

suppress = True

elif last_style in styleClassifier.string_styles():

if last_ch not in TRIGGER_IN_STRING_CHARS:

# The ', ", and / trigger chars *always* trigger in

# a string.

suppress = True

elif last_ch in TRIGGER_IN_STRING_CHARS:

suppress = True

elif last_style in styleClassifier.completion_skip_styles:

# If the user requests code-completion and previous char is

# in this style, suppress it.

suppress = True

if suppress:

if DEBUG:

print("no: completion is suppressed in style at %s: %s %s"\

% (last_pos, last_style, style_names))

return None

WHITESPACE = tuple(' \t\n\r')

EOL = tuple('\n\r')

if last_ch == ' ':

# This may be one of the following:

# class FOO < | complete-available-modules-and-classes

# not implemented yet, "<" not in trg-char tuple.

# include | complete-available-modules

# method calltip-call-signature

# Simplifying assumptions:

# With whitespace allow for a completion list after '<'

# in {class Name <}, but allow for any calltip after an identifier.

# (above) that the preceding char (stored in

# 'penultimate_ch') is '<' or a word or identifier.

# - The construct doesn't have to be on one line.

LIMIT = 50

text = accessor.text_range(max(

0, last_pos-LIMIT), last_pos) # working text

if DEBUG:

print(" working text: %r" % text)

i = len(text)-1

while i > 0: # Skip back to start of line.

if text[i] in EOL:

break

i -= 1

line = text[i:].lstrip()

if DEBUG:

print(" line: %r" % line)

if penultimate_ch == "<":

if not line.startswith("class"):

if DEBUG:

print("no: line does not start with 'class'")

return None

if DEBUG:

print("complete-available-modules-and-classes")

return Trigger("Ruby", TRG_FORM_CPLN,

"available-modules-and-classes",

pos, implicit)

elif line.strip() == "include":

if DEBUG:

print("complete-available-modules")

return Trigger("Ruby", TRG_FORM_CPLN, "available-modules",

pos, implicit)

else: # maybe a calltip on a paren-free call

if DEBUG:

print("calltip-call-signature")

return Trigger("Ruby", TRG_FORM_CALLTIP, "call-signature",

pos, implicit)

elif last_ch == '.':

# This can be:

# FOO.| complete-object-methods

# LITERAL.| complete-literal-methods

# but bug62397: not for a fixnum

# Examples:

# Foo.

# foo.

# @foo.

# ::foo.

# (foo + 1). <-- We don't bother with this one for now

# because CITDL processing won't resolve

# the expression anyway.

# foo2.

# Allow literals too:

# 0. 3.14.

# 1e6. [].

# {}. 'foo'. "bar".

# Weird literals (pickaxe p319):

# %W{...} # also q, Q, r, w, x, <empty> instead of 'W'

# 0d123456, 0xff, -0b10_1010 # specific base laterals

# ?\M-a # char literals

# here docs

# symbols

# Counter examples:

# foo . Don't allow whitespace in between.

# No examples in Ruby stdlib that I can

# see and more often interferes with range

# operator.

# foo['bar']. would need to find matching '[' and

# ensure no ident char immediately

# preceding (that's a heuristic)

# %W{foo}. don't want to go there yet

#

# def\w+CLASSNAME. Don't trigger on CLASSNAME, as we're in

# a definition context, not a use one.

if last_pos > 0:

last_last_pos = last_pos - 1

last_last_ch = accessor.char_at_pos(last_last_pos)

if DEBUG:

print(" prev char = %r" % last_last_ch)

if last_last_ch in '"\'':

return Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos, implicit,

literal="String")

elif last_last_ch == '}':

# Might be Hash literal:

# @tk_windows = {}.<|>taint

# Need to rule out counter examples:

# attributes.collect{|name, value| ...}.<|>to_s

# FileTest.exist?("#{@filename}.<|>#{i}")

# @result = Thread.new { perform_with_block }.<|>value

# Simplifying assumption (because too many counter

# examples are more common): only trigger on exactly

# {}.<|>

if last_pos > 1 \

and accessor.char_at_pos(last_pos-2) == '{':

return Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos, implicit,

literal="Hash")

else:

return None

elif last_last_ch == ']':

# Might be Array literal:

# @tk_table_list = [].<|>taint

# [1,2,3].<|>

# Need to rule out counter examples:

# @@services[host][port].stop

# foo[blah].bang

# Algorithm: Look back on currently line for

# matching '['. If the char before that is a space,

# then consider it an Array. If can't find matching

# '[' on this line, then consider it an Array.

wrk_line = accessor.text_range(

accessor.line_start_pos_from_pos(last_pos),

last_last_pos)

block_count = 1

for ch in reversed(wrk_line):

if not block_count:

if ch in WHITESPACE or ch in '=,(':

return Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos,

implicit, literal="Array")

return None

if ch == '[':

block_count -= 1

elif ch == ']':

block_count += 1

else:

return Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos,

implicit, literal="Array")

return None

elif isident(last_last_ch):

LIMIT = 50

text = accessor.text_range(max(

0, last_pos-LIMIT), last_pos) # working text

if text.find("def") > -1:

# String.find fails faster than Regex.search

idx = max(text.rfind("\n"), text.rfind("\r"))

if idx > -1:

line = text[idx + 1:]

else:

line = text

if self._method_def_header.search(line):

if DEBUG:

print("==> bailing out, defining something")

return None

return Trigger("Ruby", TRG_FORM_CPLN,

"object-methods", pos, implicit)

elif isdigit(last_last_ch):

# Could be a numeric literal or an ident.

wrk_line = accessor.text_range(

accessor.line_start_pos_from_pos(last_pos),

last_pos)

if DEBUG:

print("'<digit>.': numeric literal or identifier")

print("check for leading number in %r" % wrk_line)

if self._leading_float_re.search(wrk_line):

return Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos,

implicit, literal="Float")

elif self._leading_number_re.search(wrk_line):

return (not implicit and

Trigger("Ruby", TRG_FORM_CPLN,

"literal-methods", pos,

implicit, literal="Fixnum")) or None

else:

return Trigger("Ruby", TRG_FORM_CPLN,

"object-methods", pos, implicit)

else:

return None

elif last_ch == '(':

# This may be:

# FOO(| calltip-call-signature

# - Want to be sure to exclude precedence parens after

# keywords: "if (", "while (", etc.

# - XXX Are there instances of this trigger that we just

# want to drop here because of practical limitations in the

# Ruby codeintel handling -- as there are with Perl?

LIMIT = 100

text = accessor.text_range(max(

0, last_pos-LIMIT), last_pos) # working text

if DEBUG:

print(" working text: %r" % text)

i = len(text)-1

while i >= 0 and text[i] in WHITESPACE: # parse off whitespace

i -= 1

RUBY_SPECIAL_METHOD_END_CHARS = "?!" # XXX what about '='?

if i >= 0 and not (isident(text[i]) or isdigit(text[i])

or text[i] in RUBY_SPECIAL_METHOD_END_CHARS):

if DEBUG:

print("no: first non-ws char before "\

"trigger point is not an ident char: '%s'" % text[i])

return None

end = i+1

if text[i] in RUBY_SPECIAL_METHOD_END_CHARS:

i -= 1

while i >= 0: # parse out the preceding identifier

if isdigit(text[i]):

# might be an identifier, need to keep looking

pass

elif not isident(text[i]):

# Identifier can be prefixed with '$', '@' or '@@'.

if i >= 1 and text[i-1:i+1] == "@@":

start = i-1

elif text[i] in "$@":

start = i

else:

start = i+1

identifier = text[start:end]

break

i -= 1

else:

identifier = text[:end]

if DEBUG:

print(" identifier: %r" % identifier)

if not identifier:

if DEBUG:

print("no: no identifier preceding trigger point")

return None

elif isdigit(identifier[0]):

if DEBUG:

print("no: token preceding trigger "\

"point is not a legal identifier")

return None

if identifier in self.RUBY_KEYWORDS:

if DEBUG:

print("no: no trigger on paren "\

"after keyword: %r" % identifier)

return None

# Now we want to rule out subroutine definition lines, e.g.:

# def foo(

# def ClassName.foo(

# def self.foo(

# def (wacked+out).foo(

line = text[:end].splitlines(0)[-1]

if DEBUG:

print(" trigger line: %r" % line)

if line.lstrip().startswith("def"):

if DEBUG:

print("no: no trigger on Ruby func definition")

return None

if DEBUG:

print("calltip-call-signature")

return Trigger("Ruby", TRG_FORM_CALLTIP, "call-signature",