Initial commit

Author: edgurgel

.gitignore

@@ -0,0 +1,6 @@
+/_build
+/cover
+/deps
+erl_crash.dump
+*.ez
+/src/solid_parser.erl

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Eduardo Gurgel Pinho
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,35 @@
+# Solid
+
+Solid is an implementation in Elixir of the template engine Liquid. It uses [neotoma](https://github.com/seancribbs/neotoma) to generate the parser.
+
+## Basic Usage
+
+```elixir
+iex> template = "My name is {{ user.name }}"
+iex> Solid.parse(template) |> Solid.render(%{ "user" => %{ "name" => "José" } }) |> to_string
+"My name is José"
+```
+
+## Installation
+
+The package can be installed as:
+
+  1. Add solid to your list of dependencies in `mix.exs`:
+
+        def deps do
+          [{:solid, "~> 0.0.1"}]
+        end
+
+  2. Ensure solid is started before your application:
+
+        def application do
+          [applications: [:solid]]
+        end
+
+## TODO
+
+* [ ] Integration tests using Liquid gem to build fixtures;
+* [ ] All the standard filters
+* [ ] Tags (if, case, unless, etc)
+* [ ] Boolean operators
+* [ ] Whitespace control

lib/solid.ex

@@ -0,0 +1,45 @@
+defmodule Solid do
+  @moduledoc """
+  Main module to interact with Solid
+
+  iex> Solid.parse("{{ variable }}") |> Solid.render(%{ "variable" => "value" }) |> to_string
+  "value"
+  """
+  alias Solid.{Argument, Filter}
+
+  @doc """
+  It generates the compiled template
+  """
+  @spec parse(String.t) :: any
+  def parse(text) do
+    :solid_parser.parse(text)
+  end
+
+  @doc """
+  It renders the compiled template using a `hash` with variables
+  """
+  @spec render(any, Map.t) :: iolist
+  def render({:text, text} = template, hash \\ %{}) do
+    case text do
+      [{:string, string} | tail] -> [string | render_liquid(hd(tail), hash)]
+    end
+  end
+
+  def render_liquid([], _hash), do: []
+  def render_liquid(liquid, hash) when is_list(liquid) do
+    argument = get_in(liquid, [:liquid, :argument])
+    value    = Argument.get(argument, hash)
+
+    filters = get_in(liquid, [:liquid, :filters])
+    value  = value |> apply_filters(filters, hash)
+
+    [to_string(value) | render(liquid[:text], hash)]
+  end
+
+  defp apply_filters(input, nil, _), do: input
+  defp apply_filters(input, [], _), do: input
+  defp apply_filters(input, [{filter, args} | filters], hash) do
+    values = for arg <- args, do: Argument.get(arg, hash)
+    apply(Filter, String.to_existing_atom(filter), [input | values]) |> apply_filters(filters, hash)
+  end
+end

lib/solid/argument.ex

@@ -0,0 +1,7 @@
+defmodule Solid.Argument do
+  def get({:field, key}, hash) do
+    key = key |> String.split(".")
+    get_in(hash, key)
+  end
+  def get({:value, val}, _hash), do: val
+end

lib/solid/filter.ex

@@ -0,0 +1,16 @@
+defmodule Solid.Filter do
+  @moduledoc """
+  Standard filters
+  """
+
+  def default(nil, value), do: value
+  def default(input, _), do: input
+
+  def upcase(input), do: input |> to_string |> String.upcase
+
+  def downcase(input), do: input |> to_string |> String.downcase
+
+  def replace(input, string, replacement \\ "") do
+    input |> to_string |> String.replace(string, replacement)
+  end
+end

mix.exs

@@ -0,0 +1,39 @@
+defmodule Solid.Mixfile do
+  use Mix.Project
+
+  @description """
+    Liquid Template engine
+  """
+
+  @compile_peg_task "tasks/compile.peg.exs"
+  Code.eval_file @compile_peg_task
+
+  def project do
+    [app: :solid,
+     version: "0.0.1",
+     elixir: "~> 1.3",
+     build_embedded: Mix.env == :prod,
+     start_permanent: Mix.env == :prod,
+     compilers: [:peg, :erlang, :elixir, :app],
+     name: "solid",
+     description: @description,
+     package: package,
+     deps: deps]
+  end
+
+  def application do
+    [applications: []]
+  end
+
+  defp deps do
+    [{:neotoma, "~> 1.7.3"},
+     {:earmark, "~> 1.0", only: :dev},
+     {:ex_doc, "~> 0.13", only: :dev}]
+  end
+
+  defp package do
+    [ maintainers: ["Eduardo Gurgel Pinho"],
+      licenses: ["MIT"],
+      links: %{"Github" => "https://github.com/edgurgel/solid"} ]
+  end
+end

mix.lock

@@ -0,0 +1,3 @@
+%{"earmark": {:hex, :earmark, "1.0.1", "2c2cd903bfdc3de3f189bd9a8d4569a075b88a8981ded9a0d95672f6e2b63141", [:mix], []},
+  "ex_doc": {:hex, :ex_doc, "0.13.0", "aa2f8fe4c6136a2f7cfc0a7e06805f82530e91df00e2bff4b4362002b43ada65", [:mix], [{:earmark, "~> 1.0", [hex: :earmark, optional: false]}]},
+  "neotoma": {:hex, :neotoma, "1.7.3", "d8bd5404b73273989946e4f4f6d529e5c2088f5fa1ca790b4dbe81f4be408e61", [:rebar], []}}

src/solid_parser.peg

@@ -0,0 +1,50 @@
+text   <- string:blob (liquid:liquid text:text)? `{text, Node}`;
+blob   <- ((!open_block .)*) ~;
+liquid <- open_block:open_block space (argument:argument filters:filters / argument:argument)? space close_block:close_block `
+case Node of
+  [_, _, Block, _, _] -> lists:flatten([Block])
+end
+`;
+filters <- (space "|" space filter (":" space arguments)? )+`
+[case N of
+  [_, _, _, Filter, [_, _, Args]] -> {Filter, Args};
+  [_, _, _, Filter, _] -> {Filter, []}
+end || N <- Node]
+`;
+arguments <- argument (space "," space argument)* `
+case Node of
+  [Arg1, Args] -> [Arg1 | [Arg || [_, _, _, Arg] <- Args]]
+end
+`;
+argument <- value:value / field:field ~;
+value <- space (string / number / true / false / null) space `lists:nth(2, Node)`;
+
+%% Terminals
+
+open_block     <- "{{" ~;
+close_block    <- "}}" ~;
+field          <- [0-9a-zA-Z\.]* `iolist_to_binary(Node)`;
+filter         <- [a-zA-Z]* `iolist_to_binary(Node)`;
+space          <- [ \t\n\s\r]* `{space, iolist_to_binary(Node)}`;
+
+string <- '"' chars:(!'"' ("\\\\" / '\\"' / .))* '"' `
+iolist_to_binary(proplists:get_value(chars, Node))
+`;
+number <- int frac? exp?
+`
+case Node of
+  [Int, [], []] -> list_to_integer(binary_to_list(iolist_to_binary(Int)));
+  [Int, Frac, []] -> list_to_float(binary_to_list(iolist_to_binary([Int, Frac])));
+  [Int, [], Exp] -> list_to_float(binary_to_list(iolist_to_binary([Int, ".0", Exp])));
+  _ -> list_to_float(binary_to_list(iolist_to_binary(Node)))
+end
+`;
+int <- '-'? (non_zero_digit digit+) / digit ~;
+frac <- '.' digit+ ~;
+exp <- e digit+ ~;
+e <- [eE] ('+' / '-')? ~;
+non_zero_digit <- [1-9] ~;
+digit <- [0-9] ~;
+true <- 'true' `true`;
+false <- 'false' `false`;
+null <- 'nil' `nil`;

tasks/compile.peg.exs

@@ -0,0 +1,140 @@
+# Copyright (c) 2014 Paul Schoenfelder
+# From the conform library: https://github.com/bitwalker/conform
+defmodule Mix.Tasks.Compile.Peg do
+  @moduledoc """
+  Compiles Erlang Parsing Expression Grammars (PEGs).
+  """
+  @shortdoc "Compiles Erlang Parsing Expression Grammars (PEGs)."
+
+  use Mix.Task
+
+  @recursive     true
+  @manifest      ".compile.peg"
+
+  def run(_) do
+    manifest = load_manifest!()
+    get_sources()
+    |> Enum.filter(&(compile?(&1, manifest)))
+    |> Enum.map(&compile_peg/1)
+    |> Enum.reduce([], &build_manifest/2)
+    |> write_manifest!
+  end
+
+  def clean do
+    get_sources() |> Enum.map(&do_clean/1)
+  end
+
+  defp do_clean(source_path) do
+    erl = erl_source_path(source_path)
+    case File.exists?(erl) do
+      true  -> File.rm!(erl)
+      false -> :ok
+    end
+  end
+
+  defp get_sources,
+    do: Mix.Project.config[:erlc_paths] |> Mix.Utils.extract_files([:peg])
+
+  defp compile?(source_path, manifest) do
+    erl = source_path |> erl_source_path |> Path.expand
+    peg = source_path |> Path.expand
+    # If the compiled file doesn't exist, then compile
+    case File.exists?(erl) do
+      true ->
+        # If the manifest doesn't contain an entry for the peg file, then compile
+        case Map.get(manifest, source_path) do
+          nil -> true
+          last_compilation ->
+            # Otherwise, compare the modified time of the peg file against the
+            # last compilation time (in seconds) of that file, if modifications
+            # have been made, then compile
+            {:ok, %File.Stat{mtime: mtime}} = File.stat(peg)
+            :calendar.datetime_to_gregorian_seconds(mtime) > last_compilation
+        end
+      false -> true
+    end
+  end
+
+  defp compile_peg(source_path) do
+    peg           = Path.expand(source_path)
+    relative_path = Path.relative_to_cwd(source_path)
+    info "Compiling #{relative_path}"
+    case :neotoma.file('#{peg}') do
+      :ok -> :ok
+      {:error, reason} ->
+        error "Failed to compile #{relative_path}: #{reason}"
+        exit(:normal)
+    end
+    case File.stat(peg) do
+      {:ok, %File.Stat{mtime: last_compilation}} ->
+        {source_path, last_compilation |> :calendar.datetime_to_gregorian_seconds}
+      {:error, :enoent} ->
+        error "Cannot stat #{relative_path}!"
+        exit(:normal)
+    end
+  end
+
+  defp build_manifest({source_path, compilation_time}, manifest) do
+    [<<source_path :: binary, ?\t, ?\t, "#{compilation_time}" :: binary>> | manifest]
+  end
+
+  defp write_manifest!([]), do: :ok
+  defp write_manifest!(manifest) when is_list(manifest) do
+    serialized  = manifest |> Enum.join(<<?\n>>)
+    output_path = manifest_path()
+    case File.write!(output_path, serialized) do
+      :ok              -> info "PEG manifest updated"
+      {:error, reason} -> error "Unable to save PEG manifest: #{reason}"
+    end
+  end
+
+  defp erl_source_path(source_path), do: String.replace(source_path, ".peg", ".erl")
+  defp manifest_path, do: Mix.Project.app_path |> Path.join(@manifest) |> Path.expand
+
+  defp load_manifest! do
+    manifest = manifest_path()
+    case File.exists?(manifest_path()) do
+      true  ->
+        # Create resource from manifest
+        res = Stream.resource(
+          fn -> File.open!(manifest) end,
+          fn file ->
+            case IO.read(file, :line) do
+              data when is_binary(data) -> {[data], file}
+              _ -> {:halt, file}
+            end
+          end,
+          fn file -> File.close(file) end
+        )
+        # For each line in the manifest, split on \t, where the
+        # first part is the source file path, and the second part
+        # is the time at which that file was last compiled
+        res
+        |> Stream.map(fn line ->
+          case line |> String.split(<<?\t, ?\t>>, [parts: 2, trim: true]) do
+            [path, mtime] ->
+              {mtime, _} = Integer.parse(mtime)
+              {path, mtime}
+            _ ->
+              nil
+          end
+        end)
+        |> Stream.filter(fn meta -> meta != nil end)
+        |> Enum.into(%{})
+      false ->
+        %{}
+    end
+  end
+
+  defp info(message),  do: print(message)
+  defp error(message), do: print(message, IO.ANSI.red)
+  defp print(message, color \\ nil) do
+    has_colors? = IO.ANSI.enabled?
+    cond do
+      color == nil -> message
+      has_colors?  -> color <> message <> IO.ANSI.reset
+      true         -> message
+    end |> IO.puts
+  end
+
+end