HyML - Minimal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HyML MiNiMaL\n",
    "\n",
    "## Minimal markup language generator in Hy\n",
    "\n",
    "[HyML](https://github.com/markomanninen/hyml) (acronym for Hy Markup Language) is a set of macros to generate XML, XHTML, and HTML code in Hy.\n",
    "\n",
    "HyML MiNiMaL (``ml``) macro is departed from the more extensive document and validation oriented full version of HyML. \n",
    "\n",
    "HyML MiNiMaL is meant to be used as a minimal codebase to generate XML (Extensible Markup Language) with the next features:\n",
    "\n",
    "1. closely resembling syntax with XML\n",
    "2. ability to mix Hy / Python program code within markup\n",
    "3. processing lists and external templates\n",
    "4. using custom variables and functions\n",
    "\n",
    "You can use HyML MiNiMaL for:\n",
    "\n",
    "- static XML / XHTML / HTML content and file generation\n",
    "- render html code for the Jupyter Notebook for example\n",
    "- attach it to a server for dynamic html output generation ([sHyte 0.2](https://github.com/markomanninen/shyte))\n",
    "- practice and study [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) and macro (Lisp) programming\n",
    "- challenge your imagination\n",
    "\n",
    "To compare with full version HyML XML / HTML macros, MiNiMaL means that there is no tag name validation and no tag and attribute minimize techniques utilized. If you need them, you should see [full HyML](http://hyml.readthedocs.io/en/latest/#) documentation.\n",
    "\n",
    "HyML thus refers to XML, althought markup language term itself is more [generic](https://en.wikipedia.org/wiki/Markup_language) term."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ready, steady, go!\n",
    "\n",
    "Project is hosted at: https://github.com/markomanninen/hyml\n",
    "\n",
    "### Install\n",
    "\n",
    "For easy install, use [pip](https://pip.pypa.io/en/stable/installing/) Python repository installer:\n",
    "\n",
    "```Shell\n",
    "$ pip install hyml\n",
    "```\n",
    "\n",
    "This will install only the necessary source files for HyML, no example\n",
    "templates nor Jupyter Notebook files.\n",
    "\n",
    "There are no other dependencies except Hy language upon Python of cource. \n",
    "If Hy does not exist on your computer, it will be installed (or updated to \n",
    "the version 0.12.1 or greater) at the same time.\n",
    "\n",
    "### Import\n",
    "\n",
    "Then import MiNiMaL macros:\n",
    "\n",
    "```Clojure\n",
    "(require (hyml.minimal (*)))\n",
    "```\n",
    "\n",
    "This will load the next macros for usage\n",
    "\n",
    "- main markup macro: `ml`\n",
    "- `defvar` and `deffun` macros for custom variable and function setter\n",
    "- `include` macro for using templates\n",
    "- `list-comp*` list comprehension helper macro\n",
    "\n",
    "Optionally `ml>` render macro will be loaded, if code is executed on Jupyter \n",
    "Notebook / IPython environment with `display.HTML` function available.\n",
    "\n",
    "If you intend to use xml code `indent` function, you should also import it:\n",
    "\n",
    "```Clojure\n",
    "(import (hyml.minimal (indent)))\n",
    "```\n",
    "\n",
    "### Run\n",
    "\n",
    "And run the simple example:\n",
    "\n",
    "```Clojure\n",
    "(ml (tag :attr \"value\" (sub \"Content\")))\n",
    "```\n",
    "\n",
    "That should output:\n",
    "\n",
    "```XML\n",
    "<tag attr=\"value\"><sub>Content</sub></tag>\n",
    "```\n",
    "\n",
    "### Tests\n",
    "\n",
    "To run basic tests, you can use Jupyter Notebook [document](http://nbviewer.jupyter.org/github/markomanninen/hyml/blob/master/HyML%20-%20Minimal.ipynb#Test-main-features) for now.\n",
    "\n",
    "\n",
    "### Jupyter Notebook\n",
    "\n",
    "If you want to play with HyML Notebook documents, you should download the whole [HyML repository](https://github.com/markomanninen/hyml/archive/master.zip) (or clone it with `$ git clone https://github.com/markomanninen/hyml.git`) to your computer. It contains all necessary templates to get everything running as presented in the HyML MiNiMaL Notebook [document](http://nbviewer.jupyter.org/github/markomanninen/hyml/blob/master/HyML%20-%20Minimal.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HyML MiNiMaL codebase\n",
    "\n",
    "Because codebase for HyML MiNiMaL implementation is roughly 60 lines only, it will be provided here with structural comments for introspection. More detailed comment are available in the [minimal.hy](https://github.com/markomanninen/hyml/blob/master/hyml/minimal.hy) source file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function <lambda> at 0x0000016BD41D58C8>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "; eval and compile variables, constants and functions for ml, defvar, deffun, and include macros\n",
    "(eval-and-compile\n",
    "  ; global registry for variables and functions\n",
    "  (setv variables-and-functions {})\n",
    "  ; internal constants\n",
    "  (def **keyword** \"keyword\") (def **unquote** \"unquote\")\n",
    "  (def **splice** \"unquote_splice\") (def **unquote-splice** (, **unquote** **splice**))\n",
    "  (def **quote** \"quote\") (def **quasi** \"quasiquote\")\n",
    "  (def **quasi-quote** (, **quote** **quasi**))\n",
    "  ; given two dictionaries, merge them into a new dictionary as a shallow copy\n",
    "  (defn merge-two-dicts [x y]\n",
    "    (if-not (or (empty? x) (empty? y))\n",
    "            ; tiny optimization, if there are values in both x and y\n",
    "            (do (setv z (.copy x)) (.update z y) z)\n",
    "            ; else one more check to return the one that has values\n",
    "            ; or maybe all were empty? then either one should be fine\n",
    "            (if (empty? x) y x)))\n",
    "  ; detach keywords and content from code expression\n",
    "  (defn get-content-attributes [code &optional [vars-and-funcs {}]]\n",
    "    (setv content [] attributes [] kwd None)\n",
    "    (for [item code]\n",
    "         (do (if (iterable? item)\n",
    "                 (if (= (first item) **unquote**)\n",
    "                     (setv item (eval (second item)\n",
    "                                      (merge-two-dicts variables-and-functions vars-and-funcs)))\n",
    "                     (in (first item) **quasi-quote**) (setv item (name (eval item)))))\n",
    "             (if-not (keyword? item)\n",
    "               (if (none? kwd)\n",
    "                   (.append content (parse-mnml item vars-and-funcs))\n",
    "                   (.append attributes (, kwd (parse-mnml item vars-and-funcs)))))\n",
    "             (if (and (keyword? kwd) (keyword? item))\n",
    "                 (.append attributes (, kwd (name kwd))))\n",
    "             (if (keyword? item) (setv kwd item) (setv kwd None))))\n",
    "    (if (keyword? kwd)\n",
    "        (.append attributes (, kwd (name kwd))))\n",
    "    (, content attributes))\n",
    "  ; recursively parse expression\n",
    "  (defn parse-mnml [code &optional [vars-and-funcs {}]] \n",
    "    (if (coll? code)\n",
    "        (do (setv tag (catch-tag (first code)))\n",
    "            (if (in tag **unquote-splice**)\n",
    "                (if (= tag **unquote**)\n",
    "                    (str (eval (second code) (merge-two-dicts variables-and-functions vars-and-funcs)))\n",
    "                    (.join \"\" (map (if (empty? vars-and-funcs) parse-mnml (fn [item] (parse-mnml item vars-and-funcs)))\n",
    "                                   (eval (second code) (merge-two-dicts variables-and-functions vars-and-funcs)))))\n",
    "                (do (setv (, content attributes) (get-content-attributes (drop 1 code) vars-and-funcs))\n",
    "                    (+ (tag-start tag attributes (empty? content))\n",
    "                       (if (empty? content) \"\"\n",
    "                           (+ (.join \"\" (map str content)) (+ \"</\" tag \">\")))))))\n",
    "        (if (none? code) \"\" (str code))))\n",
    "  ; detach tag from expression\n",
    "  (defn catch-tag [code]\n",
    "    (if (and (iterable? code) (= (first code) **unquote**))\n",
    "        (eval (second code))\n",
    "        (try (name (eval code))\n",
    "             (except (e Exception) (str code)))))\n",
    "  ; concat attributes\n",
    "  (defn tag-attributes [attr]\n",
    "    (if (empty? attr) \"\"\n",
    "        (+ \" \" (.join \" \" (list-comp\n",
    "          (% \"%s=\\\"%s\\\"\" (, (name kwd) (name value))) [[kwd value] attr])))))\n",
    "  ; create start tag\n",
    "  (defn tag-start [tag-name attr short]\n",
    "    (+ \"<\" tag-name (tag-attributes attr) (if short \"/>\" \">\"))))\n",
    "; global variable registry handler\n",
    "(defmacro defvar [&rest args]\n",
    "  (setv l (len args) i 0)\n",
    "  (while (< i l) (do\n",
    "    (assoc variables-and-functions (get args i) (get args (inc i)))\n",
    "    (setv i (+ 2 i)))))\n",
    "; global function registry handler\n",
    "(defmacro deffun [name func]\n",
    "  (assoc variables-and-functions name (eval func)))\n",
    "; include functionality for template engine\n",
    "(defmacro include [template]\n",
    "  `(do (import [hy.importer [tokenize]])\n",
    "       (with [f (open ~template)]\n",
    "         (tokenize (+ \"~@`(\" (f.read) \")\")))))\n",
    "; main MiNiMaL macro to be used. passes code to parse-mnml\n",
    "(defmacro ml [&rest code]\n",
    "  (.join \"\" (map parse-mnml code)))\n",
    "; \n",
    "(defmacro macro [name params &rest body]\n",
    "  `(do\n",
    "    (defmacro ~name ~params\n",
    "      `(quote ~~@body)) None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features\n",
    "\n",
    "### Basic syntax\n",
    "\n",
    "MiNiMaL macro syntax is simple and practically follows the rules of \n",
    "[Hy syntax](http://docs.hylang.org/en/latest/language/api.html). MiNiMaL macro expression is made of the following four components:\n",
    "\n",
    "1. tag name\n",
    "2. tag attribute-value pairs\n",
    "3. tag text / literal content\n",
    "4. possible sub expression\n",
    "\n",
    "Syntax of the expression consists of:\n",
    "\n",
    "* parentheses to define hierarchical (nested) structure of the document\n",
    "* all opened parentheses `(` must have closing parentheses pair `)`\n",
    "* the first item of the expression is the tag name\n",
    "* next items in the expression are either:\n",
    "\n",
    "  * tag attribute-value pairs\n",
    "  * tag content wrapped with double quotes\n",
    "  * sub tag expression\n",
    "  * nothing at all\n",
    "\n",
    "* between keywords, keyword values, and content there must a whitespace\n",
    "  separator OR expression components must be wrapped with double quotes\n",
    "  when suitable\n",
    "* whitespace is not needed when a new expression starts or ends\n",
    "  (opening and closing parentheses)\n",
    "\n",
    "Only the tag name is mandatory on the expression. There is no limit on \n",
    "the depth of the nested levels. There is no limit on how many \n",
    "attribute-value pairs you want to use. Also it doesn't matter in what \n",
    "order you define tag content and keywords, althougt it might be easier \n",
    "to read for others, if the keywords are introduced first and then the \n",
    "content. However, all keywords are rendered in the same order they have \n",
    "been presented in the markup. Also content and sub nodes are rendered \n",
    "similarly in the given order.\n",
    "\n",
    "Main differences to XML syntax are:\n",
    "\n",
    "-  instead of `<` and `>` delimiters, parentheses `(` and `)` \n",
    "   are used\n",
    "-  there can't be a separate end tag\n",
    "-  in `ml` macro, given expressions does not need to have be inside a single root node\n",
    "-  see other possible differences by comparing HyML to \n",
    "   [wiki/XML](https://en.wikipedia.org/wiki/XML#Well-formedness_and_error-handling)\n",
    "\n",
    "### Special characters\n",
    "\n",
    "In addition to basic syntax, there are three other symbols for advanced code generation. They are:\n",
    "\n",
    "- quasiquote \\`\n",
    "- unquote `~`\n",
    "- unquote splice `~@`\n",
    "\n",
    "These all are symbols used in Hy [macro notation](http://docs.hylang.org/en/latest/language/api.html#quasiquote), so they should be self explanatory. But to make everything clear, in the MiNiMaL macro they may look they work other way around.\n",
    "\n",
    "Unquote (`~`) and unquote-splice (`~@`) gets you back to the Hy code evaluation mode. And quasiquote (\\`) sets you back to MiNiMaL macro mode. This is natural when you think that expression passed to MiNiMaL macro is a quoted code in the first place. So if you want to evaluate Hy code inside it, you need to do it inside unquote.\n",
    "\n",
    "But let us start from the simple example first.\n",
    "\n",
    "\n",
    "### Simple example\n",
    "\n",
    "Observe the simple example utilizing above features and all four components:\n",
    "\n",
    "```Lisp\n",
    "(tag :attr \"value\" (sub \"Content\"))\n",
    "```\n",
    "\n",
    "`tag` is the first element of the expression, so it regarded as a tag name. `:attr \"value\"` is the keyword-value (attribute-value) -pair. `(sub` starts a new expression. So there is no other content (or keywords) in the `tag` element. Sub node instead has the titlecase content `\"Content\"` given.\n",
    "\n",
    "Running this on a console or on the Jupyter Notebook, output would be:\n",
    "\n",
    "```XML\n",
    "<tag attr=\"value\"><sub>Content</sub></tag>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process components with unquote syntax (`~`)\n",
    "\n",
    "Any component (tag name, tag attribute / value, and tag content) can be \n",
    "generated instead of hardcoded to the expression.\n",
    "\n",
    "#### Tag name\n",
    "\n",
    "You can generate a tag name with Hy code by using ~ symbol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag/>'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (~(+ \"t\" \"a\" \"g\"))) ; output: tag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is useful if tag names collide with Hy internal symbols and datatypes. For example, the symbol `J` is reserved for the complex number type. Instead of writing: `(ml (J))` which produces `<1j/>`, you should use: `(ml (\"J\"))` or maybe `(ml (~\"J\"))`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Attribute name and value\n",
    "\n",
    "You can generate an attribute name or a value with Hy by using `~` symbol. Generated attribute name must be a keyword however:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag attr=\"value\"/>'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag ~(keyword (.join \"\" ['a 't 't 'r])) \"value\")) ; output: <tag attr=\"value\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag attr=\"value\"/>'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag :attr ~(+ 'v 'a 'l 'u 'e))) ; output: <tag attr=\"value\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Content\n",
    "\n",
    "You can generate content with Hy by using `~` symbol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag>CONTENT</tag>'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag ~(.upper \"content\"))) ; output: <tag>CONTENT</tag>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using custom variables and functions\n",
    "\n",
    "You can define custom variables and functions for the MiNiMaL macro. Variables and functions are stored on the common registry and avialble on the macro expansion. You can access predefined symbols when quoting (`~`) the expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag>McDonald, Dennis</tag>'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "; define variables with defvar macro\n",
    "(defvar firstname \"Dennis\"\n",
    "        lastname \"McDonald\")\n",
    "\n",
    "; define functions with deffun macro\n",
    "(deffun wholename (fn [x y] (+ y \", \" x)))\n",
    "\n",
    "; use variables and functions with unquote / unquote splice\n",
    "(ml (tag ~(wholename firstname lastname)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process lists with unquote splice syntax (`~@`)\n",
    "\n",
    "Unquote-splice is a special symbol to be used with the list and the template processing. It is perhaps the most powerful feature in the MiNiMaL macro.\n",
    "\n",
    "#### Generate list of items\n",
    "\n",
    "You can use list comprehension function to generate a list of xml elements. Hy code, sub expressions, and variables / functions work inside unquote spliced expression. You need to quote a line, if it contains a sub MiNiMaL expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag><sub>0</sub><sub>1</sub><sub>2</sub><sub>3</sub><sub>4</sub></tag>'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "; generate 5 sub tags and use enumerated numeric value as a content\n",
    "(ml (tag ~@(list-comp `(sub ~(str item)) [item (range 5)])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using templates\n",
    "\n",
    "Let us first show the template content existing in the external file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(note :src \"https://www.w3schools.com/xml/note.xml\"\n",
      "  (to ~to)\n",
      "  (from ~from)\n",
      "  (heading ~heading)\n",
      "  (body ~body))\n"
     ]
    }
   ],
   "source": [
    "(with [f (open \"templates/note.hy\")] (print (f.read)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we will define variables and a function to be used inside MiNiMaL macro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(defvar to \"Tove\"\n",
    "        from \"Jani\"\n",
    "        heading \"Reminder\"\n",
    "        body \"Don't forget me this weekend!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally include and render the template. Indent function is imported and used to pretty print xml: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<note src=\"https://www.w3schools.com/xml/note.xml\">\n",
      "\t<to>Tove</to>\n",
      "\t<from>Jani</from>\n",
      "\t<heading>Reminder</heading>\n",
      "\t<body>Don't forget me this weekend!</body>\n",
      "</note>\n"
     ]
    }
   ],
   "source": [
    "(import (hyml.minimal (indent)))\n",
    "(print (indent (ml ~@(include \"templates/note.hy\"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Templates extra\n",
    "\n",
    "On HyML package there is also the `render-template` function and the `extend-template` macro available via `HyML.template` module.\n",
    "\n",
    "`HyML.template` is especially useful when embedding `HyML MiNiMaL` to webserver, [Flask](http://flask.pocoo.org/) for example. Here just the basic use case is shown, more examples you can find from [sHyte 0.2 HyML Edition](https://github.com/markomanninen/shyte) codebase.\n",
    "\n",
    "In practice, `render-template` function is a shortcut to call `parse-mnml` with parameters and `include` in sequence. The first argument in `render-template` is the template name, and the rest of the arguments are dictionaries to be used on the template. So this is also an alternative way of using (bypassing the usage of) `defvar` and `deffun` macros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<root><var>Variable 1</var><func>Function 1</func></root>'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "; extend-template macro\n",
    "(require [hyml.template [*]])\n",
    "; render-template function\n",
    "(import [hyml.template [*]])\n",
    "; prepare template variables and functions\n",
    "(setv template-variables-and-functions {\"var\" \"Variable 1\" \"func\" (fn[]\"Function 1\")})\n",
    "; render template\n",
    "(render-template \"render.hyml\" template-variables-and-functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On template engines it is a common practice to extend sub template with main template. Say we have a layout template, that is used as a wapper for many other templates. We can refactor layout xml code to another file and keep the changing sub content on other files.\n",
    "\n",
    "In `HyML MiNiMaL`, `extend-template` macro is used for that.\n",
    "\n",
    "Lets show an example again. First we have the content of the `layout.hyml` template file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(html\n",
      "\t(head (title ~title))\n",
      "\t(body ~body))\n"
     ]
    }
   ],
   "source": [
    "(with [f (open \"templates/layout.hyml\")] (print (f.read)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the content of the `extend.hyml` sub template file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~(extend-template \"layout.hyml\" \n",
      "    {\"body\" `(p \"Page content\")})\n"
     ]
    }
   ],
   "source": [
    "(with [f (open \"templates/extend.hyml\")] (print (f.read)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have decided to set the `title` as a \"global\" variable but define the `body` on the sub template. The render process goes like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<html><head><title>Page title</title></head><body><p>Page content</p></body></html>'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(setv locvar {\"title\" \"Page title\"})\n",
    "(render-template \"extend.hyml\" locvar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that extension name `.hyml` was used here even though it doesn't really matter what file extension is used.\n",
    "\n",
    "At first it may look overly complicated and verbose to handle templates this way. Major advantage is found when processing multiple nested templates. Difference to simply including template files `~@(include \"templates/template.hy\")` is that on `include` you pass variables (could be evaluated `HyML` code) to template, but on `extend-template` you pass unevaluated `HyML` code to another template. This will add one more dynamic level on using `HyML MiNiMaL` for XML content generation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Template directory**\n",
    "\n",
    "Default template directory is set to `\"template/\"`. You can change directory by changing `template-dir` variable in the `HyML.template` module:\n",
    "\n",
    "```hylang\n",
    "(import hyml.template)\n",
    "(def hyml.template.template-dir \"templates-extra/\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Macro -macro **\n",
    "\n",
    "One more related feature to templates is a `macro` -macro that can be used inside template files to factorize code for local purposes. If our template file would look like this:\n",
    "\n",
    "```hylang\n",
    "~(macro custom [attr]\n",
    "  `(p :class ~attr))\n",
    "\n",
    "~(custom ~class)\n",
    "```\n",
    "\n",
    "Then rendering it, would yield:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<p class=\"main\"/>'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(render-template \"macro.hyml\" {\"class\" \"main\"}) ; output: <p class=\"main\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Directly calling the `parse-mnml` function\n",
    "\n",
    "You are not forced to use `ml` macro to generate XML. You can pass quoted code directly to `parse-mnml` function. This can actually be a good idea, for example if you want to generate tags based on a dictionary. First lets see the simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag/>'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(parse-mnml '(tag)) ; output: <tag/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then let us make it a bit more complicated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<contacs>\n",
      "\t<contact>\n",
      "\t\t<firstname>Eric</firstname>\n",
      "\t\t<lastname>Johnson</lastname>\n",
      "\t\t<telephone>+1-202-555-0170</telephone>\n",
      "\t</contact>\n",
      "\t<contact>\n",
      "\t\t<firstname>Mary</firstname>\n",
      "\t\t<lastname>Johnson</lastname>\n",
      "\t\t<telephone>+1-202-555-0185</telephone>\n",
      "\t</contact>\n",
      "</contacs>\n"
     ]
    }
   ],
   "source": [
    "; define contacts dictionary\n",
    "(defvar contacts [\n",
    "    {:firstname \"Eric\"\n",
    "     :lastname \"Johnson\"\n",
    "     :telephone \"+1-202-555-0170\"}\n",
    "    {:firstname \"Mary\"\n",
    "     :lastname \"Johnson\"\n",
    "     :telephone \"+1-202-555-0185\"}])\n",
    "; pretty print\n",
    "(print (indent\n",
    "(ml\n",
    "  ; root contacts node\n",
    "  (contacs\n",
    "    ~@(do\n",
    "      ; import parse-mnml function at the highest level of unquoted code\n",
    "      (import (hyml.minimal (parse-mnml)))\n",
    "      ; contact node\n",
    "      (list-comp `(contact\n",
    "        ; last contact detail node\n",
    "        ~@(list-comp (parse-mnml `(~tag ~val))\n",
    "            [[tag val] (.items contact)]))\n",
    "      [contact contacts]))))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `parse-mnml` it is also possible to pass an optional dictionary to be used for custom variables and functions on evaluation process. This is NOT possible with `ml` -macro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag attr=\"val\"/>'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(parse-mnml '(tag :attr ~val) {\"val\" \"val\"}) ; output: <tag attr=\"val\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `template` -macro you can actually see a very similar behaviour. In cases where variables can be hard coded, you might want to use this option:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag attr=\"val\"/>'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(template {\"val\" \"val\"} `(tag :attr ~val)) ; output: <tag attr=\"val\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn't really matter in which order you pass expression and dictionary to the `template` -macro. It is also ok to leave dictionary out if expression does not contain any variables. For `template` -macro, expression needs to be quasiquoted, if it contains `HyML` code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping up everything\n",
    "\n",
    "So all features of the MiNiMaL macro has now been introduced. Let us wrap everything and create XHTML document that occupies the most of the feature set. Additional comments will be given between the code lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
      "<!DOCTYPE html\n",
      "  PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN'\n",
      "  'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>\n",
      "<html lang=\"en\" xmlns=\"http://www.w3.org/1999/xhtml\">\n",
      "\t<head>\n",
      "\t\t<title>Conforming XHTML 1.0 Transitional Template</title>\n",
      "\t\t<meta content=\"text/html; charset=utf-8\" http-equiv=\"Content-Type\"/>\n",
      "\t</head>\n",
      "\t<body>\n",
      "\t\t<div class=\"post\">\n",
      "\t\t\t<div class=\"header\">How do you make XHTML 1.0 Transitional document with HyML?</div>\n",
      "\t\t\t<div class=\"body\">I've been wondering if it is possible to create XHTML 1.0 Transitional \n",
      "      document by using a brand new HyML?</div>\n",
      "\t\t\t<div class=\"tags\">\n",
      "\t\t\t\t<span>html</span>\n",
      "\t\t\t\t<span>xhtml</span>\n",
      "\t\t\t\t<span>hyml</span>\n",
      "\t\t\t</div>\n",
      "\t\t\t<div id=\"footer\">\n",
      "\t\t\t\t<p>Posted by: Hege Refsnes</p>\n",
      "\t\t\t\t<p>\n",
      "\t\t\t\t\tEmail: \n",
      "\t\t\t\t\t<a href=\"mailto:hege.refsnes@example.com\">hege.refsnes@example.com</a>\n",
      "\t\t\t\t\t.\n",
      "\t\t\t\t</p>\n",
      "\t\t\t</div>\n",
      "\t\t</div>\n",
      "\t\t<p>\n",
      "\t\t\t<a href=\"http://validator.w3.org/check?uri=referer\">\n",
      "\t\t\t\t<img alt=\"Valid XHTML 1.0 Transitional\" height=\"31\" src=\"http://www.w3.org/Icons/valid-xhtml10\" width=\"88\"/>\n",
      "\t\t\t</a>\n",
      "\t\t</p>\n",
      "\t</body>\n",
      "</html>\n"
     ]
    }
   ],
   "source": [
    "; define variables\n",
    "(defvar topic \"How do you make XHTML 1.0 Transitional document with HyML?\"\n",
    "        tags ['html 'xhtml 'hyml]\n",
    "        postedBy \"Hege Refsnes\"\n",
    "        contactEmail \"hege.refsnes@example.com\")\n",
    "\n",
    "; define function. note that we want to return quasiquoted HyML code here\n",
    "(deffun valid (fn []\n",
    "  `(p (a :href \"http://validator.w3.org/check?uri=referer\"\n",
    "      (img :src \"http://www.w3.org/Icons/valid-xhtml10\" \n",
    "           :alt \"Valid XHTML 1.0 Transitional\" \n",
    "           :height \"31\" :width \"88\")))))\n",
    "\n",
    "; let just arficially create a body for the post\n",
    "; and save it to the external template file\n",
    "(with [f (open \"templates/body.hy\" \"w\")]\n",
    "  (f.write \"(div :class \\\"body\\\"\n",
    "    \\\"I've been wondering if it is possible to create XHTML 1.0 Transitional \n",
    "      document by using a brand new HyML?\\\")\"))\n",
    "\n",
    "; print indented document as a pretty raw html\n",
    "(print (indent\n",
    "  ; start up the MiNiMaL macro\n",
    "  (ml\n",
    "    ; xml document declaration\n",
    "    \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\"\n",
    "    \"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Transitional//EN\\\" \n",
    "    \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\\\">\"\n",
    "    ; create html tag with xml namespace and language attributes\n",
    "    (html :xmlns \"http://www.w3.org/1999/xhtml\" :lang \"en\"\n",
    "      (head\n",
    "        ; title of the page\n",
    "        (title \"Conforming XHTML 1.0 Transitional Template\")\n",
    "        (meta :http-equiv \"Content-Type\" :content \"text/html; charset=utf-8\"))\n",
    "      (body\n",
    "        ; wrap everything inside the post div\n",
    "        (div :class \"post\"\n",
    "          ; first is the header of the post\n",
    "          (div :class \"header\" ~topic)\n",
    "          ; then body of the post from external template file\n",
    "          ~@(include \"templates/body.hy\")\n",
    "          ; then the tags in spans\n",
    "          (div :class \"tags\"\n",
    "            ~@(list-comp `(span ~tag) [tag tags]))\n",
    "          ; finally the footer\n",
    "          (div :id \"footer\"\n",
    "            (p \"Posted by: \" ~postedBy)\n",
    "            (p \"Email: \" \n",
    "              (a :href ~(+ \"mailto:\" contactEmail) ~contactEmail) \".\")))\n",
    "         ; proceed valid stamp by a defined function\n",
    "         ~(valid))))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special features\n",
    "\n",
    "These are not deliberately implemented features, but a consequence of the HyML MiNiMaL implementation and how Hy works.\n",
    "\n",
    "### Nested MiNiMaL macros\n",
    "\n",
    "It is possible to call MiNiMaL macro again inside unquoted code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag>Generator inside: <sub>content</sub></tag>'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag ~(+ \"Generator inside: \" (ml (sub \"content\")))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unrecognized symbols\n",
    "\n",
    "Unrecognized symbols (that is they are not specified as literals with double quotas and have no whitespace) are regarded as string literals, unless they are unquoted and they are not colliding with internal Hy symbols."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag alfred=\"J.\">Kwak</tag>'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag :alfred J. Kwak))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quote and quasiquote\n",
    "\n",
    "Tag names, attribute values, and tag content can be also single pre-quoted strings. It doesn't matter because in the final process of evaluating the component the string representation of the symbol is retrieved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<tag/>', '<tag/>', '<tag/>', '<tag/>']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(ml ('tag)) (ml (`tag)) (ml (tag)) (ml (\"tag\"))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With keywords, however, single pre-queted strings will get parsed as a content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<tag>attr</tag>', '<tag>attr</tag>']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(ml (tag ':attr)) (ml (tag `:attr))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword specialties\n",
    "\n",
    "Also if keyword marker is followed by a string literal, keyword will be empty, thus not a correctly wormed keyword value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag =\"attr\"/>'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag :\"attr\")) ; output: <tag =\"attr\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So only working version of keyword notation is `:{symbol}` or unquoted `~(keyword {expression})`.\n",
    "\n",
    "Note: keywords without value are interpreted as a keyword having the same value as the keyword name (called [boolean attributes](http://www.w3.org/TR/html5/infrastructure.html#boolean-attributes) in HTML)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<tag disabled=\"disabled\"/>', '<tag disabled=\"disabled\"/>', '<tag disabled=\"disabled\"/>']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(ml (tag :disabled)) (ml (tag ~(keyword \"disabled\"))) (ml (tag :disabled \"disabled\"))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wish to define multiple boolean attributes together with content, you can collect them at the end of the expression. Note that in XML boolean attributes cannot be minimized similar to HTML. Attributes always needs to have a value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag disabled=\"disabled\" enabled=\"enabled\">Content</tag>'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag \"Content\" :disabled :enabled))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more thing with keywords is that if the same keyword value pair is given multiple times, it will show up in the mark up in the same order, as multiple. Depending on the markup parser, the last attribute might be valuated OR parser might give an error, because by XML Standard attibute names should be unique and not repeated under the same element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<tag attr=\"attr\" attr=\"attr2\"/>'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ml (tag :attr :attr \"attr2\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test main features\n",
    "\n",
    "Assert tests for all main features presented above. There should be no output after running these. If there is, then *Houston, we have a problem!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    ";;;;;;;;;\n",
    "; basic ;\n",
    ";;;;;;;;;\n",
    "; empty things\n",
    "(assert (= (ml) \"\"))\n",
    "(assert (= (ml\"\") \"\"))\n",
    "(assert (= (ml \"\") \"\"))\n",
    "(assert (= (ml (\"\")) \"</>\"))\n",
    "; tag names\n",
    "(assert (= (ml (tag)) \"<tag/>\"))\n",
    "(assert (= (ml (TAG)) \"<TAG/>\"))\n",
    "(assert (= (ml (~(.upper \"tag\"))) \"<TAG/>\"))\n",
    "(assert (= (ml (tag \"\")) \"<tag></tag>\"))\n",
    "; content cases\n",
    "(assert (= (ml (tag \"content\")) \"<tag>content</tag>\"))\n",
    "(assert (= (ml (tag \"CONTENT\")) \"<tag>CONTENT</tag>\"))\n",
    "(assert (= (ml (tag ~(.upper \"content\"))) \"<tag>CONTENT</tag>\"))\n",
    "; attribute names and values\n",
    "(assert (= (ml (tag :attr \"val\")) \"<tag attr=\\\"val\\\"/>\"))\n",
    "(assert (= (ml (tag ~(keyword \"attr\") \"val\")) \"<tag attr=\\\"val\\\"/>\"))\n",
    "(assert (= (ml (tag :attr \"val\" \"\")) \"<tag attr=\\\"val\\\"></tag>\"))\n",
    "(assert (= (ml (tag :attr \"val\" \"content\")) \"<tag attr=\\\"val\\\">content</tag>\"))\n",
    "(assert (= (ml (tag :ATTR \"val\")) \"<tag ATTR=\\\"val\\\"/>\"))\n",
    "(assert (= (ml (tag ~(keyword (.upper \"attr\")) \"val\")) \"<tag ATTR=\\\"val\\\"/>\"))\n",
    "(assert (= (ml (tag :attr \"VAL\")) \"<tag attr=\\\"VAL\\\"/>\"))\n",
    "(assert (= (ml (tag :attr ~(.upper \"val\"))) \"<tag attr=\\\"VAL\\\"/>\"))\n",
    "; nested tags\n",
    "(assert (= (ml (tag (sub))) \"<tag><sub/></tag>\"))\n",
    "; unquote splice\n",
    "(assert (= (ml (tag ~@(list-comp `(sub ~(str item)) [item [1 2 3]])))\n",
    "           \"<tag><sub>1</sub><sub>2</sub><sub>3</sub></tag>\"))\n",
    "; variables\n",
    "(defvar x \"variable\")\n",
    "(assert (= (ml (tag ~x)) \"<tag>variable</tag>\"))\n",
    "; functions\n",
    "(deffun f (fn [x] x))\n",
    "(assert (= (ml (tag ~(f \"function\"))) \"<tag>function</tag>\"))\n",
    "; templates\n",
    "(with [f (open \"test/templates/test.hy\" \"w\")] (f.write \"(tag)\"))\n",
    "(assert (= (ml ~@(include \"test/templates/test.hy\")) \"<tag/>\"))\n",
    "; set up custom template directory\n",
    "(import hyml.template)\n",
    "(def hyml.template.template-dir \"test/templates/\")\n",
    "; render template function\n",
    "(import [hyml.template [*]])\n",
    "(with [f (open \"test/templates/test2.hy\" \"w\")] (f.write \"(tag ~tag)\"))\n",
    "(assert (= (render-template \"test2.hy\" {\"tag\" \"content\"}) \"<tag>content</tag>\"))\n",
    "; extend template\n",
    "(require [hyml.template [*]])\n",
    "(with [f (open \"test/templates/test3.1.hy\" \"w\")] (f.write \"(tags :attr ~val ~tag)\"))\n",
    "(with [f (open \"test/templates/test3.2.hy\" \"w\")] (f.write \"~(extend-template \\\"test3.1.hy\\\" {\\\"tag\\\" `(tag)})\"))\n",
    "(assert (= (render-template \"test3.2.hy\" {\"val\" \"val\"}) \"<tags attr=\\\"val\\\"><tag/></tags>\"))\n",
    "; macro -macro\n",
    "(with [f (open \"test/templates/test4.hy\" \"w\")] (f.write \"~(macro custom [content] `(tag ~content))~(custom ~content)\"))\n",
    "(assert (= (render-template \"test4.hy\" {\"content\" \"content\"}) \"<tag>content</tag>\"))\n",
    "; revert path\n",
    "(def hyml.template.template-dir \"templates/\")\n",
    "; template macro\n",
    "(assert (= (template {\"val\" \"val\"} `(tag :attr ~val)) (template `(tag :attr ~val) {\"val\" \"val\"})))\n",
    ";;;;;;;;;;;\n",
    "; special ;\n",
    ";;;;;;;;;;;\n",
    "; tag names\n",
    "(assert (= (ml (J)) \"<1j/>\"))\n",
    "(assert (= (ml (~\"J\")) \"<J/>\"))\n",
    "(assert (= [(ml ('tag)) (ml (`tag)) (ml (tag)) (ml (\"tag\"))] (* [\"<tag/>\"] 4)))\n",
    "; attribute values\n",
    "(assert (= [(ml (tag :attr 'val)) (ml (tag :attr `val)) (ml (tag :attr val)) (ml (tag :attr \"val\"))]\n",
    "           (* [\"<tag attr=\\\"val\\\"/>\"] 4)))\n",
    "; content\n",
    "(assert (= [(ml (tag 'val)) (ml (tag `val)) (ml (tag val)) (ml (tag \"val\"))]\n",
    "           (* [\"<tag>val</tag>\"] 4)))\n",
    "; keyword processing\n",
    "(assert (= [(ml (tag ':attr)) (ml (tag `:attr))] [\"<tag>attr</tag>\" \"<tag>attr</tag>\"]))\n",
    "(assert (= (ml (tag :\"attr\")) \"<tag =\\\"attr\\\"/>\"))\n",
    "; boolean attributes\n",
    "(assert (= [(ml (tag :attr \"attr\")) (ml (tag :attr)) (ml (tag ~(keyword \"attr\")))]\n",
    "           [\"<tag attr=\\\"attr\\\"/>\" \"<tag attr=\\\"attr\\\"/>\" \"<tag attr=\\\"attr\\\"/>\"]))\n",
    "(assert (= (ml (tag :attr1 :attr2)) \"<tag attr1=\\\"attr1\\\" attr2=\\\"attr2\\\"/>\"))\n",
    "(assert (= (ml (tag Content :attr1 :attr2)) \"<tag attr1=\\\"attr1\\\" attr2=\\\"attr2\\\">Content</tag>\"))\n",
    "(assert (= (ml (tag :attr1 :attr2 Content)) \"<tag attr1=\\\"attr1\\\" attr2=\\\"Content\\\"/>\"))\n",
    "; no space between attribute name and value as a string literal\n",
    "(assert (= (ml (tag :attr\"val\")) \"<tag attr=\\\"val\\\"/>\"))\n",
    "; no space between tag, keywords, keyword value, and content string literals\n",
    "(assert (= (ml (tag\"content\":attr\"val\")) \"<tag attr=\\\"val\\\">content</tag>\"))\n",
    ";;;;;;;;;\n",
    "; weird ;\n",
    ";;;;;;;;;\n",
    "; quote should not be unquoted or surpressed\n",
    "(assert (= (ml (quote :quote \"quote\" \"quote\")) \"<quote quote=\\\"quote\\\">quote</quote>\"))\n",
    "; tag name, keyword name, value and content can be same\n",
    "(assert (= (ml (tag :tag \"tag\" \"tag\")) \"<tag tag=\\\"tag\\\">tag</tag>\"))\n",
    "; multiple same attribute names stays in the markup in the reserved order\n",
    "(assert (= (ml (tag :attr \"attr1\" :attr \"attr2\")) \"<tag attr=\\\"attr1\\\" attr=\\\"attr2\\\"/>\"))\n",
    "; parse-mnlm with variable and function dictionary\n",
    "(assert (= (parse-mnml '(tag :attr ~var ~(func)) \n",
    "                       {\"var\" \"val\" \"func\" (fn[]\"Content\")}) \"<tag attr=\\\"val\\\">Content</tag>\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The [MIT](http://choosealicense.com/licenses/mit/) License\n",
    "\n",
    "Copyright (c) 2017 Marko Manninen"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Calysto Hy",
   "language": "hy",
   "name": "calysto_hy"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "scheme"
   },
   "mimetype": "text/x-hylang",
   "name": "hy",
   "pygments_lexer": "lisp"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}