Added import and export tests

Author: bryanjos

lib/es_tree/tools/builder.ex

@@ -203,19 +203,6 @@ defmodule ESTree.Tools.Builder do
     }
   end
 
-  @spec export_declaration(
-    ESTree.Declaration.t,
-    [ESTree.ExportSpecifier.t],
-    boolean,
-    ESTree.Identifier.t | nil,
-    ESTree.SourceLocation.t | nil
-  ) :: ESTree.ExportDeclaration.t
-  def export_declaration(declaration, specifiers \\ [], default \\ false, source \\ nil, loc \\ nil) do
-    %ESTree.ExportDeclaration{ 
-      declaration: declaration, specifiers: specifiers, default: default, source: source, loc: loc
-    }
-  end
-
   @spec export_default_declaration(
     ESTree.Declaration.t | ESTree.Expression.t | nil,                
     ESTree.SourceLocation.t | nil

lib/es_tree/tools/generator.ex

@@ -13,8 +13,6 @@ defmodule ESTree.Tools.Generator do
     :">>>=" , :"|=" , :"^=" , :"&=", :++, :--
   ]
 
-  @indent "    "
-
   @spec generate(ESTree.operator | ESTree.Node.t) :: binary
   def generate(operator) when operator in @operators do
     to_string(operator)
@@ -557,21 +555,21 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.ImportDeclaration{specifiers: [%ESTree.ImportDefaultSpecifier{}] = specifiers, source: source}) do
-    specifiers = Enum.map_join(specifiers, ",", &generate(&1))
+    specifiers = Enum.map_join(specifiers, ", ", &generate(&1))
     source = generate(source)
 
     "import #{specifiers} from #{source};"
   end
 
   def generate(%ESTree.ImportDeclaration{specifiers: [%ESTree.ImportNamespaceSpecifier{}] = specifiers, source: source}) do
-    specifiers = Enum.map_join(specifiers, ",", &generate(&1))
+    specifiers = Enum.map_join(specifiers, ", ", &generate(&1))
     source = generate(source)
 
     "import #{specifiers} from #{source};"
   end
 
   def generate(%ESTree.ImportDeclaration{specifiers: specifiers, source: source}) do
-    specifiers = Enum.map_join(specifiers, ",", &generate(&1))
+    specifiers = Enum.map_join(specifiers, ", ", &generate(&1))
     source = generate(source)
 
     "import { #{specifiers} } from #{source};"
@@ -610,27 +608,26 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.ExportNamedDeclaration{declaration: nil, specifiers: specifiers, source: nil} = ast) do
-    IO.inspect(ast)
-    specifiers = Enum.map_join(specifiers, ",", &generate(&1))
+    specifiers = Enum.map_join(specifiers, ", ", &generate(&1))
 
-    "export #{specifiers};"
+    "export { #{specifiers} };"
   end
 
   def generate(%ESTree.ExportNamedDeclaration{declaration: nil, specifiers: specifiers, source: source}) do
-    specifiers = Enum.map_join(specifiers, ",", &generate(&1))
+    specifiers = Enum.map_join(specifiers, ", ", &generate(&1))
     source = generate(source)
 
-    "export #{specifiers} from #{source};"
+    "export { #{specifiers} } from #{source};"
   end
 
   def generate(%ESTree.ExportSpecifier{local: local, exported: exported}) do
     local = generate(local)
     exported = generate(exported)
 
     if local == exported do
-      "{#{local}}"
+      "#{local}"
     else
-      "{#{exported} as #{local} }"
+      "#{exported} as #{local}"
     end
   end
 

test/tools/generator/export_declaration_test.exs

@@ -0,0 +1,61 @@
+defmodule ESTree.Tools.Generator.ExportDeclaration.Test do
+  use ShouldI
+  alias ESTree.Tools.Builder
+  alias ESTree.Tools.Generator
+
+  should "convert export named declaration with a declaration" do
+    ast = Builder.export_named_declaration(
+      Builder.identifier(:test)
+    )
+
+    assert Generator.generate(ast) == "export test;"  
+  end
+
+  should "convert export named declaration with one specifier" do
+    ast = Builder.export_named_declaration(nil, [
+      Builder.export_specifier(
+        Builder.identifier(:test),
+        Builder.identifier(:test)
+      )]
+    )
+
+    assert Generator.generate(ast) == "export { test };"  
+  end
+
+  should "convert export named declaration with one specifier with an alias" do
+    ast = Builder.export_named_declaration(nil, [
+      Builder.export_specifier(
+        Builder.identifier(:test),
+        Builder.identifier(:test1)
+      )]
+    )
+
+    assert Generator.generate(ast) == "export { test as test1 };"  
+  end
+
+  should "convert export declaration with more than one specifier" do
+    ast = Builder.export_named_declaration(nil,
+      [
+        Builder.export_specifier(
+          Builder.identifier(:top),
+          Builder.identifier(:top)
+        ),
+        Builder.export_specifier(
+          Builder.identifier(:test),
+          Builder.identifier(:test1)
+        )
+      ],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "export { top, test as test1 } from 'test';"  
+  end
+
+
+  should "convert export all declaration" do
+    ast = Builder.export_all_declaration(Builder.literal(:test))
+
+    assert Generator.generate(ast) == "export * from 'test';"  
+  end
+
+end

test/tools/generator/import_declaration_test.exs

@@ -0,0 +1,72 @@
+defmodule ESTree.Tools.Generator.ImportDeclaration.Test do
+  use ShouldI
+  alias ESTree.Tools.Builder
+  alias ESTree.Tools.Generator
+
+  should "convert import declaration with one specifier" do
+    ast = Builder.import_declaration([
+      Builder.import_specifier(
+        Builder.identifier(:test),
+        Builder.identifier(:test)
+      )],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "import { test } from 'test';"  
+  end
+
+  should "convert import declaration with one specifier with an alias" do
+    ast = Builder.import_declaration([
+      Builder.import_specifier(
+        Builder.identifier(:test),
+        Builder.identifier(:test1)
+      )],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "import { test as test1 } from 'test';"  
+  end
+
+  should "convert import declaration with more than one specifier" do
+    ast = Builder.import_declaration(
+      [
+        Builder.import_specifier(
+          Builder.identifier(:top),
+          Builder.identifier(:top)
+        ),
+        Builder.import_specifier(
+          Builder.identifier(:test),
+          Builder.identifier(:test1)
+        )
+      ],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "import { top, test as test1 } from 'test';"  
+  end
+
+
+  should "convert import declaration with one default specifier" do
+    ast = Builder.import_declaration([
+      Builder.import_default_specifier(
+        Builder.identifier(:test),
+        Builder.identifier(:test)
+      )],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "import test from 'test';"  
+  end
+
+  should "convert import declaration with a namespace specifier" do
+    ast = Builder.import_declaration([
+      Builder.import_namespace_specifier(
+        Builder.identifier(:test)
+      )],
+      Builder.literal(:test)
+    )
+
+    assert Generator.generate(ast) == "import * as test from 'test';"  
+  end
+
+end