Add hashes

lib/ahem/ast.rb

@@ -1,4 +1,5 @@
 module AST
+  require 'ahem/ast/atom'
   require 'ahem/ast/array'
   require 'ahem/ast/binary'
   require 'ahem/ast/block'
@@ -8,7 +9,9 @@ module AST
   require 'ahem/ast/conditional'
   require 'ahem/ast/function_call'
   require 'ahem/ast/function_definition'
+  require 'ahem/ast/hash'
   require 'ahem/ast/identifier'
+  require 'ahem/ast/index'
   require 'ahem/ast/member'
   require 'ahem/ast/null'
   require 'ahem/ast/number'

lib/ahem/ast/atom.rb

@@ -0,0 +1,15 @@
+class AST::Atom
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def ==(other)
+    other.is_a?(AST::Atom) && other.value == @value
+  end
+
+  def execute(env)
+    @value
+  end
+end

lib/ahem/ast/hash.rb

@@ -0,0 +1,21 @@
+class AST::Hash
+  attr_reader :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def ==(other)
+    other.is_a?(AST::Hash) && other.data == @data
+  end
+
+  def execute(env)
+    result = Hash.new
+
+    @data.each do |k, v|
+      result[k] = v.execute(env)
+    end
+
+    result
+  end
+end

lib/ahem/ast/index.rb

@@ -0,0 +1,37 @@
+class AST::Index
+  attr_reader :object, :key
+
+  def initialize(object, key)
+    @object = object
+    @key = key
+  end
+
+  def ==(other)
+    other.is_a?(AST::Index) && other.object == @object && other.key == @key
+  end
+
+  def execute(env)
+    object = @object.execute(env)
+    key = @key.execute(env)
+
+    if object.is_a?(Array)
+      if key.is_a?(Float)
+        if key.to_i == key && object.size > key
+          object[key]
+        elsif key.to_i != key
+          throw "Array index requires integer key"
+        elsif object.size <= key
+          throw "Array index out of bounds"
+        end
+      else
+        throw "Array index requires integer key"
+      end
+    elsif object.is_a?(Hash)
+      if object.has_key?(key)
+        object[key]
+      else
+        throw "Key #{key} does not exist on object"
+      end
+    end
+  end
+end

lib/ahem/lexer.rb

@@ -36,6 +36,10 @@ class Lexer
       string = source.match(/^"([^"]*)"/)[1]
       @position += (string.size + 2)
       Token.new(TokenKinds::STRING, string)
+    elsif source.match(/^\:([a-z][a-zA-Z0-9_]*)/)
+      atom = source.match(/^\:([a-z][a-zA-Z0-9_]*)/)[1]
+      @position += atom.size + 1
+      Token.new(TokenKinds::ATOM, atom.to_sym)
     elsif source.match(/^\+/)
       @position += 1
       Token.new(TokenKinds::OPERATOR, :+)
@@ -75,9 +79,12 @@ class Lexer
     elsif source.match(/^\./)
       @position += 1
       Token.new(TokenKinds::DOT)
+    elsif source.match(/^=>/)
+      @position += 2
+      Token.new(TokenKinds::ROCKET)
     elsif source.match(/^==/)
       @position += 2
-      Token.new(TokenKinds::OPERATOR, :==)      
+      Token.new(TokenKinds::OPERATOR, :==)
     elsif source.match(/^\<=/)
       @position += 2
       Token.new(TokenKinds::OPERATOR, :<=)

lib/ahem/parser.rb

@@ -217,10 +217,15 @@ class Parser
     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
     else
       throw "Unexpected token #{token.type}"
     end
@@ -228,6 +233,11 @@ class Parser
     if @current_token.type == TokenKinds::LPAREN
       args = arguments
       AST::FunctionCall.new(expr, args)
+    elsif @current_token.type == TokenKinds::LBRACKET
+      eat(TokenKinds::LBRACKET)
+      key = expression
+      eat(TokenKinds::RBRACKET)
+      AST::Index.new(expr, key)
     else
       expr
     end
@@ -257,6 +267,29 @@ class Parser
     AST::Array.new(elements)
   end
 
+  def hash
+    h = Hash.new
+    eat(TokenKinds::LBRACE)
+
+    until @current_token.type == TokenKinds::RBRACE
+      key = eat(TokenKinds::ATOM).value
+      eat(TokenKinds::ROCKET)
+      value = expression
+
+      h[key] = value
+
+      if @current_token.type == TokenKinds::COMMA
+        eat(TokenKinds::COMMA)
+      else
+        break
+      end
+    end
+
+    eat(TokenKinds::RBRACE)
+
+    AST::Hash.new(h)
+  end
+
   def arguments
     args = Array.new
     eat(TokenKinds::LPAREN)

lib/ahem/token_kinds.rb

@@ -1,4 +1,5 @@
 module TokenKinds
+  ATOM = :atom
   BOOLEAN = :boolean
   CLASS = :class
   CLASS_NAME = :class_name
@@ -22,6 +23,7 @@ module TokenKinds
   PUBLIC = :public
   RBRACE = :rbrace
   RBRACKET = :rbracket
+  ROCKET = :rocket
   RPAREN = :rparen
   SEMICOLON = :semicolon
   STRING = :string

spec/lexer_spec.rb

@@ -123,4 +123,17 @@ RSpec.describe Lexer do
       ]
     )
   end
+
+  it 'lexes hash' do
+    expect(Lexer.new('{ :a => 1 }').scan_all).to eq(
+      [
+        Token.new(TokenKinds::LBRACE),
+        Token.new(TokenKinds::ATOM, :a),
+        Token.new(TokenKinds::ROCKET),
+        Token.new(TokenKinds::NUMBER, 1.0),
+        Token.new(TokenKinds::RBRACE),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
 end

spec/parser_spec.rb

@@ -323,4 +323,36 @@ RSpec.describe Parser do
       ]
     )
   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),
+          }
+        )
+      ]
+    )
+  end
+
+  it 'parses bracket indexing' do
+    expect(parse('array[0];')).to eq(
+      [
+        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)
+      ]
+    )
+  end
 end