Prettier

lib/ahem/ast/hash.rb

   def execute(env)
     result = Hash.new
 
-    @data.each do |k, v|
-      result[k] = v.execute(env)
-    end
+    @data.each { |k, v| result[k] = v.execute(env) }
 
     result
   end

lib/ahem/ast/identifier.rb

   def execute(env)
     value = env.get(@name)
 
-    if value.respond_to?(:execute)
-      value.execute(env)
-    else
-      value
-    end
+    value.respond_to?(:execute) ? value.execute(env) : value
   end
 end

lib/ahem/ast/index.rb

         if key.to_i == key && object.size > key
           object[key]
         elsif key.to_i != key
-          raise "Array index requires integer key"
+          raise 'Array index requires integer key'
         elsif object.size <= key
-          raise "Array index out of bounds"
+          raise 'Array index out of bounds'
         end
       else
-        raise "Array index requires integer key"
+        raise 'Array index requires integer key'
       end
     elsif object.is_a?(Hash)
       if object.has_key?(key)

lib/ahem/core.rb

 CORE = {
-  :print => -> *args do
+  print: lambda do |*args|
     args.each do |arg|
       if arg.is_a?(Array)
         puts "[#{arg.join(', ')}]"
         puts arg
       end
     end
-  end,
+  end
 }

lib/ahem/environment.rb

   def initialize(parent = nil)
     @data = Hash.new
 
-    CORE.each do |k, v|
-      @data[k.to_s] = v
-    end
+    CORE.each { |k, v| @data[k.to_s] = v }
 
-    unless parent.nil?
-      parent.data.each do |k, v|
-        @data[k] = v
-      end
-    end
+    parent.data.each { |k, v| @data[k] = v } unless parent.nil?
   end
 
   def get(name)

lib/ahem/interpreter.rb

   end
 
   def interpret
-    @tree.each do |node|
-      node.execute(@env)
-    end
+    @tree.each { |node| node.execute(@env) }
   end
 end

lib/ahem/parser.rb

 
   def unary
     if @current_token.type == TokenKinds::OPERATOR &&
-        %i[- !].include?(@current_token.value)
+       %i[- !].include?(@current_token.value)
       operator = eat(TokenKinds::OPERATOR).value
       expr = primary
       AST::Unary.new(operator, expr)
 
   def primary
     token = @current_token
-    expr = case token.type
-    when TokenKinds::NULL
-      advance
-      AST::Null.new
-    when TokenKinds::BOOLEAN
-      advance
-      AST::Boolean.new(token.value)
-    when TokenKinds::NUMBER
-      advance
-      AST::Number.new(token.value)
-    when TokenKinds::STRING
-      advance
-      AST::String.new(token.value)
-    when TokenKinds::ATOM
-      advance
-      AST::Atom.new(token.value)
-    when TokenKinds::IDENTIFIER
-      identifier
-    when TokenKinds::LBRACKET
-      array
-    when TokenKinds::LBRACE
-      hash
-    when TokenKinds::LPAREN
-      eat(TokenKinds::LPAREN)
-      e = expression
-      eat(TokenKinds::RPAREN)
-      e
-    else
-      raise "Unexpected token #{token.type}"
-    end
+    expr =
+      case token.type
+      when TokenKinds::NULL
+        advance
+        AST::Null.new
+      when TokenKinds::BOOLEAN
+        advance
+        AST::Boolean.new(token.value)
+      when TokenKinds::NUMBER
+        advance
+        AST::Number.new(token.value)
+      when TokenKinds::STRING
+        advance
+        AST::String.new(token.value)
+      when TokenKinds::ATOM
+        advance
+        AST::Atom.new(token.value)
+      when TokenKinds::IDENTIFIER
+        identifier
+      when TokenKinds::LBRACKET
+        array
+      when TokenKinds::LBRACE
+        hash
+      when TokenKinds::LPAREN
+        eat(TokenKinds::LPAREN)
+        e = expression
+        eat(TokenKinds::RPAREN)
+        e
+      else
+        raise "Unexpected token #{token.type}"
+      end
 
     if @current_token.type == TokenKinds::LPAREN
       args = arguments

spec/parser_spec.rb

   it 'gives function calls higher precedence than binary operations' do
     expect(parse('x + func(y);')).to eq(
       [
-          AST::Binary.new(
-            AST::Operators::ADD,
-            AST::Identifier.new('x'),
-            AST::FunctionCall.new(
-              AST::Identifier.new('func'),
-              [
-                AST::Identifier.new('y'),
-              ]
-            )
+        AST::Binary.new(
+          AST::Operators::ADD,
+          AST::Identifier.new('x'),
+          AST::FunctionCall.new(
+            AST::Identifier.new('func'),
+            [AST::Identifier.new('y')]
           )
+        )
       ]
     )
   end
 
   it 'parses hashes' do
     expect(parse('{ :a => 1, :b => 2 };')).to eq(
-      [
-        AST::Hash.new(
-          {
-            :a => AST::Number.new(1.0),
-            :b => AST::Number.new(2.0),
-          }
-        )
-      ]
+      [AST::Hash.new({ a: AST::Number.new(1.0), b: AST::Number.new(2.0) })]
     )
   end
 
   it 'parses bracket indexing' do
     expect(parse('array[0];')).to eq(
-      [
-        AST::Index.new(
-          AST::Identifier.new('array'),
-          AST::Number.new(0),
-        )
-      ]
+      [AST::Index.new(AST::Identifier.new('array'), AST::Number.new(0))]
     )
   end
 
   it 'parses atoms' do
-    expect(parse(':atom;')).to eq(
-      [
-        AST::Atom.new(:atom)
-      ]
-    )
+    expect(parse(':atom;')).to eq([AST::Atom.new(:atom)])
   end
 
   it 'parses unary expressions' do
             AST::Number.new(1.0),
             AST::Number.new(2.0)
           ),
-          AST::Number.new(3.0),
+          AST::Number.new(3.0)
         )
       ]
     )