Added Interpreter

Author: arkada38

Cargo.toml

@@ -4,3 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+regex = "1"

README.md

@@ -21,7 +21,7 @@ Decorator               | Structural |   ✅   | [Wiki](https://en.wikipedia.org
 Facade                  | Structural |   ✅   | [Wiki](https://en.wikipedia.org/wiki/Facade_pattern)                  |
 Factory Method          | Creational |   ✅   | [Wiki](https://en.wikipedia.org/wiki/Factory_method_pattern)          |
 Flyweight               | Structural |   ✅   | [Wiki](https://en.wikipedia.org/wiki/Flyweight_pattern)               |
-Interpreter             | Behavioral |   ⏳   | [Wiki](https://en.wikipedia.org/wiki/Interpreter_pattern)             |
+Interpreter             | Behavioral |   ✅   | [Wiki](https://en.wikipedia.org/wiki/Interpreter_pattern)             |
 Iterator                | Behavioral |   ⏳   | [Wiki](https://en.wikipedia.org/wiki/Iterator_pattern)                |
 Mediator                | Behavioral |   ⏳   | [Wiki](https://en.wikipedia.org/wiki/Mediator_pattern)                |
 Memento                 | Behavioral |   ⏳   | [Wiki](https://en.wikipedia.org/wiki/Memento_pattern)                 |

examples/behavioral_interpreter_shop_assistant.rs

@@ -0,0 +1,12 @@
+use std::error::Error;
+use design_patterns::behavioral::interpreter::shop_assistant::Order;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let order = Order::parse("order x100 'pack of toothpicks' from Tesco")?;
+    println!("{:#?}", order);
+    
+    let order = Order::parse("order x5 'pack of milk' from Macro")?;
+    println!("{:#?}", order);
+
+    Ok(())
+}

src/behavioral/interpreter/mod.rs

@@ -0,0 +1,16 @@
+//! # Interpreter
+//!
+//! ## Type
+//!
+//! Behavioral
+//!
+//! ## Description
+//!
+//! In computer programming, the interpreter pattern is a design pattern that
+//! specifies how to evaluate sentences in a language. The basic idea is to
+//! have a class for each symbol (terminal or nonterminal) in a specialized
+//! computer language. The syntax tree of a sentence in the language is an
+//! instance of the composite pattern and is used to evaluate (interpret) the
+//! sentence for a client.
+
+pub mod shop_assistant;

src/behavioral/interpreter/shop_assistant.rs

@@ -0,0 +1,72 @@
+use regex::Regex;
+use std::error::Error;
+
+#[derive(Debug, PartialEq)]
+pub struct Order {
+    pub qty: u32,
+    pub product: String,
+    pub source: String,
+}
+
+impl Order {
+    pub fn new<S: Into<String>>(qty: u32, product: S, source: S) -> Self {
+        Self {
+            qty,
+            product: product.into(),
+            source: source.into(),
+        }
+    }
+
+    pub fn parse<S: Into<String>>(command: S) -> Result<Self, Box<dyn Error>> {
+        // Grammar Representationconst
+        let optional_space = " ?";
+        let qty = String::from("x(?P<qty>\\d+)") + optional_space;
+        let product = String::from("'(?P<product>[\\w ]+)'") + optional_space;
+        let source = "from (?P<source>\\w+)";
+        let order_command =
+            String::from("order") + optional_space + qty.as_str() + product.as_str() + source;
+
+        let re = Regex::new(&order_command)?;
+        let command = command.into();
+        let x = re.captures(command.as_ref()).ok_or("Bad command")?;
+
+        Ok(Self {
+            product: x
+                .name("product")
+                .ok_or("Product not defined")?
+                .as_str()
+                .to_string(),
+            qty: x.name("qty").ok_or("Qty not defined")?.as_str().parse()?,
+            source: x
+                .name("source")
+                .ok_or("Source not defined")?
+                .as_str()
+                .to_string(),
+        })
+    }
+}
+
+impl Default for Order {
+    fn default() -> Self {
+        Self::new(1, "Ice cream", "Five")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Order;
+
+    #[test]
+    fn test_1() {
+        let order = Order::new(12, "1L milk packs", "Macro");
+        let command = "order x12 '1L milk packs' from Macro";
+        assert_eq!(order, Order::parse(command).unwrap());
+    }
+
+    #[test]
+    fn test_2() {
+        let order = Order::new(1, "a bag of potatoes", "Tesco");
+        let command = "order x1 'a bag of potatoes' from Tesco";
+        assert_eq!(order, Order::parse(command).unwrap());
+    }
+}

src/behavioral/mod.rs

@@ -4,7 +4,7 @@
 //!
 //! 1. [Chain of Responsibility](chain_of_responsibility)
 //! 1. [Command](command)
-//! 1. Interpreter
+//! 1. [Interpreter](interpreter)
 //! 1. Iterator
 //! 1. Mediator
 //! 1. Memento
@@ -16,3 +16,4 @@
 
 pub mod chain_of_responsibility;
 pub mod command;
+pub mod interpreter;