blog

import pygments

""" So welcome to my Markdown module. Since the markdown library in PyPI is

fucking shit, I've decided to write my own implementation. Contary to the one in

PyPI, my version handles **all** cases, and is a **full implementation** of the

reference.

Oh, and just so you know: You don't need an entire shitty object oriented system

to make something decent. Sometimes the solution is a function. Period.

"""

"""

Checklist about all shit that must be implemented:

    - headers need to have their ID's be the same as the title. BUT! id's

      mustn't have spaces, and need to be unique. The latter isn't that big of a

      deal, but spaces in the header title must be converted to dashes.

    - HTML code needs to be escaped; & must become &amp;, < and > become &lt;

      and > and so on. This isn't necessary for UTF-8 symbols such as ©,

      which can be put in place as is, instead of converting to ©.

    - Some elements have to be placed in the tag itself, such as links in <a />.

      This is noted with the {#} tags. The context in which they are used in the

      defaults should give a good explanation on what number points to what.

    - Remember to support 2 trailing spaces as <br />!

    - There are also "closing ATX headers": "# title" is the same as 

      "# title ####" and "# title #". (So it's purely cosmetic, remove the

      trailing whitespace in these cases)

    - When code is used, call Pygments to markup the code properly. If a code

      tag is provided (e.g. "Python", "C", ...), tell that to Pygments as well,

      so it can do a better job. If nothing is provided, leave it as is. When

      it's an inline code block (`CODE`), leave that always as is.

      Look how to do it at

      <http://docs.getpelican.com/en/stable/content.html#syntax-highlighting>.

Future expansions:

    - Allow nesting of more elements. For example: Headers cannot be nested in

      blockquotes, but this is a nice thing to have.

    - Allow headers to follow a line wrapping, if the next line is perceded by

      the same amount of hashtags (=> same header level).

      https://daringfireball.net/projects/markdown/syntax#blockquote

    """

def toHTML(

        text,

        emphasis = r"<em>{text}</em>",

        strong = r"<strong>{text}</strong>",

        unordered_list = r"<ul>{items}</ul>",

        ordered_list = r"<ol>{items}</ol>",

        list_item = r"<li>{text}</li>",

        hyperlink = r'<a href="{link}" title="{title}">{text}</a>',

        image = r'<img src="{link}" alt="{alt}" title="{title}" />',

        paragraph = r"<p>{text}</p>",

        blockquote = r"<blockquote>{text}</blockquote>",

        header1 = r'<h1 id="{link}">{text}</h1>',

        header2 = r'<h2 id="{link}">{text}</h2>',

        header3 = r'<h3 id="{link}">{text}</h3>',

        header4 = r'<h4 id="{link}">{text}</h4>',

        header5 = r'<h5 id="{link}">{text}</h5>',

        header6 = r'<h6 id="{link}">{text}</h6>',

        inline_code = r'<code>\g<code></code>',

        code = r'<code lang="\g<language>">\g<code></code>',

        incorrect = r"<s>{text}</s>",

        line_break = r"<br />",

        horizontal_rule = r"<hr />",

        ):

    """ Translates Markdown code to HTML code.

    This is a pure function.

    This function will translate given Markdown code to HTML code.

    It follows the specification as good as possible, with a few custom additions:

    - Incorrect text can be marked with "~" around a text block.

    The default parameters have sane defaults, but can be customized if you wish

    to do so. Pay attention to the tags, as your custom value must also

    incorporate these.

    The function works in a simple way:

    1. Replace all redundant content with only 1 unique part

    1.1. For example: 5 blank lines mean the same as 2; a line with only spaces

         and tabs means the same as an empty line; hashtags at the end of a header

         line are meaningless; ...

    2. Handle blockquotes. Blockquotes have the highest precedence and can contain

       any other element, thus it's easiest to just handle these as soon as possible.

    3. Replace Setext with atx-style headers, to provide consistency for header handling.

    4. Handle block elements (paragraphs, code, ...).

    5. In all block elements, handle span elements (links, emphasis, ...).

    """

    # Replacing some shit:

    text = re.sub(r"^[ \t]+$", "\n", text)  # Make all blank lines consistent

    text = re.sub(r"\n{3}", "\n\n", text)  # Replace redundant blanks with 2 blank lines

    # XXX: Blockquotes have the highest precedence: **ANYTHING** can be nested

    # in a blockquote. So, handle these first, and convert them up front to

    # make it easier to handle the other text.

    """ About handling blockquotes:

    Every line that starts with "> " is a blockquote. As long as the next line

    starts in the same way, it's considered part of the same blockquote.

    **However**, there is 1 exception to this rule:

    paragraphs that are hard-wrapped only need 1 > for their first line, but can

    then be hard wrapped, and even start without prior spacing.

    """

    blockquotes_left = True

    while blockquotes_left:

         blockquote = re.compile(r"(^> .+\n)+")

         quote = blockquote.search(text)

         if quote is None:

             blockquotes_left = False

         else:

             begin, end = quote.span()

             reworked = "<blockquote>" + text[begin:end].replace(r"\n> ", r"\n") + r"</blockquote>\n"

             text = text[:begin] + reworked + text[end:]

    # All blockquotes are now removed

    # Converting setext to atx headers

    text = re.sub(r"^(?P<title>.+)\n=+$", r"# \g<title>", text, flags=re.MULTILINE)

    text = re.sub(r"^(?P<title>.+)\n-+$", r"## \g<title>", text, flags=re.MULTILINE)

    # All are now converted to atx style headers

    # Transforming headers:

    for i in range(1,7):

        header = r"^#{"+str(i)+r"} (?P<title>.+)$"

        match = re.search(header, text, flags=re.MULTILINE)

        while match is not None:

            future_id = match['title'].lower()

            future_id = re.sub(r"[_,.!]", r"", future_id)

            future_id = re.sub(r" ", r"-", future_id)

            dictionary = match.groupdict()

            dictionary['link'] = future_id

            replacement = (r'<h'+str(i)+r' id="{link}">{title}</h'+str(i)+r'>').format_map(dictionary)

            text = text[:match.start()] + replacement + text[match.end():]

            match = re.search(header, text, flags=re.MULTILINE)

    # All headers transformed

    # Paragraphs

    text = re.sub(r"(?P<text>(?:^(?!<).+\n)+)", r"<p>\n\g<text></p>", text, flags=re.MULTILINE)

    # Doing inline hyperlinks

    text = re.sub(r"\[(?P<text>.+?)\]\((?P<url>.+?) \"(?P<title>.+?)\"\)", r'<a href="\g<url>" title="\g<title>">\g<text></a>', text, flags=re.S)

    text = re.sub(r"\[(?P<text>.+?)\]\((?P<url>.+?)\)", r'<a href="\g<url>">\g<text></a>', text, flags=re.S)

    # Doing strongs

    text = re.sub(r"\*\*(?P<text>.+?)\*\*", r"<strong>\g<text></strong>", text, flags=re.S)

    text = re.sub(r"__(?P<text>.+?)__", r"<strong>\g<text></strong>", text, flags=re.S)

    # Doing emphasis

    text = re.sub(r"\*(?P<text>.+?)\*", r"<em>\g<text></em>", text, flags=re.S)

    text = re.sub(r"_(?P<text>.+?)_", r"<em>\g<text></em>", text, flags=re.S)

    # Code blocks

    text = re.sub(r"^```(?P<language>.+?)\n(?P<code>.+?)\n```$", code, text, flags=re.S)

    # Doing inline code

    text = re.sub(r"``(?P<code>.+?)``", inline_code, text, flags=re.S)

    text = re.sub(r"`(?P<code>.+?)`", inline_code, text, flags=re.S)

    # Header lines

    text = re.sub(r"^((\*|_|-) *){3,}$", horizontal_rule, text)

    # Line breaks

    text = re.sub(r"  $", line_break, text)

    return text

"""

    block_elements_table = {

        "code": r"```(?P<language>\w+)\n(    .*\n)+",

        "blockquote": r"^> (?P<text>.+)

        "paragraph": r"(?P<text>(^.+\n)+)",

        "header": r"^#{1,6} (?P<title>(\w+ ?)+ *) ?#*$",

    element_table = {

        "emphasis": (r"\*(?P<text>[^\*.]*)\*|_(?P<text>[^\_.]*)_", emphasis, emphasis_end),

        "strong": (r"\*\*(?P<text>[^*.]*)\*\*|__(?P<text>[^\_.]*)__", strong, strong_end),

        "unordered list": (r"")

        "inline link": (r"\[(\w\s)+\]\(

    def translate(text, begin, end, parameters):

        if alpha:  # If this contains no more nested elements:

            return begin.format(parameters) + text + end

        elif beta:  # text contains nested elements:

            # Find parameters or something IDK

            return begin.format(parameters) + _

        translate(text[alpha:beta], begin_tag, end_tag, found_parameters) + _

        end

    # Zoom zoom insert magic code here

    # NOTE: Hyperlinks are handled specially in Markdown. Check the syntax page

    # for more information. That said, it's imperative to **first** collect all

    # information about hyperlinks, and remove it, so it can be used when

    # parsing hyperlinks.

    # Table of all elements and their respective regular expression:

    elements = {

        paragraph: r"",

        ordered_list_item: r""

        hyperlink:

        header1: r"^# [*\(\n)] \n"

    }

"""

""" The reason the length is stored instead of the end, is because it is

    less error prone; if a parent node is updated, only the begin needs to be

    updated, as the length is still the same for the node. The begin can be

    relative to the parent node, so even that won't have to be updated. """

"""

    node = {

            "type": block_type,

            "begin": begin,

            "length": length,

            "children": children,

            }

    return markdown_code

"""

from django.utils import translation

    # TODO: This still uses Pandoc to convert the file in the background to HTML

    # code. That's a pretty bad solution (doesn't mean Pandoc is bad though).

    # Remember to write a custom implementation when there's time available.

    return subprocess.check_output(["pandoc", file_path])