# These are characters that select the first item in an open autocomplete window when pressed.

# (autocompete_on_fillup should be a configuration and fillup chars take precedence over stop chars)

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

'PHP': "~`%^&*()-+{}[]|;'\",.< ",

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

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

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

'CSS': " '\";},/",

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

# These are characters that close the autocomplete window when pressed.

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

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

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

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

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

'CSS': " ('\";{},.>/",

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

def run(self, edit, output='', clear=True):

if clear:

region = sublime.Region(0, self.view.size())

self.view.erase(edit, region)

disable_auto_insert=True, api_completions_only=True,

next_completion_if_showing=False, auto_complete_commit_on_tab=True):

# Show autocompletions:

def _show_auto_complete():

view.run_command('auto_complete', {

'disable_auto_insert': disable_auto_insert,

'api_completions_only': api_completions_only,

'next_completion_if_showing': next_completion_if_showing,

'auto_complete_commit_on_tab': auto_complete_commit_on_tab,

})

completions[view.id()] = on_query_info

show_auto_complete(view, {

'params': ("tooltips", "none", "", None, None, False),

'cplns': snippets,

codeintel_snippets = settings_manager.get('codeintel_snippets', default=True, language=lang)

codeintel_tooltips = settings_manager.get('codeintel_tooltips', default='popup', language=lang)

snippets = []

for calltip in calltips:

tip_info = calltip.split('\n')

text = ' '.join(tip_info[1:])

snippet = None

# TODO: This snippets are based and work for Python language.

# Other languages might need different treatment.

# Insert parameters as snippet:

m = re.search(r'([^\s]+)\(([^\[\(\)]*)', tip_info[0])

# Figure out how many arguments are there already:

text_in_current_line = text_in_current_line[:-1] # Remove next char after cursor

arguments = text_in_current_line.rpartition('(')[2].replace(' ', '').strip() or 0

if arguments:

initial_separator = ''

if arguments[-1] == ',':

arguments = arguments[:-1]

else:

initial_separator += ','

if not text_in_current_line.endswith(' '):

initial_separator += ' '

arguments = arguments.count(',') + 1 if arguments else 0

if m:

params = [p.strip() for p in m.group(2).split(',')]

if params:

n = 1

snippet = []

for i, p in enumerate(params):

if p and i >= arguments:

var, _, _ = p.partition('=')

var = var.strip()

if ' ' in var:

var = var.split(' ')[1]

if var[0] == '$':

var = var[1:]

snippet.append('${%s:%s}' % (n, var))

n += 1

snippet = ', '.join(snippet)

if arguments and snippet:

snippet = initial_separator + snippet

text += ' - ' + tip_info[0] # Add function to the end

else:

text = tip_info[0] + ' ' + text # No function match, just add the first line

if not codeintel_snippets:

snippet = None

# Wrap lines that are too long:

max_line_length = 80

measured_tips = []

for tip in tip_info:

if len(tip) > max_line_length:

chunks = len(tip)

for i in range(0, chunks, max_line_length):

measured_tips.append(tip[i:i + max_line_length])

else:

measured_tips.append(tip)

# Insert tooltip snippet

snippets.extend(((' ' if i > 0 else '') + l, snippet or '${0}') for i, l in enumerate(measured_tips))

if codeintel_tooltips == 'popup':

tooltip_popup(view, snippets)

elif codeintel_tooltips in ('status', 'panel'):

if codeintel_tooltips == 'status':

set_status(view, 'tip', text, timeout=15000)

else:

window = view.window()

output_panel = window.get_output_panel('tooltips')

output_panel.set_read_only(False)

text = '\n'.join(list(zip(*snippets))[0])

output_panel.run_command('tooltip_output', {'output': text})

output_panel.set_read_only(True)

window.run_command('show_panel', {'panel': 'output.tooltips'})

sublime.set_timeout(lambda: window.run_command('hide_panel', {'panel': 'output.tooltips'}), 15000)

if snippets and codeintel_snippets:

# Insert function call snippets:

# func = m.group(1)

# scope = view.scope_name(pos)

# view.run_command('new_snippet', {'contents': snippets[0][0], 'tab_trigger': func, 'scope': scope}) # FIXME: Doesn't add the new snippet... is it possible to do so?

def _insert_snippet():

# Check to see we are still at a position where the snippet is wanted:

view_sel = view.sel()

if not view_sel:

return

sel = view_sel[0]

pos = sel.end()

if not pos or pos != original_pos:

return

view.run_command('insert_snippet', {'contents': snippets[0][0]})

if timeout is None:

timeout = {'error': 3000, 'warning': 5000, 'info': 10000,

'event': 10000}.get(ltype, 3000)

if msg is None:

msg, ltype = ltype, 'debug'

msg = msg.strip()

status_lock.acquire()

try:

status_msg.setdefault(lid, [None, None, 0])

if msg == status_msg[lid][1]:

return

status_msg[lid][2] += 1

order = status_msg[lid][2]

finally:

status_lock.release()

def _set_status():

is_warning = 'warning' in lid

if not is_warning:

view_sel = view.sel()

lineno = view.rowcol(view_sel[0].end())[0] if view_sel else 0

status_lock.acquire()

try:

current_type, current_msg, current_order = status_msg.get(lid, [None, None, 0])

if msg != current_msg and order == current_order:

print("+", "%s: %s" % (ltype.capitalize(), msg), file=condeintel_log_file)

(logger or log.info)(msg)

if ltype != 'debug':

view.set_status(lid, "%s: %s" % (ltype.capitalize(), msg))

status_msg[lid] = [ltype, msg, order]

if not is_warning:

status_lineno[lid] = lineno

finally:

status_lock.release()

def _erase_status():

status_lock.acquire()

try:

if msg == status_msg.get(lid, [None, None, 0])[1]:

view.erase_status(lid)

status_msg[lid][1] = None

if lid in status_lineno:

del status_lineno[lid]

finally:

status_lock.release()

if msg:

sublime.set_timeout(_set_status, delay or 0)

sublime.set_timeout(_erase_status, timeout)

else:

view_sel = view.sel()

if not view_sel:

sublime.message_dialog("NO VIEW SELECTION IN getSublimeScope()")

return

sel = view_sel[0]

pos = sel.end()

"json": "JSON",

"js": "JavaScript",

"python.3": "Python3",

"python": "Python",

"php": "PHP",

"perl": "Perl",

"ruby": "Ruby"

if not view:

return None

#######################################

# try to guess lang using sublime scope

scopes = sublime_scope if sublime_scope else getSublimeScope(view)

if scopes:

for scope in scopes.split(" "):

if "source" in scope:

for check in ordered_checks:

if scope[7:].startswith(check):

return source_scopes[check]

if 'text.plain' in scopes:

return None

if not codeintel_enabled(view):

return None

# check for html

if "text.html" in scopes:

return "HTML"

###################################################################

# try to guess lang by sublime syntax setting (see your status bar)

syntax = None

if view:

syntax = os.path.splitext(os.path.basename(view.settings().get('syntax')))[0]

vid = view.id()

_k_ = '%s::%s' % (syntax, path)

try:

return languages[vid][_k_]

except KeyError:

pass

languages.setdefault(vid, {})

lang = None

_codeintel_syntax_map = dict((k.lower(), v) for k, v in settings_manager.get('codeintel_syntax_map', {}).items())

_lang = lang = syntax and _codeintel_syntax_map.get(syntax.lower(), syntax)

# folders = getattr(view.window(), 'folders', lambda: [])() # FIXME: it's like this for backward compatibility (<= 2060)

# folders_id = str(hash(frozenset(folders)))

mgr = None if settings_manager._settings_id is None else codeintel_manager()

if mgr and not mgr.is_citadel_lang(lang) and not mgr.is_cpln_lang(lang):

lang = None

if mgr.is_citadel_lang(syntax) or mgr.is_cpln_lang(syntax):

_lang = lang = syntax

else:

if view and not path:

path = view.file_name()

if path:

try:

_lang = lang = guess_lang_from_path(path)

except CodeIntelError:

languages[vid][_k_] = None

return

_codeintel_enabled_languages = [l.lower() for l in view.settings().get('codeintel_enabled_languages', [])]

if lang and lang.lower() not in _codeintel_enabled_languages:

languages[vid][_k_] = None

return None

if not lang and _lang and _lang in ('Console', 'Plain text'):

if mgr:

logger(view, 'debug', "Invalid language: %s. Available: %s" % (_lang, ', '.join(set(mgr.get_citadel_langs() + mgr.get_cpln_langs()))))

else:

logger(view, 'debug', "Invalid language: %s" % _lang)

languages[vid][_k_] = lang

def _autocomplete_callback(view, path, original_pos, lang, caller=None):

view_sel = view.sel()

if not view_sel:

return

# Figure out if we're still at the same position when the autocomplete was called, or abort

sel = view_sel[0]

pos = sel.end()

if not pos or pos != original_pos:

return

lpos = view.line(sel).begin()

text_in_current_line = view.substr(sublime.Region(lpos, pos + 1))

def _trigger(trigger, citdl_expr, calltips=None, cplns=None):

global cplns_were_empty, last_trigger_name, last_citdl_expr

add_word_completions = settings_manager.get("codeintel_word_completions", language=lang)

if cplns is not None or calltips is not None:

codeintel_log.info("Autocomplete called (%s) [%s]", lang, ','.join(c for c in ['cplns' if cplns else None, 'calltips' if calltips else None] if c))

# under certain circumstances we have to close before reopening

# the currently open completions-panel

# completions are available now, but were empty on last round,

# we have to close and reopen the completions tab to show them

cplns_are_empty = cplns is None

if cplns_were_empty and not cplns_are_empty:

hide_auto_complete(view)

cplns_were_empty = cplns_are_empty

# citdl_expr changed, so might the completions!

if citdl_expr != last_citdl_expr:

if not (not citdl_expr and not last_citdl_expr):

log.debug("hiding automplete-panel, b/c CITDL_EXPR CHANGED: FROM %r TO %r" % (last_citdl_expr, citdl_expr))

hide_auto_complete(view)

last_citdl_expr = citdl_expr

# the trigger changed, so will the completions!

current_trigger_name = trigger.name if trigger else None

if trigger is None and last_trigger_name is not None or last_trigger_name != current_trigger_name:

log.debug("hiding automplete-panel, b/c trigger changed: FROM %r TO %r " % (last_trigger_name, (trigger.name if trigger else 'None')))

hide_auto_complete(view)

last_trigger_name = current_trigger_name

api_completions_only = False

if trigger:

log.debug("current triggername: %r" % trigger.name)

print("current triggername: %r" % trigger.name)

api_cplns_only_trigger = [

"php-complete-static-members",

"php-complete-object-members",

"python3-complete-module-members",

"python3-complete-object-members",

"python3-complete-available-imports",

"javascript-complete-object-members"

]

if cplns is not None and trigger.name in api_cplns_only_trigger:

api_completions_only = True

add_word_completions = "None"

show_auto_complete(view, {

'params': ("cplns", add_word_completions, text_in_current_line, lang, trigger, False),

'cplns': cplns,

}, api_completions_only=api_completions_only)

if calltips:

tooltip(view, calltips, text_in_current_line, original_pos, lang)

content = view.substr(sublime.Region(0, view.size()))

codeintel(view, path, content, lang, pos, forms, _trigger, caller=caller)

"""

__lock_.acquire()

try:

QUEUE.clear()

finally:

"""An infinite loop running the codeintel in a background thread, meant to

global __signaled_, __signaled_first_

while __loop_:

# print('acquire...')

__semaphore_.acquire()

__signaled_first_ = 0

__signaled_ = 0

# print("DISPATCHING!", len(QUEUE))

global __signaled_, __signaled_first_

now = time.time()

__lock_.acquire()

try:

QUEUE[view.id()] = (view, callback, args, kwargs)

if now < __signaled_ + timeout * 4:

timeout = busy_timeout or timeout

__signaled_ = now

_delay_queue(timeout, preemptive)

if not __signaled_first_:

__signaled_first_ = __signaled_

# print('first',)

# print('queued in', (__signaled_ - now))

finally:

global __signaled_, __queued_

now = time.time()

if not preemptive and now <= __queued_ + 0.01:

return # never delay queues too fast (except preemptively)

__queued_ = now

_timeout = float(timeout) / 1000

if __signaled_first_:

if MAX_DELAY > 0 and now - __signaled_first_ + _timeout > MAX_DELAY:

_timeout -= now - __signaled_first_

if _timeout < 0:

_timeout = 0

timeout = int(round(_timeout * 1000, 0))

new__signaled_ = now + _timeout - 0.01

if __signaled_ >= now - 0.01 and (preemptive or new__signaled_ >= __signaled_ - 0.01):

__signaled_ = new__signaled_

# print('delayed to', (preemptive, __signaled_ - now))

def _signal():

if time.time() < __signaled_:

return

__semaphore_.release()

__lock_.acquire()

try:

_delay_queue(timeout, False)

finally:

global __pre_initialized_

for thread in threading.enumerate():

if thread.isAlive() and thread.name == queue_thread_name:

__pre_initialized_ = True

print("thread finalize")

thread.__semaphore_.release()

global _ci_next_savedb_, _ci_next_cullmem_

__lock_.acquire()

try:

views = list(QUEUE.values())

QUEUE.clear()

finally:

__lock_.release()

for view, callback, args, kwargs in views:

def _callback():

callback(view, *args, **kwargs)

sublime.set_timeout(_callback, 0)

# saving and culling cached parts of the database:

for manager_id in list(_ci_mgr_.keys()):

mgr = codeintel_manager(manager_id)

if mgr is None:

del _ci_mgr_[manager_id]

print("NO MANAGER")

return

now = time.time()

if now >= _ci_next_savedb_ or force:

if _ci_next_savedb_:

log.debug('Saving database')

mgr.db.save() # Save every 6 seconds

_ci_next_savedb_ = now + 6

if now >= _ci_next_cullmem_ or force:

if _ci_next_cullmem_:

log.debug('Culling memory')

mgr.db.cull_mem() # Every 30 seconds

if id in _ci_envs_:

del _ci_envs_[id]

if id in _ci_next_scan_:

global _ci_mgr_, condeintel_log_filename, condeintel_log_file

if manager_id is not None:

mgr = _ci_mgr_.get(manager_id, None)

return mgr

manager_id = settings_manager._settings_id

mgr = _ci_mgr_.get(manager_id, None)

if mgr is None:

codeintel_database_dir = os.path.expanduser(settings_manager.get("codeintel_database_dir"))

for thread in threading.enumerate():

if thread.name == "CodeIntel Manager":

thread.finalize() # this finalizes the index, citadel and the manager and waits them to end (join)

mgr = Manager(

extra_module_dirs=None,

db_base_dir=codeintel_database_dir, # os.path.expanduser(os.path.join('~', '.codeintel', 'databases', folders_id)),

db_catalog_dirs=[],

db_import_everything_langs=None,

)

mgr.upgrade()

mgr.initialize()

# Connect the logging file to the handler

condeintel_log_filename = os.path.join(codeintel_database_dir, 'codeintel.log')

condeintel_log_file = open(condeintel_log_filename, 'w', 1)

codeintel_log.handlers = [logging.StreamHandler(condeintel_log_file)]

msg = "Starting logging SublimeCodeIntel v%s rev %s (%s) on %s" % (VERSION, get_revision()[:12], os.stat(__file__)[stat.ST_MTIME], datetime.datetime.now().ctime())

print("%s\n%s" % (msg, "=" * len(msg)), file=condeintel_log_file)

_ci_mgr_ = {}

_ci_mgr_[manager_id] = mgr

global despair

for thread in threading.enumerate():

if thread.isAlive() and thread.name == "scanning thread":

logger(view, 'info', "Updating indexes... The first time this can take a while. Do not despair!", timeout=20000, delay=despair)

despair = 0

return

logger(view, 'info', "processing `%s': please wait..." % lang)

is_scratch = view.is_scratch()

is_dirty = view.is_dirty()

vid = view.id()

folders = getattr(view.window(), 'folders', lambda: [])() # FIXME: it's like this for backward compatibility (<= 2060)

# load settings for this language

config = settings_manager.getSettings(lang)

def _codeintel_scan():

global despair, despaired

env = None

mtime = None

catalogs = []

now = time.time()

mgr = codeintel_manager()

mgr.db.event_reporter = lambda m: logger(view, 'event', m)

# config values are provided per view(!) and are stored in an

# Environment Object

try:

env = _ci_envs_[vid]

if env._folders != folders:

raise KeyError

if env._lang != lang:

# if the language changes within one view (HTML/PHP) we need to

# update our Environment Object on each change!

raise KeyError

if env._mtime != settings_manager._settings_id:

raise KeyError

except KeyError:

# Generate new Environment

env = generateEnvironment(config, mgr, lang, folders)

_ci_envs_[vid] = env

# env._time = now + 5 # don't check again in less than five seconds

# this happens in any case:

msgs = []

buf = None

if env._valid:

# is citadel language or other supported language

if forms:

set_status(view, 'tip', "")

set_status(view, 'event', "")

msg = "CodeIntel(%s) for %s@%s [%s]" % (', '.join(forms), path, pos, lang)

msgs.append(('info', "\n%s\n%s" % (msg, "-" * len(msg))))

if catalogs:

msg = "New env with catalogs for '%s': %s" % (lang, ', '.join(catalogs) or None)

log.debug(msg)

codeintel_log.warning(msg)

msgs.append(('info', msg))

if mgr.is_citadel_lang(lang):

buf = mgr.buf_from_content(content, lang, env, path or "<Unsaved>", 'utf-8')

buf.caller = caller

buf.orig_pos = pos

now = datetime.datetime.now()

if not _ci_next_scan_.get(vid) or now > _ci_next_scan_[vid]:

_ci_next_scan_[vid] = now + datetime.timedelta(seconds=10)

despair = 0

despaired = False

msg = "Updating indexes for '%s'... The first time this can take a while." % lang

print(msg, file=condeintel_log_file)

logger(view, 'info', msg, timeout=20000, delay=1000)

if not path or is_scratch:

buf.scan() # FIXME: Always scanning unsaved files (since many tabs can have unsaved files, or find other path as ID)

else:

if is_dirty:

mtime = 1

else:

mtime = os.stat(path)[stat.ST_MTIME]

buf.scan(mtime=mtime, skip_scan_time_check=is_dirty)

if callback:

msg = "Doing CodeIntel for '%s' (hold on)..." % lang

print(msg, file=condeintel_log_file)

logger(view, 'info', msg, timeout=20000, delay=1000)

callback(buf, msgs)

else:

logger(view, 'info', "")

start = time.time()

def _codeintel(buf, msgs):

cplns = None

calltips = None

defns = None

if not buf:

logger(view, 'warning', "`%s' (%s) is not a language that uses CIX" % (path, lang))

return [None] * len(forms)

def get_trg(type, *args):

try:

trg = getattr(buf, type, lambda *a: None)(*args)

except CodeIntelError:

codeintel_log.exception("Exception! %s:%s (%s)" % (path or '<Unsaved>', pos, lang))

logger(view, 'info', "Error indexing! Please send the log file: '%s" % condeintel_log_filename)

trg = None

except:

codeintel_log.exception("Exception! %s:%s (%s)" % (path or '<Unsaved>', pos, lang))

logger(view, 'info', "Error indexing! Please send the log file: '%s" % condeintel_log_filename)

raise

return trg

bpos = pos2bytes(content, pos)

if caller == 'on_modified':

trg = get_trg('trg_from_pos', bpos) # Use fast trg_from_pos

else:

trg = get_trg('preceding_trg_from_pos', bpos, bpos) # Use more precise preceding_trg_from_pos

defn_trg = get_trg('defn_trg_from_pos', bpos) if 'defns' in forms else None

eval_log_stream = StringIO()

_hdlrs = codeintel_log.handlers

hdlr = logging.StreamHandler(eval_log_stream)

hdlr.setFormatter(logging.Formatter("%(name)s: %(levelname)s: %(message)s"))

codeintel_log.handlers = list(_hdlrs) + [hdlr]

ctlr = LogEvalController(codeintel_log)

try:

if 'cplns' in forms:

if trg and trg.form == TRG_FORM_CPLN:

cplns = buf.cplns_from_trg(trg, ctlr=ctlr, timeout=20)

if 'calltips' in forms:

if trg and trg.form == TRG_FORM_CALLTIP:

calltips = buf.calltips_from_trg(trg, ctlr=ctlr, timeout=20)

if 'defns' in forms:

if defn_trg and defn_trg.form == TRG_FORM_DEFN:

defns = buf.defns_from_trg(defn_trg, ctlr=ctlr, timeout=20)

except EvalTimeout:

logger(view, 'info', "Timeout while resolving completions!")

finally:

codeintel_log.handlers = _hdlrs

logger(view, 'warning', "")

logger(view, 'event', "")

result = False

merge = ''

for msg in reversed(eval_log_stream.getvalue().strip().split('\n')):

msg = msg.strip()

if msg:

try:

name, levelname, msg = msg.split(':', 2)

name = name.strip()

levelname = levelname.strip().lower()

msg = msg.strip()

except:

merge = (msg + ' ' + merge) if merge else msg

continue

merge = ''

if not result and msg.startswith('evaluating '):

set_status(view, 'warning', msg)

result = True

# collect citdl_expr from this run

citdl_expr = buf.last_citdl_expr

ret = {

"trigger": trg,

"citdl_expr": citdl_expr

}

for f in forms:

if f == 'cplns':

ret["cplns"] = cplns

elif f == 'calltips':

ret["calltips"] = calltips

elif f == 'defns':

ret["defns"] = defns

total = (time.time() - start) * 1000

if total > 1000:

timestr = "~%ss" % int(round(total / 1000))

else:

timestr = "%sms" % int(round(total))

if not despaired or total < timeout:

msg = "Done '%s' CodeIntel! Full CodeIntel took %s" % (lang, timestr)

print(msg, file=condeintel_log_file)

def _callback():

view_sel = view.sel()

if view_sel and view.line(view_sel[0]) == view.line(pos):

callback(**ret)

logger(view, 'info', "")

sublime.set_timeout(_callback, 0)

else:

msg = "Just finished indexing '%s'! Please try again. Full CodeIntel took %s" % (lang, timestr)

print(msg, file=condeintel_log_file)

logger(view, 'info', msg, timeout=3000)

catalogs = []

valid = True

if not mgr.is_citadel_lang(lang) and not mgr.is_cpln_lang(lang):

if lang in ('Console', 'Plain text'):

msg = "Invalid language: %s. Available: %s" % (lang, ', '.join(set(mgr.get_citadel_langs() + mgr.get_cpln_langs())))

log.debug(msg)

codeintel_log.warning(msg)

valid = False

codeintel_selected_catalogs = config.get('codeintel_selected_catalogs')

avail_catalogs = mgr.db.get_catalogs_zone().avail_catalogs()

# Load configuration files:

all_catalogs = []

for catalog in avail_catalogs:

all_catalogs.append("%s (for %s: %s)" % (catalog['name'], catalog['lang'], catalog['description']))

if catalog['lang'] == lang:

if catalog['name'] in codeintel_selected_catalogs:

catalogs.append(catalog['name'])