blog

============

Since web apps (and everything web related) is known to suck at dependency handling (which is why we have Bower, NPM, cdnjs, docker, ... (I'll explain sometime somewhere why this is done, and why it's useless), I've decided to take matters in my own hands; I'll just provide one simple markdown file listing all dependencies in human-readable format. I don't care whether this helps or not, but no harm is done, right?

Legend

------

The dependencies themselves have been ranked with a certain grade. I explain what they mean here:

 * A : This dependency is present inside the app. This will be in the form of ready-to-use source code files. As such, they need no further attention.

 * B : This dependency is present inside the app. This will be in the form of an archive file (i.e. .tar.gz), OR this needs additional work to function properly. In these cases, I refer to their documentation which will be available at the location of the files.

 * C : This dependency does not come with the app. These are often system packages, which often means (if you're on GNU/Linux) to search for it in your repositories. Their documentation is your last resort for these if it doesn't work as it should.

I hope I never will, but when it's necessary, I'll add a D grade, for unreadable, egregious bogus software that will give you all horrible kinds of diseases if you dare to work with it, but are indispensable to make the web app function. Just be happy I don't use it yet. (For example, PHP qualifies as D, so praise [our lord and saviour](https://rms.sexy) I write Python.)

A

-

 * [Materialize](http://materializecss.com/): The layout framework for the web app. (Material Design is the best)

B

-

C

-

 * [Markdown](https://pypi.python.org/pypi/Markdown): Required to compile the

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

    """

def toHTML(

        file,

    # Zoom zoom insert magic code here

    # Assuming the file is open

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

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

    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.shortcuts import get_object_or_404, render # This allows to render the template with the view here. It's pretty cool and important.

from django.http import HttpResponseRedirect, HttpResponse

from django.core.urlresolvers import reverse # Why?

from django.template import loader # This allows to actually load the template.

from django.contrib.auth.decorators import login_required

from django.contrib.auth import authenticate, login

from .models import Post

from django.core.exceptions import ObjectDoesNotExist

from markdown import markdown

from django.utils import translation

# FIXME: Remove this template trash. THIS IS A VIEW, NOT A FUCKING TEMPLATE FFS

context = {

    'materialDesign_color': "green",

    'materialDesign_accentColor': "purple",

    'navbar_title': "Blog",

    'navbar_fixed': True,

    'navbar_backArrow': True,

    #'footer_title': "Maarten's blog",

    #'footer_description': "My personal scribbly notepad.",

    #'footer_links': footer_links,

    }

def get_available_post_languages(post):

    """ Returns the language codes for which a blog post exists. This function

    always returns English (because that field mustn't be empty).

    So say a blog post has an English, Dutch and French version (which means

    english_file, french_file and dutch_file aren't empty), the function will return {"en",

    "fr", "nl"}. """

    available_languages = {"en"}

    if post.german_file is not none:

    if post.spanish_file is not None:

        available_languages.add("es")

    if post.french_file is not None:

        available_languages.add("fr")

    if post.dutch_file is not None:

        available_languages.add("nl")

    return available_languages

def get_preferred_post_language(post, language):

    """ Returns the post language file that best suits the given language. This

    is handy if you know what language the user prefers, but aren't sure whether

    you can provide that language. This function will try to provide the file

    for that language, or return English if that's not possible. """

    if language == "de" and post.german_file is not None:

        return post.german_file

    if language == "es" and post.spanish_file is not None:

        return post.spanish_file

    if language == "fr" and post.french_file is not None:

        return post.french_file

    if language == "nl" and post.dutch_file is not None:

        return post.dutch_file

    return post.english_file  # Returned if all other choices wouldn't be satisfactory, or the requested language is English.

def index(request):

    template = "blog/index.html"

    posts = Post.objects.all()

    language = translation.get_language()

    post_links = []

    for post in posts:

        blog_file = get_preferred_post_language(post, language)

        # TODO: Find a cleaner way to determine the title. First and foremost:

        # If the language differs from English, the other language file needs to

        # be loaded. Plus: look for a built in function to remove the full path

        # and only return the file name.

        title = (blog_file.name.rpartition("/")[2]).rpartition(".")[0]

        date = post.published

        description = "Lorem ipsum"

        # TODO: The link can possibly be reversed in the DTL using the title, which is actually

        # a cleaner way to do it. Investigate.

        link = reverse("blog-post", args=[str(post)])

        post_links.append([title, date, description, link])

    context = {

            'post_links': post_links,

            }

    return render(request, template, context)

def post(request, title):

    template = "blog/post.html"

    posts = Post.objects.get(english_file=title)

    language = translation.get_language()

    blog_file = get_preferred_post_language(post, language)

    blog_text = markdown(blog_file)

    context = {

        'article': blog_text,

        'title': blog_file.name,

        }

    return render(request, template, context)