syntax-highlight

Author: gauteh

.gitignore

@@ -0,0 +1 @@
+__pycache__

LICENSE

@@ -0,0 +1,29 @@
+Syntax highlight plugin
+====================
+
+Intro
+-----
+
+This plugins syntax highlights code segments between `\`\`\`` and `<code></code>` tags.
+
+Requires:
+
+  * pygments
+
+Installation
+------------
+
+the installation is simple as:
+
+```sh
+mkdir -p ~/.config/astroid/plugins/
+cd ~/.config/astroid/plugins/
+git clone https://github.com/astroidmail/syntax-highlight
+```
+...and restart astroid.
+
+Licensing
+---------
+
+See [LICENSE](./LICENSE) for licensing information.
+

README.md

@@ -0,0 +1,11 @@
+[Plugin]
+Module=syntax_highlight_plugin
+Depends=
+Loader=python3
+Name=Syntax Highlight plugin
+Description=plugin
+Authors=Gaute Hope
+Copyright=GPLv3
+Website=
+Help=
+Hidden=false

syntax-highlight.plugin

@@ -0,0 +1,110 @@
+#! /usr/bin/env python
+import gi
+try:
+  gi.require_version ('GMime', '3.0')
+except ValueError:
+  gi.require_version ('GMime', '2.6')
+
+from gi.repository import GMime
+
+from pygments               import highlight
+from pygments.lexers        import guess_lexer
+from pygments.formatters    import HtmlFormatter
+
+class SyntaxHighlight:
+
+  def high (self, segment):
+    lexer = guess_lexer (segment)
+
+    print ("filtering: guessed language:", str(lexer))
+
+    return highlight (segment, lexer, HtmlFormatter (noclasses = True))
+
+  def do_filter_part (self, text, html, mime_type, is_patch):
+    """
+    Filter the part and output safe HTML.
+
+    Search for code tags (``` or <code>), or determine if part is a patch.
+    Syntax highlight the relevant parts and use the html part for the rest.
+    """
+
+    ## Try to figure out if part is a patch
+    if is_patch:
+      from pygments.lexers.diff import DiffLexer
+      return highlight (text, DiffLexer (), HtmlFormatter (noclasses = True))
+
+    ## Look for code segments between code-tags
+    starttags = [ '```', '<code>'  ]
+    endtags   = [ '```', '</code>' ]
+
+    if mime_type == 'text/html':
+      for tag, antitag in zip(starttags, endtags):
+        i = 0
+
+        def tags ():
+          nonlocal i
+          i = html.find (tag, i)
+          if i != -1:
+            i += len (tag)
+            yield i
+
+        for j in tags ():
+          e = html.find (antitag, i)
+
+          if e != -1:
+            segment = self.high (html[i:e])
+            html    = html[:i-len(tag)] + segment + html[e + len(antitag):]
+
+            i += len(segment) - len(tag)
+
+          else:
+            break
+
+      return html
+
+    elif mime_type == 'text/plain':
+      # The GMime filter has created the HTML line-for-line. So if we find the
+      # code tag on a line, it matches the same line in the HTML part.
+
+      text_lines = text.split ('\n')
+      html_lines = html.split ('\n')
+
+      no     = 0
+      offset = 0 # offset between HTML and TEXT part after syntax highlighting a segment
+      while no < len(text_lines):
+        l = text_lines[no]
+        for tag, antitag in zip (starttags, endtags):
+          it = l.find (tag)
+          if it > -1:
+            ih = html_lines[no + offset].find (tag)
+
+            # find end
+            for eno,el in enumerate (text_lines[no:]):
+              iet = el.find (antitag)
+              ieh = html_lines[no + eno + offset].find (antitag)
+
+              if (eno > 0 and iet > -1) or (eno == 0 and iet > it):
+                # found end tag
+                segment     = text_lines[no:no + eno+1]
+                segment[0]  = segment[0][it + len(tag):]
+                segment[-1] = segment[-1][:iet]
+
+                html_segment = self.high ('\n'.join (segment)).split ('\n')
+
+                html_segment[0]  = html_lines[no + offset][ih + len(tag):] + html_segment[0]
+                html_segment[-1] = html_segment[-1] + html_lines[no + eno + offset][ieh + len(antitag):]
+
+                html_lines = html_lines[:no + offset] + html_segment + html_lines[no + eno + offset +1:]
+
+                offset += len(html_segment) - len(segment)
+                no     += eno
+                break
+            break
+        no += 1
+
+      return '\n'.join(html_lines)
+
+    else:
+      return html
+
+

syntax_highlight.py

@@ -0,0 +1,27 @@
+#! /usr/bin/env python
+import gi
+gi.require_version ('Astroid', '0.1')
+gi.require_version ('Gtk', '3.0')
+
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import Astroid
+
+from syntax_highlight import SyntaxHighlight
+
+class SyntaxHighlightPlugin (GObject.Object, Astroid.ThreadViewActivatable, SyntaxHighlight):
+  object = GObject.property (type = GObject.Object)
+  thread_view = GObject.property (type = Gtk.Box)
+
+  def do_activate (self):
+    print ('syntax: activated', __file__)
+
+  def do_deactivate (self):
+    print ('syntax: deactivated')
+
+  def do_filter_part (self, text, html, mime_type, is_patch):
+    return SyntaxHighlight.do_filter_part (self, text, html, mime_type, is_patch)
+
+
+print ('syntax: plugin loaded')
+

syntax_highlight_plugin.py

@@ -0,0 +1,106 @@
+#! /usr/bin/env python
+
+import unittest
+
+from syntax_highlight import *
+
+class TestSyntaxHighlight (unittest.TestCase):
+
+  def test_html_py (self):
+    html = '''
+    <html>
+    <body>
+      <p>Some text</p>
+      <pre>
+        <code>
+        import sys
+
+        def something (foo):
+          return foo
+
+        sys.exit (1)
+        </code>
+      </pre>
+      <p> some more text </p>
+    </body>
+    </html>
+    '''
+
+    s = SyntaxHighlight ()
+
+    print ( s.do_filter_part ('', html, 'text/html', False) )
+
+  def test_text_c (self):
+    text = '''```
+int main (int argc, char ** argv) {
+  int a = 0;
+  int b = 2;
+  int c;
+
+  c = a + b;
+  return c;
+}
+
+```'''
+
+    html = '''```<br>
+int main (int argc, char ** argv) {<br>
+&nbsp; int a = 0;<br>
+&nbsp; int b = 2;<br>
+&nbsp; int c;<br>
+<br>
+&nbsp; c = a + b;<br>
+&nbsp; return c;<br>
+}<br>
+<br>
+```<br>
+<br>'''
+
+    s = SyntaxHighlight ()
+
+    print ( s.do_filter_part (text, html, 'text/plain', False) )
+
+  def test_two_segments (self):
+
+    text = '''```
+<html>
+  <head>
+  </head>
+</html>
+```
+
+```
+import sys
+
+def foo (bar):
+  return bar + 1
+```
+
+'''
+
+
+    html = '''```<br>
+&lt;html&gt;<br>
+&nbsp; &lt;head&gt;<br>
+&nbsp; &lt;/head&gt;<br>
+&lt;/html&gt;<br>
+```<br>
+<br>
+```<br>
+import sys<br>
+<br>
+def foo (bar):<br>
+&nbsp; return bar + 1<br>
+```<br>
+<br>
+<br>'''
+
+    s = SyntaxHighlight ()
+
+    print ( s.do_filter_part (text, html, 'text/plain', False) )
+
+if __name__ == '__main__':
+  unittest.main ()
+
+
+