lang = lang

def __init__(self, mgr):

self._properties = SilverCity.PropertySet()

self._lexer = SilverCity.find_lexer_module_by_id(

ScintillaConstants.SCLEX_CPP)

jsli = mgr.lidb.langinfo_from_lang(self.lang)

self._keyword_lists = [

SilverCity.WordList(' '.join(jsli.keywords)),

SilverCity.WordList(),

SilverCity.WordList(),

SilverCity.WordList(),

SilverCity.WordList()

def __init__(self):

self.is_udl = False

self.operator_style = SCE_C_OPERATOR

self.identifier_style = SCE_C_IDENTIFIER

self.keyword_style = SCE_C_WORD

self.comment_styles = (SCE_C_COMMENT,

SCE_C_COMMENTDOC,

SCE_C_COMMENTLINE,

SCE_C_COMMENTLINEDOC,

SCE_C_COMMENTDOCKEYWORD,

SCE_C_COMMENTDOCKEYWORDERROR)

self.string_styles = (

SCE_C_STRING, SCE_C_CHARACTER, SCE_C_STRINGEOL)

self.whitespace_style = SCE_C_DEFAULT

def __init__(self):

self.is_udl = True

self.operator_style = SCE_UDL_CSL_OPERATOR

self.identifier_style = SCE_UDL_CSL_IDENTIFIER

self.keyword_style = SCE_UDL_CSL_WORD

self.comment_styles = (SCE_UDL_CSL_COMMENT,

SCE_UDL_CSL_COMMENTBLOCK,)

self.string_styles = (SCE_UDL_CSL_STRING, )

self.whitespace_style = SCE_UDL_CSL_DEFAULT

ParenStyleCalltipIntelMixin,

ProgLangTriggerIntelMixin,

PythonCITDLExtractorMixin):

lang = lang

_evaluatorClass = JavaScriptTreeEvaluator

extraPathsPrefName = "javascriptExtraPaths"

# The way namespacing is done with variables in JS means that grouping

# global vars is just annoying.

cb_group_global_vars = False

# Define the trigger chars we use, used by ProgLangTriggerIntelMixin

trg_chars = tuple(".(,@'\" ")

calltip_trg_chars = tuple('(') # excluded ' ' for perf (bug 55497)

# Define literal mapping to citdl member, used in PythonCITDLExtractorMixin

citdl_from_literal_type = {"string": "String"}

def cb_variable_data_from_elem(self, elem):

"""Use the 'namespace' image in the Code Browser for a variable

data = CitadelLangIntel.cb_variable_data_from_elem(self, elem)

if len(elem) and data["img"].startswith("variable"):

data["img"] = data["img"].replace("variable", "namespace")

return data

def _functionCalltipTrigger(self, ac, jsClassifier, pos, DEBUG=False):

# Implicit calltip triggering from an arg separater ",", we trigger a

# calltip if we find a function open paren "(" and function identifier

# http://bugs.activestate.com/show_bug.cgi?id=93864

if DEBUG:

print("Arg separater found, looking for start of function, pos: %r" % (pos, ))

ac.getPrevPosCharStyle()

# Move back to the open paren of the function

paren_count = 0

p = pos

min_p = max(0, p - 100) # look back max 100 chars

while p > min_p:

p, c, style = ac.getPrecedingPosCharStyle(

ignore_styles=jsClassifier.comment_styles)

if DEBUG:

print(' p: %r, ch: %r, st: %d' % (p, c, style))

loopcount = 0

while style == jsClassifier.operator_style and loopcount < 10:

loopcount += 1

if c == ")":

paren_count += 1

if DEBUG:

print(' paren_count: %r' % (paren_count, ))

elif c == "(":

if DEBUG:

print(' paren_count: %r' % (paren_count, ))

if paren_count == 0:

# We found the open brace of the func

trg_from_pos = p+1

p, ch, style = ac.getPrevPosCharStyle()

if DEBUG:

print(" function start found, pos: %d" % (p, ))

if style in jsClassifier.ignore_styles:

# Find previous non-ignored style then

p, c, style = ac.getPrecedingPosCharStyle(

style, jsClassifier.ignore_styles)

if style == jsClassifier.identifier_style:

# Ensure that this isn't a new function

# declaration.

p, c, style = ac.getPrecedingPosCharStyle(

style, jsClassifier.ignore_styles)

if style == jsClassifier.keyword_style:

p, prev_text = ac.getTextBackWithStyle(

style, jsClassifier.ignore_styles, max_text_len=len("function")+1)

if prev_text in ("function", ):

# Don't trigger here

return None

return Trigger(lang, TRG_FORM_CALLTIP,

"call-signature",

trg_from_pos, implicit=True)

return None

else:

paren_count -= 1

elif c in ";{}":

# Gone too far and noting was found

if DEBUG:

print(" no function found, hit stop char: %s at p: %d" % (c, p))

return None

p, c, style = ac.getPrevPosCharStyle()

if DEBUG:

print(' p: %r, ch: %r, st: %d' % (p, c, style))

# Did not find the function open paren

if DEBUG:

print(" no function found, ran out of chars to look at, p: %d" % (p,))

return None

def trg_from_pos(self, buf, pos, implicit=True,

lang=None):

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

# DEBUG = True

# if DEBUG:

# print util.banner("JavaScript trg_from_pos(pos=%r, implicit=%r)"

# % (pos, implicit))

if pos == 0:

return None

if lang is None:

lang = self.lang

if isinstance(buf, UDLBuffer):

jsClassifier = udlJSClassifier

else:

jsClassifier = pureJSClassifier

accessor = buf.accessor

last_pos = pos - 1

last_char = accessor.char_at_pos(last_pos)

last_style = accessor.style_at_pos(last_pos)

if DEBUG:

print(" last_pos: %s" % last_pos)

print(" last_ch: %r" % last_char)

print(" last_style: %r" % last_style)

if (jsClassifier.is_udl and last_char == '/'

and last_pos > 0 and accessor.char_at_pos(last_pos-1) == '<'

and last_style not in (SCE_UDL_CSL_STRING,

SCE_UDL_CSL_COMMENTBLOCK,

SCE_UDL_CSL_COMMENT,

SCE_UDL_CSL_REGEX)):

# Looks like start of closing '</script>' tag. While typing this

# the styling will still be in the CSL range.

return Trigger(buf.m_lang, TRG_FORM_CPLN,

"end-tag", pos, implicit)

# JSDoc completions

elif last_char == "@" and last_style in jsClassifier.comment_styles:

# If the preceeding non-whitespace character is a "*" or newline

# then we complete for jsdoc tag names

p = last_pos - 1

min_p = max(

0, p - 50) # Don't bother looking more than 50 chars

if DEBUG:

print("Checking match for jsdoc completions")

while p >= min_p and \

accessor.style_at_pos(p) in jsClassifier.comment_styles:

ch = accessor.char_at_pos(p)

p -= 1

# if DEBUG:

# print "Looking at ch: %r" % (ch)

if ch == "*" or ch in "\r\n":

break

elif ch not in " \t\v":

# Not whitespace, not a valid tag then

return None

else:

# Nothing found in the specified range

if DEBUG:

print("trg_from_pos: not a jsdoc")

return None

if DEBUG:

print("Matched trigger for jsdoc completion")

return Trigger(lang, TRG_FORM_CPLN,

"jsdoc-tags", pos, implicit)

# JSDoc calltip

elif last_char in " \t" and last_style in jsClassifier.comment_styles:

# whitespace in a comment, see if it matches for jsdoc calltip

p = last_pos - 1

min_p = max(

0, p - 50) # Don't bother looking more than 50 chars

if DEBUG:

print("Checking match for jsdoc calltip")

ch = None

ident_found_pos = None

while p >= min_p and \

accessor.style_at_pos(p) in jsClassifier.comment_styles:

ch = accessor.char_at_pos(p)

p -= 1

if ident_found_pos is None:

# print "jsdoc: Looking for identifier, at ch: %r" % (ch)

if ch in " \t":

pass

elif _isident(ch):

ident_found_pos = p+1

else:

if DEBUG:

print("No jsdoc, whitespace not preceeded by an " \

"identifer")

return None

elif ch == "@":

# This is what we've been looking for!

jsdoc_field = accessor.text_range(p+2, ident_found_pos+1)

if DEBUG:

print("Matched trigger for jsdoc calltip: '%s'" % (jsdoc_field, ))

return Trigger(lang, TRG_FORM_CALLTIP,

"jsdoc-tags", ident_found_pos, implicit,

jsdoc_field=jsdoc_field)

elif not _isident(ch):

if DEBUG:

print("No jsdoc, identifier not preceeded by an '@'")

# Not whitespace, not a valid tag then

return None

# Nothing found in the specified range

if DEBUG:

print("No jsdoc, ran out of characters to look at.")

elif last_char not in self.trg_chars:

# Check if this could be a 'complete-names' trigger, this is

# an implicit 3-character trigger i.e. " win<|>" or an explicit

# trigger on 3 or more characters. We cannot support less than than

# 3-chars without involving a big penalty hit (as our codeintel

# database uses a 3-char index).

if last_pos >= 2 and (last_style == jsClassifier.identifier_style or

last_style == jsClassifier.keyword_style):

if DEBUG:

print("Checking for 'names' three-char-trigger")

# The previous two characters must be the same style.

p = last_pos - 1

min_p = max(0, p - 1)

citdl_expr = [last_char]

while p >= min_p:

if accessor.style_at_pos(p) != last_style:

if DEBUG:

print("No 'names' trigger, inconsistent style: " \

"%d, pos: %d" % (accessor.style_at_pos(p), p))

break

citdl_expr += accessor.char_at_pos(p)

p -= 1

else:

# Now check the third character back.

# "p < 0" is for when we are at the start of a document.

if p >= 0:

ac = None

style = accessor.style_at_pos(p)

if style == last_style:

if implicit:

if DEBUG:

print("No 'names' trigger, third char " \

"style: %d, pos: %d" % (style, p))

return None

else:

# explicit can be longer than 3-chars, skip over

# the rest of the word/identifier.

ac = AccessorCache(accessor, p)

p, ch, style = ac.getPrecedingPosCharStyle(

last_style,

jsClassifier.ignore_styles,

max_look_back=80)

# Now we know that we are three identifier characters

# preceeded by something different, which is not that

# common, we now need to be a little more cpu-intensive

# with our search to ensure we're not preceeded by a

# dot ".", as this would mean a different cpln type!

if style == jsClassifier.whitespace_style:

# Find out what occurs before the whitespace,

# ignoring whitespace and comments.

if ac is None:

ac = AccessorCache(accessor, p)

p, ch, style = ac.getPrecedingPosCharStyle(style,

jsClassifier.ignore_styles,

max_look_back=80)

if style is not None:

ch = accessor.char_at_pos(p)

if ch == ".":

if DEBUG:

print("No 'names' trigger, third char " \

"is a dot")

return None

elif style == jsClassifier.keyword_style:

p, prev_text = ac.getTextBackWithStyle(

style, jsClassifier.ignore_styles, max_text_len=len("function")+1)

if prev_text in ("function", ):

# We don't trigger after function, this is

# defining a new item that does not exist.

if DEBUG:

print("No 'names' trigger, preceeding "\

"text is 'function'")

return None

if DEBUG:

print("triggering 'javascript-complete-names' at " \

"pos: %d" % (last_pos - 2, ))

return Trigger(self.lang, TRG_FORM_CPLN,

"names", last_pos - 2, implicit,

citdl_expr="".join(reversed(citdl_expr)))

if DEBUG:

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

last_char, "".join(self.trg_chars), ))

return None

elif last_style == jsClassifier.operator_style:

# Go back and check what we are operating on, should be

# an identifier or a close brace type ")]}".

p = last_pos - 1

while p >= 0:

style = accessor.style_at_pos(p)

if style == jsClassifier.identifier_style:

break

elif style == jsClassifier.keyword_style and last_char == ".":

break

elif style == jsClassifier.operator_style and \

last_char == "." and accessor.char_at_pos(p) in ")]}":

break

elif style in jsClassifier.string_styles:

break

elif style not in jsClassifier.ignore_styles:

# Else, wrong style for calltip

if DEBUG:

print("not a trigger: unexpected style: %d at pos: %d" \

% (style, p))

return None

p -= 1

else:

# Did not find the necessary style, no completion/calltip then

return None

if last_char == ".":

if style in jsClassifier.string_styles:

return Trigger(lang, TRG_FORM_CPLN,

"literal-members", pos, implicit,

citdl_expr="String")

elif style == jsClassifier.keyword_style:

# Check if it's a "this." expression

isThis = False

if last_pos >= 4:

word = []

p = last_pos - 1

p_end = last_pos - 5

while p > p_end:

word.insert(0, accessor.char_at_pos(p))

p -= 1

if "".join(word) == "this":

isThis = True

if not isThis:

return None

return Trigger(lang, TRG_FORM_CPLN,

"object-members", pos, implicit)

elif last_char in "(,":

# p is now at the end of the identifier, go back and check

# that we are not defining a function

ac = AccessorCache(accessor, p)

# Implicit calltip triggering from an arg separater ","

# http://bugs.activestate.com/show_bug.cgi?id=93864

if implicit and last_char == ',':

return self._functionCalltipTrigger(ac, jsClassifier, p, DEBUG)

# Get the previous style, if it's a keyword style, check that

# the keyword is not "function"

prev_pos, prev_char, prev_style = ac.getPrecedingPosCharStyle(

jsClassifier.identifier_style, jsClassifier.ignore_styles)

if prev_style == jsClassifier.keyword_style:

p, prev_text = ac.getTextBackWithStyle(

prev_style, jsClassifier.ignore_styles, max_text_len=len("function")+1)

if prev_text in ("function", ):

# Don't trigger here

return None

return Trigger(lang, TRG_FORM_CALLTIP,

"call-signature", pos, implicit)

elif last_style in jsClassifier.string_styles and last_char in "\"'":

prev_pos = last_pos - 1

prev_char = accessor.char_at_pos(prev_pos)

if prev_char != '[':

prev_style = accessor.style_at_pos(prev_pos)

ac = AccessorCache(accessor, prev_pos)

if prev_style in jsClassifier.ignore_styles:

# Look back further.

prev_pos, prev_char, prev_style = ac.getPrevPosCharStyle(

ignore_styles=jsClassifier.ignore_styles)

if prev_char == '[':

# We're good to go.

if DEBUG:

print("Matched trigger for array completions")

return Trigger(lang, TRG_FORM_CPLN,

"array-members", pos, implicit,

bracket_pos=prev_pos, trg_char=last_char)

return None

def preceding_trg_from_pos(self, buf, pos, curr_pos,

preceding_trg_terminators=None, DEBUG=False):

DEBUG = False

if DEBUG:

print("pos: %d" % (pos, ))

print("ch: %r" % (buf.accessor.char_at_pos(pos), ))

print("curr_pos: %d" % (curr_pos, ))

# Check if we can match on either of the 3-character trigger or on the

# normal preceding_trg_terminators.

# Try the default preceding_trg_from_pos handler

if pos != curr_pos and self._last_trg_type == "names":

# The last trigger type was a 3-char trigger "names", we must try

# triggering from the same point as before to get other available

# trigger types defined at the same poisition or before.

trg = ProgLangTriggerIntelMixin.preceding_trg_from_pos(

self, buf, pos+2, curr_pos, preceding_trg_terminators,

DEBUG=DEBUG)

else:

trg = ProgLangTriggerIntelMixin.preceding_trg_from_pos(

self, buf, pos, curr_pos, preceding_trg_terminators,

DEBUG=DEBUG)

# Now try the 3-char trigger, if we get two triggers, take the closest

# match.

names_trigger = None

if isinstance(buf, UDLBuffer):

jsClassifier = udlJSClassifier

else:

jsClassifier = pureJSClassifier

style = None

if pos > 0:

accessor = buf.accessor

if pos == curr_pos:

# We actually care about whats left of the cursor.

pos -= 1

style = accessor.style_at_pos(pos)

if style in (jsClassifier.identifier_style, jsClassifier.keyword_style):

ac = AccessorCache(accessor, pos)

prev_pos, prev_ch, prev_style = ac.getPrecedingPosCharStyle(

style)

if prev_style is not None and (pos - prev_pos) > 3:

# We need at least 3 character for proper completion

# handling.

names_trigger = self.trg_from_pos(

buf, prev_pos + 4, implicit=False)

if DEBUG:

print("trg: %r" % (trg, ))

print("names_trigger: %r" % (names_trigger, ))

print("last_trg_type: %r" % (self._last_trg_type, ))

if names_trigger:

if not trg:

trg = names_trigger

# Two triggers, choose the best one.

elif trg.pos == names_trigger.pos:

if self._last_trg_type != "names":

# The names trigger gets priority over the other trigger

# types, unless the previous trigger was also a names trg.

trg = names_trigger

elif trg.pos < names_trigger.pos:

trg = names_trigger

elif trg is None and style in jsClassifier.comment_styles:

# Check if there is a JSDoc to provide a calltip for, example:

# /** @param foobar {sometype} This is field for <|>

if DEBUG:

print("\njs preceding_trg_from_pos::jsdoc: check for calltip")

comment = accessor.text_range(max(0, curr_pos-200), curr_pos)

at_idx = comment.rfind("@")

if at_idx >= 0:

if DEBUG:

print("\njs preceding_trg_from_pos::jsdoc: contains '@'")

space_idx = comment[at_idx:].find(" ")

if space_idx >= 0:

# Trigger after the space character.

trg_pos = (curr_pos - len(

comment)) + at_idx + space_idx + 1

if DEBUG:

print("\njs preceding_trg_from_pos::jsdoc: calltip at %d" % (trg_pos, ))

trg = self.trg_from_pos(buf, trg_pos, implicit=False)

if trg:

self._last_trg_type = trg.type

return trg

_jsdoc_cplns = [("variable", t) for t in sorted(jsdoc_tags)]

def async_eval_at_trg(self, buf, trg, ctlr):

if _xpcom_:

trg = UnwrapObject(trg)

ctlr = UnwrapObject(ctlr)

ctlr.start(buf, trg)

# JSDoc completions

if trg.id == (self.lang, TRG_FORM_CPLN, "jsdoc-tags"):

# TODO: Would like a "javadoc tag" completion image name.

ctlr.set_cplns(self._jsdoc_cplns)

ctlr.done("success")

return

# JSDoc calltip

elif trg.id == (self.lang, TRG_FORM_CALLTIP, "jsdoc-tags"):

# TODO: Would like a "javadoc tag" completion image name.

jsdoc_field = trg.extra.get("jsdoc_field")

if jsdoc_field:

# print "jsdoc_field: %r" % (jsdoc_field, )

calltip = jsdoc_tags.get(jsdoc_field)

if calltip:

ctlr.set_calltips([calltip])

ctlr.done("success")

return

if trg.type == "literal-members":

# We could leave this to citdl_expr_from_trg, but this is a

# little bit faster, since we already know the citdl expr.

citdl_expr = trg.extra.get("citdl_expr")

elif trg.type == "names":

# We could leave this to citdl_expr_from_trg, but since we already

# know the citdl expr, use it.

citdl_expr = trg.extra.get("citdl_expr")

else:

try:

citdl_expr = self.citdl_expr_from_trg(buf, trg)

except CodeIntelError as ex:

ctlr.error(str(ex))

ctlr.done("error")

return

line = buf.accessor.line_from_pos(trg.pos)

evalr = self._evaluatorClass(ctlr, buf, trg, citdl_expr, line)

buf.mgr.request_eval(evalr)

def _extra_dirs_from_env(self, env):

extra_dirs = set()

include_project = env.get_pref("codeintel_scan_files_in_project", True)

if include_project:

proj_base_dir = env.get_proj_base_dir()

if proj_base_dir is not None:

extra_dirs.add(proj_base_dir) # Bug 68850.

for pref in env.get_all_prefs(self.extraPathsPrefName):

if not pref:

continue

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

if exists(d.strip()))

if extra_dirs:

log.debug("%s extra lib dirs: %r", self.lang, extra_dirs)

max_depth = env.get_pref("codeintel_max_recursive_dir_depth", 10)

# Always include common JS associations - bug 91915.

js_assocs = env.assoc_patterns_from_lang("JavaScript")

if self.lang != "JavaScript":

# Add any language specific associations.

js_assocs = set(js_assocs)

js_assocs.update(env.assoc_patterns_from_lang(self.lang))

js_assocs = list(js_assocs)

extra_dirs = tuple(

util.gen_dirs_under_dirs(extra_dirs,

max_depth=max_depth,

interesting_file_patterns=js_assocs)

)

# TODO Why doesn't it pick-up the value in the setting file???

exclude_patterns = env.get_pref("codeintel_scan_exclude_dir", {"JavaScript": ["/build/"]}).get(self.lang)

if not exclude_patterns is None:

for p in exclude_patterns:

extra_dirs = [d for d in extra_dirs if not re.search(p, d)]

else:

extra_dirs = () # ensure retval is a tuple

return extra_dirs

def _get_stdlibs_from_env(self, env=None):

return [self.mgr.db.get_stdlib(self.lang)]

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 "javascript-buf-libs" not in env.cache:

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

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

if buf not in cache:

env.add_pref_observer(self.extraPathsPrefName,

self._invalidate_cache_and_rescan_extra_dirs)

env.add_pref_observer("codeintel_selected_catalogs",

self._invalidate_cache)

env.add_pref_observer("codeintel_max_recursive_dir_depth",

self._invalidate_cache)

env.add_pref_observer("codeintel_scan_files_in_project",

self._invalidate_cache)

env.add_pref_observer("codeintel_scan_exclude_dir",

self._invalidate_cache)

db = self.mgr.db

libs = []

# - extradirslib

extra_dirs = self._extra_dirs_from_env(env)

if extra_dirs:

libs.append(db.get_lang_lib(self.lang, "extradirslib",

extra_dirs))

# Warn the user if there is a huge number of import dirs that

# might slow down completion.

num_import_dirs = len(extra_dirs)

if num_import_dirs > 100:

msg = "This buffer is configured with %d %s import dirs: " \

"this may result in poor completion performance" % \

(num_import_dirs, self.lang)

self.mgr.report_message(msg, "\n".join(extra_dirs))

if buf.lang == self.lang:

# - curdirlib (before extradirslib; only if pure JS file)

cwd = dirname(normpath(buf.path))

if cwd not in extra_dirs:

libs.insert(0, db.get_lang_lib(

self.lang, "curdirlib", [cwd]))

# - cataloglibs

if buf.lang == "HTML5":

# Implicit HTML 5 catalog additions.

libs.append(db.get_catalog_lib("JavaScript", ["html5"]))

catalog_selections = env.get_pref("codeintel_selected_catalogs")

libs.append(db.get_catalog_lib(self.lang, catalog_selections))

# - stdlibs

libs += self._get_stdlibs_from_env(env)

cache[buf] = libs

return cache[buf]

def _invalidate_cache(self, env, pref_name):

if "javascript-buf-libs" in env.cache:

log.debug("invalidate 'javascript-buf-libs' cache on %r", env)

del env.cache["javascript-buf-libs"]

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(

self.lang, "extradirslib", extra_dirs)

request = PreloadLibRequest(extradirslib)

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

def lpaths_from_blob(self, blob):

"""Return <lpaths> for this blob

return set(lpath for child in blob

for lpath in _walk_js_symbols(child))

def citdl_expr_from_trg(self, buf, trg):

"""Return a CITDL expression preceding the given trigger. This is the

DEBUG = False

if trg.form != TRG_FORM_DEFN:

if trg.type == 'array-members':

# Get everything before the bracket position.

pos = trg.extra.get('bracket_pos') - 1

else:

pos = trg.pos - 2 # skip past the trigger char

return self._citdl_expr_from_pos(buf, pos, implicit=trg.implicit,

DEBUG=DEBUG, trg=trg,

array_as_attr=True)

lang = lang

# Fillup chars for JavaScript: basically, any non-identifier char.

# XXX - '@' removed in order to better support XPCOM completions:

# Components.interfaces['@mozilla.]

# Whilst not an ideal solution, as when the '.' is hit we run into the

# same problem again... the ideal solution would be to override the

# cpln_fillup_chars to be only "\"'" for the 'array-members' trigger

# event. But this is not yet possible...

# - dropped ' ' It gets in the way of common usage: "var " (bug 77950).

cpln_fillup_chars = "~`!#%^&*()-=+{}[]|\\;:'\",.<>?/"

cpln_stop_chars = "~`!@#%^&*()-=+{}[]|\\;:'\",.<>?/ "

sce_prefixes = ["SCE_C_"]

cb_show_if_empty = True

def __init__(self, *args, **kwargs):

CitadelBuffer.__init__(self, *args, **kwargs)

if isinstance(self.accessor, KoDocumentAccessor):

# Encourage the database to pre-scan dirs relevant to completion

# for this buffer -- because of recursive-dir-include-everything

# semantics for JavaScript this first-time scan can take a while.

request = PreloadBufLibsRequest(self)

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

@property

def libs(self):

return self.langintel.libs_from_buf(self)

@property

def stdlib(self):

return self.libs[-1]

def scoperef_from_blob_and_line(self, blob, line):

"""Return the scope for the given position in this buffer.

DEBUG = False

if DEBUG:

print("scoperef_from_pos: look for line %d in %r" % (line, blob))

best_fit_lpath = None

for scope, lpath in _walk_js_scopes(blob):

start = int(scope.get("line"))

# JS CIX <scope> should alway have lineend. The default is

# because JS <variable>'s with content (i.e. anonymous

# custom Object instances) do not typically have lineend.

# Note: not sure the fallback is correct.

end = int(scope.get("lineend", start))

if DEBUG:

print("scoperef_from_pos: scope %r (%r-%r)?"\

% (scope, start, end), end=' ')

if line < start:

if DEBUG:

print("no, before start")

continue

elif line > end:

if DEBUG:

print("no, after end")

continue

elif line <= end:

if DEBUG:

print("yes, could be")

best_fit_lpath = lpath

else:

if DEBUG:

print("no, passed end")

if best_fit_lpath is not None:

break

if best_fit_lpath is not None:

return (blob, best_fit_lpath)

else:

# The file extensions that this import handler will use when importing.

import_file_extensions = (".js", )

ignore_file_extensions = (".min.js", "-min.js", ".pkg.js", "-pkg.js", )

def setCorePath(self, compiler=None, extra=None):

self.corePath = []

def _findScannableFiles(self, xxx_todo_changeme, dirname, names):

(files, searchedDirs) = xxx_todo_changeme

if sys.platform.startswith("win"):

cpath = dirname.lower()

else:

cpath = dirname

if cpath in searchedDirs:

while names:

del names[0]

return

else:

searchedDirs[cpath] = 1

for i in range(len(names)-1, -1, -1): # backward so can del from list

path = os.path.join(dirname, names[i])

if os.path.isdir(path):

pass

elif names[i].endswith(self.import_file_extensions) and not names[i].endswith(self.ignore_file_extensions):

# XXX The list of extensions should be settable on

# the ImportHandler and Komodo should set whatever is

# set in prefs.

# XXX This check for files should probably include

# scripts, which might likely not have the

# extension: need to grow filetype-from-content smarts.

files.append(path)

def find_importables_in_dir(self, dir):

"""See citadel.py::ImportHandler.find_importables_in_dir() for

from os.path import join, isdir, splitext

if dir == "<Unsaved>":

# TODO: stop these getting in here.

return {}

# TODO: log the fs-stat'ing a la codeintel.db logging.

try:

names = os.listdir(dir)

except OSError as ex:

return {}

dirs, nondirs = set(), set()

for name in names:

try:

if isdir(join(dir, name)):

dirs.add(name)

else:

nondirs.add(name)

except UnicodeDecodeError: