perf: speed up page and post extensions (#64)

mhanberg · web-flow · commit 357d0f9b2fb4 · 2024-01-07T13:21:38.000-05:00
Closes #48
diff --git a/lib/mix/tasks/tableau.build.ex b/lib/mix/tasks/tableau.build.ex
@@ -52,11 +52,12 @@ defmodule Mix.Tasks.Tableau.Build do
 
     mods = :code.all_available()
     graph = Tableau.Graph.new(mods)
+
     File.mkdir_p!(out)
 
     pages =
-      for mod <- Graph.vertices(graph), {:ok, :page} == Tableau.Graph.Node.type(mod) do
-        {mod, Map.new(mod.__tableau_opts__() || [])}
+      for mod <- Graph.vertices(graph), {:ok, :page} == Tableau.Graph.Nodable.type(mod) do
+        {mod, Map.new(Tableau.Graph.Nodable.opts(mod) || [])}
       end
 
     {page_mods, pages} = Enum.unzip(pages)
@@ -65,7 +66,7 @@ defmodule Mix.Tasks.Tableau.Build do
 
     for mod <- page_mods do
       content = Tableau.Document.render(graph, mod, token)
-      permalink = mod.__tableau_permalink__()
+      permalink = Tableau.Graph.Nodable.permalink(mod)
       dir = Path.join(out, permalink)
 
       File.mkdir_p!(dir)
diff --git a/lib/tableau/document.ex b/lib/tableau/document.ex
@@ -11,7 +11,7 @@ defmodule Tableau.Document do
       quote do
         case unquote(inner_content) do
           [{module, page_assigns, assigns} | rest] ->
-            module.template(Map.merge(assigns, %{page: page_assigns, inner_content: rest}))
+            Tableau.Graph.Nodable.template(module, Map.merge(assigns, %{page: page_assigns, inner_content: rest}))
 
           [] ->
             nil
@@ -32,9 +32,9 @@ defmodule Tableau.Document do
           raise "Failed to find layout path for #{inspect(module)}"
       end
 
-    page_assigns = Map.new(module.__tableau_opts__() || [])
+    page_assigns = Map.new(Tableau.Graph.Nodable.opts(module) || [])
     mods = for mod <- mods, do: {mod, page_assigns, assigns}
 
-    root.template(Map.merge(assigns, %{inner_content: mods, page: page_assigns}))
+    Tableau.Graph.Nodable.template(root, Map.merge(assigns, %{inner_content: mods, page: page_assigns}))
   end
 end
diff --git a/lib/tableau/extensions/common.ex b/lib/tableau/extensions/common.ex
@@ -0,0 +1,35 @@
+defmodule Tableau.Extension.Common do
+  @moduledoc false
+
+  def paths(wildcard) do
+    wildcard |> Path.wildcard() |> Enum.sort()
+  end
+
+  def entries(paths, parser_module, builder, opts) do
+    Enum.flat_map(paths, fn path ->
+      parsed_contents = parse_contents!(path, File.read!(path), parser_module)
+      build_entry(builder, path, parsed_contents, opts)
+    end)
+  end
+
+  defp build_entry(builder, path, {_attrs, _body} = parsed_contents, opts) do
+    build_entry(builder, path, [parsed_contents], opts)
+  end
+
+  defp build_entry(builder, path, parsed_contents, opts) when is_list(parsed_contents) do
+    converter_module = Keyword.get(opts, :html_converter)
+
+    Enum.map(parsed_contents, fn {attrs, body} ->
+      body =
+        case converter_module do
+          module -> module.convert(path, body, attrs, opts)
+        end
+
+      builder.build(path, attrs, body)
+    end)
+  end
+
+  defp parse_contents!(path, contents, parser_module) do
+    parser_module.parse(path, contents)
+  end
+end
diff --git a/lib/tableau/extensions/page_extension.ex b/lib/tableau/extensions/page_extension.ex
@@ -47,64 +47,8 @@ defmodule Tableau.PageExtension do
 
   use Tableau.Extension, key: :pages, type: :pre_build, priority: 100
 
-  {:ok, config} =
-    Tableau.PageExtension.Config.new(Map.new(Application.compile_env(:tableau, Tableau.PageExtension, %{})))
-
-  @config config
-
   def run(token) do
-    :global.trans(
-      {:create_pages_module, make_ref()},
-      fn ->
-        Module.create(
-          Tableau.PageExtension.Pages,
-          quote do
-            use NimblePublisher,
-              build: __MODULE__.Page,
-              from: "#{unquote(@config.dir)}/**/*.md",
-              as: :pages,
-              parser: Tableau.PageExtension.Pages.Page,
-              html_converter: Tableau.PageExtension.Pages.HTMLConverter
-
-            def pages(_opts \\ []) do
-              @pages
-            end
-          end,
-          Macro.Env.location(__ENV__)
-        )
-
-        for {mod, _, _} <- :code.all_available(),
-            mod = Module.concat([to_string(mod)]),
-            {:ok, :page} == Tableau.Graph.Node.type(mod),
-            mod.__tableau_opts__()[:__tableau_page_extension__] do
-          :code.purge(mod)
-          :code.delete(mod)
-        end
-
-        pages =
-          for page <- apply(Tableau.PageExtension.Pages, :pages, []) do
-            {:module, _module, _binary, _term} =
-              [:"#{System.unique_integer()}"]
-              |> Module.concat()
-              |> Module.create(
-                quote do
-                  use Tableau.Page, unquote(Macro.escape(Keyword.new(page)))
-
-                  @external_resource unquote(page.file)
-                  def template(_assigns) do
-                    unquote(page.body)
-                  end
-                end,
-                Macro.Env.location(__ENV__)
-              )
-
-            page
-          end
-
-        {:ok, Map.put(token, :pages, pages)}
-      end,
-      [Node.self()],
-      :infinity
-    )
+    token = put_in(token.pages, Tableau.PageExtension.Pages.pages())
+    {:ok, token}
   end
 end
diff --git a/lib/tableau/extensions/page_extension/pages.ex b/lib/tableau/extensions/page_extension/pages.ex
@@ -0,0 +1,34 @@
+defmodule Tableau.PageExtension.Pages do
+  @moduledoc false
+  alias Tableau.Extension.Common
+
+  @config Map.new(Application.compile_env(:tableau, Tableau.PageExtension, %{}))
+
+  def __tableau_type__, do: :pages
+
+  def pages(opts \\ []) do
+    opts
+    |> pages2()
+    |> Enum.map(fn page ->
+      %{
+        type: :page,
+        parent: page.layout,
+        permalink: page.permalink,
+        template: page.body,
+        opts: page
+      }
+    end)
+  end
+
+  def pages2(opts \\ []) do
+    {:ok, config} =
+      Tableau.PageExtension.Config.new(@config)
+
+    opts = Keyword.put_new(opts, :html_converter, Tableau.PageExtension.Pages.HTMLConverter)
+
+    config.dir
+    |> Path.join("**/*.md")
+    |> Common.paths()
+    |> Common.entries(Tableau.PageExtension.Pages.Page, Tableau.PageExtension.Pages.Page, opts)
+  end
+end
diff --git a/lib/tableau/extensions/post_extension.ex b/lib/tableau/extensions/post_extension.ex
@@ -53,72 +53,8 @@ defmodule Tableau.PostExtension do
 
   use Tableau.Extension, key: :posts, type: :pre_build, priority: 100
 
-  {:ok, config} =
-    Tableau.PostExtension.Config.new(Map.new(Application.compile_env(:tableau, Tableau.PostExtension, %{})))
-
-  @config config
-
   def run(token) do
-    :global.trans(
-      {:create_posts_module, make_ref()},
-      fn ->
-        Module.create(
-          Tableau.PostExtension.Posts,
-          quote do
-            use NimblePublisher,
-              build: __MODULE__.Post,
-              from: "#{unquote(@config.dir)}/**/*.md",
-              as: :posts,
-              parser: Tableau.PostExtension.Posts.Post,
-              html_converter: Tableau.PostExtension.Posts.HTMLConverter
-
-            def posts(_opts \\ []) do
-              @posts
-              |> Enum.sort_by(& &1.date, {:desc, DateTime})
-              |> then(fn posts ->
-                if unquote(@config.future) do
-                  posts
-                else
-                  Enum.reject(posts, &DateTime.after?(&1.date, DateTime.utc_now()))
-                end
-              end)
-            end
-          end,
-          Macro.Env.location(__ENV__)
-        )
-
-        for {mod, _, _} <- :code.all_available(),
-            mod = Module.concat([to_string(mod)]),
-            {:ok, :page} == Tableau.Graph.Node.type(mod),
-            mod.__tableau_opts__()[:__tableau_post_extension__] do
-          :code.purge(mod)
-          :code.delete(mod)
-        end
-
-        posts =
-          for post <- apply(Tableau.PostExtension.Posts, :posts, []) do
-            {:module, _module, _binary, _term} =
-              [:"#{System.unique_integer()}"]
-              |> Module.concat()
-              |> Module.create(
-                quote do
-                  use Tableau.Page, unquote(Macro.escape(Keyword.new(post)))
-
-                  @external_resource unquote(post.file)
-                  def template(_assigns) do
-                    unquote(post.body)
-                  end
-                end,
-                Macro.Env.location(__ENV__)
-              )
-
-            post
-          end
-
-        {:ok, Map.put(token, :posts, posts)}
-      end,
-      [Node.self()],
-      :infinity
-    )
+    token = put_in(token.posts, Tableau.PostExtension.Posts.posts())
+    {:ok, token}
   end
 end
diff --git a/lib/tableau/extensions/post_extension/posts.ex b/lib/tableau/extensions/post_extension/posts.ex
@@ -0,0 +1,42 @@
+defmodule Tableau.PostExtension.Posts do
+  @moduledoc false
+  alias Tableau.Extension.Common
+
+  @config Map.new(Application.compile_env(:tableau, Tableau.PostExtension, %{}))
+
+  def __tableau_type__, do: :pages
+
+  def pages(opts \\ []) do
+    opts
+    |> posts()
+    |> Enum.map(fn post ->
+      %{
+        type: :page,
+        parent: post.layout,
+        permalink: post.permalink,
+        template: post.body,
+        opts: post
+      }
+    end)
+  end
+
+  def posts(opts \\ []) do
+    {:ok, config} =
+      Tableau.PostExtension.Config.new(@config)
+
+    opts = Keyword.put_new(opts, :html_converter, Tableau.PostExtension.Posts.HTMLConverter)
+
+    config.dir
+    |> Path.join("**/*.md")
+    |> Common.paths()
+    |> Common.entries(Tableau.PostExtension.Posts.Post, Tableau.PostExtension.Posts.Post, opts)
+    |> Enum.sort_by(& &1.date, {:desc, DateTime})
+    |> then(fn posts ->
+      if config.future do
+        posts
+      else
+        Enum.reject(posts, &DateTime.after?(&1.date, DateTime.utc_now()))
+      end
+    end)
+  end
+end
diff --git a/lib/tableau/graph.ex b/lib/tableau/graph.ex
@@ -10,8 +10,17 @@ defmodule Tableau.Graph do
         Node.type(mod) != :error,
         reduce: graph do
       graph ->
-        {:ok, parent} = Node.parent(mod)
-        Graph.add_edge(graph, mod, parent)
+        case Node.type(mod) do
+          {:ok, :pages} ->
+            for page <- mod.pages(), reduce: graph do
+              graph ->
+                Graph.add_edge(graph, page, page.parent)
+            end
+
+          _ ->
+            {:ok, parent} = Node.parent(mod)
+            Graph.add_edge(graph, mod, parent)
+        end
     end
   end
 end
diff --git a/lib/tableau/graph/nodable.ex b/lib/tableau/graph/nodable.ex
@@ -0,0 +1,21 @@
+defprotocol Tableau.Graph.Nodable do
+  @moduledoc false
+  def template(nodable, assigns)
+  def type(nodable)
+  def permalink(nodable)
+  def opts(nodable)
+end
+
+defimpl Tableau.Graph.Nodable, for: Map do
+  def template(nodable, _assigns), do: nodable.template
+  def type(nodable), do: {:ok, nodable.type}
+  def opts(nodable), do: nodable.opts
+  def permalink(nodable), do: nodable.permalink
+end
+
+defimpl Tableau.Graph.Nodable, for: Atom do
+  def template(nodable, assigns), do: nodable.template(assigns)
+  def type(nodable), do: Tableau.Graph.Node.type(nodable)
+  def opts(nodable), do: nodable.__tableau_opts__()
+  def permalink(nodable), do: nodable.__tableau_permalink__()
+end
