Ensure __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:

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

A convenience macro for embeding templates as functions.

This macro is built on top of the more general compile_all/3 functionality.

Options

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

A wildcard pattern may be used to select all files within a directory tree. For example, imagine a directory listing:

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

Then to embed the templates in your module:

defmodule MyAppWeb.Renderer do
  import Phoenix.Template, only: [embed_templates: 1]
  embed_templates "pages/*"
end

Now, your module will have a about/1 and sitemap/1 functions. Note that functions across different formats were embedded. In case you want to distinguish between them, you can give a more specific pattern:

defmodule MyAppWeb.Emails do
  import Phoenix.Template, only: [embed_templates: 2]

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

Now the functions will be about_html and sitemap_xml.

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

Returns a keyword list with all template engines extensions followed by their modules.

@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 the given template.

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

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

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

Renders template from module.

For a module called MyApp.FooHTML and template "index.html.heex", it will:

• First attempt to call MyApp.FooHTML.index(assigns)

• Then fallback to MyApp.FooHTML.render("index.html", assigns)

• Raise otherwise

It expects the HTML 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

Phoenix.Template.render(YourApp.UserView, "index", "html", name: "John Doe")
#=> {:safe, "Hello John Doe"}

Assigns

Assigns are meant to be user data that will be available in templates. However, there are keys under assigns that are specially handled by Phoenix, they are:

• :layout - tells Phoenix to wrap the rendered result in the given layout. See next section

Layouts

Templates can be rendered within other templates using the :layout option. :layout accepts a tuple of the form {LayoutModule, "template.extension"}.

To template that goes inside the layout will be placed in the @inner_content assign:

<%= @inner_content %>

Renders the template and returns iodata.

Renders the template to string.