markdown-xblock 2.4.0__py3-none-any.whl

markdown_xblock/__init__.py

@@ -0,0 +1,2 @@
+"""Markdown XBlock module."""
+from .html import MarkdownXBlock  # noqa: F401

markdown_xblock/html.py

@@ -0,0 +1,335 @@
+"""This XBlock help creating a secure and easy-to-use HTML blocks in edx-platform."""
+
+import logging
+import os
+
+import markdown2
+from path import Path as path
+from django.conf import settings as django_settings
+from xblock.core import XBlock
+from xblock.fields import List, Scope, String
+from web_fragments.fragment import Fragment
+from xblock.utils.resources import ResourceLoader
+from xblock.utils.settings import XBlockWithSettingsMixin
+from xblock.utils.studio_editable import StudioEditableXBlockMixin, loader
+
+from .utils import _
+
+log = logging.getLogger(__name__)  # pylint: disable=invalid-name
+xblock_loader = ResourceLoader(__name__)  # pylint: disable=invalid-name
+
+SETTINGS_KEY = 'markdown'
+DEFAULT_EXTRAS = [
+    "code-friendly",
+    "fenced-code-blocks",
+    "footnotes",
+    "tables",
+    "use-file-vars"
+]
+DEFAULT_SETTINGS = {
+    "extras": DEFAULT_EXTRAS,
+    "safe_mode": 'replace'
+}
+
+
+def get_xblock_settings():
+    """Extract xblock settings."""
+    try:
+        xblock_settings = django_settings.XBLOCK_SETTINGS
+        settings = xblock_settings.get(
+            SETTINGS_KEY, DEFAULT_SETTINGS)
+    except AttributeError:
+        settings = DEFAULT_SETTINGS
+
+    return settings
+
+
+@XBlock.wants('settings')
+class MarkdownXBlock(StudioEditableXBlockMixin, XBlockWithSettingsMixin, XBlock):
+    """
+    This XBlock provides content editing in Markdown and displays it in HTML.
+    """
+
+    display_name = String(
+        display_name=_('Display Name'),
+        help=_('The display name for this component.'),
+        scope=Scope.settings,
+        default=_('Markdown')
+    )
+    classes = List(
+        display_name=_('Classes'),
+        help=_('JSON list of strings representing custom CSS classes to add to this component'),
+        scope=Scope.settings,
+        default=[]
+    )
+    data = String(
+        help=_('The Markdown content for this module'),
+        default=u'',
+        scope=Scope.content
+    )
+    editor = 'markdown'
+    editable_fields = ('display_name', 'classes')
+    show_in_read_only_mode = True
+
+    @XBlock.supports('multi_device')
+    def student_view(self, context=None):  # pylint: disable=unused-argument
+        """
+        Return a fragment that contains the html for the student view.
+        """
+        frag = Fragment()
+        frag.content = xblock_loader.render_django_template('static/html/lms.html', {'self': self})
+
+        frag.add_css_url(self.runtime.local_resource_url(self, 'public/plugins/codesample/css/prism.css'))
+        frag.add_javascript_url(self.runtime.local_resource_url(self, 'public/plugins/codesample/js/prism.js'))
+
+        frag.add_css_url(self.runtime.local_resource_url(self, 'static/css/pygments.css'))
+        frag.add_css_url(self.runtime.local_resource_url(self, 'static/css/html.css'))
+
+        return frag
+
+    def studio_view(self, context=None):  # pylint: disable=unused-argument
+        """
+        Return a fragment that contains the html for the Studio view.
+        """
+        frag = Fragment()
+        settings_fields = self.get_editable_fields()
+        settings_page = loader.render_django_template('templates/studio_edit.html', {'fields': settings_fields})
+        context = {
+            'self': self,
+            'settings_page': settings_page,
+        }
+
+        frag.content = xblock_loader.render_django_template('static/html/studio.html', context)
+
+        self.add_stylesheets(frag)
+        self.add_scripts(frag)
+
+        js_data = {
+            'editor': self.editor,
+            'skin_url': self.runtime.local_resource_url(self, 'public/skin'),
+            'external_plugins': self.get_editor_plugins()
+        }
+        frag.initialize_js('MarkdownXBlock', js_data)
+
+        return frag
+
+    @XBlock.supports("multi_device")
+    def public_view(self, context=None):
+        """
+        Return the student_view when course is set to be public.
+        """
+        return self.student_view(context)
+
+    @XBlock.json_handler
+    def update_content(self, data, suffix=''):  # pylint: disable=unused-argument
+        """
+        Update the saved HTML data with the new HTML passed in the JSON 'content' field.
+        """
+        self.data = data['content']
+
+        return {'content': self.data}
+
+    @staticmethod
+    def workbench_scenarios():
+        """A canned scenario for display in the workbench."""
+        return [
+            ('MarkdownXBlock',
+             """<vertical_demo>
+                    <markdown>
+                        # This is h1
+                        ## This is h2
+                        ```
+                        This is a code block
+                        ```
+                        * This is
+                        * an unordered
+                        * list
+                        This is a regular paragraph
+                        1. This is
+                        1. an ordered
+                        1. list
+                        *This is italic*
+                        **This is bold**
+                    </markdown>
+                </vertical_demo>
+             """),
+        ]
+
+    def add_stylesheets(self, frag):
+        """
+        A helper method to add all necessary styles to the fragment.
+        :param frag: The fragment that will hold the scripts.
+        """
+        frag.add_css_url(self.runtime.local_resource_url(self, 'static/css/html.css'))
+
+        frag.add_css_url(self.runtime.local_resource_url(
+            self, 'public/plugins/codemirror/codemirror-4.8/lib/codemirror.css'))
+
+    def add_scripts(self, frag):
+        """
+        A helper method to add all necessary scripts to the fragment.
+        :param frag: The fragment that will hold the scripts.
+        """
+        frag.add_javascript_url(self.runtime.local_resource_url(self, 'static/js/tinymce/tinymce.min.js'))
+        frag.add_javascript_url(self.runtime.local_resource_url(self, 'static/js/tinymce/themes/modern/theme.min.js'))
+        frag.add_javascript_url(self.runtime.local_resource_url(self, 'static/js/html.js'))
+        frag.add_javascript(loader.load_unicode('public/studio_edit.js'))
+
+        code_mirror_dir = 'public/plugins/codemirror/codemirror-4.8/'
+
+        frag.add_javascript_url(self.runtime.local_resource_url(self, code_mirror_dir + 'lib/codemirror.js'))
+        frag.add_javascript_url(self.runtime.local_resource_url(self, code_mirror_dir + 'mode/markdown/markdown.js'))
+
+    def get_editor_plugins(self):
+        """
+        This method will generate a list of external plugins urls to be used in TinyMCE editor.
+        These plugins should live in `public` directory for us to generate URLs for.
+
+        const PLUGINS_DIR = "/resource/html5/public/plugins/";
+        const EXTERNAL_PLUGINS = PLUGINS.map(function(p) { return PLUGINS_DIR + p + "/plugin.min.js" });
+
+        :return: A list of URLs
+        """
+        plugin_path = 'public/plugins/{plugin}/plugin.min.js'
+        plugins = ['codesample', 'image', 'link', 'lists', 'textcolor', 'codemirror']
+
+        return {
+            plugin: self.runtime.local_resource_url(self, plugin_path.format(plugin=plugin)) for plugin in plugins
+        }
+
+    def substitute_keywords(self, html):
+        """
+        Replaces all %%-encoded words using KEYWORD_FUNCTION_MAP mapping functions.
+
+        Iterates through all keywords that must be substituted and replaces them by calling the corresponding functions
+        stored in `keywords`. If the function throws a specified exception, the substitution is not performed.
+
+        Functions stored in `keywords` must either:
+            - return a replacement string
+            - throw `KeyError` or `AttributeError`, `TypeError`.
+        """
+        data = html
+        system = getattr(self, 'system', None)
+        if not system:  # This shouldn't happen, but if `system` is missing, then skip substituting keywords.
+            return data
+
+        keywords = {
+            '%%USER_ID%%': lambda: getattr(system, 'anonymous_student_id'),
+            '%%COURSE_ID%%': lambda: getattr(system, 'course_id').html_id(),
+        }
+
+        for key, substitutor in keywords.items():
+            if key in data:
+                try:
+                    data = data.replace(key, substitutor())
+                except (KeyError, AttributeError, TypeError):
+                    # Do not replace the keyword when substitutor is not present.
+                    pass
+
+        return data
+
+    @property
+    def html(self):
+        """
+        A property that returns the markdown content data as html.
+        """
+        settings = get_xblock_settings()
+        extras = settings.get("extras",
+                              DEFAULT_SETTINGS['extras'])
+        safe_mode = settings.get("safe_mode",
+                                 DEFAULT_SETTINGS['safe_mode'])
+
+        html = markdown2.markdown(
+            self.data,
+            extras=extras,
+            safe_mode=safe_mode
+        )
+
+        html = self.substitute_keywords(html)
+
+        return html
+
+    def get_editable_fields(self):
+        """
+        This method extracts the editable fields from this XBlock and returns them after validating them.
+
+        Part of this method's copied from StudioEditableXBlockMixin#submit_studio_edits
+        with some modifications..
+        :return: A list of the editable fields with the information that
+                the template needs to render a form field for them.
+
+        """
+        fields = []
+
+        # Build a list of all the fields that can be edited:
+        for field_name in self.editable_fields:
+            field = self.fields[field_name]  # pylint: disable=unsubscriptable-object
+            assert field.scope in (Scope.content, Scope.settings), (
+                'Only Scope.content or Scope.settings fields can be used with '
+                'StudioEditableXBlockMixin. Other scopes are for user-specific data and are '
+                'not generally created/configured by content authors in Studio.'
+            )
+            field_info = self._make_field_info(field_name, field)
+            if field_info is not None:
+                fields.append(field_info)
+
+        return fields
+
+    @classmethod
+    def parse_xml(cls, node, runtime, keys):
+        """
+        Use `node` to construct a new block.
+        """
+        block = runtime.construct_xblock_from_class(cls, keys)
+        id_generator = runtime.id_generator
+
+        # Read markdown content from file and add to editor.
+        url_name = node.get('url_name', node.get('slug'))
+        location = id_generator.create_definition(node.tag, url_name)
+
+        filename = node.get('filename')
+        pointer_path = "{category}/{url_path}".format(
+            category='markdown',
+            url_path=location.block_id.replace(':', '/')
+        )
+        base = path(pointer_path).dirname()
+        filepath = u"{base}/{name}.md".format(base=base, name=filename)
+
+        with runtime.resources_fs.open(filepath, encoding='utf-8') as infile:
+            markdown = infile.read()
+            block.data = markdown
+
+        # Attributes become fields.
+        for name, value in list(node.items()):  # lxml has no iteritems
+            cls._set_field_if_present(block, name, value, {})
+
+        return block
+
+    def add_xml_to_node(self, node):
+        """
+        For exporting, set data on etree.Element `node`.
+        """
+
+        # Write markdown data to file
+        pathname = self.url_name.replace(':', '/')
+        filepath = u'{category}/{pathname}.md'.format(
+            category=self.category,
+            pathname=pathname
+        )
+
+        self.runtime.export_fs.makedirs(
+            os.path.dirname(filepath),
+            recreate=True)
+
+        with self.runtime.export_fs.open(filepath, 'wb') as filestream:
+            markdown_data = self.data.encode('utf-8')
+            filestream.write(markdown_data)
+
+        # Write out the markdown file name
+        filename = path(pathname).basename()
+
+        node.tag = self.category
+        node.set("filename", filename)
+        node.set('xblock-family', self.entry_point)
+        node.set('display_name', self.display_name)
+        node.set('classes', str(self.classes))

markdown_xblock/public/plugins/codemirror/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2017 by Marijn Haverbeke <marijnh@gmail.com> and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

markdown_xblock/public/plugins/codemirror/codemirror-4.8/addon/dialog/dialog.css

@@ -0,0 +1,32 @@
+.CodeMirror-dialog {
+  position: absolute;
+  left: 0; right: 0;
+  background: white;
+  z-index: 15;
+  padding: .1em .8em;
+  overflow: hidden;
+  color: #333;
+}
+
+.CodeMirror-dialog-top {
+  border-bottom: 1px solid #eee;
+  top: 0;
+}
+
+.CodeMirror-dialog-bottom {
+  border-top: 1px solid #eee;
+  bottom: 0;
+}
+
+.CodeMirror-dialog input {
+  border: none;
+  outline: none;
+  background: transparent;
+  width: 20em;
+  color: inherit;
+  font-family: monospace;
+}
+
+.CodeMirror-dialog button {
+  font-size: 70%;
+}

markdown_xblock/public/plugins/codemirror/codemirror-4.8/addon/dialog/dialog.js

@@ -0,0 +1,155 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Open simple dialogs on top of an editor. Relies on dialog.css.
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  function dialogDiv(cm, template, bottom) {
+    var wrap = cm.getWrapperElement();
+    var dialog;
+    dialog = wrap.appendChild(document.createElement("div"));
+    if (bottom)
+      dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
+    else
+      dialog.className = "CodeMirror-dialog CodeMirror-dialog-top";
+
+    if (typeof template == "string") {
+      dialog.innerHTML = template;
+    } else { // Assuming it's a detached DOM element.
+      dialog.appendChild(template);
+    }
+    return dialog;
+  }
+
+  function closeNotification(cm, newVal) {
+    if (cm.state.currentNotificationClose)
+      cm.state.currentNotificationClose();
+    cm.state.currentNotificationClose = newVal;
+  }
+
+  CodeMirror.defineExtension("openDialog", function(template, callback, options) {
+    if (!options) options = {};
+
+    closeNotification(this, null);
+
+    var dialog = dialogDiv(this, template, options.bottom);
+    var closed = false, me = this;
+    function close(newVal) {
+      if (typeof newVal == 'string') {
+        inp.value = newVal;
+      } else {
+        if (closed) return;
+        closed = true;
+        dialog.parentNode.removeChild(dialog);
+        me.focus();
+
+        if (options.onClose) options.onClose(dialog);
+      }
+    }
+
+    var inp = dialog.getElementsByTagName("input")[0], button;
+    if (inp) {
+      if (options.value) {
+        inp.value = options.value;
+        inp.select();
+      }
+
+      if (options.onInput)
+        CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);});
+      if (options.onKeyUp)
+        CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});
+
+      CodeMirror.on(inp, "keydown", function(e) {
+        if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
+        if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) {
+          inp.blur();
+          CodeMirror.e_stop(e);
+          close();
+        }
+        if (e.keyCode == 13) callback(inp.value);
+      });
+
+      if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close);
+
+      inp.focus();
+    } else if (button = dialog.getElementsByTagName("button")[0]) {
+      CodeMirror.on(button, "click", function() {
+        close();
+        me.focus();
+      });
+
+      if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close);
+
+      button.focus();
+    }
+    return close;
+  });
+
+  CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) {
+    closeNotification(this, null);
+    var dialog = dialogDiv(this, template, options && options.bottom);
+    var buttons = dialog.getElementsByTagName("button");
+    var closed = false, me = this, blurring = 1;
+    function close() {
+      if (closed) return;
+      closed = true;
+      dialog.parentNode.removeChild(dialog);
+      me.focus();
+    }
+    buttons[0].focus();
+    for (var i = 0; i < buttons.length; ++i) {
+      var b = buttons[i];
+      (function(callback) {
+        CodeMirror.on(b, "click", function(e) {
+          CodeMirror.e_preventDefault(e);
+          close();
+          if (callback) callback(me);
+        });
+      })(callbacks[i]);
+      CodeMirror.on(b, "blur", function() {
+        --blurring;
+        setTimeout(function() { if (blurring <= 0) close(); }, 200);
+      });
+      CodeMirror.on(b, "focus", function() { ++blurring; });
+    }
+  });
+
+  /*
+   * openNotification
+   * Opens a notification, that can be closed with an optional timer
+   * (default 5000ms timer) and always closes on click.
+   *
+   * If a notification is opened while another is opened, it will close the
+   * currently opened one and open the new one immediately.
+   */
+  CodeMirror.defineExtension("openNotification", function(template, options) {
+    closeNotification(this, close);
+    var dialog = dialogDiv(this, template, options && options.bottom);
+    var closed = false, doneTimer;
+    var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000;
+
+    function close() {
+      if (closed) return;
+      closed = true;
+      clearTimeout(doneTimer);
+      dialog.parentNode.removeChild(dialog);
+    }
+
+    CodeMirror.on(dialog, 'click', function(e) {
+      CodeMirror.e_preventDefault(e);
+      close();
+    });
+
+    if (duration)
+      doneTimer = setTimeout(close, duration);
+
+    return close;
+  });
+});

markdown_xblock/public/plugins/codemirror/codemirror-4.8/addon/display/fullscreen.css

@@ -0,0 +1,6 @@
+.CodeMirror-fullscreen {
+  position: fixed;
+  top: 0; left: 0; right: 0; bottom: 0;
+  height: auto;
+  z-index: 9;
+}

markdown_xblock/public/plugins/codemirror/codemirror-4.8/addon/display/fullscreen.js

@@ -0,0 +1,41 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineOption("fullScreen", false, function(cm, val, old) {
+    if (old == CodeMirror.Init) old = false;
+    if (!old == !val) return;
+    if (val) setFullscreen(cm);
+    else setNormal(cm);
+  });
+
+  function setFullscreen(cm) {
+    var wrap = cm.getWrapperElement();
+    cm.state.fullScreenRestore = {scrollTop: window.pageYOffset, scrollLeft: window.pageXOffset,
+                                  width: wrap.style.width, height: wrap.style.height};
+    wrap.style.width = "";
+    wrap.style.height = "auto";
+    wrap.className += " CodeMirror-fullscreen";
+    document.documentElement.style.overflow = "hidden";
+    cm.refresh();
+  }
+
+  function setNormal(cm) {
+    var wrap = cm.getWrapperElement();
+    wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, "");
+    document.documentElement.style.overflow = "";
+    var info = cm.state.fullScreenRestore;
+    wrap.style.width = info.width; wrap.style.height = info.height;
+    window.scrollTo(info.scrollLeft, info.scrollTop);
+    cm.refresh();
+  }
+});