Do not add spaces after { and before }

This makes the source code consistent with the result
returned by inspect/2.

Author: José Valim

CHANGELOG.md

@@ -810,7 +810,7 @@
   * [ExUnit] Support context data in `setup_all`, `setup`, `teardown` and `teardown_all` callbacks
   * [IEx] Support `after_spawn` callbacks which are invoked after each process is spawned
   * [Kernel] Better error messages when invalid options are given to `import`, `alias` or `require`
-  * [Kernel] Allow partial application on literals, for example: `{ &1, &2 }` to build tuples or `[&1|&2]` to build cons cells
+  * [Kernel] Allow partial application on literals, for example: `{&1, &2}` to build tuples or `[&1|&2]` to build cons cells
   * [Kernel] Added `integer_to_binary` and `binary_to_integer`
   * [Kernel] Added `float_to_binary` and `binary_to_float`
   * [Kernel] Many improvements to `unquote` and `unquote_splicing`. For example, `unquote(foo).unquote(bar)(args)` is supported and no longer need to be written via `apply`
@@ -863,7 +863,7 @@
   * [Kernel] Deprecate `__LINE__` and `__FUNCTION__` in favor of `__ENV__.line` and `__ENV__.function`
   * [Kernel] Deprecate `in_guard` in favor of `__CALLER__.in_guard?`
   * [Kernel] `refer` is deprecated in favor of `alias`
-  * [Module] `Module.add_compile_callback(module, target, callback)` is deprecated in favor of `Module.put_attribute(module, :before_compile, { target, callback })`
+  * [Module] `Module.add_compile_callback(module, target, callback)` is deprecated in favor of `Module.put_attribute(module, :before_compile, {target, callback})`
   * [Module] `Module.function_defined?` is deprecated in favor of `Module.defines?`
   * [Module] `Module.defined_functions` is deprecated in favor of `Module.definitions_in`
 

lib/eex/lib/eex.ex

@@ -108,7 +108,7 @@ defmodule EEx do
   defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
     quote bind_quoted: binding do
       info = Keyword.merge [file: __ENV__.file, line: __ENV__.line], options
-      args = Enum.map args, fn arg -> { arg, [line: info[:line]], nil } end
+      args = Enum.map args, fn arg -> {arg, [line: info[:line]], nil} end
       compiled = EEx.compile_string(source, info)
 
       case kind do
@@ -144,7 +144,7 @@ defmodule EEx do
   defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
     quote bind_quoted: binding do
       info = Keyword.merge options, [file: file, line: 1]
-      args = Enum.map args, fn arg -> { arg, [line: 1], nil } end
+      args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
       compiled = EEx.compile_file(file, info)
 
       @file file
@@ -207,7 +207,7 @@ defmodule EEx do
   ### Helpers
 
   defp do_eval(compiled, bindings, options) do
-    { result, _ } = Code.eval_quoted(compiled, bindings, options)
+    {result, _} = Code.eval_quoted(compiled, bindings, options)
     result
   end
 end

lib/eex/lib/eex/compiler.ex

@@ -17,37 +17,37 @@ defmodule EEx.Compiler do
 
   # Generates the buffers by handling each expression from the tokenizer
 
-  defp generate_buffer([{ :text, chars }|t], buffer, scope, state) do
+  defp generate_buffer([{:text, chars}|t], buffer, scope, state) do
     buffer = state.engine.handle_text(buffer, String.from_char_data!(chars))
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{ :expr, line, mark, chars }|t], buffer, scope, state) do
+  defp generate_buffer([{:expr, line, mark, chars}|t], buffer, scope, state) do
     expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
     buffer = state.engine.handle_expr(buffer, mark, expr)
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{ :start_expr, start_line, mark, chars }|t], buffer, scope, state) do
-    { contents, line, t } = look_ahead_text(t, start_line, chars)
-    { contents, t } = generate_buffer(t, "", [contents|scope], state.dict([]).line(line).start_line(start_line))
+  defp generate_buffer([{:start_expr, start_line, mark, chars}|t], buffer, scope, state) do
+    {contents, line, t} = look_ahead_text(t, start_line, chars)
+    {contents, t} = generate_buffer(t, "", [contents|scope], state.dict([]).line(line).start_line(start_line))
     buffer = state.engine.handle_expr(buffer, mark, contents)
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{ :middle_expr, line, _, chars }|t], buffer, [current|scope], state) do
-    { wrapped, state } = wrap_expr(current, line, buffer, chars, state)
+  defp generate_buffer([{:middle_expr, line, _, chars}|t], buffer, [current|scope], state) do
+    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
     generate_buffer(t, "", [wrapped|scope], state.line(line))
   end
 
-  defp generate_buffer([{ :end_expr, line, _, chars }|t], buffer, [current|_], state) do
-    { wrapped, state } = wrap_expr(current, line, buffer, chars, state)
+  defp generate_buffer([{:end_expr, line, _, chars}|t], buffer, [current|_], state) do
+    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
     tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
     buffer = insert_quotes(tuples, state.dict)
-    { buffer, t }
+    {buffer, t}
   end
 
-  defp generate_buffer([{ :end_expr, line, _, chars }|_], _buffer, [], _state) do
+  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], _state) do
     raise EEx.SyntaxError, message: "unexpected token: #{inspect chars} at line #{inspect line}"
   end
 
@@ -65,21 +65,21 @@ defmodule EEx.Compiler do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.dict)
     placeholder = '__EEX__(' ++ integer_to_list(key) ++ ');'
-    { current ++ placeholder ++ new_lines ++ chars, state.update_dict(&[{key, buffer}|&1]) }
+    {current ++ placeholder ++ new_lines ++ chars, state.update_dict(&[{key, buffer}|&1])}
   end
 
   # Look text ahead on expressions
 
-  defp look_ahead_text([{ :text, text }, { :middle_expr, line, _, chars }|t]=list, start, contents) do
+  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars}|t]=list, start, contents) do
     if only_spaces?(text) do
-      { contents ++ text ++ chars, line, t }
+      {contents ++ text ++ chars, line, t}
     else
-      { contents, start, list }
+      {contents, start, list}
     end
   end
 
   defp look_ahead_text(t, start, contents) do
-    { contents, start, t }
+    {contents, start, t}
   end
 
   defp only_spaces?(chars) do
@@ -88,17 +88,17 @@ defmodule EEx.Compiler do
 
   # Changes placeholder to real expression
 
-  defp insert_quotes({ :__EEX__, _, [key] }, dict) do
-    { ^key, value } = List.keyfind dict, key, 0
+  defp insert_quotes({:__EEX__, _, [key]}, dict) do
+    {^key, value} = List.keyfind dict, key, 0
     value
   end
 
-  defp insert_quotes({ left, line, right }, dict) do
-    { insert_quotes(left, dict), line, insert_quotes(right, dict) }
+  defp insert_quotes({left, line, right}, dict) do
+    {insert_quotes(left, dict), line, insert_quotes(right, dict)}
   end
 
-  defp insert_quotes({ left, right }, dict) do
-    { insert_quotes(left, dict), insert_quotes(right, dict) }
+  defp insert_quotes({left, right}, dict) do
+    {insert_quotes(left, dict), insert_quotes(right, dict)}
   end
 
   defp insert_quotes(list, dict) when is_list(list) do

lib/eex/lib/eex/smart_engine.ex

@@ -27,12 +27,12 @@ defmodule EEx.TransformerEngine do
         EEx.Engine.handle_expr(buffer, mark, transform(expr))
       end
 
-      defp transform({ a, b, c }) do
-        { transform(a), b, transform(c) }
+      defp transform({a, b, c}) do
+        {transform(a), b, transform(c)}
       end
 
-      defp transform({ a, b }) do
-        { transform(a), transform(b) }
+      defp transform({a, b}) do
+        {transform(a), transform(b)}
       end
 
       defp transform(list) when is_list(list) do
@@ -91,7 +91,7 @@ defmodule EEx.AssignsEngine do
   @doc false
   defmacro __using__(_) do
     quote unquote: false do
-      defp transform({ :@, line, [{ name, _, atom }] }) when is_atom(name) and is_atom(atom) do
+      defp transform({:@, line, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
         quote do: Dict.get(var!(assigns), unquote(name))
       end
 

lib/eex/lib/eex/tokenizer.ex

@@ -5,11 +5,11 @@ defmodule EEx.Tokenizer do
   Tokenizes the given char list or binary.
   It returns 4 different types of tokens as result:
 
-  * { :text, contents }
-  * { :expr, line, marker, contents }
-  * { :start_expr, line, marker, contents }
-  * { :middle_expr, line, marker, contents }
-  * { :end_expr, line, marker, contents }
+  * {:text, contents}
+  * {:expr, line, marker, contents}
+  * {:start_expr, line, marker, contents}
+  * {:middle_expr, line, marker, contents}
+  * {:end_expr, line, marker, contents}
 
   """
   def tokenize(bin, line) when is_binary(bin) do
@@ -21,22 +21,22 @@ defmodule EEx.Tokenizer do
   end
 
   defp tokenize('<%%' ++ t, line, buffer, acc) do
-    { buffer, new_line, rest } = tokenize_expr t, line, [?%, ?<|buffer]
+    {buffer, new_line, rest} = tokenize_expr t, line, [?%, ?<|buffer]
     tokenize rest, new_line, [?>, ?%|buffer], acc
   end
 
   defp tokenize('<%#' ++ t, line, buffer, acc) do
-    { _, new_line, rest } = tokenize_expr t, line, []
+    {_, new_line, rest} = tokenize_expr t, line, []
     tokenize rest, new_line, buffer, acc
   end
 
   defp tokenize('<%' ++ t, line, buffer, acc) do
-    { marker, t } = retrieve_marker(t)
-    { expr, new_line, rest } = tokenize_expr t, line, []
+    {marker, t} = retrieve_marker(t)
+    {expr, new_line, rest} = tokenize_expr t, line, []
 
     token = token_name(expr)
     acc   = tokenize_text(buffer, acc)
-    final = { token, line, marker, Enum.reverse(expr) }
+    final = {token, line, marker, Enum.reverse(expr)}
     tokenize rest, new_line, [], [final | acc]
   end
 
@@ -55,17 +55,17 @@ defmodule EEx.Tokenizer do
   # Retrieve marker for <%
 
   defp retrieve_marker('=' ++ t) do
-    { "=", t }
+    {"=", t}
   end
 
   defp retrieve_marker(t) do
-    { "", t }
+    {"", t}
   end
 
   # Tokenize an expression until we find %>
 
   defp tokenize_expr([?%, ?>|t], line, buffer) do
-    { buffer, line, t }
+    {buffer, line, t}
   end
 
   defp tokenize_expr('\n' ++ t, line, buffer) do
@@ -104,7 +104,7 @@ defmodule EEx.Tokenizer do
     # token and, if so, it is not followed by an "end"
     # token. If this is the case, we are on a start expr.
     case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
-      { :ok, _line, tokens } ->
+      {:ok, _line, tokens} ->
         tokens   = Enum.reverse(tokens)
         fn_index = fn_index(tokens)
 
@@ -130,14 +130,14 @@ defmodule EEx.Tokenizer do
 
   defp fn_index(tokens) do
     Enum.find_index tokens, fn
-      { :fn_paren, _ } -> true
-      { :fn, _ }       -> true
+      {:fn_paren, _} -> true
+      {:fn, _}       -> true
       _                -> false
     end
   end
 
   defp end_index(tokens) do
-    Enum.find_index(tokens, &match?({ :end, _ }, &1)) || :infinity
+    Enum.find_index(tokens, &match?({:end, _}, &1)) || :infinity
   end
 
   defp check_spaces(string, token) do
@@ -156,6 +156,6 @@ defmodule EEx.Tokenizer do
   end
 
   defp tokenize_text(buffer, acc) do
-    [{ :text, Enum.reverse(buffer) } | acc]
+    [{:text, Enum.reverse(buffer)} | acc]
   end
 end

lib/eex/test/eex/tokenizer_test.exs

@@ -5,23 +5,23 @@ defmodule EEx.TokenizerTest do
   require EEx.Tokenizer, as: T
 
   test "simple chars lists" do
-    assert T.tokenize('foo', 1) == [ { :text, 'foo' } ]
+    assert T.tokenize('foo', 1) == [ {:text, 'foo'} ]
   end
 
   test "simple strings" do
-    assert T.tokenize("foo", 1) == [ { :text, 'foo' } ]
+    assert T.tokenize("foo", 1) == [ {:text, 'foo'} ]
   end
 
   test "strings with embedded code" do
-    assert T.tokenize('foo <% bar %>', 1) == [ { :text, 'foo ' }, { :expr, 1, "", ' bar ' } ]
+    assert T.tokenize('foo <% bar %>', 1) == [ {:text, 'foo '}, {:expr, 1, "", ' bar '} ]
   end
 
   test "strings with embedded equals code" do
-    assert T.tokenize('foo <%= bar %>', 1) == [ { :text, 'foo ' }, { :expr, 1, "=", ' bar ' } ]
+    assert T.tokenize('foo <%= bar %>', 1) == [ {:text, 'foo '}, {:expr, 1, "=", ' bar '} ]
   end
 
   test "strings with more than one line" do
-    assert T.tokenize('foo\n<%= bar %>', 1) == [ { :text, 'foo\n' }, { :expr, 2, "=", ' bar ' } ]
+    assert T.tokenize('foo\n<%= bar %>', 1) == [ {:text, 'foo\n'}, {:expr, 2, "=", ' bar '} ]
   end
 
   test "strings with more than one line and expression with more than one line" do
@@ -43,57 +43,57 @@ baz %>
 
   test "quotation" do
     assert T.tokenize('foo <%% true %>', 1) == [
-      { :text, 'foo <% true %>' }
+      {:text, 'foo <% true %>'}
     ]
   end
 
   test "quotation with do/end" do
     assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == [
-      { :text, 'foo <% true do %>bar<% end %>' }
+      {:text, 'foo <% true do %>bar<% end %>'}
     ]
   end
 
   test "comments" do
     assert T.tokenize('foo <%# true %>', 1) == [
-      { :text, 'foo ' }
+      {:text, 'foo '}
     ]
   end
 
   test "comments with do/end" do
     assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == [
-      { :text, 'foo bar' }
+      {:text, 'foo bar'}
     ]
   end
 
   test "strings with embedded do end" do
     assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == [
-      { :text, 'foo ' },
-      { :start_expr, 1, "", ' if true do ' },
-      { :text, 'bar' },
-      { :end_expr, 1, "", ' end ' }
+      {:text, 'foo '},
+      {:start_expr, 1, "", ' if true do '},
+      {:text, 'bar'},
+      {:end_expr, 1, "", ' end '}
     ]
   end
 
   test "strings with embedded -> end" do
     assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == [
-      { :text, 'foo ' },
-      { :start_expr, 1, "", ' cond do ' },
-      { :middle_expr, 1, "", ' false -> ' },
-      { :text, 'bar' },
-      { :middle_expr, 1, "", ' true -> ' },
-      { :text, 'baz' },
-      { :end_expr, 1, "", ' end ' }
+      {:text, 'foo '},
+      {:start_expr, 1, "", ' cond do '},
+      {:middle_expr, 1, "", ' false -> '},
+      {:text, 'bar'},
+      {:middle_expr, 1, "", ' true -> '},
+      {:text, 'baz'},
+      {:end_expr, 1, "", ' end '}
     ]
   end
 
   test "strings with embedded keywords blocks" do
     assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == [
-      { :text, 'foo ' },
-      { :start_expr, 1, "", ' if true do ' },
-      { :text, 'bar' },
-      { :middle_expr, 1, "", ' else ' },
-      { :text, 'baz' },
-      { :end_expr, 1, "", ' end ' }
+      {:text, 'foo '},
+      {:start_expr, 1, "", ' if true do '},
+      {:text, 'bar'},
+      {:middle_expr, 1, "", ' else '},
+      {:text, 'baz'},
+      {:end_expr, 1, "", ' end '}
     ]
   end