Ensures that __mix_recompile__?/0 will be defined.

Compiles a function for each template in the given root.

converter is an anonymous function that receives the template path and returns the function name (as a string).

For example, to compile all .eex templates in a given directory, you might do:

Combo.Template.compile_all(
  &(&1 |> Path.basename() |> Path.rootname(".eex")),
  __DIR__,
  "*.eex"
)

If the directory has templates named foo.eex and bar.eex, they will be compiled into the functions foo/1 and bar/1 that receive the template assigns as argument.

You may optionally pass a keyword list of engines. If a list is given, we will lookup and compile only this subset of engines. If none is passed (nil), the default list returned by engines/0 is used.

Embeds external template files into the module as functions.

This macro is built on top of compile_all/3.

Options

• :root - The root directory to embed template files. Defaults to the directory of current module (__DIR__).
• :suffix - The string value to append to the embedded function names. By default, function names will be the name of the template file excluding the format and engine.

Examples

Imagine a directory listing:

├── pages
│   ├── about.html.ceex
│   └── sitemap.xml.eex

To embed the templates into a module, we can define a module like this:

defmodule DemoWeb.Pages do
  import Combo.Template, only: [embed_templates: 1]

  # a wildcard pattern is used to select all files within a directory
  embed_templates "pages/*"
end

Now, the module will have about/1 and sitemap/1 functions.

Multiple invocations of embed_templates is also supported, which can be useful if we have more than one template format. For example:

defmodule DemoWeb.Pages do
  import Combo.Template, only: [embed_templates: 2]

  embed_templates "pages/*.html", suffix: "_html"
  embed_templates "pages/*.xml", suffix: "_xml"
end

Now, the module will have about_html and sitemap_xml functions.

@spec engines() :: %{required(atom()) => module()}

Returns all template engines as a map.

@spec find_all(root(), pattern :: String.t(), %{required(atom()) => module()}) :: [
  path()
]

Returns all template paths in a given template root.

@spec format_encoder(format :: String.t()) :: module() | nil

Returns the format encoder for a given format.

@spec format_encoders() :: %{required(String.t()) => module()}

Returns all format encoders as a map.

@spec hash(root(), pattern :: String.t(), %{required(atom()) => module()}) :: binary()

Returns the hash of all template paths in the given root.

Used by Combo to check if a given root path requires recompilation.

Renders template from module.

For a module called DemoWeb.UserHTML and template "index.html.ceex", it will:

• First attempt to call DemoWeb.UserHTML.index(assigns)

• Then fallback to DemoWeb.UserHTML.render("index.html", assigns)

• Raise otherwise

It expects the the module, the template as a string, the format, and a set of assigns.

Notice that this function returns the inner representation of a template. If you want the encoded template as a result, use render_to_iodata/4 instead.

Examples

Combo.Template.render(DemoWeb.UserHTML, "index", "html", name: "Charie Brown")
#=> {:safe, "Hello, Charlie Brown"}

Renders the template and returns iodata.

Renders the template to string.