rhai/src/packages/string_more.rs

#![allow(non_snake_case)]

use crate::plugin::*;
use crate::stdlib::{
    any::TypeId, boxed::Box, format, mem, string::String, string::ToString, vec::Vec,
};
use crate::{def_package, Dynamic, FnPtr, ImmutableString, StaticVec, INT};

macro_rules! gen_concat_functions {
    ($root:ident => $($arg_type:ident),+ ) => {
        pub mod $root { $( pub mod $arg_type {
            use super::super::*;

            #[export_module]
            pub mod functions {
                #[rhai_fn(name = "+")]
                pub fn append_func(string: &str, arg: $arg_type) -> String {
                    format!("{}{}", string, arg)
                }

                #[rhai_fn(name = "+", pure)]
                pub fn prepend_func(arg: &mut $arg_type, string: &str) -> String {
                    format!("{}{}", arg, string)
                }
            }
        } )* }
    }
}

macro_rules! reg_functions {
    ($mod_name:ident += $root:ident ; $($arg_type:ident),+) => { $(
        combine_with_exported_module!($mod_name, "strings_concat", $root::$arg_type::functions);
    )* }
}

def_package!(crate:MoreStringPackage:"Additional string utilities, including string building.", lib, {
    reg_functions!(lib += basic; INT, bool,  FnPtr);

    #[cfg(not(feature = "only_i32"))]
    #[cfg(not(feature = "only_i64"))]
    {
        reg_functions!(lib += numbers; i8, u8, i16, u16, i32, i64, u32, u64);

        #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
        reg_functions!(lib += num_128; i128, u128);
    }

    #[cfg(not(feature = "no_float"))]
    reg_functions!(lib += float; f32, f64);

    combine_with_exported_module!(lib, "string", string_functions);

    // Register string iterator
    lib.set_iter(
        TypeId::of::<ImmutableString>(),
        |string: Dynamic| Box::new(string.cast::<ImmutableString>().chars().collect::<Vec<_>>().into_iter().map(Into::into))
    );
});

gen_concat_functions!(basic => INT, bool, char, FnPtr);

#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
gen_concat_functions!(numbers => i8, u8, i16, u16, i32, i64, u32, u64);

#[cfg(not(feature = "only_i32"))]
#[cfg(not(feature = "only_i64"))]
#[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
gen_concat_functions!(num_128 => i128, u128);

#[cfg(not(feature = "no_float"))]
gen_concat_functions!(float => f32, f64);

#[export_module]
mod string_functions {
    use crate::ImmutableString;

    #[rhai_fn(name = "+")]
    pub fn add_append_unit(string: ImmutableString, _x: ()) -> ImmutableString {
        string
    }
    #[rhai_fn(name = "+")]
    pub fn add_prepend_unit(_x: (), string: ImmutableString) -> ImmutableString {
        string
    }

    #[rhai_fn(name = "len", get = "len")]
    pub fn len(string: &str) -> INT {
        string.chars().count() as INT
    }

    pub fn clear(string: &mut ImmutableString) {
        string.make_mut().clear();
    }
    pub fn truncate(string: &mut ImmutableString, len: INT) {
        if len > 0 {
            let chars: StaticVec<_> = string.chars().collect();
            let copy = string.make_mut();
            copy.clear();
            copy.extend(chars.into_iter().take(len as usize));
        } else {
            string.make_mut().clear();
        }
    }
    pub fn trim(string: &mut ImmutableString) {
        let trimmed = string.trim();

        if trimmed.len() < string.len() {
            *string = trimmed.to_string().into();
        }
    }

    #[rhai_fn(name = "contains")]
    pub fn contains_char(string: &str, ch: char) -> bool {
        string.contains(ch)
    }
    pub fn contains(string: &str, find_string: &str) -> bool {
        string.contains(find_string)
    }

    #[rhai_fn(name = "index_of")]
    pub fn index_of_char_starting_from(string: &str, ch: char, start: INT) -> INT {
        let start = if start < 0 {
            0
        } else if start as usize >= string.chars().count() {
            return -1 as INT;
        } else {
            string
                .chars()
                .take(start as usize)
                .collect::<String>()
                .len()
        };

        string[start..]
            .find(ch)
            .map(|index| string[0..start + index].chars().count() as INT)
            .unwrap_or(-1 as INT)
    }
    #[rhai_fn(name = "index_of")]
    pub fn index_of_char(string: &str, ch: char) -> INT {
        string
            .find(ch)
            .map(|index| string[0..index].chars().count() as INT)
            .unwrap_or(-1 as INT)
    }
    #[rhai_fn(name = "index_of")]
    pub fn index_of_string_starting_from(string: &str, find_string: &str, start: INT) -> INT {
        let start = if start < 0 {
            0
        } else if start as usize >= string.chars().count() {
            return -1 as INT;
        } else {
            string
                .chars()
                .take(start as usize)
                .collect::<String>()
                .len()
        };

        string[start..]
            .find(find_string)
            .map(|index| string[0..start + index].chars().count() as INT)
            .unwrap_or(-1 as INT)
    }
    #[rhai_fn(name = "index_of")]
    pub fn index_of(string: &str, find_string: &str) -> INT {
        string
            .find(find_string)
            .map(|index| string[0..index].chars().count() as INT)
            .unwrap_or(-1 as INT)
    }

    pub fn sub_string(string: &str, start: INT, len: INT) -> ImmutableString {
        let offset = if string.is_empty() || len <= 0 {
            return "".to_string().into();
        } else if start < 0 {
            0
        } else if start as usize >= string.chars().count() {
            return "".to_string().into();
        } else {
            start as usize
        };

        let chars: StaticVec<_> = string.chars().collect();

        let len = if offset + len as usize > chars.len() {
            chars.len() - offset
        } else {
            len as usize
        };

        chars
            .iter()
            .skip(offset)
            .take(len)
            .cloned()
            .collect::<String>()
            .into()
    }
    #[rhai_fn(name = "sub_string")]
    pub fn sub_string_starting_from(string: &str, start: INT) -> ImmutableString {
        let len = string.len() as INT;
        sub_string(string, start, len)
    }

    #[rhai_fn(name = "crop")]
    pub fn crop(string: &mut ImmutableString, start: INT, len: INT) {
        let offset = if string.is_empty() || len <= 0 {
            string.make_mut().clear();
            return;
        } else if start < 0 {
            0
        } else if start as usize >= string.chars().count() {
            string.make_mut().clear();
            return;
        } else {
            start as usize
        };

        let chars: StaticVec<_> = string.chars().collect();

        let len = if offset + len as usize > chars.len() {
            chars.len() - offset
        } else {
            len as usize
        };

        let copy = string.make_mut();
        copy.clear();
        copy.extend(chars.iter().skip(offset).take(len));
    }
    #[rhai_fn(name = "crop")]
    pub fn crop_string_starting_from(string: &mut ImmutableString, start: INT) {
        crop(string, start, string.len() as INT);
    }

    #[rhai_fn(name = "replace")]
    pub fn replace(string: &mut ImmutableString, find_string: &str, substitute_string: &str) {
        *string = string.replace(find_string, substitute_string).into();
    }
    #[rhai_fn(name = "replace")]
    pub fn replace_string_with_char(
        string: &mut ImmutableString,
        find_string: &str,
        substitute_char: char,
    ) {
        *string = string
            .replace(find_string, &substitute_char.to_string())
            .into();
    }
    #[rhai_fn(name = "replace")]
    pub fn replace_char_with_string(
        string: &mut ImmutableString,
        find_char: char,
        substitute_string: &str,
    ) {
        *string = string
            .replace(&find_char.to_string(), substitute_string)
            .into();
    }
    #[rhai_fn(name = "replace")]
    pub fn replace_char(string: &mut ImmutableString, find_char: char, substitute_char: char) {
        *string = string
            .replace(&find_char.to_string(), &substitute_char.to_string())
            .into();
    }

    #[rhai_fn(return_raw)]
    pub fn pad(
        _ctx: NativeCallContext,
        string: &mut ImmutableString,
        len: INT,
        ch: char,
    ) -> Result<Dynamic, Box<crate::EvalAltResult>> {
        // Check if string will be over max size limit
        #[cfg(not(feature = "unchecked"))]
        if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
            return crate::EvalAltResult::ErrorDataTooLarge(
                "Length of string".to_string(),
                crate::Position::NONE,
            )
            .into();
        }

        if len > 0 {
            let orig_len = string.chars().count();

            if len as usize > orig_len {
                let p = string.make_mut();

                for _ in 0..(len as usize - orig_len) {
                    p.push(ch);
                }

                #[cfg(not(feature = "unchecked"))]
                if _ctx.engine().max_string_size() > 0
                    && string.len() > _ctx.engine().max_string_size()
                {
                    return crate::EvalAltResult::ErrorDataTooLarge(
                        "Length of string".to_string(),
                        crate::Position::NONE,
                    )
                    .into();
                }
            }
        }

        Ok(Dynamic::UNIT)
    }
    #[rhai_fn(name = "pad", return_raw)]
    pub fn pad_with_string(
        _ctx: NativeCallContext,
        string: &mut ImmutableString,
        len: INT,
        padding: &str,
    ) -> Result<Dynamic, Box<crate::EvalAltResult>> {
        // Check if string will be over max size limit
        #[cfg(not(feature = "unchecked"))]
        if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
            return crate::EvalAltResult::ErrorDataTooLarge(
                "Length of string".to_string(),
                crate::Position::NONE,
            )
            .into();
        }

        if len > 0 {
            let mut str_len = string.chars().count();
            let padding_len = padding.chars().count();

            if len as usize > str_len {
                let p = string.make_mut();

                while str_len < len as usize {
                    if str_len + padding_len <= len as usize {
                        p.push_str(padding);
                        str_len += padding_len;
                    } else {
                        p.extend(padding.chars().take(len as usize - str_len));
                        str_len = len as usize;
                    }
                }

                #[cfg(not(feature = "unchecked"))]
                if _ctx.engine().max_string_size() > 0
                    && string.len() > _ctx.engine().max_string_size()
                {
                    return crate::EvalAltResult::ErrorDataTooLarge(
                        "Length of string".to_string(),
                        crate::Position::NONE,
                    )
                    .into();
                }
            }
        }

        Ok(Dynamic::UNIT)
    }

    #[cfg(not(feature = "no_index"))]
    pub mod arrays {
        use crate::Array;

        #[rhai_fn(name = "+")]
        pub fn append(string: &str, array: Array) -> String {
            format!("{}{:?}", string, array)
        }
        #[rhai_fn(name = "+", pure)]
        pub fn prepend(array: &mut Array, string: &str) -> String {
            format!("{:?}{}", array, string)
        }
        pub fn split(string: &str, delimiter: &str) -> Array {
            string.split(delimiter).map(Into::<Dynamic>::into).collect()
        }
        #[rhai_fn(name = "split")]
        pub fn split_char(string: &str, delimiter: char) -> Array {
            string.split(delimiter).map(Into::<Dynamic>::into).collect()
        }
    }

    #[cfg(not(feature = "no_object"))]
    pub mod maps {
        use crate::Map;

        #[rhai_fn(name = "+")]
        pub fn append(string: &str, map: Map) -> String {
            format!("{}#{:?}", string, map)
        }
        #[rhai_fn(name = "+", pure)]
        pub fn prepend(map: &mut Map, string: &str) -> String {
            format!("#{:?}{}", map, string)
        }
    }
}