Merge pull request #16 from nafasebra/stable

Add some string functions in built-in functions

Author: ali77gh

src/builtin_function/mod.rs

@@ -80,6 +80,10 @@ pub fn function_match(function_name: &str) -> Option<BuiltinFunction> {
         "length" | "len" => Some(strings::length::length),
         "contains" | "has" => Some(strings::contains::contains),
         "slice" | "substring" => Some(strings::slice::slice),
+        "charat" => Some(strings::char_at::char_at),
+        "toupper" | "uppercase" => Some(strings::to_upper::to_upper),
+        "tolower" | "lowercase" => Some(strings::to_lower::to_lower),
+        "trim" => Some(strings::trim::trim),
         "insert" | "push" => Some(list::insert::insert),
         "get" | "at" => Some(list::get::get),
         "pop" => Some(list::pop::pop),

src/builtin_function/strings/char_at.rs

@@ -0,0 +1,54 @@
+use crate::builtin_function::utils::{param_to_datatype, returns};
+use crate::common::data_type::DataType;
+use crate::common::errors::{ChapError, Result};
+use crate::{common::executable::ExecutableLine, runtime::Runtime};
+
+pub fn char_at(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
+    let p1 = param_to_datatype(runtime, executable.params.first(), executable.line_number)?;
+    let p2 = param_to_datatype(runtime, executable.params.get(1), executable.line_number)?;
+
+    let (string_value, index) = match (&p1, &p2) {
+        (DataType::String(s), DataType::Int(i)) => (s, *i),
+        _ => {
+            return Err(ChapError::runtime_with_msg(
+                executable.line_number,
+                format!(
+                    "{} function requires a string as first parameter and an integer as second parameter",
+                    executable.function_name
+                ),
+            ));
+        }
+    };
+
+    // Chap uses 1-based indexing, so index must be >= 1
+    if index < 1 {
+        return Err(ChapError::runtime_with_msg(
+            executable.line_number,
+            format!(
+                "Index {} is invalid. Index must be 1 or greater (1-based indexing)",
+                index
+            ),
+        ));
+    }
+
+    let index_usize = index as usize;
+    
+    // Check if index is within bounds (convert to 0-based for length check)
+    if index_usize > string_value.len() {
+        return Err(ChapError::runtime_with_msg(
+            executable.line_number,
+            format!(
+                "Index {} is out of bounds for string of length {}",
+                index,
+                string_value.len()
+            ),
+        ));
+    }
+
+    // Get the character at the specified index (convert to 0-based indexing)
+    let chars: Vec<char> = string_value.chars().collect();
+    let result_char = chars[index_usize - 1];
+    let result = DataType::String(result_char.to_string());
+
+    returns(runtime, executable, result)
+}

src/builtin_function/strings/mod.rs

@@ -1,5 +1,9 @@
+pub mod char_at;
 pub mod contact;
 pub mod contains;
 pub mod length;
 pub mod repeat;
 pub mod slice;
+pub mod to_lower;
+pub mod to_upper;
+pub mod trim;

src/builtin_function/strings/to_lower.rs

@@ -0,0 +1,23 @@
+use crate::builtin_function::utils::{param_to_datatype, returns};
+use crate::common::data_type::DataType;
+use crate::common::errors::{ChapError, Result};
+use crate::{common::executable::ExecutableLine, runtime::Runtime};
+
+pub fn to_lower(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
+    let p1 = param_to_datatype(runtime, executable.params.first(), executable.line_number)?;
+
+    let result = match p1 {
+        DataType::String(s) => DataType::String(s.to_lowercase()),
+        _ => {
+            return Err(ChapError::runtime_with_msg(
+                executable.line_number,
+                format!(
+                    "{} function input param should be string",
+                    executable.function_name
+                ),
+            ));
+        }
+    };
+
+    returns(runtime, executable, result)
+}

src/builtin_function/strings/to_upper.rs

@@ -0,0 +1,23 @@
+use crate::builtin_function::utils::{param_to_datatype, returns};
+use crate::common::data_type::DataType;
+use crate::common::errors::{ChapError, Result};
+use crate::{common::executable::ExecutableLine, runtime::Runtime};
+
+pub fn to_upper(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
+    let p1 = param_to_datatype(runtime, executable.params.first(), executable.line_number)?;
+
+    let result = match p1 {
+        DataType::String(s) => DataType::String(s.to_uppercase()),
+        _ => {
+            return Err(ChapError::runtime_with_msg(
+                executable.line_number,
+                format!(
+                    "{} function input param should be string",
+                    executable.function_name
+                ),
+            ));
+        }
+    };
+
+    returns(runtime, executable, result)
+}

src/builtin_function/strings/trim.rs

@@ -0,0 +1,23 @@
+use crate::builtin_function::utils::{param_to_datatype, returns};
+use crate::common::data_type::DataType;
+use crate::common::errors::{ChapError, Result};
+use crate::{common::executable::ExecutableLine, runtime::Runtime};
+
+pub fn trim(runtime: &mut Runtime, executable: &ExecutableLine) -> Result<()> {
+    let p1 = param_to_datatype(runtime, executable.params.first(), executable.line_number)?;
+
+    let result = match p1 {
+        DataType::String(s) => DataType::String(s.trim().to_string()),
+        _ => {
+            return Err(ChapError::runtime_with_msg(
+                executable.line_number,
+                format!(
+                    "{} function input param should be string",
+                    executable.function_name
+                ),
+            ));
+        }
+    };
+
+    returns(runtime, executable, result)
+}