chore: add render_template with jinja-like syntax

[Jcharis]

Type of PR

• Add render_template() and render_html() to render data passed from backend to frontend html files
• Utilize Julia code in html

[ndortega]

Hi @Jcharis,

Thanks for the PR! I like the idea and decided to approach this with a different interface to mustache and oteraengine. The primary reason is that these functions have to load the template every time they are rendered. In most cases, templates don't change at runtime so we can store the template files in memory and reuse them as needed.

Here are the different function signatures of the mustache helper function. Together they can handle strings, files and the native mustache templates. These helper functions can also autodetect mime types so we can use mustache to template any kind of file and return it with the correct headers.

function mustache(template::String; kwargs...)
function mustache(tokens::Mustache.MustacheTokens; kwargs...)
function mustache(file::IO; mime_type=nothing, kwargs...)

Here's a simple example of how to use it

using Oxygen

# define our template
mustache_template_str = """
Hello {{name}}
You have just won {{value}} dollars!
{{#in_ca}}
Well, {{taxed_value}} dollars, after taxes.
{{/in_ca}}
"""

# load the template and provide a helper function to create the HTML Response
# (the name of this variable doesn't matter)
render = mustache(mustache_template_str)

@get "/mustache/string" function()
  data = Dict(
      "name" => "Chris",
      "value" => 10000,
      "taxed_value" => 10000 - (10000 * 0.4),
      "in_ca" => true
  )
  # render this template with our data and return an HTML.Response 
  return render(data)
end

Here's the mustache helper function that handles string templates and filepaths. it will pass off any files to the mustache function that deals with files explicitly

"""
    mustache(template::String; kwargs...)

Create a function that renders a Mustache `template` string with the provided `kwargs`.
If `template` is a file path, it reads the file content as the template string.
Returns a function that takes a dictionary `data`, optional `status`, and `headers`, and
returns an HTTP Response object with the rendered content.
"""
function mustache(template::String; kwargs...)
    # Case 1: a path to a file was passed
    if isfile(template)
        # deterime the mime type based on the extension type 
        content_type = mime_from_path(template, MIME"application/octet-stream"()) |> contenttype_from_mime
        return mustache(open(template); mime_type=content_type, kwargs...)
    end

    # Case 2: A string template was passed directly
    return function(data::AbstractDict; status=200, headers=[])
        content = Mustache.render(template, data; kwargs...)
        response(content, status, headers)
    end
end

What do you think?

[Jcharis]

Hi @ndortega, thanks for the reply and the feedback. I like your approach,
I did not consider that in most cases the templates don't change at runtime, so I think we can use your implementation

[ndortega]

closing this pr to replace it for #132