add str::substring

README.md

@@ -407,6 +407,7 @@ Symmetrically, the `EmptyContextWithBuiltinFunctions` has builtin functions enab
 | `str::to_uppercase`  | 1               | String                        | Returns the upper-case version of the string |
 | `str::trim`          | 1               | String                        | Strips whitespace from the start and the end of the string |
 | `str::from`          | >= 0            | Any                           | Returns passed value as string |
+| `str::substring`     | 3               | String, Int, Int              | Returns a substring of the first argument, starting at the second argument and ending at the third argument. If the last argument is omitted, the substring extends to the end of the string |
 | `bitand`             | 2               | Int                           | Computes the bitwise and of the given integers |
 | `bitor`              | 2               | Int                           | Computes the bitwise or of the given integers |
 | `bitxor`             | 2               | Int                           | Computes the bitwise xor of the given integers |

src/error/display.rs

@@ -128,6 +128,7 @@ impl fmt::Display for EvalexprError {
                 write!(f, "This context does not allow disabling builtin functions")
             },
             IllegalEscapeSequence(string) => write!(f, "Illegal escape sequence: {}", string),
+            OutOfBoundsAccess => write!(f, "Tried to access a tuple or string at an invalid index"),
             CustomMessage(message) => write!(f, "Error: {}", message),
         }
     }

src/error/mod.rs

@@ -214,6 +214,9 @@ pub enum EvalexprError {
     /// This context does not allow disabling builtin functions.
     BuiltinFunctionsCannotBeDisabled,
 
+    /// Out of bounds sequence access.
+    OutOfBoundsAccess,
+
     /// A custom error explained by its message.
     CustomMessage(String),
 }

src/function/builtin.rs

@@ -5,7 +5,10 @@ use crate::{
     value::{FloatType, IntType},
     EvalexprError, Function, Value, ValueType,
 };
-use std::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
+use std::{
+    convert::TryFrom,
+    ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr},
+};
 
 macro_rules! simple_math {
     ($func:ident) => {
@@ -267,6 +270,27 @@ pub fn builtin_function(identifier: &str) -> Option<Function> {
         "str::from" => Some(Function::new(|argument| {
             Ok(Value::String(argument.to_string()))
         })),
+        "str::substring" => Some(Function::new(|argument| {
+            let args = argument.as_tuple()?;
+            let subject = args
+                .get(0)
+                .ok_or_else(|| EvalexprError::wrong_function_argument_amount(0, 2))?
+                .as_string()?;
+            let start = args
+                .get(1)
+                .ok_or_else(|| EvalexprError::wrong_function_argument_amount(1, 2))?
+                .as_int()?;
+            let start = usize::try_from(start).map_err(|_| EvalexprError::OutOfBoundsAccess)?;
+            let end = if let Some(end) = args.get(2) {
+                usize::try_from(end.as_int()?).map_err(|_| EvalexprError::OutOfBoundsAccess)?
+            } else {
+                subject.len()
+            };
+            if start > end || end > subject.len() {
+                return Err(EvalexprError::OutOfBoundsAccess);
+            }
+            Ok(Value::from(&subject[start..end]))
+        })),
         #[cfg(feature = "rand")]
         "random" => Some(Function::new(|argument| {
             argument.as_empty()?;

src/lib.rs

@@ -388,6 +388,7 @@
 //! | `str::to_uppercase`  | 1               | String                        | Returns the upper-case version of the string |
 //! | `str::trim`          | 1               | String                        | Strips whitespace from the start and the end of the string |
 //! | `str::from`          | >= 0            | Any                           | Returns passed value as string |
+//! | `str::substring`     | 3               | String, Int, Int              | Returns a substring of the first argument, starting at the second argument and ending at the third argument. If the last argument is omitted, the substring extends to the end of the string |
 //! | `bitand`             | 2               | Int                           | Computes the bitwise and of the given integers |
 //! | `bitor`              | 2               | Int                           | Computes the bitwise or of the given integers |
 //! | `bitxor`             | 2               | Int                           | Computes the bitwise xor of the given integers |
@@ -565,7 +566,7 @@
 //! ## License
 //!
 //! This crate is primarily distributed under the terms of the MIT license.
 //! See [LICENSE](LICENSE) for details.
 //!
 
 #![deny(missing_docs)]

tests/integration.rs

@@ -515,6 +515,24 @@ fn test_builtin_functions() {
         Ok(Value::String(String::from("(1, 2, 3)")))
     );
     assert_eq!(eval("str::from()"), Ok(Value::String(String::from("()"))));
+    assert_eq!(
+        eval("str::substring(\"foobar\", 3)"),
+        Ok(Value::String(String::from("bar")))
+    );
+    assert_eq!(
+        eval("str::substring(\"foobar\", 3, 3)"),
+        Ok(Value::String(String::from("")))
+    );
+    assert_eq!(
+        eval("str::substring(\"foobar\", 3, 4)"),
+        Ok(Value::String(String::from("b")))
+    );
+    assert!(eval("str::substring()").is_err());
+    assert!(eval("str::substring(\"foobar\")").is_err());
+    assert!(eval("str::substring(\"foobar\", 2, 1)").is_err());
+    assert!(eval("str::substring(\"foobar\", 99999)").is_err());
+    assert!(eval("str::substring(\"foobar\", -1)").is_err());
+    assert!(eval("str::substring(\"foobar\", 0, -1)").is_err());
     // Bitwise
     assert_eq!(eval("bitand(5, -1)"), Ok(Value::Int(5)));
     assert_eq!(eval("bitand(6, 5)"), Ok(Value::Int(4)));