Add unary operations

lib/ahem/ast.rb

   require 'ahem/ast/number'
   require 'ahem/ast/operators'
   require 'ahem/ast/string'
+  require 'ahem/ast/unary'
   require 'ahem/ast/variable_declaration'
 end

lib/ahem/ast/operators.rb

   DOUBLE_EQUALS = :==
   OR = :or
   AND = :and
+  NOT = :not
 end

lib/ahem/ast/unary.rb

+class AST::Unary
+  attr_reader :operation, :expr
+
+  def initialize(operation, expr)
+    @operation = operation
+    @expr = expr
+  end
+
+  def ==(other)
+    other.operation == @operation && other.expr == @expr
+  end
+
+  def execute(env)
+    case @operation
+    when AST::Operators::SUBTRACT
+      0.0 - @expr.execute(env)
+    when AST::Operators::NOT
+      !@expr.execute(env)
+    end
+  end
+end

lib/ahem/lexer.rb

     elsif source.match(/^=>/)
       @position += 2
       Token.new(TokenKinds::ROCKET)
+    elsif source.match(/^!/)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :!)
     elsif source.match(/^==/)
       @position += 2
       Token.new(TokenKinds::OPERATOR, :==)
     elsif source.match(/^or/)
       @position += 2
       Token.new(TokenKinds::OPERATOR, :or)
+    elsif source.match(/^not/)
+      @position += 3
+      Token.new(TokenKinds::OPERATOR, :not)
     elsif source.match(/^\=/)
       @position += 1
       Token.new(TokenKinds::EQUALS)

lib/ahem/parser.rb

   end
 
   def multiplication
-    left = primary
+    left = unary
 
     if @current_token.type == TokenKinds::OPERATOR &&
        %i[* /].include?(@current_token.value)
       operator = @current_token.value
       advance
-      right = primary
+      right = unary
       AST::Binary.new(operator, left, right)
     else
       left
     end
   end
 
+  def unary
+    if @current_token.type == TokenKinds::OPERATOR &&
+        %i[- !].include?(@current_token.value)
+      operator = eat(TokenKinds::OPERATOR).value
+      expr = primary
+      AST::Unary.new(operator, expr)
+    else
+      primary
+    end
+  end
+
   def primary
     token = @current_token
     expr = case token.type

spec/lexer_spec.rb

   end
 
   it 'lexes operators' do
-    expect(Lexer.new('+-*/<<=>>=== and or').scan_all).to eq(
+    expect(Lexer.new('+-*/<<=>>=== and or not').scan_all).to eq(
       [
         Token.new(TokenKinds::OPERATOR, :+),
         Token.new(TokenKinds::OPERATOR, :-),
         Token.new(TokenKinds::OPERATOR, :==),
         Token.new(TokenKinds::OPERATOR, :and),
         Token.new(TokenKinds::OPERATOR, :or),
+        Token.new(TokenKinds::OPERATOR, :not),
         Token.new(TokenKinds::EOF)
       ]
     )

spec/parser_spec.rb

       ]
     )
   end
+
+  it 'parses unary expressions' do
+    expect(parse('-1;')).to eq([AST::Unary.new(:-, AST::Number.new(1.0))])
+    expect(parse('!true;')).to eq([AST::Unary.new(:!, AST::Boolean.new(true))])
+  end
 end