Added generation of template literals

Author: bryanjos

lib/es_tree/template_element.ex

@@ -2,11 +2,11 @@ defmodule ESTree.TemplateElement do
   @type t :: %ESTree.TemplateElement{ 
     type: binary, 
     loc: ESTree.SourceLocation.t | nil,
-    value: %{cooked: binary, raw: binary},
+    value: %{cooked: binary, value: binary},
     tail: boolean
   }
   defstruct type: "TemplateElement", 
             loc: nil,
-            value: %{cooked: "", binary: ""},
+            value: %{cooked: "", value: ""},
             tail: false
 end 

lib/es_tree/tools/builder.ex

@@ -643,9 +643,9 @@ defmodule ESTree.Tools.Builder do
     boolean,
     ESTree.SourceLocation.t | nil
   ) :: ESTree.TemplateElement.t
-  def template_element(cooked_value, raw_value, tail, loc \\ nil) do
+  def template_element(value, cooked_value, tail, loc \\ nil) do
     %ESTree.TemplateElement{ 
-      value: %{cooked: cooked_value, raw: raw_value}, tail: tail, loc: loc
+      value: %{cooked: cooked_value, value: value}, tail: tail, loc: loc
     }
   end
 

lib/es_tree/tools/generator.ex

@@ -41,8 +41,7 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.Literal{value: value}) when is_binary(value) do
-    value = String.replace(value, "\n", "\\n")
-    |> String.replace("\t", "\\t")
+    value = convert_string_characters(value)
 
     "'#{value}'"
   end
@@ -645,6 +644,51 @@ defmodule ESTree.Tools.Generator do
     source = generate(source)
     "export * from #{source};"
   end
+
+  def generate(%ESTree.TaggedTemplateExpression{tag: tag, quasi: quasi}) do
+    tag = generate(tag)
+    quasi = generate(quasi)
+
+    "#{tag} #{quasi}"
+  end
+
+  def generate(%ESTree.TemplateLiteral{expressions: [], quasis: []}) do
+    "``"
+  end
+
+  def generate(%ESTree.TemplateLiteral{expressions: [expression], quasis: []}) do
+    expression = generate(expression)
+    "`${#{expression}}`"
+  end
+
+  def generate(%ESTree.TemplateLiteral{expressions: [], quasis: [quasi]}) do
+    quasi = convert_string_characters(quasi.value.value)
+    "`#{quasi}`"
+  end
+
+  def generate(%ESTree.TemplateLiteral{expressions: expressions, quasis: quasis}) do
+    elements = expressions ++ quasis
+
+    literal = Enum.sort(elements, fn(one, two) ->
+      one.loc.start.column < two.loc.start.column
+    end)
+    |> Enum.reduce("", fn(el, str) ->
+      case el do
+        %ESTree.TemplateElement{} ->
+          str <> convert_string_characters(el.value.value)
+        _ ->
+          str <> "${#{generate(el)}}"
+      end
+    end)
+
+
+    "`#{literal}`"
+  end
+
+  defp convert_string_characters(str) do
+    String.replace(str, "\n", "\\n")
+        |> String.replace("\t", "\\t")
+  end
 
   defp params_and_defaults(params, []) do
     Enum.map_join(params, ",", &generate(&1))

test/tools/generator/template_literal_test.exs

@@ -0,0 +1,105 @@
+defmodule ESTree.Tools.Generator.TemplateLiteral.Test do
+  use ShouldI
+  alias ESTree.Tools.Builder
+  alias ESTree.Tools.Generator
+
+
+  should "convert empty template literal" do
+    ast = Builder.template_literal([],[])
+    assert Generator.generate(ast) == "``" 
+  end
+
+  should "convert template literal with no expressions" do
+    ast = Builder.template_literal([
+      Builder.template_element("hello ", "hello ", false, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 1),
+          Builder.position(0, 5)
+        )
+      ),
+      Builder.template_element("there", "there", true, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 5),
+          Builder.position(0, 10)
+        )
+      )
+    ],[])
+    assert Generator.generate(ast) == "`hello there`" 
+  end
+
+  should "convert template literal with no quasis" do
+    ast = Builder.template_literal([],[
+      Builder.identifier(:a, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 1),
+          Builder.position(0, 2)
+        )
+      )
+    ])
+    assert Generator.generate(ast) == "`${a}`" 
+  end
+
+
+  should "convert template literal with interlaping quasis and expressions" do
+    ast = Builder.template_literal([
+      Builder.template_element("hello ", "hello ", false, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 1),
+          Builder.position(0, 5)
+        )
+      ),
+      Builder.template_element(" there", " there", true, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 6),
+          Builder.position(0, 12)
+        )
+      )
+      ],[
+      Builder.identifier(:a, 
+        Builder.source_location(
+          nil,
+          Builder.position(0, 5),
+          Builder.position(0, 6)
+        )
+      )
+    ])
+    assert Generator.generate(ast) == "`hello ${a} there`" 
+  end
+
+  should "convert tagged template expressions" do
+    ast = Builder.tagged_template_expression(
+      Builder.identifier(:tag),
+      Builder.template_literal([
+            Builder.template_element("hello ", "hello ", false, 
+              Builder.source_location(
+                nil,
+                Builder.position(0, 1),
+                Builder.position(0, 5)
+              )
+            ),
+            Builder.template_element(" there", " there", true, 
+              Builder.source_location(
+                nil,
+                Builder.position(0, 6),
+                Builder.position(0, 12)
+              )
+            )
+            ],[
+            Builder.identifier(:a, 
+              Builder.source_location(
+                nil,
+                Builder.position(0, 5),
+                Builder.position(0, 6)
+              )
+            )
+          ])
+    )
+    assert Generator.generate(ast) == "tag `hello ${a} there`" 
+  end
+
+end