Accept function as custom_filters (#182)

Author: drtheuns-enreach

README.md

@@ -96,6 +96,31 @@ end
 # 42
 ```
 
+Alternatively, you can pass a function to the `custom_filters` option. This allows
+your filters to access predefined state. An example use-case could be to allow the
+filters to render strings in the user's default locale (or to override it by
+argument).
+
+``` elixir
+user_locale = "en"
+
+"{{ number | format_number }}"
+|> Solid.parse!()
+|> Solid.render!(%{ "number" => 41}, custom_filters: fn
+  "format_number", [num] ->
+    {:ok, Cldr.Number.to_string(num, locale: user_locale)}
+
+  "format_number", [num, locale] ->
+    {:ok, Cldr.Number.to_string(num, locale: locale)}
+
+  _, _ ->
+    :error
+end)
+|> IO.puts()
+```
+
+The callback must return either `{:ok, value}` or `:error`.
+
 ## Strict rendering
 
 If there are any missing variables/filters and `strict_variables: true` or `strict_filters: true` are passed as options `Solid.render/3` returns `{:error, errors, result}` where errors is the list of collected errors and `result` is the rendered template.

lib/solid.ex

@@ -129,7 +129,7 @@ defmodule Solid do
 
   - `file_system`: a tuple of {FileSystemModule, options}. If this option is not specified, `Solid` uses `Solid.BlankFileSystem` which returns an error when the `render` tag is used. `Solid.LocalFileSystem` can be used or a custom module may be implemented. See `Solid.FileSystem` for more details.
 
-  - `custom_filters`: a module name where additional filters are defined. The base filters (those from `Solid.StandardFilter`) still can be used, however, custom filters always take precedence.
+  - `custom_filters`: a module name where additional filters are defined. The base filters (those from `Solid.StandardFilter`) still can be used, however, custom filters always take precedence. May also be a function that receives the filter name and the arguments and must return `{:ok, term} | :error`.
 
   - `strict_variables`: if `true`, it collects an error when a variable is referenced in the template, but not given in the map
 

lib/solid/standard_filter.ex

@@ -10,12 +10,12 @@ defmodule Solid.StandardFilter do
   @spec apply(String.t(), list(), Solid.Parser.Loc.t(), keyword()) ::
           {:ok, any()} | {:error, Exception.t(), any()} | {:error, Exception.t()}
   def apply(filter, args, loc, opts) do
-    custom_module =
+    custom_module_or_callback =
       opts[:custom_filters] || Application.get_env(:solid, :custom_filters, __MODULE__)
 
     strict_filters = Keyword.get(opts, :strict_filters, false)
 
-    with :error <- apply_filter(custom_module, filter, args, loc),
+    with :error <- apply_filter(custom_module_or_callback, filter, args, loc),
          :error <- apply_filter(__MODULE__, filter, args, loc) do
       if strict_filters do
         {:error, %Solid.UndefinedFilterError{loc: loc, filter: filter}, List.first(args)}
@@ -43,9 +43,13 @@ defmodule Solid.StandardFilter do
     end
   end
 
-  defp apply_filter(mod, func, args, loc) do
-    func = String.to_existing_atom(func)
-    {:ok, Kernel.apply(mod, func, args)}
+  defp apply_filter(mod_or_callback, func, args, loc) do
+    if is_function(mod_or_callback, 2) do
+      mod_or_callback.(func, args)
+    else
+      func = String.to_existing_atom(func)
+      {:ok, Kernel.apply(mod_or_callback, func, args)}
+    end
   rescue
     # Unknown function name atom or unknown function -> fallback
     ArgumentError ->
@@ -56,7 +60,7 @@ defmodule Solid.StandardFilter do
       {:error, %{e | loc: loc}}
 
     UndefinedFunctionError ->
-      find_correct_function(mod, String.to_existing_atom(func), Enum.count(args), loc)
+      find_correct_function(mod_or_callback, String.to_existing_atom(func), Enum.count(args), loc)
   end
 
   @doc """

test/solid/standard_filter_test.exs

@@ -45,4 +45,31 @@ defmodule Solid.StandardFilterTest do
                }
     end
   end
+
+  test "it applies a function as custom filter" do
+    user_locale = "en"
+
+    custom_filters = fn
+      "format_number", [num] ->
+        {:ok, "#{user_locale}: #{num}"}
+
+      "format_number", [num, locale] ->
+        {:ok, "#{locale}: #{num}"}
+
+      _, _ ->
+        :error
+    end
+
+    assert "en: 41" ==
+             "{{ number | format_number }}"
+             |> Solid.parse!()
+             |> Solid.render!(%{"number" => 41}, custom_filters: custom_filters)
+             |> to_string()
+
+    assert "fr: 41" ==
+             "{{ number | format_number: 'fr' }}"
+             |> Solid.parse!()
+             |> Solid.render!(%{"number" => 41}, custom_filters: custom_filters)
+             |> to_string()
+  end
 end