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).

    - Allow the special p "Perseverance porn" stories, about how someone walks 10 miles to work every day, have the effect of normalizing the big disadvantages from society that make people do hard labor that society should not need.

    """

        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>',

        code = r'<code lang="{language}">{code}</code>',

        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)

            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)

    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.db import models

import datetime

import os

def post_title_directory(instance, filename):

    """ Files will be uploaded to MEDIA_ROOT/blog/<year of publishing>/<blog

    title>

    The blog title is determined by the text before the first period (".") in

    the filename. So if the file has the name "Trains are bæ.en.md", the file

    will be stored in "blog/<this year>/Trains are bæ". Name your files

    properly!

    It should also be noted that all files are stored in the same folder if they

    belong to the same blogpost, regardless of language. The titles that are

    displayed to the user however, should be the titles of the files themselves,

    which should be in the native language. So if a blog post is titled

    "Universities of Belgium", its Dutch counterpart should be titled

    "Universiteiten van België", so the correct title can be derived from the

    filename.

    Recommended way to name the uploaded file: "<name of blog post in language

    it's written>.md". This removes the maximum amount of redundancy (e.g. the

    language of the file can be derived from the title, no ".fr.md" or something

    like that necessary), and can directly be used for the end user (the title

    is what should be displayed).

    """

    english_file_name = os.path.basename(instance.english_file.name) # TODO: Test if this returns the file name!

    english_title = english_file_name.rpartition(".")[0] 

    year = datetime.date.today().year

    return "blog/{0}/{1}/{2}".format(year, english_title, filename)

class Post(models.Model):

    """ Represents a blog post. The title of the blog post is determnined by the name

    of the files.

    A blog post can be in 5 different languages: German, Spanish, English, French,

    and Dutch. For all these languages, a seperate field exists. Thus, a

    translated blog post has a seperate file for each translation, and is

    seperated from Django's internationalization/localization system.

    Only the English field is mandatory. The others may contain a value if a

    translated version exists, which will be displayed accordingly.

    """

    published = models.DateTimeField(auto_now_add=True)

    english_file = models.FileField(upload_to=post_title_directory, unique=True, blank=False)

    dutch_file = models.FileField(upload_to=post_title_directory, blank=True)

    french_file = models.FileField(upload_to=post_title_directory, blank=True)

    german_file = models.FileField(upload_to=post_title_directory, blank=True)

    spanish_file = models.FileField(upload_to=post_title_directory, blank=True)

    # Only the English file can be unique, because apparantly, there can't be

    # two blank fields in a unique column. Okay then.

    def __str__(self):

        return os.path.basename(self.english_file.name).rpartition(".")[0]