Prettier

lib/ahem/ast/for_loop.rb

 
   def ==(other)
     other.is_a?(AST::ForLoop) && other.iterator == @iterator &&
-      other.iterable == @iterable && other.block == @block
+      other.iterable == @iterable &&
+      other.block == @block
   end
 
   def execute(env)
     @iterable.execute(env).each do |i|
       _env = Environment.new
       _env.set(@iterator.name, i)
-      @block.statements.each do |statement|
-        statement.execute(_env)
-      end
+      @block.statements.each { |statement| statement.execute(_env) }
     end
   end
 end

lib/ahem/lexer.rb

 
   def scan_all
     tokens = Array.new
-    until at_end
-      tokens << get_token
-    end
+    tokens << get_token until at_end
     tokens << Token.new(TokenKinds::EOF)
   end
 
   private
 
   def skip_whitespace
-    while !at_end && @source[@position].match(/\A\s/)
-      @position += 1
-    end
+    @position += 1 while !at_end && @source[@position].match(/\A\s/)
   end
 
   def skip_comment

lib/ahem/parser.rb

     elsif @current_token.type == TokenKinds::FUNCTION
       next_token = @lexer.peek
       if next_token && next_token.type == TokenKinds::IDENTIFIER
-				function_definition
+        function_definition
       else
-				expression_statement
+        expression_statement
       end
     elsif @current_token.type == TokenKinds::CLASS
       class_definition
     elsif @current_token.type == TokenKinds::FOR
       for_loop
     else
-			expression_statement
+      expression_statement
     end
   end
 
-	def expression_statement
+  def expression_statement
     expr = expression
     eat(TokenKinds::SEMICOLON)
     return expr
-	end
+  end
 
   def variable_declaration
     eat(TokenKinds::LET)
     expr = binary
 
     if @current_token.type == TokenKinds::EQUALS
-      raise 'Invalid left hand side of assignment' unless expr.is_a?(AST::Identifier)
+      unless expr.is_a?(AST::Identifier)
+        raise 'Invalid left hand side of assignment'
+      end
       eat(TokenKinds::EQUALS)
       value = expression
       AST::Assignment.new(expr, value)
 
   def eat(type)
     token = @current_token
+
     if token.type == type
       advance
       token

spec/ast/assignment_spec.rb

 RSpec.describe AST::Assignment do
   it 'reassigns an existing variable' do
     env = Environment.new
-    AST::VariableDeclaration.new(
-      AST::Identifier.new('x'),
-      AST::Number.new(5.0),
-    ).execute(env)
-    AST::Assignment.new(
-      AST::Identifier.new('x'),
-      AST::Number.new(6.0),
-    ).execute(env)
+    AST::VariableDeclaration.new(AST::Identifier.new('x'), AST::Number.new(5.0))
+      .execute(env)
+    AST::Assignment.new(AST::Identifier.new('x'), AST::Number.new(6.0)).execute(
+      env
+    )
     expect(env.get('x').execute(env)).to eq(6.0)
   end
 
   it 'raises for an undeclared variable' do
     env = Environment.new
     expect {
-      AST::Assignment.new(
-        AST::Identifier.new('x'),
-        AST::Number.new(6.0),
-      ).execute(env)
-    }.to raise_error("Undefined variable x")
-
+      AST::Assignment.new(AST::Identifier.new('x'), AST::Number.new(6.0))
+        .execute(env)
+    }.to raise_error('Undefined variable x')
   end
 end

spec/ast/class_definition_spec.rb

 RSpec.describe AST::ClassDefinition do
   it 'defines a class' do
     env = Environment.new(env)
-    klass = AST::ClassDefinition.new(
-      AST::Identifier.new('Class'), [], []
-    )
+    klass = AST::ClassDefinition.new(AST::Identifier.new('Class'), [], [])
     klass.execute(env)
     expect(env.get('Class')).to eq(klass)
   end

spec/ast/conditional_spec.rb

             AST::Binary.new(
               AST::Operators::GREATER_THAN,
               AST::Number.new(5.0),
-              AST::Number.new(4.0),
+              AST::Number.new(4.0)
             ),
-            AST::Block.new(
-              [
-                AST::String.new("5 is greater than 4")
-              ]
-            )
+            AST::Block.new([AST::String.new('5 is greater than 4')])
           )
         ]
-      ).execute(Environment.new)
-    ).to eq("5 is greater than 4")
+      )
+        .execute(Environment.new)
+    ).to eq('5 is greater than 4')
   end
 
   it 'evaluates an else statement' do
             AST::Binary.new(
               AST::Operators::GREATER_THAN,
               AST::Number.new(3.0),
-              AST::Number.new(4.0),
+              AST::Number.new(4.0)
             ),
-            AST::Block.new(
-              [
-                AST::String.new("3 is greater than 4")
-              ]
-            )
+            AST::Block.new([AST::String.new('3 is greater than 4')])
           ),
           AST::Branch.new(
             AST::Boolean.new(true),
-            AST::Block.new(
-              [
-                AST::String.new("3 is _not_ greater than 4")
-              ]
-            )
+            AST::Block.new([AST::String.new('3 is _not_ greater than 4')])
           )
         ]
-      ).execute(Environment.new)
-    ).to eq("3 is _not_ greater than 4")
+      )
+        .execute(Environment.new)
+    ).to eq('3 is _not_ greater than 4')
   end
 
   it 'evaluates an else if statement' do
             AST::Binary.new(
               AST::Operators::GREATER_THAN,
               AST::Number.new(3.0),
-              AST::Number.new(4.0),
+              AST::Number.new(4.0)
             ),
-            AST::Block.new(
-              [
-                AST::String.new("3 is greater than 4")
-              ]
-            )
+            AST::Block.new([AST::String.new('3 is greater than 4')])
           ),
           AST::Branch.new(
             AST::Binary.new(
               AST::Operators::GREATER_THAN,
               AST::Number.new(3.0),
-              AST::Number.new(2.0),
+              AST::Number.new(2.0)
             ),
-            AST::Block.new(
-              [
-                AST::String.new("3 is greater than 2")
-              ]
-            )
+            AST::Block.new([AST::String.new('3 is greater than 2')])
           ),
           AST::Branch.new(
             AST::Boolean.new(true),
-            AST::Block.new(
-              [
-                AST::String.new("3 is _not_ greater than 4")
-              ]
-            )
+            AST::Block.new([AST::String.new('3 is _not_ greater than 4')])
           )
         ]
-      ).execute(Environment.new)
-    ).to eq("3 is greater than 2")
+      )
+        .execute(Environment.new)
+    ).to eq('3 is greater than 2')
   end
 end

spec/ast/for_loop_spec.rb

       AST::ForLoop.new(
         AST::Identifier.new('x'),
         AST::Array.new(
-          [
-            AST::Number.new(1.0),
-            AST::Number.new(2.0),
-            AST::Number.new(3.0),
-          ]
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
         ),
         AST::Block.new(
           [
             AST::FunctionCall.new(
               AST::Identifier.new('print'),
-              [
-                AST::Identifier.new('x')
-              ]
+              [AST::Identifier.new('x')]
             )
           ]
         )
-      ).execute(Environment.new)
+      )
+        .execute(Environment.new)
     }.to output("1.0\n2.0\n3.0\n").to_stdout
   end
 end

spec/ast/function_call_spec.rb

       AST::FunctionCall.new(
         AST::Identifier.new('print'),
         [AST::String.new('hello world')]
-      ).execute(Environment.new)
+      )
+        .execute(Environment.new)
     }.to output("hello world\n").to_stdout
   end
 
     AST::FunctionDefinition.new(
       AST::Identifier.new('add_one'),
       [AST::Identifier.new('n')],
-      AST::Block.new([
-        AST::Binary.new(
-          AST::Operators::ADD,
-          AST::Identifier.new('n'),
-          AST::Number.new(1.0)
-        )
-      ])
-    ).execute(env)
+      AST::Block.new(
+        [
+          AST::Binary.new(
+            AST::Operators::ADD,
+            AST::Identifier.new('n'),
+            AST::Number.new(1.0)
+          )
+        ]
+      )
+    )
+      .execute(env)
     expect(
       AST::FunctionCall.new(
         AST::Identifier.new('add_one'),
         [AST::Number.new(5.0)]
-      ).execute(env)
+      )
+        .execute(env)
     ).to eq(6.0)
   end
 
     AST::FunctionDefinition.new(
       AST::Identifier.new('factorial'),
       [AST::Identifier.new('n')],
-      AST::Block.new([
-        AST::Conditional.new(
-          [
-            AST::Branch.new(
-              AST::Binary.new(
-                AST::Operators::DOUBLE_EQUALS,
-                AST::Identifier.new('n'),
-                AST::Number.new(0.0),
-              ),
-              AST::Block.new([
-                AST::Number.new(1.0),
-              ])
-            ),
-            AST::Branch.new(
-              AST::Boolean.new(true),
-              AST::Block.new([
+      AST::Block.new(
+        [
+          AST::Conditional.new(
+            [
+              AST::Branch.new(
                 AST::Binary.new(
-                  AST::Operators::MULTIPLY,
+                  AST::Operators::DOUBLE_EQUALS,
                   AST::Identifier.new('n'),
-                  AST::FunctionCall.new(
-                    AST::Identifier.new('factorial'),
-                    [
-                      AST::Binary.new(
-                        AST::Operators::SUBTRACT,
-                        AST::Identifier.new('n'),
-                        AST::Number.new(1.0),
+                  AST::Number.new(0.0)
+                ),
+                AST::Block.new([AST::Number.new(1.0)])
+              ),
+              AST::Branch.new(
+                AST::Boolean.new(true),
+                AST::Block.new(
+                  [
+                    AST::Binary.new(
+                      AST::Operators::MULTIPLY,
+                      AST::Identifier.new('n'),
+                      AST::FunctionCall.new(
+                        AST::Identifier.new('factorial'),
+                        [
+                          AST::Binary.new(
+                            AST::Operators::SUBTRACT,
+                            AST::Identifier.new('n'),
+                            AST::Number.new(1.0)
+                          )
+                        ]
                       )
-                    ]
-                  )
+                    )
+                  ]
                 )
-              ])
-            ),
-          ]
-        )
-      ])
-    ).execute(env)
+              )
+            ]
+          )
+        ]
+      )
+    )
+      .execute(env)
     expect(
       AST::FunctionCall.new(
         AST::Identifier.new('factorial'),
         [AST::Number.new(5.0)]
-      ).execute(env)
+      )
+        .execute(env)
     ).to eq(120.0)
   end
 
     AST::FunctionDefinition.new(
       AST::Identifier.new('add_one'),
       [AST::Identifier.new('n')],
-      AST::Block.new([
-        AST::Binary.new(
-          AST::Operators::ADD,
-          AST::Identifier.new('n'),
-          AST::Number.new(1.0)
-        )
-      ])
-    ).execute(env)
+      AST::Block.new(
+        [
+          AST::Binary.new(
+            AST::Operators::ADD,
+            AST::Identifier.new('n'),
+            AST::Number.new(1.0)
+          )
+        ]
+      )
+    )
+      .execute(env)
 
-    AST::FunctionCall.new(
-      AST::Identifier.new('add_one'),
-      [
-        AST::Number.new(5)
-      ]
-    ).execute(env)
+    AST::FunctionCall.new(AST::Identifier.new('add_one'), [AST::Number.new(5)])
+      .execute(env)
 
-    expect do
+    expect {
       AST::FunctionCall.new(
         AST::Identifier.new('print'),
-        [
-          AST::Identifier.new('n')
-        ]
-      ).execute(env)
-    end.to raise_error('Undefined variable n')
+        [AST::Identifier.new('n')]
+      )
+        .execute(env)
+    }.to raise_error('Undefined variable n')
   end
 
   # let add_one = function(n) { n + 1; };
       AST::Identifier.new('add_one'),
       AST::FunctionDefinition.new(
         nil,
-        [
-          AST::Identifier.new('n'),
-        ],
+        [AST::Identifier.new('n')],
         AST::Block.new(
           [
             AST::Binary.new(
           ]
         )
       )
-    ).execute(env)
+    )
+      .execute(env)
 
     AST::VariableDeclaration.new(
       AST::Identifier.new('do'),
       AST::FunctionDefinition.new(
         nil,
-        [
-          AST::Identifier.new('f'),
-          AST::Identifier.new('x'),
-        ],
+        [AST::Identifier.new('f'), AST::Identifier.new('x')],
         AST::Block.new(
           [
             AST::FunctionCall.new(
               AST::Identifier.new('f'),
-              [
-                AST::Identifier.new('x')
-              ]
+              [AST::Identifier.new('x')]
             )
           ]
         )
       )
-    ).execute(env)
+    )
+      .execute(env)
 
-    result = AST::FunctionCall.new(
-      AST::Identifier.new('do'),
-      [
-        AST::Identifier.new('add_one'),
-        AST::Number.new(5.0)
-      ]
-    ).execute(env)
+    result =
+      AST::FunctionCall.new(
+        AST::Identifier.new('do'),
+        [AST::Identifier.new('add_one'), AST::Number.new(5.0)]
+      )
+        .execute(env)
 
     expect(result).to eq(6)
   end

spec/ast/index_spec.rb

   it 'evaluates array index' do
     expect(
       AST::Index.new(
-        AST::Array.new([
-          AST::Number.new(1.0),
-          AST::Number.new(2.0),
-          AST::Number.new(3.0),
-        ]),
+        AST::Array.new(
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+        ),
         AST::Number.new(2.0)
-      ).execute(Environment.new)
+      )
+        .execute(Environment.new)
     ).to eq(3.0)
   end
 
     expect(
       AST::Index.new(
         AST::Hash.new(
-          :a => AST::Number.new(1.0),
-          :b => AST::Number.new(2.0),
-          :c => AST::Number.new(3.0),
+          a: AST::Number.new(1.0),
+          b: AST::Number.new(2.0),
+          c: AST::Number.new(3.0)
         ),
         AST::Atom.new(:b)
-      ).execute(Environment.new)
+      )
+        .execute(Environment.new)
     ).to eq(2.0)
   end
 
   it 'raises for out of bounds array index' do
     expect {
       AST::Index.new(
-        AST::Array.new([
-          AST::Number.new(1.0),
-          AST::Number.new(2.0),
-          AST::Number.new(3.0),
-        ]),
+        AST::Array.new(
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+        ),
         AST::Number.new(3.0)
-      ).execute(Environment.new)
-    }.to raise_error("Array index out of bounds")
+      )
+        .execute(Environment.new)
+    }.to raise_error('Array index out of bounds')
   end
 
   it 'raises for non-integral key on array' do
     expect {
       AST::Index.new(
-        AST::Array.new([
-          AST::Number.new(1.0),
-          AST::Number.new(2.0),
-          AST::Number.new(3.0),
-        ]),
+        AST::Array.new(
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+        ),
         AST::Number.new(1.5)
-      ).execute(Environment.new)
-    }.to raise_error("Array index requires integer key")
+      )
+        .execute(Environment.new)
+    }.to raise_error('Array index requires integer key')
 
     expect {
       AST::Index.new(
-        AST::Array.new([
-          AST::Number.new(1.0),
-          AST::Number.new(2.0),
-          AST::Number.new(3.0),
-        ]),
-        AST::String.new("5")
-      ).execute(Environment.new)
-    }.to raise_error("Array index requires integer key")
+        AST::Array.new(
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+        ),
+        AST::String.new('5')
+      )
+        .execute(Environment.new)
+    }.to raise_error('Array index requires integer key')
 
     expect {
       AST::Index.new(
-        AST::Array.new([
-          AST::Number.new(1.0),
-          AST::Number.new(2.0),
-          AST::Number.new(3.0),
-        ]),
+        AST::Array.new(
+          [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+        ),
         AST::Atom.new(:atom)
-      ).execute(Environment.new)
-    }.to raise_error("Array index requires integer key")
+      )
+        .execute(Environment.new)
+    }.to raise_error('Array index requires integer key')
   end
 
   it 'raises for missing hash key' do
     expect {
       AST::Index.new(
-        AST::Hash.new({
-          :a => AST::Number.new(1.0),
-          :b => AST::Number.new(2.0),
-          :c => AST::Number.new(3.0),
-        }),
+        AST::Hash.new(
+          {
+            a: AST::Number.new(1.0),
+            b: AST::Number.new(2.0),
+            c: AST::Number.new(3.0)
+          }
+        ),
         AST::Atom.new(:d)
-      ).execute(Environment.new)
-    }.to raise_error("Key d does not exist on object")
+      )
+        .execute(Environment.new)
+    }.to raise_error('Key d does not exist on object')
   end
 end

spec/ast/variable_declaration_spec.rb

 RSpec.describe AST::VariableDeclaration do
   it 'defines a variable' do
     env = Environment.new
-    AST::VariableDeclaration.new(
-      AST::Identifier.new('x'),
-      AST::Number.new(5.0),
-    ).execute(env)
+    AST::VariableDeclaration.new(AST::Identifier.new('x'), AST::Number.new(5.0))
+      .execute(env)
     expect(env.get('x').execute(env)).to eq(5.0)
   end
 
   it 'raises if a variable is already defined' do
     env = Environment.new
-    AST::VariableDeclaration.new(
-      AST::Identifier.new('x'),
-      AST::Number.new(5.0),
-    ).execute(env)
+    AST::VariableDeclaration.new(AST::Identifier.new('x'), AST::Number.new(5.0))
+      .execute(env)
     expect {
       AST::VariableDeclaration.new(
         AST::Identifier.new('x'),
-        AST::Number.new(6.0),
-      ).execute(env)
+        AST::Number.new(6.0)
+      )
+        .execute(env)
     }.to raise_error('Invalid declaration of previously declared variable x')
   end
 end

spec/lexer_spec.rb

       [
         Token.new(TokenKinds::FOR),
         Token.new(TokenKinds::IN),
-        Token.new(TokenKinds::EOF),
+        Token.new(TokenKinds::EOF)
       ]
     )
   end
     expect(Lexer.new('"hello \"world\""').scan_all).to eq(
       [
         Token.new(TokenKinds::STRING, 'hello "world"'),
-        Token.new(TokenKinds::EOF),
+        Token.new(TokenKinds::EOF)
       ]
     )
   end
       [
         Token.new(TokenKinds::STRING, "hello\nworld"),
         Token.new(TokenKinds::STRING, "hello\tworld"),
-        Token.new(TokenKinds::EOF),
+        Token.new(TokenKinds::EOF)
       ]
     )
   end
         Token.new(TokenKinds::LPAREN),
         Token.new(TokenKinds::NUMBER, 5),
         Token.new(TokenKinds::RPAREN),
-        Token.new(TokenKinds::EOF),
+        Token.new(TokenKinds::EOF)
       ]
     )
   end

spec/parser_spec.rb

             [
               AST::FunctionCall.new(
                 AST::Identifier.new('print'),
-                [
-                  AST::Identifier.new('x')
-                ]
+                [AST::Identifier.new('x')]
               )
             ]
           )
                 AST::Binary.new(
                   AST::Operators::ADD,
                   AST::Identifier.new('x'),
-                  AST::Identifier.new('y'),
+                  AST::Identifier.new('y')
                 )
               ]
             )
   end
 
   it 'allows returning an anonymous function from another function' do
-    expect(parse('function outer() { function() { print("Hello world"); }; }')).to eq(
+    expect(
+      parse('function outer() { function() { print("Hello world"); }; }')
+    ).to eq(
       [
         AST::FunctionDefinition.new(
           AST::Identifier.new('outer'),
                   [
                     AST::FunctionCall.new(
                       AST::Identifier.new('print'),
-                      [
-                        AST::String.new('Hello world')
-                      ]
+                      [AST::String.new('Hello world')]
                     )
                   ]
                 )
     )
   end
 
-	it 'allows toplevel function expressions' do
+  it 'allows toplevel function expressions' do
     expect(parse('function() { print("Hello world"); };')).to eq(
       [
         AST::FunctionDefinition.new(
             [
               AST::FunctionCall.new(
                 AST::Identifier.new('print'),
-                [
-                  AST::String.new('Hello world')
-                ]
+                [AST::String.new('Hello world')]
               )
             ]
           )
         )
       ]
     )
-	end
+  end
 
   it 'parses assignments' do
     expect(parse('x = 5;')).to eq(
-      [
-        AST::Assignment.new(
-          AST::Identifier.new('x'),
-          AST::Number.new(5.0),
-        )
-      ]
+      [AST::Assignment.new(AST::Identifier.new('x'), AST::Number.new(5.0))]
     )
   end
 end