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

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

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

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

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

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

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

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

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

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

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

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

if timeout is None:

timeout = {None: 3000, 'error': 3000, 'warning': 5000, 'info': 10000, 'event': 10000, 'tip': 15000}.get(type)

if msg is None:

msg, type = type, 'debug'

msg = msg.strip()

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

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

return

status_lock.acquire()

try:

status_msg[id][2] += 1

order = status_msg[id][2]

finally:

status_lock.release()

def _calltip_erase():

status_lock.acquire()

try:

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

view.erase_status(id)

status_msg[id][1] = None

if id in status_lineno:

del status_lineno[id]

finally:

status_lock.release()

def _calltip_set():

lineno = view.line(view.sel()[0])

status_lock.acquire()

try:

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

if msg != current_msg and order == current_order:

if msg:

view.set_status(id, "%s: %s" % (type.capitalize(), msg))

(logger or log.info)(msg)

else:

view.erase_status(id)

status_msg[id][0] = [type, msg, order]

if 'warning' not in id and msg:

status_lineno[id] = lineno

elif id in status_lineno:

del status_lineno[id]

finally:

status_lock.release()

try:

if delay and delay is not None:

sublime.set_timeout(_calltip_set, delay)

else:

_calltip_set()

except:

sublime.set_timeout(_calltip_set, delay)

if msg:

def _autocomplete_callback(view, path):

id = view.id()

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

sel = view.sel()[0]

pos = sel.end()

try:

next = content[pos].strip()

except IndexError:

next = ''

if pos and content and content[view.line(sel).begin():pos].strip() and not next.isalnum() and next != '_':

#TODO: For the sentinel to work, we need to send a prefix to the completions... but no show_completions() currently available

#pos = sentinel[path] if sentinel[path] is not None else view.sel()[0].end()

lang, _ = os.path.splitext(os.path.basename(view.settings().get('syntax')))

def _trigger(cplns, calltips):

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))

if cplns:

# Show autocompletions:

completions[id] = sorted(

[('%s (%s)' % (name, type), name) for type, name in cplns],

cmp=lambda a, b: a[1] < b[1] if a[1].startswith('_') and b[1].startswith('_') else False if a[1].startswith('_') else True if b[1].startswith('_') else a[1] < b[1]

)

view.run_command('auto_complete', {'disable_auto_insert': True})

elif calltips is not None:

# Trigger a tooltip

calltip(view, 'tip', calltips[0])

sentinel[path] = None

codeintel(view, path, content, lang, pos, ('cplns', 'calltips'), _trigger)

# If it's a fill char, queue using lower values and preemptive behavior

def on_close(self, view):

path = view.file_name()

status_lock.acquire()

try:

if path in sentinel:

del sentinel[path]

if path in status_msg:

del status_msg[path]

if path in status_lineno:

del status_lineno[path]

finally:

status_lock.release()

codeintel_cleanup(path)

def on_modified(self, view):

path = view.file_name()

lang, _ = os.path.splitext(os.path.basename(view.settings().get('syntax')))

try:

lang = lang or guess_lang_from_path(path)

except CodeIntelError:

pass

live = view.settings().get('codeintel_live', True)

pos = view.sel()[0].end()

text = view.substr(sublime.Region(pos - 1, pos))

_sentinel = sentinel.get(path)

is_fill_char = (text and text[-1] in cpln_fillup_chars.get(lang, ''))

sentinel[path] = _sentinel if _sentinel is not None else pos if is_fill_char else None

if not live and text and sentinel[path] is not None:

live = True

if live:

if not hasattr(view, 'command_history') or view.command_history(0)[0] == 'insert':

autocomplete(view, 0 if is_fill_char else 200, 50 if is_fill_char else 600, is_fill_char, args=[path])

else:

view.run_command('hide_auto_complete')

else:

def _scan_callback(view, path):

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

lang, _ = os.path.splitext(os.path.basename(view.settings().get('syntax')))

codeintel_scan(view, path, content, lang)

queue(view, _scan_callback, 3000, args=[path])

def on_selection_modified(self, view):

global despair, despaired, old_pos

delay_queue(600) # on movement, delay queue (to make movement responsive)

rowcol = view.rowcol(view.sel()[0].end())

if old_pos != rowcol:

old_pos = rowcol

despair = 1000

despaired = True

status_lock.acquire()

try:

slns = [id for id, sln in status_lineno.items() if sln != rowcol[0]]

finally:

status_lock.release()

for id in slns:

calltip(view, "", id=id)

def on_query_completions(self, view, prefix, locations):

id = view.id()

if id in completions:

_completions = completions[id]

del completions[id]

return _completions

def run(self, edit, block=False):

view = self.view

path = view.file_name()

def run(self, edit, block=False):

view = self.view

path = view.file_name()

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

lang, _ = os.path.splitext(os.path.basename(view.settings().get('syntax')))

pos = view.sel()[0].end()

file_name = view.file_name()

def _trigger(defns):

if defns is not None:

defn = defns[0]

if defn.path and defn.line:

if defn.line != 1 or defn.path != file_name:

path = defn.path + ':' + str(defn.line)

msg = 'Jumping to: %s' % path

log.debug(msg)

codeintel_log.debug(msg)

window = sublime.active_window()

window.open_file(path, sublime.ENCODED_POSITION)

window.open_file(path, sublime.ENCODED_POSITION)

global _ci_next_savedb_, _ci_next_cullmem_

__lock_.acquire()

try:

views = 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:

if _ci_mgr_:

now = time.time()

if now >= _ci_next_savedb_ or force:

if _ci_next_savedb_:

log.debug('Saving database')

_ci_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')

_ci_mgr_.db.cull_mem() # Every 30 seconds

'''An infinite loop running the linter 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

thread.__semaphore_.release()

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

try:

lang = lang or guess_lang_from_path(path)

except CodeIntelError:

logger(view, 'warning', "skip `%s': couldn't determine language" % path)

return

if lang.lower() in [l.lower() for l in view.settings().get('codeintel_disabled_languages', [])]:

return

is_scratch = view.is_scratch()

is_dirty = view.is_dirty()

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

def _codeintel_scan():

global _ci_mgr_, despair, despaired

env = None

mtime = None

catalogs = []

now = time.time()

try:

env = _ci_envs_[path]

if env._folders != folders:

raise KeyError

mgr = _ci_mgr_

if now > env._time:

mtime = max(tryGetMTime(env._config_file), tryGetMTime(env._config_default_file))

if env._mtime < mtime:

raise KeyError

except KeyError:

if env is not None:

config_default_file = env._config_default_file

project_dir = env._project_dir

project_base_dir = env._project_base_dir

config_file = env._config_file

else:

config_default_file = os.path.join(CODEINTEL_HOME_DIR, 'config')

if not (config_default_file and os.path.exists(config_default_file)):

config_default_file = None

project_dir = None

project_base_dir = None

if path:

# Try to find a suitable project directory (or best guess):

for folder in ['.codeintel', '.git', '.hg', 'trunk']:

project_dir = find_folder(path, folder)

if project_dir and (folder != '.codeintel' or not os.path.exists(os.path.join(project_dir, 'db'))):

if folder.startswith('.'):

project_base_dir = os.path.abspath(os.path.join(project_dir, '..'))

else:

project_base_dir = project_dir

break

if not (project_dir and os.path.exists(project_dir)):

project_dir = None

config_file = project_dir and folder == '.codeintel' and os.path.join(project_dir, 'config')

if not (config_file and os.path.exists(config_file)):

config_file = None

if _ci_mgr_:

mgr = _ci_mgr_

else:

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=_ci_extra_module_dirs_,

db_base_dir=_ci_db_base_dir_,

db_catalog_dirs=_ci_db_catalog_dirs_,

db_import_everything_langs=_ci_db_import_everything_langs,

db_event_reporter=lambda m: logger(view, 'event', m),

)

mgr.upgrade()

mgr.initialize()

# Connect the logging file to the handler

condeintel_log_file = os.path.join(mgr.db.base_dir, 'codeintel.log')

codeintel_log.handlers = [logging.StreamHandler(open(condeintel_log_file, 'w', 1))]

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

codeintel_log.info("%s\n%s" % (msg, "=" * len(msg)))

_ci_mgr_ = mgr

# Load configuration files:

for catalog in mgr.db.get_catalogs_zone().avail_catalogs():

if catalog['lang'] == lang:

catalogs.append(catalog['name'])

config = {

"codeintel_selected_catalogs": catalogs,

"codeintel_max_recursive_dir_depth": 10,

"codeintel_scan_files_in_project": True,

}

_config = {}

try:

tryReadDict(config_default_file, _config)

except Exception, e:

msg = "Malformed configuration file '%s': %s" % (config_default_file, e)

log.error(msg)

codeintel_log.error(msg)

try:

tryReadDict(config_file, _config)

except Exception, e:

msg = "Malformed configuration file '%s': %s" % (config_default_file, e)

log.error(msg)

codeintel_log.error(msg)

config.update(_config.get(lang, {}))

for conf in ['pythonExtraPaths', 'rubyExtraPaths', 'perlExtraPaths', 'javascriptExtraPaths', 'phpExtraPaths']:

v = [p.strip() for p in config.get(conf, []) + folders if p.strip()]

config[conf] = os.pathsep.join(set(p if p.startswith('/') else os.path.expanduser(p) if p.startswith('~') else os.path.abspath(os.path.join(project_base_dir, p)) if project_base_dir else p for p in v if p.strip()))

env = SimplePrefsEnvironment(**config)

env._mtime = mtime or max(tryGetMTime(config_file), tryGetMTime(config_default_file))

env._folders = folders

env._config_default_file = config_default_file

env._project_dir = project_dir

env._project_base_dir = project_base_dir

env._config_file = config_file

env.__class__.get_proj_base_dir = lambda self: project_base_dir

_ci_envs_[path] = env

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

msgs = []

if forms:

calltip(view, 'tip', "")

calltip(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:

msgs.append(('info', "New env with atalogs for '%s': %s" % (lang, ', '.join(catalogs) or None)))

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

if isinstance(buf, CitadelBuffer):

despair = 0

despaired = False

logger(view, 'info', "Updating indexes... The first time this can take a while.", 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]

try:

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

except KeyError:

msg = "Invalid language: %s. Available: %s" % (lang, ', '.join(mgr.citadel._cile_driver_from_lang))

log.debug(msg)

codeintel_log.debug(msg)

if callback:

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, buf.lang))

return [None] * len(forms)

try:

trg = getattr(buf, 'trg_from_pos', lambda p: None)(pos2bytes(content, pos))

defn_trg = getattr(buf, 'defn_trg_from_pos', lambda p: None)(pos2bytes(content, pos))

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_file)

trg = None

defn_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_file)

raise

else:

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 = [hdlr]

ctlr = LogEvalController(codeintel_log)

try:

if 'cplns' in forms and trg and trg.form == TRG_FORM_CPLN:

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

if 'calltips' in forms and trg and trg.form == TRG_FORM_CALLTIP:

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

if 'defns' in forms and defn_trg and defn_trg.form == TRG_FORM_DEFN:

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

finally:

codeintel_log.handlers = _hdlrs

logger(view, 'warning', "")

logger(view, 'event', "")

result = False

merge = ''

_msgs = []

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

_msgs.append((levelname, name + ':' + ((msg + ' ' + merge) if merge else msg)))

merge = ''

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

calltip(view, 'warning', msg)

result = True

if any((cplns, calltips, defns, result)):

_msgs.reverse()

for msg in msgs + _msgs:

getattr(codeintel_log, msg[0], codeintel_log.info)(msg[1])

ret = []

l = locals()

for f in forms:

ret.append(l.get(f))

total = (time.time() - start)

if not despaired or total * 1000 < timeout:

def _callback():

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

callback(*ret)

logger(view, 'info', "")

sublime.set_timeout(_callback, 0)

else:

logger(view, 'info', "Just finished indexing! Please try again. Scan took %s" % total, timeout=3000)

start_at = os.path.abspath(start_at)

if not os.path.isdir(start_at):

start_at = os.path.dirname(start_at)

while True:

if look_for in os.listdir(start_at):

return os.path.join(start_at, look_for)

continue_at = os.path.abspath(os.path.join(start_at, '..'))

if continue_at == start_at:

return None

for key, value in partial.items():

if isinstance(value, dict):

master.setdefault(key, {}).update(value)

elif isinstance(value, (list, tuple)):

if filename:

file = open(filename, 'r')

try:

updateCodeIntelDict(dictToUpdate, eval(file.read()))

finally:

path = os.path.join(path, '.git')

revision_file = os.path.join(path, 'refs', 'heads', 'master')

if not os.path.exists(revision_file):

return None

fh = open(revision_file, 'r')

try:

return fh.read().strip()

finally:

"""

path = os.path.abspath(os.path.normpath(__path__ if path is None else path))

while path and path != '/' and path != '\\':

rev = _get_git_revision(path)

if rev:

return u'GIT-%s' % rev

path = os.path.abspath(os.path.join(path, '..'))