def GetIncludes(self):
includes = []
for name, include_type in iteritems(self._includes):
includes.append(
responses.BuildCompletionData(name,
GetPathTypeName(include_type)))
return includes
def _ConvertCompletionData( completion_data ):
return responses.BuildCompletionData(
insertion_text = completion_data[ 'name' ],
menu_text = completion_data[ 'name' ],
kind = completion_data[ 'kind' ],
extra_data = completion_data[ 'kind' ]
)
def _FindLabels(self):
"""
Find LaTeX labels for \\ref{} completion.
This time we scan through all .tex files in the current
directory and extract the content of all \label{} commands
as sources for completion.
"""
# recursively search in the root directory
texs = " ".join(recursive_glob(self._data["root"], "*.tex"))
cat_process = subprocess.Popen(shlex.split("cat %s" % texs),
stdout=subprocess.PIPE)
grep_process = subprocess.Popen(shlex.split(r"grep \\\\label"),
stdin=cat_process.stdout,
stdout=subprocess.PIPE)
cat_process.stdout.close()
lines = grep_process.communicate()[0]
ret = []
for label in lines.split("\n"):
ret.append(
responses.BuildCompletionData(
re.sub(r".*\label{(.*)}.*", r"\1", label)))
return ret
def _ConvertCompletionData( completion_data ):
return responses.BuildCompletionData(
insertion_text = utils.ToUtf8IfNeeded( completion_data[ 'name' ] ),
menu_text = utils.ToUtf8IfNeeded( completion_data[ 'name' ] ),
kind = utils.ToUtf8IfNeeded( completion_data[ 'kind' ] ),
extra_data = utils.ToUtf8IfNeeded( completion_data[ 'kind' ] )
)
def ComputeCandidatesInner(self, request_data):
return [
responses.BuildCompletionData(completion['CompletionText'],
completion['DisplayText'],
completion['Description'])
for completion in self._GetCompletions(request_data)
]
def ComputeCandidatesInner(self, request_data):
query = {
'type': 'completions',
'types': True,
'docs': True,
'filter': False,
'caseInsensitive': True,
'guess': False,
'sort': False,
'includeKeywords': False,
'expandWordForward': False,
'omitObjectPrototype': False
}
completions = self._GetResponse(query, request_data['start_codepoint'],
request_data).get('completions', [])
def BuildDoc(completion):
doc = completion.get('type', 'Unknown type')
if 'doc' in completion:
doc = doc + '\n' + completion['doc']
return doc
return [
responses.BuildCompletionData(completion['name'],
completion.get('type', '?'),
BuildDoc(completion))
for completion in completions
]
def GetYCMDCompletions(self):
return [
responses.BuildCompletionData(completion.name,
menu_text=completion.description,
detailed_info=completion.docbrief)
for completion in self.GetCompletions()
]
def OnBufferVisit(self, request_data):
raw_candidates = request_data.get('ultisnips_snippets', [])
self._candidates = [
responses.BuildCompletionData(snip['trigger'],
'<snip> ' + snip['description'])
for snip in raw_candidates
]
def GeneratePathCompletionData(entries):
completion_dicts = []
for entry in entries:
completion_dicts.append(
responses.BuildCompletionData(entry[0], GetPathTypeName(entry[1])))
return completion_dicts
def ConvertCompletionData(completion_data):
return responses.BuildCompletionData(
insertion_text=completion_data.TextToInsertInBuffer(),
menu_text=completion_data.MainCompletionText(),
extra_menu_info=completion_data.ExtraMenuInfo(),
kind=completion_data.kind_.name,
detailed_info=completion_data.DetailedInfoForPreviewWindow())
def _FindLabels(self):
"""
Find LaTeX labels for \ref{} completion.
This time we scan through all .tex files in the current
directory and extract the content of all \label{} commands
as sources for completion.
"""
ret = []
for filename in self._Walk(self._main_directory, ".tex"):
skip, cache = self._CacheDataAndSkip(filename)
if skip:
ret.extend(cache)
continue
resp = []
for i, line in enumerate(codecs.open(filename, 'r', 'utf-8')):
line = line.rstrip()
match = re.search(r".*\label{(.*)}.*", line)
if match is not None:
lid = re.sub(r".*\label{(.*)}.*", r"\1", line)
self._goto_labels[lid] = (filename, i + 1, match.start(1))
resp.append(responses.BuildCompletionData(lid))
self._cached_data[filename] = resp
ret.extend(resp)
return ret
def _FindBibEntriesParser(self):
"""
"""
ret = []
parser = BibTexParser()
parser.customization = bib_customizations
for filename in self._Walk(self._main_directory, ".bib"):
skip, cache = self._CacheDataAndSkip(filename)
if skip:
ret.extend(cache)
continue
resp = []
with open(filename) as bibtex_file:
bib_database = bibtexparser.load(bibtex_file, parser=parser)
for entry in bib_database.entries:
if 'ID' not in entry:
continue
title = entry['title']
author = entry['author']
resp.append(
responses.BuildCompletionData(
entry['ID'], "%s (%s)" % (title, author)))
ret.extend(resp)
self._cached_data[filename] = resp
return ret
def ComputeCandidatesInner( self, request_data ):
return [ responses.BuildCompletionData(
completion[ 'name' ],
completion[ 'description' ],
completion[ 'docstring' ],
extra_data = self._GetExtraData( completion ) )
for completion in self._JediCompletions( request_data ) ]
def _ConvertDetailedCompletionData(request_data, completion_data):
name = completion_data['name']
display_parts = completion_data['displayParts']
signature = ''.join([part['text'] for part in display_parts])
if name == signature:
extra_menu_info = None
detailed_info = []
else:
# Strip new lines and indentation from the signature to display it on one
# line.
extra_menu_info = re.sub('\s+', ' ', signature)
detailed_info = [signature]
docs = completion_data.get('documentation', [])
detailed_info += [doc['text'].strip() for doc in docs if doc]
detailed_info = '\n\n'.join(detailed_info)
fixits = None
if 'codeActions' in completion_data:
location = responses.Location(request_data['line_num'],
request_data['column_num'],
request_data['filepath'])
fixits = responses.BuildFixItResponse([
responses.FixIt(
location, _BuildFixItForChanges(request_data,
action['changes']),
action['description'])
for action in completion_data['codeActions']
])
return responses.BuildCompletionData(insertion_text=name,
extra_menu_info=extra_menu_info,
detailed_info=detailed_info,
kind=completion_data['kind'],
extra_data=fixits)
def BuildOurCompletes(self, name):
"""
Surround the response value with brackets.
TODO- perhaps add a square bracket option
"""
return responses.BuildCompletionData("{" + name + "}",
self._completion_target, None,
name)
def ComputeCandidatesInner( self, request_data ):
script = self._GetJediScript( request_data )
return [ responses.BuildCompletionData(
ToUtf8IfNeeded( completion.name ),
ToUtf8IfNeeded( completion.description ),
ToUtf8IfNeeded( completion.docstring() ),
extra_data = self._GetExtraData( completion ) )
for completion in script.completions() ]
def ComputeCandidatesInner(self, request_data):
script = self._GetJediScript(request_data)
return [
responses.BuildCompletionData(str(completion.name),
str(completion.description),
str(completion.doc))
for completion in script.completions()
]
def _ConvertDetailedCompletionData(completion_data, padding=0):
name = completion_data['name']
display_parts = completion_data['displayParts']
signature = ''.join([p['text'] for p in display_parts])
menu_text = '{0} {1}'.format(name.ljust(padding), signature)
return responses.BuildCompletionData(insertion_text=name,
menu_text=menu_text,
kind=completion_data['kind'])
def ComputeCandidatesInner( self, request_data ):
with self._jedi_lock:
return [ responses.BuildCompletionData(
insertion_text = completion.name,
# We store the Completion object returned by Jedi in the extra_data
# field to detail the candidates once the filtering is done.
extra_data = completion
) for completion in self._GetJediScript( request_data ).completions() ]
def ComputeCandidatesInner(self, request_data):
solutioncompleter = self._GetSolutionCompleter(request_data)
return [
responses.BuildCompletionData(completion['CompletionText'],
completion['DisplayText'],
completion['Description'], None,
completion['Kind'])
for completion in solutioncompleter._GetCompletions(request_data)
]
def ComputeCandidatesInner(self, request_data):
return [
responses.BuildCompletionData(
completion['CompletionText'], completion['DisplayText'],
completion['Description'], None, None, {
"required_namespace_import":
completion['RequiredNamespaceImport']
}) for completion in self._GetCompletions(request_data)
]
def _ConvertCompletionData(completion_data):
return responses.BuildCompletionData(
insertion_text=completion_data['name'],
menu_text=completion_data['name'],
extra_menu_info=completion_data['type'],
kind=completion_data['class'],
detailed_info=' '.join([
completion_data['name'], completion_data['type'],
completion_data['class']
]))
def ComputeCandidatesInner(self, request_data):
query = {
'type': 'completions',
'types': True,
'docs': True,
'filter': False,
'caseInsensitive': True,
'guess': False,
'sort': False,
'includeKeywords': False,
'expandWordForward': False,
'omitObjectPrototype': False
}
response = self._GetResponse(query, request_data['start_codepoint'],
request_data)
completions = response.get('completions', [])
tern_start_codepoint = response['start']['ch']
# Tern returns the range of the word in the file which it is replacing. This
# may not be the same range that our "completion start column" calculation
# decided (i.e. it might not strictly be an identifier according to our
# rules). For example, when completing:
#
# require( '|
#
# with the cursor on |, tern returns something like 'test' (i.e. including
# the single-quotes). Single-quotes are not a JavaScript identifier, so
# should not normally be considered an identifier character, but by using
# our own start_codepoint calculation, the inserted string would be:
#
# require( ''test'
#
# which is clearly incorrect. It should be:
#
# require( 'test'
#
# So, we use the start position that tern tells us to use.
# We add 1 because tern offsets are 0-based and ycmd offsets are 1-based
request_data['start_codepoint'] = tern_start_codepoint + 1
def BuildDoc(completion):
doc = completion.get('type', 'Unknown type')
if 'doc' in completion:
doc = doc + '\n' + completion['doc']
return doc
return [
responses.BuildCompletionData(completion['name'],
completion.get('type', '?'),
BuildDoc(completion))
for completion in completions
]
def _ConvertDetailedCompletionData(completion_data, padding=0):
name = completion_data['name']
display_parts = completion_data['displayParts']
signature = ''.join([p['text'] for p in display_parts])
# needed to strip new lines and indentation from the signature
signature = re.sub('\s+', ' ', signature)
menu_text = '{0} {1}'.format(name.ljust(padding), signature)
return responses.BuildCompletionData(insertion_text=name,
menu_text=menu_text,
kind=completion_data['kind'])
def ComputeCandidatesInner(self, request_data):
with self._jedi_lock:
return [
responses.BuildCompletionData(
insertion_text=completion.name,
extra_menu_info=completion.description,
detailed_info=completion.docstring(),
kind=completion.type,
extra_data=self._GetExtraData(completion)) for completion
in self._GetJediScript(request_data).completions()
]
def ComputeCandidatesInner(self, request_data):
with self._jedi_lock:
completions = [
responses.BuildCompletionData(insertion_text=completion.name,
extra_menu_info=" ▸ jedi",
detailed_info="",
kind="",
extra_data=None) for completion
in self._GetJediScript(request_data).completions()
]
return completions
def _GeneratePathCompletionCandidates(path_dir):
completions = []
unicode_path = ToUnicode(path_dir)
for rel_path in ListDirectory(unicode_path):
absolute_path = os.path.join(unicode_path, rel_path)
path_type = GetPathTypeName(GetPathType(absolute_path))
completions.append(responses.BuildCompletionData(rel_path, path_type))
return completions
def ComputeCandidates(self, request_data):
script = self._GetScript(request_data)
completions = self._Request('completions', script)
return [
responses.BuildCompletionData(
ToUtf8IfNeeded(completion['name']),
ToUtf8IfNeeded(completion['description']),
ToUtf8IfNeeded(completion['docstring']),
extra_data=self._GetExtraData(completion))
for completion in completions
]
def ComputeCandidatesInner(self, request_data):
solutioncompleter = self._GetSolutionCompleter(request_data)
completion_type = self.CompletionType(request_data)
return [
responses.BuildCompletionData(
completion['CompletionText'], completion['DisplayText'],
completion['Description'], None, None, {
"required_namespace_import":
completion['RequiredNamespaceImport']
}) for completion in solutioncompleter._GetCompletions(
request_data, completion_type)
]
def ComputeCandidatesInner(self, request_data):
self._UpdateCurrentBuffer(request_data, discard_current_line=True)
current_line = request_data['line_value']
start_column = request_data['start_column']
line = current_line[:start_column]
if len(line) >= 2 and line[start_column - 2] == '.':
fields = self.fields_pat.findall(line[:start_column])
if len(fields):
namelist = self.field_elem_pat.findall(fields[-1])
return [
responses.BuildCompletionData(str(completion['word']),
str(completion['menu']))
for completion in self.daemon.get_fields(namelist)
]
else:
return [
responses.BuildCompletionData(
str(completion['word']),
str(completion['menu']),
) for completion in self.daemon.get_candidates()
]
