Commit 425b1bd2 authored by Daniel Brötzmann's avatar Daniel Brötzmann

[syntax_highlight] Simplify plugin code

Fix deprecations warnings in config
parent 68d78970
# Syntax Highlighting Plugin for Gajim
[Gajim](https://gajim.org) Plugin that highlights source code blocks in the chat window.
## Installation
The recommended way of installing this plugin is to use Gajim's Plugin Installer.
For more information and instruction on how to install plugins manually, please
refer to the [Gajim Plugin Wiki site](https://dev.gajim.org/gajim/gajim-plugins/wikis/home#how-to-install-plugins).
## Usage
This plugin uses markdown-style syntax to identify which parts of a message
should be formatted as code in the chat window.
```
Inline source code will be highlighted when placed in between `two single
back-ticks`.
```
The language used to highlight the syntax of inline code is selected as the
default language in the plugin settings.
Multi-line code blocks are started by three back-ticks followed by a newline.
Optionally, a language can be specified directly after the opening back-ticks and
before the line break:
````
```language
Note, that the last line of a code block may only contain the closing back-ticks,
i.e. there must be a newline here.
```
````
In case no language is specified with the opening tag or the specified language
could not be identified, the default language configured in the settings is
used.
You can test it by copying and sending the following text to one of your
contacts:
````
```python
def test():
print("Hello, world!")
```
````
(**Note:** your contact will not receive highlighted text unless she is also
using the plugin.)
## Relation to XEP-0393 - 'Message Styling'
https://xmpp.org/extensions/xep-0393.html#pre-block
In [XEP-0393](https://xmpp.org/extensions/xep-0393.html),
the back-tick based syntax is defined as markup for preformatted
text blocks, respectively inline preformatted text.
Formatting of such text blocks with mono-spaced fonts is recommended by the XEP.
By using the same syntax as defined in XEP-0393 XMPP clients with only XEP-0393
support but without syntax highlighting can at least present their users blocks
of preformatted text.
Since text in between the back-tick markers is not further formatted by this
plugin, it can be considered "preformatted".
Hence, this plugin is compatible to the formatting options defined by XEP-0393,
[section 5.1.2, "Preformatted Text"](https://xmpp.org/extensions/xep-0393.html#pre-block)
and [section 5.2.5, "Preformatted Span"](https://xmpp.org/extensions/xep-0393.html#mono).
Nevertheless, syntax highlighting for source code is not part of XEP but
rather a non-standard extension introduced with this plugin.
## Configuration
The configuration can be found via 'Gajim' > 'Plugins', then select the
'Source Code Syntax Highlight' Plugin and click the gears symbol.
The configuration options let you specify many details how code is formatted,
including default language, style, font settings, background color and formatting
of the code markers.
In the configuration window, the current settings are displayed in an
interactive preview panel. This allows you to directly check how code would
look like in the message
window.
## Report Bugs and Feature Requests
For bug reports, please report them to the [Gajim Plugin Issue tracker](https://dev.gajim.org/gajim/gajim-plugins/issues/new?issue[FlorianMuenchbach]=&issue[description]=Gajim%20Version%3A%20%0APlugin%20Version%3A%0AOperating%20System%3A&issue[title]=[syntax_highlight]).
Please make sure that the issue you create contains `[syntax_highlight]` in the
title and information such as Gajim version, Plugin version, Operating system,
etc.
## Debug
The plugin adds its own logger. It can be used to set a specific debug level
for this plugin and/or filter log messages.
Run
```
gajim --loglevel gajim.p.syntax_highlight=DEBUG
```
in a terminal to display the debug messages.
## Known Issues / ToDo
* ~~Gajim crashes when correcting a message containing highlighted code.~~
(fixed in version 1.1.0)
## Credits
Since I had no experience in writing Plugins for Gajim, I used the
[Latex Plugin](https://dev.gajim.org/gajim/gajim-plugins/wikis/LatexPlugin)
written by Yves Fischer and Yann Leboulanger as an example and copied a big
portion of initial code. Therefore, credits go to the authors of the Latex
Plugin for providing an example.
The syntax highlighting itself is done by [pygments](http://pygments.org/).
This diff is collapsed.
import logging
import re
import math
from pathlib import Path
import pygments
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository.Pango import FontDescription
from gi.repository.Pango import Style
from gi.repository.Pango import SCALE
from gajim.common import app
from gajim.plugins.plugins_i18n import _
from gajim.plugins.helpers import get_builder
from syntax_highlight.gtkformatter import GTKFormatter
from syntax_highlight.types import LineBreakOptions
from syntax_highlight.types import CodeMarkerOptions
from syntax_highlight.types import PLUGIN_INTERNAL_NONE_LEXER_ID
log = logging.getLogger('gajim.p.syntax_highlight')
PLUGIN_INTERNAL_NONE_LEXER = ('None (monospace only)',
PLUGIN_INTERNAL_NONE_LEXER_ID)
class SyntaxHighlighterPluginConfig(Gtk.ApplicationWindow):
def __init__(self, plugin, transient):
Gtk.ApplicationWindow.__init__(self)
self.set_application(app.app)
self.set_show_menubar(False)
self.set_title(_('Syntax Highlighter Configuration'))
self.set_transient_for(transient)
self.set_default_size(400, 500)
self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
self.set_modal(True)
self.set_destroy_with_parent(True)
ui_path = Path(__file__).parent
self._ui = get_builder(ui_path.resolve() / 'config_dialog.ui')
self.add(self._ui.main_box)
self.show_all()
self._ui.preview_textview.get_buffer().connect(
'insert-text', self._on_preview_text_inserted)
self._ui.connect_signals(self)
self._lexer_liststore = Gtk.ListStore(str)
self._ui.default_lexer_combobox.set_model(self._lexer_liststore)
self._style_liststore = Gtk.ListStore(str)
self._ui.style_combobox.set_model(self._style_liststore)
self._plugin = plugin
self._lexers = plugin.highlighter_config.get_lexer_list()
self._styles = plugin.highlighter_config.get_styles_list()
self._provider = None
self._add_css_provider()
self._initialize()
def _initialize(self):
default_lexer = self._plugin.highlighter_config.get_default_lexer_name()
for i, lexer in enumerate(self._lexers):
self._lexer_liststore.append([lexer[0]])
if lexer[1] == default_lexer:
self._ui.default_lexer_combobox.set_active(i)
for i, style in enumerate(self._styles):
self._style_liststore.append([style])
if style == self._plugin.config['style']:
self._ui.style_combobox.set_active(i)
self._ui.line_break_combobox.set_active(
self._plugin.config['line_break'].value)
self._ui.code_marker_combobox.set_active(
self._plugin.config['code_marker'])
self._ui.font_button.set_font(self._plugin.config['font'])
bg_override_enabled = self._plugin.config['bgcolor_override']
self._ui.bg_color_checkbutton.set_active(bg_override_enabled)
self._ui.bg_color_colorbutton.set_sensitive(bg_override_enabled)
color = Gdk.RGBA()
if color.parse(self._plugin.config['bgcolor']):
self._ui.bg_color_colorbutton.set_rgba(color)
self._update_preview()
def _lexer_changed(self, widget):
self._plugin.highlighter_config.set_default_lexer(
self._lexers[widget.get_active()][1])
self._update_preview()
def _line_break_changed(self, widget):
self._plugin.config['line_break'] = LineBreakOptions(
widget.get_active())
self._update_preview()
def _code_marker_changed(self, widget):
self._plugin.config['code_marker'] = CodeMarkerOptions(
widget.get_active())
def _bg_color_enabled(self, widget):
override_color = widget.get_active()
self._plugin.config['bgcolor_override'] = override_color
self._ui.bg_color_colorbutton.set_sensitive(override_color)
self._update_preview()
def _bg_color_changed(self, widget):
color = widget.get_rgba()
self._plugin.config['bgcolor'] = color.to_string()
self._update_preview()
def _style_changed(self, widget):
style = self._styles[widget.get_active()]
if style is not None and style != '':
self._plugin.config['style'] = style
self._update_preview()
def _font_changed(self, widget):
font = widget.get_font()
if font is not None and font != '':
self._plugin.config['font'] = font
self._update_preview()
def _update_preview(self):
self._format_preview_text()
def _on_preview_text_inserted(self, _buf, _iterator, text, length, *_args):
if (length == 1 and re.match(r'\s', text)) or length > 1:
self._format_preview_text()
def _add_css_provider(self):
self._context = self._ui.preview_textview.get_style_context()
self._provider = Gtk.CssProvider()
self._context.add_provider(
self._provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
self._context.add_class('syntax-preview')
def _format_preview_text(self):
buf = self._ui.preview_textview.get_buffer()
start_iter = buf.get_start_iter()
start_mark = buf.create_mark(None, start_iter, True)
buf.remove_all_tags(start_iter, buf.get_end_iter())
formatter = GTKFormatter(
style=self._plugin.config['style'], start_mark=start_mark)
code = start_iter.get_text(buf.get_end_iter())
lexer = self._plugin.highlighter_config.get_default_lexer()
if lexer != PLUGIN_INTERNAL_NONE_LEXER_ID:
tokens = pygments.lex(code, lexer)
pygments.format(tokens, formatter, buf)
buf.delete_mark(start_mark)
css = self._get_css()
self._provider.load_from_data(bytes(css.encode()))
def _get_css(self):
# Build CSS from Pango.FontDescription
description = FontDescription.from_string(self._plugin.config['font'])
size = description.get_size() / SCALE
style = self._get_string_from_pango_style(description.get_style())
weight = self._pango_to_css_weight(int(description.get_weight()))
family = description.get_family()
font = '%spt %s' % (size, family)
if self._plugin.config['bgcolor_override']:
color = self._plugin.config['bgcolor']
else:
color = '@theme_base_color'
css = '''
.syntax-preview {
font: %s;
font-weight: %s;
font-style: %s;
}
.syntax-preview > text {
background-color: %s;
}
''' % (font, weight, style, color)
return css
@staticmethod
def _pango_to_css_weight(number):
# Pango allows for weight values between 100 and 1000
# CSS allows only full hundred numbers like 100, 200 ..
number = int(number)
if number < 100:
return 100
if number > 900:
return 900
return int(math.ceil(number / 100.0)) * 100
@staticmethod
def _get_string_from_pango_style(style: Style) -> str:
if style == Style.NORMAL:
return 'normal'
if style == Style.ITALIC:
return 'italic'
# Style.OBLIQUE:
return 'oblique'
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.22.1 -->
<!-- Generated with glade 3.36.0 -->
<interface>
<requires lib="gtk+" version="3.20"/>
<requires lib="gtk+" version="3.22"/>
<object class="GtkTextBuffer"/>
<object class="GtkListStore" id="code_marker_selection">
<columns>
......@@ -309,7 +309,4 @@
</packing>
</child>
</object>
<object class="GtkTextBuffer" id="textbuffer1">
<property name="text">Plug-in decription should be displayed here. This text will be erased during PluginsWindow initialization.</property>
</object>
</interface>
......@@ -67,7 +67,7 @@ class GTKFormatter(Formatter):
def format(self, tokensource, outfile):
if not isinstance(outfile, Gtk.TextBuffer) or outfile is None:
log.warn("Did not get a buffer to format...")
log.warning('Did not get a buffer to format...')
return
buf = outfile
......
import logging
from gi.repository import Gdk
from pygments.lexers import get_lexer_by_name
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
from pygments.util import ClassNotFound
from syntax_highlight.types import LineBreakOptions
from syntax_highlight.types import CodeMarkerOptions
from syntax_highlight.types import PLUGIN_INTERNAL_NONE_LEXER_ID
log = logging.getLogger('gajim.p.syntax_highlight')
PLUGIN_INTERNAL_NONE_LEXER = ('None (monospace only)',
PLUGIN_INTERNAL_NONE_LEXER_ID)
class HighlighterConfig:
def __init__(self, plugin_config):
self._plugin_config = plugin_config
self._lexer_list = self._create_lexer_list()
self._style_list = []
for style in get_all_styles():
self._style_list.append(style)
self._style_list.sort()
class SyntaxHighlighterConfig:
PLUGIN_INTERNAL_NONE_LEXER = ('None (monospace only)',
PLUGIN_INTERNAL_NONE_LEXER_ID)
self._default_lexer = None
self.set_default_lexer(self._plugin_config['default_lexer'])
def _create_lexer_list(self):
@staticmethod
def _create_lexer_list():
# The list we create here contains the plain text name and the lexer's
# id string
lexers = []
......@@ -33,16 +41,11 @@ class SyntaxHighlighterConfig:
lexers.sort()
# Insert our internal 'none' type at top of the list
lexers.insert(0, self.PLUGIN_INTERNAL_NONE_LEXER)
lexers.insert(0, PLUGIN_INTERNAL_NONE_LEXER)
return lexers
def is_internal_none_lexer(self, lexer):
return lexer == PLUGIN_INTERNAL_NONE_LEXER_ID
def get_internal_none_lexer(self):
return self.PLUGIN_INTERNAL_NONE_LEXER
def get_lexer_by_name(self, name):
@staticmethod
def get_lexer_by_name(name):
lexer = None
try:
lexer = get_lexer_by_name(name)
......@@ -55,114 +58,40 @@ class SyntaxHighlighterConfig:
if lexer is None:
log.info('Falling back to default lexer for %s.',
self.get_default_lexer_name())
lexer = self.default_lexer[1]
lexer = self._default_lexer[1]
return lexer
def set_font(self, font):
if font is not None and font != '':
self.config['font'] = font
def set_style(self, style):
if style is not None and style != '':
self.config['style'] = style
def set_line_break_action(self, option):
if isinstance(option, int):
option = LineBreakOptions(option)
self.config['line_break'] = option
def set_default_lexer(self, name):
if not self.is_internal_none_lexer(name):
if name != PLUGIN_INTERNAL_NONE_LEXER_ID:
lexer = get_lexer_by_name(name)
if lexer is None and self.default_lexer is None:
if lexer is None and self._default_lexer is None:
log.error('Failed to get default lexer by name.'
'Falling back to simply using the first lexer '
'in the list.')
lexer = self.lexer_list[0]
lexer = self._lexer_list[0]
name = lexer[0]
self.default_lexer = (name, lexer)
if lexer is None and self.default_lexer is not None:
self._default_lexer = (name, lexer)
if lexer is None and self._default_lexer is not None:
log.info('Failed to get default lexer by name, keeping '
'previous setting (lexer = %s).',
self.default_lexer[0])
name = self.default_lexer[0]
self._default_lexer[0])
name = self._default_lexer[0]
else:
self.default_lexer = (name, lexer)
self._default_lexer = (name, lexer)
else:
self.default_lexer = self.PLUGIN_INTERNAL_NONE_LEXER
self.config['default_lexer'] = name
def set_bgcolor_override_enabled(self, state):
self.config['bgcolor_override'] = state
self._default_lexer = PLUGIN_INTERNAL_NONE_LEXER
def set_bgcolor(self, color):
if isinstance(color, Gdk.RGBA):
color = color.to_string()
self.config['bgcolor'] = color
def set_code_marker_setting(self, option):
if isinstance(option, int):
option = CodeMarkerOptions(option)
self.config['code_marker'] = option
def set_pygments_path(self, path):
self.config['pygments_path'] = path
self._plugin_config['default_lexer'] = name
def get_default_lexer(self):
return self.default_lexer[1]
return self._default_lexer[1]
def get_default_lexer_name(self):
return self.default_lexer[0]
return self._default_lexer[0]
def get_lexer_list(self):
return self.lexer_list
def get_line_break_action(self):
# Return int only
if isinstance(self.config['line_break'], int):
# In case of legacy settings, convert.
action = self.config['line_break']
self.set_line_break_action(action)
else:
action = self.config['line_break'].value
return action
def get_pygments_path(self):
return self.config['pygments_path']
def get_font(self):
return self.config['font']
def get_style_name(self):
return self.config['style']
def is_bgcolor_override_enabled(self):
return self.config['bgcolor_override']
def get_bgcolor(self):
return self.config['bgcolor']
def get_code_marker_setting(self):
return self.config['code_marker']
return self._lexer_list
def get_styles_list(self):
return self.style_list
def init_pygments(self):
"""
Initialize all config variables that depend directly on pygments being
available.
"""
self.lexer_list = self._create_lexer_list()
self.style_list = [s for s in get_all_styles()]
self.style_list.sort()
self.set_default_lexer(self.config['default_lexer'])
def __init__(self, config):
self.lexer_list = []
self.style_list = []
self.config = config
self.default_lexer = None
return self._style_list
import re
import pygments
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository.Pango import FontDescription
from gajim.plugins.gui import GajimPluginConfigDialog
from gajim.plugins.helpers import get_builder
from syntax_highlight.gtkformatter import GTKFormatter
from syntax_highlight.types import LineBreakOptions
from syntax_highlight.types import CodeMarkerOptions
class SyntaxHighlighterPluginConfiguration(GajimPluginConfigDialog):
def init(self):
path = self.plugin.local_file_path('config_dialog.ui')
self._ui = get_builder(path)
box = self.get_content_area()
box.pack_start(self._ui.main_box, True, True, 0)
self._ui.set_translation_domain('gajim_plugins')
self.liststore = Gtk.ListStore(str)
self._ui.default_lexer_combobox.set_model(self.liststore)
self.style_liststore = Gtk.ListStore(str)
self._ui.style_combobox.set_model(self.style_liststore)
self._ui.preview_textview.get_buffer().connect(
'insert-text', self._on_preview_text_inserted)
self._ui.connect_signals(self)
self.default_lexer_id = 0
self.style_id = 0
def set_config(self, config):
self.config = config
self.lexers = self.config.get_lexer_list()
self.styles = self.config.get_styles_list()
default_lexer = self.config.get_default_lexer_name()
default_style = self.config.get_style_name()
for i, lexer in enumerate(self.lexers):
self.liststore.append([lexer[0]])
if lexer[1] == default_lexer:
self.default_lexer_id = i
for i, style in enumerate(self.styles):
self.style_liststore.append([style])
if style == default_style:
self.style_id = i
self._update_preview()
def _lexer_changed(self, _widget):
new = self._ui.default_lexer_combobox.get_active()
if new != self.default_lexer_id:
self.default_lexer_id = new
self.config.set_default_lexer(self.lexers[self.default_lexer_id][1])
self._update_preview()
def _line_break_changed(self, _widget):
new = LineBreakOptions(self._ui.line_break_combobox.get_active())
if new != self.config.get_line_break_action():
self.config.set_line_break_action(new)
self._update_preview()
def _code_marker_changed(self, _widget):
new = CodeMarkerOptions(self._ui.code_marker_combobox.get_active())
if new != self.config.get_code_marker_setting():
self.config.set_code_marker_setting(new)
def _bg_color_enabled(self, _widget):
new = self._ui.bg_color_checkbutton.get_active()
if new != self.config.is_bgcolor_override_enabled():
bg_override_enabled = new
self.config.set_bgcolor_override_enabled(bg_override_enabled)
self._ui.bg_color_colorbutton.set_sensitive(bg_override_enabled)
self._update_preview()
def _bg_color_changed(self, _widget):