class SnippetEditor(QDialog):
SNIPPET_VALID = _('Valid snippet')
SNIPPET_INVALID = _('Invalid snippet')
INVALID_CB_CSS = "QComboBox {border: 1px solid red;}"
VALID_CB_CSS = "QComboBox {border: 1px solid green;}"
INVALID_LINE_CSS = "QLineEdit {border: 1px solid red;}"
VALID_LINE_CSS = "QLineEdit {border: 1px solid green;}"
MIN_SIZE = QSize(850, 600)
def __init__(self,
parent,
language=None,
trigger_text='',
description='',
snippet_text='',
remove_trigger=False,
trigger_texts=[],
descriptions=[],
get_option=None,
set_option=None):
super(SnippetEditor, self).__init__(parent)
snippet_description = _(
"To add a new text snippet, you need to define the text "
"that triggers it, a short description (two words maximum) "
"of the snippet and if it should delete the trigger text when "
"inserted. Finally, you need to define the snippet body to insert."
)
self.parent = parent
self.trigger_text = trigger_text
self.description = description
self.remove_trigger = remove_trigger
self.snippet_text = snippet_text
self.descriptions = descriptions
self.base_snippet = Snippet(language=language,
trigger_text=trigger_text,
snippet_text=snippet_text,
description=description,
remove_trigger=remove_trigger,
get_option=get_option,
set_option=set_option)
# Widgets
self.snippet_settings_description = QLabel(snippet_description)
self.snippet_settings_description.setFixedWidth(450)
# Trigger text
self.trigger_text_label = QLabel(_('Trigger text:'))
self.trigger_text_cb = QComboBox(self)
self.trigger_text_cb.setEditable(True)
# Description
self.description_label = QLabel(_('Description:'))
self.description_input = QLineEdit(self)
# Remove trigger
self.remove_trigger_cb = QCheckBox(
_('Remove trigger text on insertion'), self)
self.remove_trigger_cb.setToolTip(
_('Check if the text that triggers '
'this snippet should be removed '
'when inserting it'))
self.remove_trigger_cb.setChecked(self.remove_trigger)
# Snippet body input
self.snippet_label = QLabel(_('<b>Snippet text:</b>'))
self.snippet_valid_label = QLabel(self.SNIPPET_INVALID, self)
self.snippet_input = SimpleCodeEditor(None)
# Dialog buttons
self.bbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = self.bbox.button(QDialogButtonBox.Ok)
self.button_cancel = self.bbox.button(QDialogButtonBox.Cancel)
# Widget setup
self.setWindowTitle(_('Snippet editor'))
self.snippet_settings_description.setWordWrap(True)
self.trigger_text_cb.setToolTip(
_('Trigger text for the current snippet'))
self.trigger_text_cb.addItems(trigger_texts)
if self.trigger_text != '':
idx = trigger_texts.index(self.trigger_text)
self.trigger_text_cb.setCurrentIndex(idx)
self.description_input.setText(self.description)
self.description_input.textChanged.connect(lambda _x: self.validate())
text_inputs = (self.trigger_text, self.description, self.snippet_text)
non_empty_text = all([x != '' for x in text_inputs])
if non_empty_text:
self.button_ok.setEnabled(True)
self.snippet_input.setup_editor(language=language,
color_scheme=get_option(
'selected', section='appearance'),
wrap=False,
highlight_current_line=True,
font=get_font())
self.snippet_input.set_language(language)
self.snippet_input.setToolTip(_('Snippet text completion to insert'))
self.snippet_input.set_text(snippet_text)
# Layout setup
general_layout = QVBoxLayout()
general_layout.addWidget(self.snippet_settings_description)
snippet_settings_group = QGroupBox(_('Trigger information'))
settings_layout = QGridLayout()
settings_layout.addWidget(self.trigger_text_label, 0, 0)
settings_layout.addWidget(self.trigger_text_cb, 0, 1)
settings_layout.addWidget(self.description_label, 1, 0)
settings_layout.addWidget(self.description_input, 1, 1)
all_settings_layout = QVBoxLayout()
all_settings_layout.addLayout(settings_layout)
all_settings_layout.addWidget(self.remove_trigger_cb)
snippet_settings_group.setLayout(all_settings_layout)
general_layout.addWidget(snippet_settings_group)
text_layout = QVBoxLayout()
text_layout.addWidget(self.snippet_label)
text_layout.addWidget(self.snippet_input)
text_layout.addWidget(self.snippet_valid_label)
general_layout.addLayout(text_layout)
general_layout.addWidget(self.bbox)
self.setLayout(general_layout)
# Signals
self.trigger_text_cb.editTextChanged.connect(self.validate)
self.description_input.textChanged.connect(self.validate)
self.snippet_input.textChanged.connect(self.validate)
self.bbox.accepted.connect(self.accept)
self.bbox.rejected.connect(self.reject)
# Final setup
if trigger_text != '' or snippet_text != '':
self.validate()
@Slot()
def validate(self):
trigger_text = self.trigger_text_cb.currentText()
description_text = self.description_input.text()
snippet_text = self.snippet_input.toPlainText()
invalid = False
try:
build_snippet_ast(snippet_text)
self.snippet_valid_label.setText(self.SNIPPET_VALID)
except SyntaxError:
invalid = True
self.snippet_valid_label.setText(self.SNIPPET_INVALID)
if trigger_text == '':
invalid = True
self.trigger_text_cb.setStyleSheet(self.INVALID_CB_CSS)
else:
self.trigger_text_cb.setStyleSheet(self.VALID_CB_CSS)
if trigger_text in self.descriptions:
if self.trigger_text != trigger_text:
if description_text in self.descriptions[trigger_text]:
invalid = True
self.description_input.setStyleSheet(self.INVALID_LINE_CSS)
else:
self.description_input.setStyleSheet(self.VALID_LINE_CSS)
else:
if description_text != self.description:
if description_text in self.descriptions[trigger_text]:
invalid = True
self.description_input.setStyleSheet(
self.INVALID_LINE_CSS)
else:
self.description_input.setStyleSheet(
self.VALID_LINE_CSS)
else:
self.description_input.setStyleSheet(self.VALID_LINE_CSS)
self.button_ok.setEnabled(not invalid)
def get_options(self):
trigger_text = self.trigger_text_cb.currentText()
description_text = self.description_input.text()
snippet_text = self.snippet_input.toPlainText()
remove_trigger = self.remove_trigger_cb.isChecked()
self.base_snippet.update(trigger_text, description_text, snippet_text,
remove_trigger)
return self.base_snippet
class LSPServerEditor(QDialog):
DEFAULT_HOST = '127.0.0.1'
DEFAULT_PORT = 2084
DEFAULT_CMD = ''
DEFAULT_ARGS = ''
DEFAULT_CONFIGURATION = '{}'
DEFAULT_EXTERNAL = False
DEFAULT_STDIO = False
HOST_REGEX = re.compile(r'^\w+([.]\w+)*$')
NON_EMPTY_REGEX = re.compile(r'^\S+$')
JSON_VALID = _('Valid JSON')
JSON_INVALID = _('Invalid JSON')
MIN_SIZE = QSize(850, 600)
INVALID_CSS = "QLineEdit {border: 1px solid red;}"
VALID_CSS = "QLineEdit {border: 1px solid green;}"
def __init__(self,
parent,
language=None,
cmd='',
host='127.0.0.1',
port=2084,
args='',
external=False,
stdio=False,
configurations={},
get_option=None,
set_option=None,
remove_option=None,
**kwargs):
super(LSPServerEditor, self).__init__(parent)
description = _(
"To create a new server configuration, you need to select a "
"programming language, set the command to start its associated "
"server and enter any arguments that should be passed to it on "
"startup. Additionally, you can set the server's hostname and "
"port if connecting to an external server, "
"or to a local one using TCP instead of stdio pipes."
"<br><br>"
"<i>Note</i>: You can use the placeholders <tt>{host}</tt> and "
"<tt>{port}</tt> in the server arguments field to automatically "
"fill in the respective values.<br>")
self.parent = parent
self.external = external
self.set_option = set_option
self.get_option = get_option
self.remove_option = remove_option
# Widgets
self.server_settings_description = QLabel(description)
self.lang_cb = QComboBox(self)
self.external_cb = QCheckBox(_('External server'), self)
self.host_label = QLabel(_('Host:'))
self.host_input = QLineEdit(self)
self.port_label = QLabel(_('Port:'))
self.port_spinner = QSpinBox(self)
self.cmd_label = QLabel(_('Command:'))
self.cmd_input = QLineEdit(self)
self.args_label = QLabel(_('Arguments:'))
self.args_input = QLineEdit(self)
self.json_label = QLabel(self.JSON_VALID, self)
self.conf_label = QLabel(_('<b>Server Configuration:</b>'))
self.conf_input = SimpleCodeEditor(None)
self.bbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = self.bbox.button(QDialogButtonBox.Ok)
self.button_cancel = self.bbox.button(QDialogButtonBox.Cancel)
# Widget setup
self.setMinimumSize(self.MIN_SIZE)
self.setWindowTitle(_('LSP server editor'))
self.server_settings_description.setWordWrap(True)
self.lang_cb.setToolTip(
_('Programming language provided by the LSP server'))
self.lang_cb.addItem(_('Select a language'))
self.lang_cb.addItems(SUPPORTED_LANGUAGES)
self.button_ok.setEnabled(False)
if language is not None:
idx = SUPPORTED_LANGUAGES.index(language)
self.lang_cb.setCurrentIndex(idx + 1)
self.button_ok.setEnabled(True)
self.host_input.setPlaceholderText('127.0.0.1')
self.host_input.setText(host)
self.host_input.textChanged.connect(lambda _: self.validate())
self.port_spinner.setToolTip(_('TCP port number of the server'))
self.port_spinner.setMinimum(1)
self.port_spinner.setMaximum(60000)
self.port_spinner.setValue(port)
self.port_spinner.valueChanged.connect(lambda _: self.validate())
self.cmd_input.setText(cmd)
self.cmd_input.setPlaceholderText('/absolute/path/to/command')
self.args_input.setToolTip(
_('Additional arguments required to start the server'))
self.args_input.setText(args)
self.args_input.setPlaceholderText(r'--host {host} --port {port}')
self.conf_input.setup_editor(language='json',
color_scheme=get_option(
'selected', section='appearance'),
wrap=False,
highlight_current_line=True,
font=get_font())
self.conf_input.set_language('json')
self.conf_input.setToolTip(
_('Additional LSP server configuration '
'set at runtime. JSON required'))
try:
conf_text = json.dumps(configurations, indent=4, sort_keys=True)
except Exception:
conf_text = '{}'
self.conf_input.set_text(conf_text)
self.external_cb.setToolTip(
_('Check if the server runs on a remote location'))
self.external_cb.setChecked(external)
self.stdio_cb = QCheckBox(_('Use stdio pipes for communication'), self)
self.stdio_cb.setToolTip(
_('Check if the server communicates '
'using stdin/out pipes'))
self.stdio_cb.setChecked(stdio)
# Layout setup
hlayout = QHBoxLayout()
general_vlayout = QVBoxLayout()
general_vlayout.addWidget(self.server_settings_description)
vlayout = QVBoxLayout()
lang_group = QGroupBox(_('Language'))
lang_layout = QVBoxLayout()
lang_layout.addWidget(self.lang_cb)
lang_group.setLayout(lang_layout)
vlayout.addWidget(lang_group)
server_group = QGroupBox(_('Language server'))
server_layout = QGridLayout()
server_layout.addWidget(self.cmd_label, 0, 0)
server_layout.addWidget(self.cmd_input, 0, 1)
server_layout.addWidget(self.args_label, 1, 0)
server_layout.addWidget(self.args_input, 1, 1)
server_group.setLayout(server_layout)
vlayout.addWidget(server_group)
address_group = QGroupBox(_('Server address'))
host_layout = QVBoxLayout()
host_layout.addWidget(self.host_label)
host_layout.addWidget(self.host_input)
port_layout = QVBoxLayout()
port_layout.addWidget(self.port_label)
port_layout.addWidget(self.port_spinner)
conn_info_layout = QHBoxLayout()
conn_info_layout.addLayout(host_layout)
conn_info_layout.addLayout(port_layout)
address_group.setLayout(conn_info_layout)
vlayout.addWidget(address_group)
advanced_group = QGroupBox(_('Advanced'))
advanced_layout = QVBoxLayout()
advanced_layout.addWidget(self.external_cb)
advanced_layout.addWidget(self.stdio_cb)
advanced_group.setLayout(advanced_layout)
vlayout.addWidget(advanced_group)
conf_layout = QVBoxLayout()
conf_layout.addWidget(self.conf_label)
conf_layout.addWidget(self.conf_input)
conf_layout.addWidget(self.json_label)
vlayout.addStretch()
hlayout.addLayout(vlayout, 2)
hlayout.addLayout(conf_layout, 3)
general_vlayout.addLayout(hlayout)
general_vlayout.addWidget(self.bbox)
self.setLayout(general_vlayout)
self.form_status(False)
# Signals
if not external:
self.cmd_input.textChanged.connect(lambda x: self.validate())
self.external_cb.stateChanged.connect(self.set_local_options)
self.stdio_cb.stateChanged.connect(self.set_stdio_options)
self.lang_cb.currentIndexChanged.connect(self.lang_selection_changed)
self.conf_input.textChanged.connect(self.validate)
self.bbox.accepted.connect(self.accept)
self.bbox.rejected.connect(self.reject)
# Final setup
if language is not None:
self.form_status(True)
self.validate()
if stdio:
self.set_stdio_options(True)
if external:
self.set_local_options(True)
@Slot()
def validate(self):
host_text = self.host_input.text()
cmd_text = self.cmd_input.text()
if host_text not in ['127.0.0.1', 'localhost']:
self.external = True
self.external_cb.setChecked(True)
if not self.HOST_REGEX.match(host_text):
self.button_ok.setEnabled(False)
self.host_input.setStyleSheet(self.INVALID_CSS)
if bool(host_text):
self.host_input.setToolTip(_('Hostname must be valid'))
else:
self.host_input.setToolTip(
_('Hostname or IP address of the host on which the server '
'is running. Must be non empty.'))
else:
self.host_input.setStyleSheet(self.VALID_CSS)
self.host_input.setToolTip(_('Hostname is valid'))
self.button_ok.setEnabled(True)
if not self.external:
if not self.NON_EMPTY_REGEX.match(cmd_text):
self.button_ok.setEnabled(False)
self.cmd_input.setStyleSheet(self.INVALID_CSS)
self.cmd_input.setToolTip(
_('Command used to start the LSP server locally. Must be '
'non empty'))
return
if find_program(cmd_text) is None:
self.button_ok.setEnabled(False)
self.cmd_input.setStyleSheet(self.INVALID_CSS)
self.cmd_input.setToolTip(
_('Program was not found '
'on your system'))
else:
self.cmd_input.setStyleSheet(self.VALID_CSS)
self.cmd_input.setToolTip(
_('Program was found on your '
'system'))
self.button_ok.setEnabled(True)
else:
port = int(self.port_spinner.text())
response = check_connection_port(host_text, port)
if not response:
self.button_ok.setEnabled(False)
try:
json.loads(self.conf_input.toPlainText())
try:
self.json_label.setText(self.JSON_VALID)
except Exception:
pass
except ValueError:
try:
self.json_label.setText(self.JSON_INVALID)
self.button_ok.setEnabled(False)
except Exception:
pass
def form_status(self, status):
self.host_input.setEnabled(status)
self.port_spinner.setEnabled(status)
self.external_cb.setEnabled(status)
self.stdio_cb.setEnabled(status)
self.cmd_input.setEnabled(status)
self.args_input.setEnabled(status)
self.conf_input.setEnabled(status)
self.json_label.setVisible(status)
@Slot()
def lang_selection_changed(self):
idx = self.lang_cb.currentIndex()
if idx == 0:
self.set_defaults()
self.form_status(False)
self.button_ok.setEnabled(False)
else:
server = self.parent.get_server_by_lang(SUPPORTED_LANGUAGES[idx -
1])
self.form_status(True)
if server is not None:
self.host_input.setText(server.host)
self.port_spinner.setValue(server.port)
self.external_cb.setChecked(server.external)
self.stdio_cb.setChecked(server.stdio)
self.cmd_input.setText(server.cmd)
self.args_input.setText(server.args)
self.conf_input.set_text(json.dumps(server.configurations))
self.json_label.setText(self.JSON_VALID)
self.button_ok.setEnabled(True)
else:
self.set_defaults()
def set_defaults(self):
self.cmd_input.setStyleSheet('')
self.host_input.setStyleSheet('')
self.host_input.setText(self.DEFAULT_HOST)
self.port_spinner.setValue(self.DEFAULT_PORT)
self.external_cb.setChecked(self.DEFAULT_EXTERNAL)
self.stdio_cb.setChecked(self.DEFAULT_STDIO)
self.cmd_input.setText(self.DEFAULT_CMD)
self.args_input.setText(self.DEFAULT_ARGS)
self.conf_input.set_text(self.DEFAULT_CONFIGURATION)
self.json_label.setText(self.JSON_VALID)
@Slot(bool)
@Slot(int)
def set_local_options(self, enabled):
self.external = enabled
self.cmd_input.setEnabled(True)
self.args_input.setEnabled(True)
if enabled:
self.cmd_input.setEnabled(False)
self.cmd_input.setStyleSheet('')
self.args_input.setEnabled(False)
self.stdio_cb.stateChanged.disconnect()
self.stdio_cb.setChecked(False)
self.stdio_cb.setEnabled(False)
else:
self.cmd_input.setEnabled(True)
self.args_input.setEnabled(True)
self.stdio_cb.setEnabled(True)
self.stdio_cb.setChecked(False)
self.stdio_cb.stateChanged.connect(self.set_stdio_options)
try:
self.validate()
except Exception:
pass
@Slot(bool)
@Slot(int)
def set_stdio_options(self, enabled):
self.stdio = enabled
if enabled:
self.cmd_input.setEnabled(True)
self.args_input.setEnabled(True)
self.external_cb.stateChanged.disconnect()
self.external_cb.setChecked(False)
self.external_cb.setEnabled(False)
self.host_input.setStyleSheet('')
self.host_input.setEnabled(False)
self.port_spinner.setEnabled(False)
else:
self.cmd_input.setEnabled(True)
self.args_input.setEnabled(True)
self.external_cb.setChecked(False)
self.external_cb.setEnabled(True)
self.external_cb.stateChanged.connect(self.set_local_options)
self.host_input.setEnabled(True)
self.port_spinner.setEnabled(True)
try:
self.validate()
except Exception:
pass
def get_options(self):
language_idx = self.lang_cb.currentIndex()
language = SUPPORTED_LANGUAGES[language_idx - 1]
host = self.host_input.text()
port = int(self.port_spinner.value())
external = self.external_cb.isChecked()
stdio = self.stdio_cb.isChecked()
args = self.args_input.text()
cmd = self.cmd_input.text()
configurations = json.loads(self.conf_input.toPlainText())
server = LSPServer(language=language.lower(),
cmd=cmd,
args=args,
host=host,
port=port,
external=external,
stdio=stdio,
configurations=configurations,
get_option=self.get_option,
set_option=self.set_option,
remove_option=self.remove_option)
return server