Added more tests, updated dependencies, fixed spec errors

Author: bryanjos

lib/es_tree.ex

@@ -18,4 +18,6 @@ defmodule ESTree do
                                 :"|=" | :"^=" | :"&="
 
   @type update_operator  ::  :++ | :--
+
+  @type operator :: unary_operator | binary_operator | logical_operator | assignment_operator | update_operator
 end

lib/es_tree/expression.ex

@@ -10,7 +10,6 @@ defmodule ESTree.Expression do
               ESTree.AssignmentExpression.t |
               ESTree.UpdateExpression.t |
               ESTree.LogicalExpression.t |
-              ESTree.ConditionalExpression.t |
               ESTree.NewExpression.t |
               ESTree.CallExpression.t |
               ESTree.MemberExpression.t |

lib/es_tree/statement.ex

@@ -17,5 +17,6 @@ defmodule ESTree.Statement do
               ESTree.ForInStatement.t |
               ESTree.ForOfStatement.t |
               ESTree.DebuggerStatement.t |
+              ESTree.ConditionalStatement.t |
               ESTree.Declaration.t
 end 

lib/es_tree/tools/builder.ex

@@ -205,7 +205,7 @@ defmodule ESTree.Tools.Builder do
 
   @spec export_declaration(
     ESTree.Declaration.t,
-    [ESTree.ExportSpecifier.t | ESTree.ExportBatchSpecifier.t],
+    [ESTree.ExportSpecifier.t],
     boolean,
     ESTree.Identifier.t | nil,
     ESTree.SourceLocation.t | nil
@@ -217,7 +217,7 @@ defmodule ESTree.Tools.Builder do
   end
 
   @spec export_default_declaration(
-    ESTree.Declaration.t | ESTree.Expression.t,                
+    ESTree.Declaration.t | ESTree.Expression.t | nil,                
     ESTree.SourceLocation.t | nil
   ) :: ESTree.ExportDefaultDeclaration.t
   def export_default_declaration(declaration \\ nil, loc \\ nil) do
@@ -526,7 +526,7 @@ defmodule ESTree.Tools.Builder do
     boolean,
     ESTree.SourceLocation.t | nil
   ) :: ESTree.Property.t
-  def property(key, value, kind \\ :init, method \\ false, shorthand \\ false, computed \\false, loc \\ nil) do
+  def property(key, value, kind \\ :init, shorthand \\ false, method \\ false, computed \\false, loc \\ nil) do
     %ESTree.Property{ 
       key: key, value: value,
       kind: kind, shorthand: shorthand, method: method,

lib/es_tree/tools/generator.ex

@@ -4,45 +4,20 @@ defmodule ESTree.Tools.Generator do
   it to JavaScript code
   """
 
-  @unary_operators [:-, :+ , :! , :"~" , :typeof , :void , :delete]
-  
-  @binary_operators [:== , :!= , :=== , :!== , :< , :<= , :> , :>= , 
-                            :"<<" , :">>" , :>>> , :+ , :- , :* , :/ , :% , :| , 
-                            :^ , :& , :in , :instanceof]
-
-  @logical_operators  [:|| , :&&]
-
-  @assignment_operators [:= , :"+=" , :"-=" , :"*=" , :"/=" ,
-                         :"%=" , :"<<=" , :">>=" , :">>>=" ,
-                         :"|=" , :"^=" , :"&="]
-
-  @update_operators [:++, :--]
+  @operators [
+    :-, :+ , :! , :"~" , :typeof , :void , :delete,
+    :== , :!= , :=== , :!== , :< , :<= , :> , :>= , 
+    :"<<" , :">>" , :>>> , :+ , :- , :* , :/ , :% , :| , 
+    :^ , :& , :in , :instanceof, :|| , :&&, := , :"+=" , 
+    :"-=" , :"*=" , :"/=" , :"%=" , :"<<=" , :">>=" , 
+    :">>>=" , :"|=" , :"^=" , :"&=", :++, :--
+  ]
 
   @indent "    "
 
-  @spec generate(ESTree.unary_operator | ESTree.binary_operator | ESTree.logical_operator | ESTree.assignment_operator | ESTree.update_operator | ESTree.Node.t) :: binary
-  def generate(unary_operator) when unary_operator in @unary_operators do
-    to_string(unary_operator)
-  end
-
-  def generate(binary_operator) when binary_operator in @binary_operators do
-    to_string(binary_operator)
-  end
-
-  def generate(logical_operator) when logical_operator in @logical_operators  do
-    to_string(logical_operator)
-  end
-
-  def generate(assignment_operator) when assignment_operator in @assignment_operators do
-    to_string(assignment_operator)
-  end
-
-  def generate(update_operator) when update_operator in @update_operators do
-    to_string(update_operator)
-  end
-
-  def generate(nil) do
-    ""
+  @spec generate(ESTree.operator | ESTree.Node.t) :: binary
+  def generate(operator) when operator in @operators do
+    to_string(operator)
   end
 
   def generate(%ESTree.Identifier{name: name}) do
@@ -85,11 +60,7 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.FunctionDeclaration{} = ast) do
-    generator = if ast.generator do
-      "*"
-    else
-      ""
-    end
+    generator = if ast.generator, do: "*", else: ""
 
     params = params_and_defaults(ast.params, ast.defaults)
     id = generate(ast.id)
@@ -98,11 +69,7 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.FunctionExpression{} = ast) do
-    generator = if ast.generator do
-      "*"
-    else
-      ""
-    end
+    generator = if ast.generator, do: "*", else: ""
     params = params_and_defaults(ast.params, ast.defaults)
 
     "function#{generator}(#{params})#{generate(ast.body)}"
@@ -195,7 +162,7 @@ defmodule ESTree.Tools.Generator do
   def generate(%ESTree.TryStatement{block: block, handler: handler, finalizer: finalizer}) do
     "try#{generate(block)}#{generate(handler)}finally#{generate(finalizer)}"
   end
-
+  
   def generate(%ESTree.WhileStatement{test: test, body: body}) do
     "while(#{generate(test)}) #{generate(body)}"
   end
@@ -252,15 +219,23 @@ defmodule ESTree.Tools.Generator do
   end
 
   def generate(%ESTree.ArrayExpression{elements: nil}) do
-    ""
+    "[]"
   end
 
   def generate(%ESTree.ArrayExpression{elements: elements}) do
-   "[" <> Enum.map_join(elements, ",", &generate(&1)) <> "]"
+   "[" <> Enum.map_join(elements, ", ", &generate(&1)) <> "]"
   end
 
+  def generate(%ESTree.ObjectExpression{properties: nil}) do
+   "{}"
+  end
+
+  def generate(%ESTree.ObjectExpression{properties: []}) do
+   "{}"
+  end
+  
   def generate(%ESTree.ObjectExpression{properties: properties}) do
-   "{" <> Enum.map_join(properties, ",", &generate(&1)) <> "}"
+   "{" <> Enum.map_join(properties, ", ", &generate(&1)) <> "}"
   end
 
   def generate(%ESTree.Property{key: key, value: value, kind: :init, shorthand: false, method: false, computed: false}) do
@@ -596,7 +571,7 @@ defmodule ESTree.Tools.Generator do
     "import #{specifiers} from #{source};"
   end
 
-  def generate(%ESTree.ImportDeclaration{specifiers: specifiers, source: source} = ast) do
+  def generate(%ESTree.ImportDeclaration{specifiers: specifiers, source: source}) do
     specifiers = Enum.map_join(specifiers, ",", &generate(&1))
     source = generate(source)
 

mix.exs

@@ -19,7 +19,7 @@ defmodule ESTree.Mixfile do
     [
       {:earmark, "~> 0.1", only: :dev},
       {:ex_doc, "~> 0.7", only: :dev},
-      {:dialyze, "~> 0.1.3", only: :dev},
+      {:dialyze, "~> 0.2", only: :dev},
       {:shouldi, only: :test}
     ]
   end

mix.lock

@@ -1,4 +1,4 @@
-%{"dialyze": {:hex, :dialyze, "0.1.3"},
-  "earmark": {:hex, :earmark, "0.1.13"},
-  "ex_doc": {:hex, :ex_doc, "0.7.1"},
+%{"dialyze": {:hex, :dialyze, "0.2.0"},
+  "earmark": {:hex, :earmark, "0.1.17"},
+  "ex_doc": {:hex, :ex_doc, "0.7.3"},
   "shouldi": {:hex, :shouldi, "0.2.3"}}

test/tools/generator/array_expression_test.exs

@@ -0,0 +1,31 @@
+defmodule ESTree.Tools.Generator.ArrayExpression.Test do
+  use ShouldI
+  alias ESTree.Tools.Builder
+  alias ESTree.Tools.Generator
+
+  should "convert array when elements is nil" do
+    ast = Builder.array_expression(nil)
+    assert Generator.generate(ast) == "[]" 
+  end
+
+  should "convert array when elements is empty" do
+    ast = Builder.array_expression([])
+    assert Generator.generate(ast) == "[]" 
+  end
+
+  should "convert array when elements contains one element" do
+    ast = Builder.array_expression([
+      Builder.literal(1)
+    ])
+    assert Generator.generate(ast) == "[1]" 
+  end
+
+  should "convert array when elements contains multiple elements" do
+    ast = Builder.array_expression([
+      Builder.literal(1),
+      Builder.identifier(:a)
+    ])
+    assert Generator.generate(ast) == "[1, a]" 
+  end
+
+end

test/tools/generator/object_expression_test.exs

@@ -0,0 +1,88 @@
+defmodule ESTree.Tools.Generator.ObjectExpression.Test do
+  use ShouldI
+  alias ESTree.Tools.Builder
+  alias ESTree.Tools.Generator
+
+  should "convert object when properties is nil" do
+    ast = Builder.object_expression(nil)
+    assert Generator.generate(ast) == "{}" 
+  end
+
+  should "convert object when properties is empty" do
+    ast = Builder.object_expression([])
+    assert Generator.generate(ast) == "{}" 
+  end
+
+  should "convert object when properties contains one property" do
+    ast = Builder.object_expression([
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.identifier(:value)
+      )
+    ])
+    assert Generator.generate(ast) == "{key: value}" 
+  end
+
+  should "convert object when properties contains multiple properties" do
+    ast = Builder.object_expression([
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.identifier(:value)
+      ),
+      Builder.property(
+        Builder.identifier(:key1),
+        Builder.identifier(:value1)
+      )
+    ])
+    assert Generator.generate(ast) == "{key: value, key1: value1}" 
+  end
+
+
+  should "convert object when properties contains getters and setters" do
+    ast = Builder.object_expression([
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.function_expression([],[], Builder.block_statement([])),
+        :get
+      ),
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.function_expression([Builder.identifier(:p)],[], Builder.block_statement([])),
+        :set
+      ),
+    ])
+    assert Generator.generate(ast) == "{get key() {}, set key(p) {}}" 
+  end
+
+  should "convert object when properties contains getter and setter methods" do
+    ast = Builder.object_expression([
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.function_expression([],[], Builder.block_statement([])),
+        :get,
+        false,
+        true
+      ),
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.function_expression([Builder.identifier(:p)],[], Builder.block_statement([])),
+        :set,
+        false,
+        true
+      ),
+    ])
+    assert Generator.generate(ast) == "{key() {}, key(p) {}}" 
+  end
+
+  should "convert object when properties contains shorthand properties" do
+    ast = Builder.object_expression([
+      Builder.property(
+        Builder.identifier(:key),
+        Builder.identifier(:key),
+        :init,
+        true)
+    ])
+    assert Generator.generate(ast) == "{key}" 
+  end
+  
+end