Use method and classmethod keywords

lib/ahem/ast/class_definition.rb

 class AST::ClassDefinition
-  attr_reader :name, :members, :methods
+  attr_reader :name, :members, :instance_methods, :class_methods
 
-  def initialize(name, members, methods)
+  def initialize(name, members, instance_methods, class_methods)
     @name = name
     @members = members
-    @methods = methods
+    @instance_methods = instance_methods
+    @class_methods = class_methods
   end
 
   def ==(other)
     other.is_a?(AST::ClassDefinition) && other.name == @name &&
       other.members == @members &&
-      other.methods == @methods
+      other.instance_methods == @instance_methods
+      other.class_methods == @class_methods
   end
 
   def execute(env)

lib/ahem/lexer.rb

     elsif source.match(/\Afunction/)
       @position += 8
       Token.new(TokenKinds::FUNCTION)
+    elsif source.match(/\Amethod/)
+      @position += 6
+      Token.new(TokenKinds::METHOD)
+    elsif source.match(/\Aclassmethod/)
+      @position += 11
+      Token.new(TokenKinds::CLASSMETHOD)
     elsif source.match(/\Aclass/)
       @position += 5
       Token.new(TokenKinds::CLASS)

lib/ahem/parser.rb

 
   def function_definition
     eat(TokenKinds::FUNCTION)
+    _function_definition
+  end
+
+  def method_definition
+    eat(TokenKinds::METHOD)
+    _function_definition
+  end
+
+  def classmethod_definition
+    eat(TokenKinds::CLASSMETHOD)
+    _function_definition
+  end
+
+  def _function_definition
     name = identifier
     params = parameters
     body = block
       eat(TokenKinds::SEMICOLON)
     end
 
-    methods = Array.new
-    while @current_token.type == TokenKinds::FUNCTION
-      methods << function_definition
+    class_methods = Array.new
+    instance_methods = Array.new
+    while [TokenKinds::METHOD, TokenKinds::CLASSMETHOD].include?(@current_token.type)
+      case @current_token.type
+      when TokenKinds::METHOD
+        instance_methods << method_definition
+      when TokenKinds::CLASSMETHOD
+        class_methods << classmethod_definition
+      end
     end
 
     eat(TokenKinds::RBRACE)
 
-    AST::ClassDefinition.new(class_name, property_declarations, methods)
+    AST::ClassDefinition.new(class_name, property_declarations, instance_methods, class_methods)
   end
 
   def conditional

lib/ahem/token_kinds.rb

   ATOM = :atom
   BOOLEAN = :boolean
   CLASS = :class
+  CLASSMETHOD = :classmethod
   CLASS_NAME = :class_name
   COMMA = :comma
   DOT = :dot
   LBRACKET = :lbracket
   LPAREN = :lparen
   LET = :let
+  METHOD = :method
   NULL = :null
   NUMBER = :number
   OPERATOR = :operator

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/lexer_spec.rb

       [Token.new(TokenKinds::HASH), Token.new(TokenKinds::EOF)]
     )
   end
+
+  it 'lexes method and classmethod' do
+    expect(Lexer.new('method classmethod').scan_all).to eq(
+      [
+        Token.new(TokenKinds::METHOD),
+        Token.new(TokenKinds::CLASSMETHOD),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
 end

spec/parser_spec.rb

           class Class {
             public foo, bar;
             private baz;
-            function method() {
-              "method";
+            method my_method() {
+              "my method";
+            }
+            classmethod my_classmethod() {
+              "my classmethod";
             }
           }
         CLASS
           ],
           [
             AST::FunctionDefinition.new(
-              AST::Identifier.new('method'),
+              AST::Identifier.new('my_method'),
               [],
               AST::Block.new([AST::String.new('method')])
             )
+          ],
+          [
+            AST::FunctionDefinition.new(
+              AST::Identifier.new('my_classmethod'),
+              [],
+              AST::Block.new([AST::String.new('my classmethod')])
+            )
           ]
         )
       ]