feat!: pass assigns to post/page extension rendering (#102)

This allows you to use dynamic data in your content files if your
converter supports it.

Closes #99

  BREAKING-CHANGE: Posts no longer fallback to the first <h1> tag as the
  title of the post

Author: mhanberg

lib/tableau/converter.ex

@@ -8,6 +8,6 @@ defmodule Tableau.Converter do
 
   Is given the file path, the content of the files (sans front matter), the front matter, and a list of options.
   """
-  @callback convert(filepath :: String.t(), content :: String.t(), front_matter :: map(), opts :: Keyword.t()) ::
+  @callback convert(filepath :: String.t(), front_matter :: map(), content :: String.t(), opts :: Keyword.t()) ::
               String.t()
 end

lib/tableau/converters/mdex_converter.ex

@@ -2,7 +2,7 @@ defmodule Tableau.MDExConverter do
   @moduledoc """
   Converter to parse markdown content with `MDEx`
   """
-  def convert(_filepath, body, _front_matter, _opts) do
+  def convert(_filepath, _front_matter, body, _opts) do
     {:ok, config} = Tableau.Config.get()
 
     MDEx.to_html!(body, config.markdown[:mdex])

lib/tableau/extensions/common.ex

@@ -5,14 +5,11 @@ defmodule Tableau.Extension.Common do
     wildcard |> Path.wildcard() |> Enum.sort()
   end
 
-  def entries(paths, builder, opts) do
+  def entries(paths, callback) do
     for path <- paths do
       {front_matter, body} = Tableau.YamlFrontMatter.parse!(File.read!(path), atoms: true)
       "." <> ext = Path.extname(path)
-      converter = opts[:converters][String.to_atom(ext)]
-      body = converter.convert(path, body, front_matter, opts)
-
-      builder.build(path, front_matter, body)
+      callback.(%{path: path, ext: String.to_atom(ext), front_matter: front_matter, pre_convert_body: body})
     end
   end
 end

lib/tableau/extensions/page_extension.ex

@@ -1,6 +1,6 @@
 defmodule Tableau.PageExtension do
   @moduledoc """
-  Markdown files (with YAML frontmatter) in the configured pages directory will be automatically compiled into Tableau pages.
+  Content files (with YAML frontmatter) in the configured pages directory will be automatically compiled into Tableau pages.
 
   Certain frontmatter keys are required and all keys are passed as options to the `Tableau.Page`.
 
@@ -44,7 +44,7 @@ defmodule Tableau.PageExtension do
     layout: "MyApp.PageLayout"
   ```
 
-  ## Other markup formats
+  ## Content formats
 
   If you're interested in authoring your content in something other than markdown (or you want to use a different markdown parser), you can configure
   a converter for your format in the global configuration.
@@ -63,20 +63,39 @@ defmodule Tableau.PageExtension do
 
   use Tableau.Extension, key: :pages, type: :pre_build, priority: 100
 
+  alias Tableau.Extension.Common
+  alias Tableau.PageExtension.Page
+
+  @config Map.new(Application.compile_env(:tableau, Tableau.PageExtension, %{}))
+
   def run(token) do
-    pages = Tableau.PageExtension.Pages.pages()
+    {:ok, config} = Tableau.PageExtension.Config.new(@config)
+
+    {:ok, %{converters: converters}} = Tableau.Config.get()
+
+    exts = Enum.map_join(converters, ",", fn {ext, _} -> to_string(ext) end)
+
+    pages =
+      config.dir
+      |> Path.join("**/*.{#{exts}}")
+      |> Common.paths()
+      |> Common.entries(fn %{path: path, ext: ext, front_matter: front_matter, pre_convert_body: pre_convert_body} ->
+        renderer = fn assigns -> converters[ext].convert(path, front_matter, pre_convert_body, assigns) end
+
+        {Page.build(path, front_matter, pre_convert_body), renderer}
+      end)
 
     graph =
       Tableau.Graph.insert(
         token.graph,
-        Enum.map(pages, fn page ->
-          %Tableau.Page{parent: page.layout, permalink: page.permalink, template: page.body, opts: page}
+        Enum.map(pages, fn {page, renderer} ->
+          %Tableau.Page{parent: page.layout, permalink: page.permalink, template: renderer, opts: page}
         end)
       )
 
     {:ok,
      token
-     |> Map.put(:pages, pages)
+     |> Map.put(:pages, pages |> Enum.unzip() |> elem(0))
      |> Map.put(:graph, graph)}
   end
 end

lib/tableau/extensions/page_extension/page.ex

@@ -0,0 +1,45 @@
+defmodule Tableau.PageExtension.Page do
+  @moduledoc false
+  def build(filename, front_matter, body) do
+    {:ok, page_config} =
+      Tableau.PageExtension.Config.new(Map.new(Application.get_env(:tableau, Tableau.PageExtension, %{})))
+
+    front_matter
+    |> Map.put(:__tableau_page_extension__, true)
+    |> Map.put(:body, body)
+    |> Map.put(:file, filename)
+    |> Map.put(:layout, Module.concat([front_matter.layout || page_config.layout]))
+    |> build_permalink(page_config)
+  end
+
+  defp build_permalink(%{permalink: permalink} = front_matter, _config) do
+    permalink
+    |> transform_permalink(front_matter)
+    |> then(&Map.put(front_matter, :permalink, &1))
+  end
+
+  defp build_permalink(front_matter, %{permalink: permalink}) when not is_nil(permalink) do
+    permalink
+    |> transform_permalink(front_matter)
+    |> then(&Map.put(front_matter, :permalink, &1))
+  end
+
+  defp build_permalink(%{file: filename} = front_matter, config) do
+    filename
+    |> Path.rootname()
+    |> String.replace_prefix(config.dir, "")
+    |> transform_permalink(front_matter)
+    |> then(&Map.put(front_matter, :permalink, &1))
+  end
+
+  defp transform_permalink(path, front_matter) do
+    vars = Map.new(front_matter, fn {k, v} -> {":#{k}", v} end)
+
+    path
+    |> String.replace(Map.keys(vars), &to_string(Map.fetch!(vars, &1)))
+    |> String.replace(" ", "-")
+    |> String.replace("_", "-")
+    |> String.replace(~r/[^[:alnum:]\/\-.]/, "")
+    |> String.downcase()
+  end
+end

lib/tableau/extensions/page_extension/pages.ex

@@ -1,14 +1,14 @@
 defmodule Tableau.PostExtension do
   @moduledoc """
-  Markdown files (with YAML frontmatter) in the configured posts directory will be automatically compiled into Tableau pages.
+  Content files (with YAML frontmatter) in the configured posts directory will be automatically compiled into Tableau pages.
 
   Certain frontmatter keys are required and all keys are passed as options to the `Tableau.Page`.
 
   ## Options
 
   Frontmatter is compiled with `yaml_elixir` and all keys are converted to atoms.
 
-  * `:title` - The title of the post. Falls back to the first `<h1>` tag if present in the body.
+  * `:title` - The title of the post.
   * `:permalink` - The permalink of the post. `:title` will be replaced with the posts title and non alphanumeric characters removed. Optional.
   * `:date` - A string representation of an Elixir `NaiveDateTime`, often presented as a `sigil_N`. This will be converted to your configured timezone.
   * `:layout` - A string representation of a Tableau layout module.
@@ -51,7 +51,7 @@ defmodule Tableau.PostExtension do
   ```
 
 
-  ## Other markup formats
+  ## Content formats
 
   If you're interested in authoring your content in something other than markdown (or you want to use a different markdown parser), you can configure
   a converter for your format in the global configuration.
@@ -70,20 +70,46 @@ defmodule Tableau.PostExtension do
 
   use Tableau.Extension, key: :posts, type: :pre_build, priority: 100
 
+  alias Tableau.Extension.Common
+  alias Tableau.PostExtension.Post
+
+  @config Map.new(Application.compile_env(:tableau, Tableau.PostExtension, %{}))
+
   def run(token) do
-    posts = Tableau.PostExtension.Posts.posts()
+    {:ok, config} = Tableau.PostExtension.Config.new(@config)
+
+    {:ok, %{converters: converters}} = Tableau.Config.get()
+
+    exts = Enum.map_join(converters, ",", fn {ext, _} -> to_string(ext) end)
+
+    posts =
+      config.dir
+      |> Path.join("**/*.{#{exts}}")
+      |> Common.paths()
+      |> Common.entries(fn %{path: path, ext: ext, front_matter: front_matter, pre_convert_body: pre_convert_body} ->
+        renderer = fn assigns -> converters[ext].convert(path, front_matter, pre_convert_body, assigns) end
+
+        {Post.build(path, front_matter, pre_convert_body), renderer}
+      end)
+      |> then(fn posts ->
+        if config.future do
+          posts
+        else
+          Enum.reject(posts, fn {post, _} -> DateTime.after?(post.date, DateTime.utc_now()) end)
+        end
+      end)
 
     graph =
       Tableau.Graph.insert(
         token.graph,
-        Enum.map(posts, fn post ->
-          %Tableau.Page{parent: post.layout, permalink: post.permalink, template: post.body, opts: post}
+        Enum.map(posts, fn {post, renderer} ->
+          %Tableau.Page{parent: post.layout, permalink: post.permalink, template: renderer, opts: post}
         end)
       )
 
     {:ok,
      token
-     |> Map.put(:posts, posts)
+     |> Map.put(:posts, posts |> Enum.unzip() |> elem(0))
      |> Map.put(:graph, graph)}
   end
 end

lib/tableau/extensions/page_extension/pages/page.ex

@@ -1,4 +1,4 @@
-defmodule Tableau.PostExtension.Posts.Post do
+defmodule Tableau.PostExtension.Post do
   @moduledoc false
   def build(filename, attrs, body) do
     {:ok, post_config} =

lib/tableau/extensions/post_extension.ex

@@ -0,0 +1,8 @@
+defmodule Tableau.LazyPage do
+  @moduledoc false
+  defstruct [:handler]
+
+  def run(lazy_page, assigns) do
+    lazy_page.handler.(assigns)
+  end
+end

lib/tableau/extensions/post_extension/posts/post.ex lib/tableau/extensions/post_extension/post.ex

@@ -32,7 +32,10 @@ defmodule Tableau.Page do
   defstruct [:parent, :permalink, :template, :opts]
 
   defimpl Tableau.Graph.Nodable do
-    def template(nodable, _assigns), do: nodable.template
+    def template(nodable, assigns) do
+      nodable.template.(assigns)
+    end
+
     def type(_nodable), do: {:ok, :page}
     def parent(nodable), do: {:ok, nodable.parent}
     def opts(nodable), do: nodable.opts

lib/tableau/extensions/post_extension/posts.ex

@@ -1,7 +1,7 @@
-defmodule Tableau.PostExtension.Posts.PostTest do
+defmodule Tableau.PostExtension.PostTest do
   use ExUnit.Case, async: true
 
-  alias Tableau.PostExtension.Posts.Post
+  alias Tableau.PostExtension.Post
 
   describe "build/3" do
     test "substitutes arbitrary front matter into permalink" do