def _create_completion_item(library_name,
selection,
token,
start_col_offset=None):
from robocode_ls_core.lsp import (
CompletionItem,
InsertTextFormat,
Position,
Range,
TextEdit,
)
from robocode_ls_core.lsp import MarkupKind
from robocode_ls_core.lsp import CompletionItemKind
text_edit = TextEdit(
Range(
start=Position(
selection.line,
start_col_offset
if start_col_offset is not None else token.col_offset,
),
end=Position(selection.line, token.end_col_offset),
),
library_name,
)
# text_edit = None
return CompletionItem(
library_name,
kind=CompletionItemKind.Module,
text_edit=text_edit,
documentation="",
insertTextFormat=InsertTextFormat.Snippet,
documentationFormat=MarkupKind.PlainText,
).to_dict()
def test_document_multiline_edit():
old = ["def hello(a, b):\n", " print a\n", " print b\n"]
doc = Document("file:///uri", u"".join(old))
change = TextDocumentContentChangeEvent(
Range(Position(1, 4), Position(2, 11)), 0, u"print a, b")
doc.apply_change(change)
assert doc.get_internal_lines() == ("def hello(a, b):\n",
" print a, b\n")
def test_document_end_of_file_edit():
old = ["print 'a'\n", "print 'b'\n"]
doc = Document("file:///uri", u"".join(old))
change = TextDocumentContentChangeEvent(
Range(Position(2, 0), Position(2, 0)), 0, u"o")
doc.apply_change(change)
assert doc.get_internal_lines() == ("print 'a'\n", "print 'b'\n", "o")
def _create_completion_item_from_keyword(self,
keyword_found,
selection,
token,
col_delta=0):
"""
:param IKeywordFound keyword_found:
:param selection:
:param token:
"""
from robocode_ls_core.lsp import (
CompletionItem,
InsertTextFormat,
Position,
Range,
TextEdit,
)
from robocode_ls_core.lsp import MarkupKind
label = keyword_found.keyword_name
text = label
for i, arg in enumerate(keyword_found.keyword_args):
arg = arg.replace("$", "\\$").replace("{", "").replace("}", "")
if arg.startswith("**"):
arg = "&" + arg[2:]
elif arg.startswith("*"):
arg = "@" + arg[1:]
colon_i = arg.rfind(":")
equals_i = arg.rfind("=")
if colon_i != -1 and equals_i != -1 and equals_i > colon_i:
arg = arg[:colon_i] + arg[equals_i:]
text += " ${%s:%s}" % (i + 1, arg)
text_edit = TextEdit(
Range(
start=Position(selection.line, token.col_offset + col_delta),
end=Position(selection.line, token.end_col_offset),
),
text,
)
# text_edit = None
return CompletionItem(
keyword_found.keyword_name,
kind=keyword_found.completion_item_kind,
text_edit=text_edit,
documentation=keyword_found.docs,
insertTextFormat=InsertTextFormat.Snippet,
documentationFormat=(MarkupKind.Markdown
if keyword_found.docs_format == "markdown"
else MarkupKind.PlainText),
).to_dict()
def m_find_definition(self, doc_uri, line, col):
from robotframework_ls.impl.find_definition import find_definition
import os.path
from robocode_ls_core.lsp import Location, Range
from robocode_ls_core import uris
completion_context = self._create_completion_context(
doc_uri, line, col)
if completion_context is None:
return None
definitions = find_definition(completion_context)
ret = []
for definition in definitions:
if not definition.source:
log.info("Found definition with empty source (%s).",
definition)
continue
if not os.path.exists(definition.source):
log.info("Found definition: %s (but source does not exist).",
definition)
continue
lineno = definition.lineno
if lineno is None or lineno < 0:
lineno = 0
end_lineno = definition.end_lineno
if end_lineno is None or end_lineno < 0:
end_lineno = 0
col_offset = definition.col_offset
end_col_offset = definition.end_col_offset
ret.append(
Location(
uris.from_fs_path(definition.source),
Range((lineno, col_offset), (end_lineno, end_col_offset)),
).to_dict())
return ret
def _create_completion_item_from_variable(self, variable_found, selection,
token):
"""
:param IVariableFound variable_found:
:param selection:
:param token:
"""
from robocode_ls_core.lsp import (
CompletionItem,
InsertTextFormat,
Position,
Range,
TextEdit,
)
from robocode_ls_core.lsp import MarkupKind
from robocode_ls_core.lsp import CompletionItemKind
label = variable_found.variable_name
text = label
text = text.replace("$", "\\$")
text_edit = TextEdit(
Range(
start=Position(selection.line, token.col_offset),
end=Position(selection.line, token.end_col_offset),
),
text,
)
# text_edit = None
return CompletionItem(
variable_found.variable_name,
kind=CompletionItemKind.Variable,
text_edit=text_edit,
documentation=variable_found.variable_value,
insertTextFormat=InsertTextFormat.Snippet,
documentationFormat=MarkupKind.PlainText,
).to_dict()
def _create_completion_item_from_snippet(label, snippet, selection,
line_to_col):
"""
:param selection: DocumentSelection
"""
from robocode_ls_core.lsp import (
CompletionItem,
InsertTextFormat,
Position,
Range,
TextEdit,
)
from robocode_ls_core.lsp import MarkupKind
from robocode_ls_core.lsp import CompletionItemKind
current_col = selection.col
text = "\n".join(snippet["body"])
text_edit = TextEdit(
Range(
start=Position(selection.line, current_col - len(line_to_col)),
end=Position(selection.line, current_col),
),
text,
)
return CompletionItem(
label,
kind=CompletionItemKind.Snippet,
text_edit=text_edit,
documentation=snippet["description"] +
"\n".join(["", ""] + snippet["body"]),
insertTextFormat=InsertTextFormat.Snippet,
documentationFormat=MarkupKind.Markdown,
).to_dict()
def complete(completion_context):
"""
:param CompletionContext completion_context:
"""
import itertools
from robocode_ls_core.lsp import (
TextEdit,
Range,
Position,
CompletionItem,
CompletionItemKind,
)
section_name = completion_context.get_current_section_name()
if section_name:
from robotframework_ls.impl.string_matcher import RobotStringMatcher
section = completion_context.get_section(section_name)
if section is not None:
selection = completion_context.sel #: :type selection: DocumentSelection
line_to_col = selection.line_to_column
replace_to_col = selection.col
if section.names_in_brackets:
for i, c in enumerate(line_to_col):
if c.isspace():
continue
elif c == "[":
line_to_col = line_to_col[i + 1:]
replace_from_col = i
break
else:
return []
else:
return []
matcher = RobotStringMatcher(line_to_col)
else:
# i.e.: Needs to be the first char
matcher = RobotStringMatcher(line_to_col)
replace_from_col = 0
ret = []
for word in sorted(itertools.chain(section.names,
section.aliases)):
if matcher.accepts(word):
if section.names_in_brackets:
label = "[%s]" % (word, )
line = selection.current_line
replacement = "[%s]" % (word, )
if line[selection.col:].startswith("]"):
replace_to_col += 1
else:
label = word
replacement = word
text_edit = TextEdit(
Range(
start=Position(selection.line, replace_from_col),
end=Position(selection.line, replace_to_col),
),
replacement,
)
# text_edit = None
ret.append(
CompletionItem(label,
kind=CompletionItemKind.Keyword,
text_edit=text_edit).to_dict())
return ret
return []
def test_document_line_edit():
doc = Document("file:///uri", u"itshelloworld")
change = TextDocumentContentChangeEvent(
Range(Position(0, 3), Position(0, 8)), 0, u"goodbye")
doc.apply_change(change)
assert doc.source == u"itsgoodbyeworld"
def test_document_empty_edit():
doc = Document("file:///uri", u"")
change = TextDocumentContentChangeEvent(
Range(Position(0, 0), Position(0, 0)), 0, u"f")
doc.apply_change(change)
assert doc.source == u"f"
def complete(completion_context):
"""
:param CompletionContext completion_context:
"""
from robocode_ls_core.lsp import CompletionItemKind
from robocode_ls_core.lsp import CompletionItem
from robocode_ls_core.lsp import TextEdit
from robocode_ls_core.lsp import Range
from robocode_ls_core.lsp import Position
from robotframework_ls.impl import text_utilities
from robotframework_ls.impl.string_matcher import RobotStringMatcher
from robotframework_ls.impl.robot_lsp_constants import (
OPTION_ROBOT_COMPLETION_SECTION_HEADERS_FORM,
)
from robotframework_ls.impl.robot_lsp_constants import (
OPTION_ROBOT_COMPLETION_SECTION_HEADERS_FORM_PLURAL,
)
selection = completion_context.sel #: :type selection: DocumentSelection
line_start = selection.line_to_column
items = []
if line_start:
tu = text_utilities.TextUtilities(line_start)
if tu.strip_leading_chars("*"): # i.e.: the line must start with '*'
tu.strip()
words = completion_context.get_accepted_section_header_words()
config = completion_context.config
form = config.get_setting(
OPTION_ROBOT_COMPLETION_SECTION_HEADERS_FORM,
str,
OPTION_ROBOT_COMPLETION_SECTION_HEADERS_FORM_PLURAL,
)
matcher = RobotStringMatcher(tu.text)
for word in words:
if form == "plural":
if not word.endswith("s"):
continue
elif form == "singular":
if word.endswith("s"):
continue
if matcher.accepts(word):
label = "*** %s ***" % (word,)
text_edit = TextEdit(
Range(
# i.e.: always replace from the start of the line.
start=Position(selection.line, 0),
end=Position(selection.line, selection.col),
),
label,
)
# text_edit = None
items.append(
CompletionItem(
label, kind=CompletionItemKind.Class, text_edit=text_edit
)
)
return [item.to_dict() for item in items]