Implements interpreter

Author: LBeghini

README.md

@@ -1,90 +1,7 @@
 # ☕ Java Design Patterns
 
-## About
+## Interpreter
 
-This application is a simple Java Console Application that aims to implement design pattern examples to a Programmin Language Class. A set of design patterns will be developed
-each week, and they are divided in different [branches](https://github.com/LBeghini/Java-Design-Patterns/branches).  
+Interpreter pattern interprets sentences to match an desired expression type.
 
-The main branch is just a template for every other branch.
-
-Also, to make it easier to download the source code, [releases](https://github.com/LBeghini/Java-Design-Patterns/releases) are created related to the task of the week, giving a snapshot of the code for that specific implementation.
-
-## Implemented design patterns
-
-### Behavioural patterns
-
-- [x] [Chain of responsibility](https://github.com/LBeghini/Java-Design-Patterns/tree/4-chain-of-responsibility)
-- [x] [Command](https://github.com/LBeghini/Java-Design-Patterns/tree/6-command)
-- [x] [Iterator](https://github.com/LBeghini/Java-Design-Patterns/tree/4-iterator)
-- [x] [Memento](https://github.com/LBeghini/Java-Design-Patterns/tree/5-memento)
-- [x] [Observer](https://github.com/LBeghini/Java-Design-Patterns/tree/5-observer)
-- [x] [State](https://github.com/LBeghini/Java-Design-Patterns/tree/3-state)
-- [x] [Strategy](https://github.com/LBeghini/Java-Design-Patterns/tree/6-strategy)
-- [x] [Template method](https://github.com/LBeghini/Java-Design-Patterns/tree/4-template-method)
-
-### Creational patterns
-
-- [ ] Abstract factory
-- [x] [Builder](https://github.com/LBeghini/Java-Design-Patterns/tree/1-builder)
-- [x] [Factory method](https://github.com/LBeghini/Java-Design-Patterns/tree/2-factory-method)
-- [x] [Prototype](https://github.com/LBeghini/Java-Design-Patterns/tree/2-prototype)
-- [x] [Singleton](https://github.com/LBeghini/Java-Design-Patterns/tree/1-singleton)
-
-### Structural patterns
-
-- [x] [Adapter](https://github.com/LBeghini/Java-Design-Patterns/tree/7-adapter)
-- [x] [Bridge](https://github.com/LBeghini/Java-Design-Patterns/tree/7-bridge)
-- [x] [Composite](https://github.com/LBeghini/Java-Design-Patterns/tree/8-composite)
-- [ ] Decorator
-- [x] [Facade](https://github.com/LBeghini/Java-Design-Patterns/tree/8-facade)
-- [ ] Flyweight
-- [ ] Mediator
-- [ ] Proxy
-
-## Technologies
-
-- Java
-- JUnit
-- Maven
-
-## Requirements 
-
-To run and edit the project, be sure to have installed in your computer the following softwares:
-- A code editor
-
-After that, you'll need to clone this repo:
-
-```bash
-git clone https://github.com/LBeghini/Java-Design-Patterns.git
-```
-
-## Change branch
-
-To change to a different branch, run the command:
-
-```bash
-git checkout name-of-the-branch
-```
-
-The branch names have the pattern:
-
-```bash
-{number-of-the-week}-{pattern-name}
-```
-
-> `number-of-the-week` corresponds to the week asked to be implemented certain pattern 
-
-## Testing
-
-This project has no aim to run any of the implemented classes, as the goal is the code itself. However, the classes will be tested to visualize the behaviour and implementation 
-of the patterns.  
-
-You can run the tests using the maven wrapper:
-
-```bash
-./mvnw test 
-```
-
-## :balance_scale: License
-
-[MIT License](https://github.com/LBeghini/Java-Design-Patterns/blob/main/LICENSE)
+For example, let's say we want to validate logical expressions such as greather than, less than and equals. For that, we would write "6 > 3" or "3 < 7" or "2 = 2". However, those are strings, and they must be interpreted so the computer can understand.

src/main/java/com/language/programming/model/Interpreter.java

@@ -0,0 +1,15 @@
+package com.language.programming.model;
+
+public abstract class Interpreter {
+
+    protected Integer left;
+    protected Integer right;
+
+    public Interpreter(Integer left, Integer right) {
+        this.left = left;
+        this.right = right;
+    };
+
+    public abstract boolean interpret();
+
+}

src/main/java/com/language/programming/model/InterpreterLogicExpressions.java

@@ -0,0 +1,49 @@
+package com.language.programming.model;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.language.programming.model.operators.*;
+
+public class InterpreterLogicExpressions {
+
+    private String expression;
+
+    public InterpreterLogicExpressions(String expression) {
+        this.expression = expression;
+    }
+
+    public boolean interpret() {
+        List<String> elements = Arrays.asList(expression.split(" "));
+        Integer left = 0;
+        Integer right = 0;
+        Interpreter interpreter = null;
+
+        if (elements.size() != 3) {
+            throw new IllegalArgumentException();
+        }
+
+        try {
+            left = Integer.parseInt(elements.get(0));
+            right = Integer.parseInt(elements.get(2));
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        if (elements.get(1).equals(">")) {
+            interpreter = new GreaterThan(left, right);
+        }
+
+        if (elements.get(1).equals("<")) {
+            interpreter = new LessThan(left, right);
+        }
+
+        if (elements.get(1).equals("=")) {
+            interpreter = new Equals(left, right);
+        }
+
+        return interpreter.interpret();
+    }
+
+}

src/main/java/com/language/programming/model/operators/Equals.java

@@ -0,0 +1,15 @@
+package com.language.programming.model.operators;
+
+import com.language.programming.model.Interpreter;
+
+public class Equals extends Interpreter {
+
+    public Equals(Integer left, Integer right) {
+        super(left, right);
+    }
+
+    @Override
+    public boolean interpret() {
+        return left == right;
+    }
+}

src/main/java/com/language/programming/model/operators/GreaterThan.java

@@ -0,0 +1,15 @@
+package com.language.programming.model.operators;
+
+import com.language.programming.model.Interpreter;
+
+public class GreaterThan extends Interpreter {
+
+    public GreaterThan(Integer left, Integer right) {
+        super(left, right);
+    }
+
+    @Override
+    public boolean interpret() {
+        return left > right;
+    }
+}

src/main/java/com/language/programming/model/operators/LessThan.java

@@ -0,0 +1,15 @@
+package com.language.programming.model.operators;
+
+import com.language.programming.model.Interpreter;
+
+public class LessThan extends Interpreter {
+
+    public LessThan(Integer left, Integer right) {
+        super(left, right);
+    }
+
+    @Override
+    public boolean interpret() {
+        return left < right;
+    }
+}

src/test/java/com/language/programming/model/InterpreterTest.java

@@ -0,0 +1,45 @@
+package com.language.programming.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class InterpreterTest {
+
+    @Test
+    public void shouldReturnTrueGreatherThan() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("6 > 3");
+        assertTrue(interpreter.interpret());
+    }
+
+    @Test
+    public void shouldReturnFalseGreatherThan() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("3 > 3");
+        assertFalse(interpreter.interpret());
+    }
+
+    @Test
+    public void shouldReturnTrueLessThan() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("6 < 7");
+        assertTrue(interpreter.interpret());
+    }
+
+    @Test
+    public void shouldReturnFalseLessThan() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("3 < 3");
+        assertFalse(interpreter.interpret());
+    }
+
+    @Test
+    public void shouldReturnTrueEquals() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("6 = 6");
+        assertTrue(interpreter.interpret());
+    }
+
+    @Test
+    public void shouldReturnFalseEquals() {
+        InterpreterLogicExpressions interpreter = new InterpreterLogicExpressions("3 = 6");
+        assertFalse(interpreter.interpret());
+    }
+
+}