Merge pull request #12 from Ph0enixKM/A10

A10 Feature: Add Text Interpolation

Cargo.toml

@@ -6,5 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heraclitus-compiler = "0.2.1"
-similar-string = "0.1.1"
+heraclitus-compiler = "1.2.2"
+similar-string = "1.4.2"

src/main.rs

@@ -8,14 +8,14 @@ use crate::utils::metadata::ParserMetadata;
 
 fn main() {
     let code = vec![
-        "let age = 12",
-        "age = age + 12"
+        "'interpolate {'this {1} this'} and {'that'} :)'"
     ].join("\n");
     let rules = rules::get_rules();
     let mut cc = Compiler::new("Amber", rules);
     let mut block = block::Block::new();
     cc.load(code);
     if let Ok(tokens) = cc.tokenize() {
+        println!("{:?}", tokens);
         let path = Some(format!("/path/to/file"));
         let mut meta = ParserMetadata::new(tokens, path);
         if let Ok(()) = block.parse_debug(&mut meta) {

src/modules/expression/binop/mod.rs

@@ -40,8 +40,8 @@ fn binop_left_cut(meta: &mut ParserMetadata, op: impl AsRef<str>) -> Result<usiz
             }
         }
         match token.word.as_str() {
-            "(" => parenthesis += 1,
-            ")" => parenthesis -= 1,
+            "(" | "{" => parenthesis += 1,
+            ")" | "}" => parenthesis -= 1,
             "\n" => break,
             _ => {}
         };

src/modules/expression/literal/text.rs

@@ -1,9 +1,57 @@
 use heraclitus_compiler::prelude::*;
 use crate::{utils::metadata::ParserMetadata, modules::{Type, Typed}};
+use crate::modules::expression::expr::Expr;
 
 #[derive(Debug)]
 pub struct Text {
-    value: String
+    strings: Vec<String>,
+    interps: Vec<Expr>
+}
+
+impl Text {
+    fn closure_full_string(word: &String) -> bool {
+        word.starts_with('\'') && word.ends_with('\'') && word.len() > 1
+    }
+
+    fn parse_text(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        // Handle full string
+        if let Ok(word) = token_by(meta, Text::closure_full_string) {
+            let stripped = word.chars().take(word.len() - 1).skip(1).collect::<String>();
+            self.strings.push(stripped);
+            Ok(())
+        }
+        else {
+            let mut is_interp = false;
+            // Initialize string
+            self.strings.push(token_by(meta, |word| word.starts_with('\''))?);
+            // Factor rest of the interpolation
+            while let Some(token) = meta.get_current_token() {
+                // Track interpolations
+                match token.word.as_str() {
+                    "{" => is_interp = true,
+                    "}" => is_interp = false,
+                    // Manage inserting strings and intrpolations
+                    _ => if is_interp {
+                        let mut expr = Expr::new();
+                        syntax(meta, &mut expr)?;
+                        self.interps.push(expr);
+                        // TODO: [H50] In the next release of Heraclitus
+                        // Change this line to `meta.offset_index(-1)`
+                        meta.set_index(meta.get_index() - 1);
+                    }
+                    else {
+                        self.strings.push(token.word.clone());
+                        if token.word.ends_with('\'') {
+                            meta.increment_index();
+                            return Ok(())
+                        }
+                    }
+                }
+                meta.increment_index();
+            }
+            Err(ErrorDetails::from_metadata(meta))
+        }
+    }
 }
 
 impl Typed for Text {
@@ -17,13 +65,13 @@ impl SyntaxModule<ParserMetadata> for Text {
 
     fn new() -> Self {
         Text {
-            value: format!("")
+            strings: vec![],
+            interps: vec![]
         }
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        self.value = token_by(meta, |word| word.starts_with('\'') && word.ends_with('\''))?;
-        self.value = self.value.chars().take(self.value.len() - 2).skip(1).collect::<String>();
+        self.parse_text(meta)?;
         Ok(())
     }
 }

src/modules/variable/mod.rs

@@ -29,9 +29,10 @@ pub fn handle_variable_reference(meta: &mut ParserMetadata, token: Option<Token>
 
 fn handle_similar_variable(meta: &mut ParserMetadata, name: String) -> Option<String> {
     let vars = Vec::from_iter(meta.var_mem.get_available_variables());
-    let (match_name, score) = find_best_similarity(name, &vars);
-    match score >= 0.75 {
-        true => Some(format!("Did you mean '{match_name}'?")),
-        false => None
-    }
+    if let Some((match_name, score)) = find_best_similarity(name, &vars) {
+        match score >= 0.75 {
+            true => Some(format!("Did you mean '{match_name}'?")),
+            false => None
+        }
+    } else { None }
 }

src/rules.rs

@@ -15,7 +15,13 @@ pub fn get_rules() -> Rules {
         reg!(string as "string literal" => {
             begin: "'",
             end: "'"
-        })
+        } => [
+            reg!(interp as "string interpolation" => {
+                begin: "{",
+                end: "}",
+                tokenize: true
+            } ref global)
+        ])
     ];
     Rules::new(symbols, compounds, region)
 }