Formatting

lib/ahem/lexer.rb

       Token.new(TokenKinds::ROCKET)
     elsif source.match(/\A\#/)
       @position += 1
-      Token.new(TokenKinds::HASH)      
+      Token.new(TokenKinds::HASH)
     elsif source.match(/\A!/)
       @position += 1
       Token.new(TokenKinds::OPERATOR, :!)

lib/ahem/parser.rb

         raise "Unexpected token #{token.type}"
       end
 
-    while [TokenKinds::LPAREN, TokenKinds::LBRACKET, TokenKinds::HASH].include?(@current_token.type)
+    while [TokenKinds::LPAREN, TokenKinds::LBRACKET, TokenKinds::HASH].include?(
+      @current_token.type
+    )
       case @current_token.type
       when TokenKinds::LPAREN
         args = arguments

spec/ast/function_call_spec.rb

   end
 
   it 'allows calling an anonymous function directly' do
-    result = AST::FunctionCall.new(
-      AST::FunctionDefinition.new(
-        nil,
-        [],
-        AST::Block.new(
-          [
-            AST::Number.new(5.0)
-          ]
-        )
-      ),
-      []
-    ).execute(Environment.new)
+    result =
+      AST::FunctionCall.new(
+        AST::FunctionDefinition.new(
+          nil,
+          [],
+          AST::Block.new([AST::Number.new(5.0)])
+        ),
+        []
+      )
+        .execute(Environment.new)
     expect(result).to eq(5.0)
   end
 
   # }
   # let y = outer();
   # y();
-  it 'keeps a reference to a closure\'s environment' do
+  it "keeps a reference to a closure's environment" do
     env = Environment.new
     AST::FunctionDefinition.new(
       AST::Identifier.new('outer'),
           AST::FunctionDefinition.new(
             nil,
             [],
-            AST::Block.new(
-              [
-                AST::Identifier.new('x'),
-              ]
-            )
+            AST::Block.new([AST::Identifier.new('x')])
           )
         ]
       )
-    ).execute(env)
+    )
+      .execute(env)
     AST::VariableDeclaration.new(
       AST::Identifier.new('y'),
-      AST::FunctionCall.new(
-        AST::Identifier.new('outer'),
-        []
-      )
-    ).execute(env)
-    result = AST::FunctionCall.new(
-      AST::Identifier.new('y'),
-      []
-    ).execute(env)
-    expect(result).to eq("hello world")
+      AST::FunctionCall.new(AST::Identifier.new('outer'), [])
+    )
+      .execute(env)
+    result = AST::FunctionCall.new(AST::Identifier.new('y'), []).execute(env)
+    expect(result).to eq('hello world')
   end
 end

spec/lexer_spec.rb

   end
 
   it 'lexes hashes' do
-    expect(Lexer.new("#").scan_all).to eq(
-      [
-        Token.new(TokenKinds::HASH),
-        Token.new(TokenKinds::EOF)
-      ]
+    expect(Lexer.new('#').scan_all).to eq(
+      [Token.new(TokenKinds::HASH), Token.new(TokenKinds::EOF)]
     )
   end
 end

spec/parser_spec.rb

     expect(parse('func()();')).to eq(
       [
         AST::FunctionCall.new(
-          AST::FunctionCall.new(
-            AST::Identifier.new('func'),
-            [],
-          ),
+          AST::FunctionCall.new(AST::Identifier.new('func'), []),
           []
         )
       ]
             AST::Index.new(
               AST::FunctionCall.new(
                 AST::Index.new(
-                  AST::FunctionCall.new(
-                    AST::Identifier.new('func'),
-                    []
-                  ),
+                  AST::FunctionCall.new(AST::Identifier.new('func'), []),
                   AST::Number.new(0.0)
                 ),
                 []
       [
         AST::Property.new(
           AST::Identifier.new('hello'),
-          AST::Identifier.new('world'),
-        ),
+          AST::Identifier.new('world')
+        )
       ]
     )
   end
         AST::FunctionCall.new(
           AST::Property.new(
             AST::Identifier.new('hello'),
-            AST::Identifier.new('world'),
+            AST::Identifier.new('world')
           ),
-          []          
+          []
         )
       ]
     )