Executor planned. Interpreted started. Minor fixes in Parser

build.gradle

@@ -25,3 +25,18 @@ project(':parser') {
         compile project(":lexer")
     }
 }
+
+project(':interpreter') {
+    dependencies {
+        compile project(":lexer")
+        compile project(":parser")
+    }
+}
+
+project(':executor') {
+    dependencies {
+        compile project(":lexer")
+        compile project(":parser")
+        compile project(":interpreter")
+    }
+}

executor/src/main/java/Executor.java

@@ -0,0 +1,23 @@
+import lexer.Lexer;
+import lexer.LexerImpl;
+import parser.Parser;
+import parser.ParserImpl;
+import interpreter.Interpreter;
+import interpreter.InterpreterImpl;
+
+public class Executor {
+
+    private Lexer lexer;
+    private Parser parser;
+    private Interpreter interpreter;
+
+    public Executor(){
+        this.lexer = new LexerImpl();
+        this.parser = new ParserImpl();
+        this.interpreter = new InterpreterImpl();
+    }
+
+    public void execute(String file){
+        interpreter.interpret(parser.parse(lexer.lex(file)));
+    }
+}

executor/src/test/java/ExecutorTest.java

@@ -0,0 +1,15 @@
+import org.junit.jupiter.api.Test;
+
+public class ExecutorTest {
+
+    @Test
+    public void executeLines(){
+        Executor executor = new Executor();
+
+        String program = "let foo : number= 5;\n" +
+                         "let bar :number = foo + 4;\n" +
+                         "print(bar + \"is a\" + \'word\');\n";
+
+        executor.execute(program);
+    }
+}

interpreter/src/main/java/interpreter/Interpreter.java

@@ -0,0 +1,7 @@
+package interpreter;
+
+import ast.ASTNode;
+
+public interface Interpreter {
+    void interpret(ASTNode program);
+}

interpreter/src/main/java/interpreter/InterpreterImpl.java

@@ -0,0 +1,10 @@
+package interpreter;
+
+import ast.ASTNode;
+
+public class InterpreterImpl implements Interpreter {
+    @Override
+    public void interpret(ASTNode program) {
+
+    }
+}

lexer/src/main/java/lexer/Lexer.java

@@ -14,5 +14,5 @@ public interface Lexer {
      * @param file a text file converted to string properly separated by the ' ' character (whitespace)
      * @return a list of the tokens contained in the file, in lexical order
      */
-    List<Token> tokenize(String file);
+    List<Token> lex(String file);
 }

lexer/src/main/java/lexer/LexerImpl.java

@@ -20,7 +20,7 @@ public LexerImpl(){
     }
 
     @Override
-    public List<Token> tokenize(String file) {
+    public List<Token> lex(String file) {
         return mapToToken(splitPossibleTokens(file));
     }
 

parser/src/main/java/ast/ASTNodeFactory.java

@@ -1,21 +1,24 @@
 package ast;
 
 import exceptions.ParserException;
-import handlers.AssignationHandler;
-import handlers.DeclarationAssignationHandler;
-import handlers.DeclarationHandler;
-import handlers.PrintHandler;
+import handlers.*;
 import tokens.Token;
 import tokens.TokenType;
 
 import java.util.List;
 
 public class ASTNodeFactory {
-    private DeclarationHandler declarationHandler;
-    private AssignationHandler assignationHandler;
-    private DeclarationAssignationHandler declarationAssignationHandler;
-    private PrintHandler printHandler;
+    private Handler declarationHandler;
+    private Handler assignationHandler;
+    private Handler declarationAssignationHandler;
+    private Handler printHandler;
 
+    public ASTNodeFactory(){
+        this.declarationHandler = new DeclarationHandler();
+        this.assignationHandler = new AssignationHandler();
+        this.declarationAssignationHandler = new DeclarationAssignationHandler();
+        this.printHandler = new PrintHandler();
+    }
 
     public ASTNode getNode(List<Token> statement) {
         switch (statement.get(0).getType()) {

parser/src/main/java/handlers/ExpressionHandler.java

@@ -17,14 +17,14 @@ protected ASTNode parseNode(List<Token> expression) {
                 () -> parseBinaryExpression(TokenType.MINUS, expression).orElseGet(
                         () -> parseBinaryExpression(TokenType.MULTIPLY, expression).orElseGet(
                                 () -> parseBinaryExpression(TokenType.DIVIDE, expression).orElseGet(
-                                        ()-> parseIndentifierOrLiteral(expression)
+                                        ()-> parseIdentifierOrLiteral(expression)
                                )
                        )
                 )
         );
     }
 
-    private ASTNode parseIndentifierOrLiteral(List<Token> expression) {
+    private ASTNode parseIdentifierOrLiteral(List<Token> expression) {
         Token token = expression.get(0);
         if(Arrays.asList(TokenType.NUM_LITERAL, TokenType.STR_LITERAL).contains(expression.get(0).getType())) return new Literal(Type.from(token), token.getValue());
         if(TokenType.IDENTIFIER == token.getType()) return new Identifier(token.getValue());