Run prettier

lib/chervil.rb

 require 'chervil/token'
 require 'chervil/version'
 
-module Chervil
-end
+module Chervil; end

spec/env_spec.rb

   RSpec.describe Env do
     it 'has arithmetic from core' do
       env = Env.new
-      expect(env.get("+").call([1, 2], env)).to eq(3)
+      expect(env.get('+').call([1, 2], env)).to eq(3)
     end
 
     it 'inherits from parent env' do
       parent = Env.new
-      parent.set("x", 5)
+      parent.set('x', 5)
       child = Env.new(parent)
-      expect(child.get("x")).to eq(5)
+      expect(child.get('x')).to eq(5)
     end
   end
 end

spec/interpreter_spec.rb

     it 'interprets a definition and variable usage' do
       env = Env.new
       interpret('(define x 5)', env)
-      expect(env.get("x")).to eq(AST::Number.new(5.0))
+      expect(env.get('x')).to eq(AST::Number.new(5.0))
       expect(interpret('x', env).first).to eq(5.0)
     end
 

spec/lexer_spec.rb

     end
 
     it 'lexes booleans' do
-      lexer = Lexer.new("#t #f")
+      lexer = Lexer.new('#t #f')
       expect(lexer.get_next_token).to eq(Token.new(:boolean, true))
       expect(lexer.get_next_token).to eq(Token.new(:boolean, false))
     end

spec/parser_spec.rb

 
     it 'parses booleans' do
       expect(parse('#t #f')).to eq(
-        [
-          AST::Boolean.new(true),
-          AST::Boolean.new(false),
-        ]
+        [AST::Boolean.new(true), AST::Boolean.new(false)]
       )
     end
 
     it 'parses a nested expression' do
       expect(parse('(+ (+ 1 2) (- 3 4))').first).to eq(
         AST::Application.new(
-          AST::Identifier.new("+"),
+          AST::Identifier.new('+'),
           [
             AST::Application.new(
-              AST::Identifier.new("+"),
-              [
-                AST::Number.new(1.0),
-                AST::Number.new(2.0),
-              ]
+              AST::Identifier.new('+'),
+              [AST::Number.new(1.0), AST::Number.new(2.0)]
             ),
             AST::Application.new(
-              AST::Identifier.new("-"),
-              [
-                AST::Number.new(3.0),
-                AST::Number.new(4.0),
-              ]
-            ),
+              AST::Identifier.new('-'),
+              [AST::Number.new(3.0), AST::Number.new(4.0)]
+            )
           ]
         )
       )
     it 'parses a function definition' do
       expect(parse('(define (square x) (* x x))').first).to eq(
         AST::Definition.new(
-          AST::Identifier.new("square"),
+          AST::Identifier.new('square'),
           AST::Function.new(
-            AST::Identifier.new("square"),
-            [
-              AST::Identifier.new("x")
-            ],
+            AST::Identifier.new('square'),
+            [AST::Identifier.new('x')],
             [
               AST::Application.new(
-                AST::Identifier.new("*"),
-                [
-                  AST::Identifier.new("x"),
-                  AST::Identifier.new("x"),
-                ]
+                AST::Identifier.new('*'),
+                [AST::Identifier.new('x'), AST::Identifier.new('x')]
               )
             ]
           )
     end
 
     it 'returns a syntax error object instead of raising' do
-      expect(parse('(+ 1')).to eq(Error.new("Expected rparen but got eof"))
-      expect(parse('1)')).to eq(Error.new("Unexpected token rparen: )"))
+      expect(parse('(+ 1')).to eq(Error.new('Expected rparen but got eof'))
+      expect(parse('1)')).to eq(Error.new('Unexpected token rparen: )'))
     end
 
     it 'parses a conditional' do
         AST::Conditional.new(
           AST::Boolean.new(true),
           AST::Number.new(1.0),
-          AST::Number.new(0.0),
+          AST::Number.new(0.0)
         )
       )
     end