The so-called *content functions* are a feature of this blogging system that gives you an easy way to reference another item of your blog from the content of any other item, without the need to hard link the URL of the referenced item.

This document explains the available *content functions* that are shipped with the system by default and shows you how to add your own customized *content functions* to do some interesting things and prevent repetitive lines of text in your content.

**Note:** There is a second older syntax for the so-called *content tags* (like `{POST[1]}`) which are deprecated now. They are still supported and will still be parsed and transformed, but please do not use them anymore if you can use the much more powerful *content functions* described in this document.

## Registered default functions
The table below contains all default *content functions* you can use.

| Function   | Description                                     | Parameters (`?` means optional) |
|------------|-------------------------------------------------|---------------------------------|
| `BASE_URL` | Return pure URL relative to root directory.     | `?extend`                       |
| `FILE_URL` | Return pure URL relative to `rsrc` directory.   | `?extend`                       |
| `CATEGORY` | Return Markdown formatted link to **category**. | `id`, `?text`, `?title`         |
| `PAGE`     | Return Markdown formatted link to **page**.     | `id`, `?text`, `?title`         |
| `POST`     | Return Markdown formatted link to **post**.     | `id`, `?text`, `?title`         |
| `USER`     | Return Markdown formatted link to **user**.     | `id`, `?text`, `?title`         |

## Syntax
The name of the *content function* and its parameters is put between an opening (`{`) and closing (`}`) curly brace. An optional blank space (` `) is permitted between the opening and closing curly braces (but not necessary).

After the opening curly brace (and the optional blank space), the name of the *content function* (in uppercase letters) is followed directly after. If the *content function* shall be called without any parameters, the function name is followed by the optional space (mentioned above) and directly after by the closing curly brace.

### Example: Call `BASE_URL`
~~~
{BASE_URL}
~~~

Parameters (or "arguments") for the *content function* are separated from the function name by a required colon (`:`) and a required blank space. The parameter list consists of either integer values (`123`) or string values (`"Hello"`).

String values must be put between double quotes (`"`) while integer values do not need quotes around. Multiple parameters are separated from each other by a required comma (`,`) with an optional blank space directly after the comma.

**Note:** The parameters passed to the PHP callback function are (currently) always of type `string`!

### Example: Call functions with parameters
~~~
{BASE_URL: "readme.md"}
{CATEGORY: 1, "Look at this category!"}
~~~

## How to add custom functions?
The new *content function* feature gives you the ability to define your own custom functions. This is especially useful if you, for example, want to embed a YouTube video in a post but do not want to repeat the repetitive HTML embed code anytime when you want to show a YouTube video in your posts. You can just register a new *content function* to do this!

The interface to register a new *content function* is the method `addContentFunction` of the `Application` class. This method requires exactly two parameters: The **function name** and the **callback function**. The function name is validated and must contain only numbers, uppercase letters and underscores. An exception is thrown if this rule is violated.

The function can take required and optional parameters, but currently only parameters of type `string` are supported. So if you define the type of a parameter to be something other than `string`, it could cause errors when calling the function.

There is also a check for required paremeters. If the function needs required parameters but is called with less than the required amount of parameters, the `FunctionParser` will return `{FUNCTION_NAME: *Missing arguments*}` instead.

In the function itself, it is perfectly OK to use application internal code if you know what you are doing. But please be aware that application internal code will change over time, so you need to keep track of the changes made to the codebase if you use some application internal code in your functions.

### Example: Embed YouTube videos (via Invidious)
So lets register the content function `YOUTUBE` to easily embed YouTube videos! In this example, I will use a public instance of the privacy-friendly *YouTube* frontend called [*Invidious*](https://github.com/iv-org/invidious).

~~~php
# core/configuration.php
Application::addContentFunction('YOUTUBE', function($watch) {
	return sprintf('<div class="video">
		<iframe src="https://ytprivate.com/embed/%s" allowfullscreen referrerpolicy="no-referrer"></iframe>
	</div>', $watch);
});
~~~

Done. You can now call this function by typing `{YOUTUBE: "aqz-KE-bpKQ"}` into the editor!

The benefits of this are obvious: If you later change your mind about the way how videos are embedded, you just need to change your *content function* without modifying all the posts in which you have a video embedded.