BadStringExtension.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.Common.Extensions;
 
public class BadStringExtension : BadInteropExtension
{
    private static BadObject StringSplit(string str, BadObject splitChar, BadObject skipEmpty)
    {
        if (splitChar is not IBadString splitStr)
        {
            throw new BadRuntimeException("splitChar must be a string");
        }
 
        bool skip = false;
 
        if (skipEmpty is not IBadBoolean skipB)
        {
            if (skipEmpty != BadObject.Null)
            {
                throw new BadRuntimeException("skipEmpty must be a boolean");
            }
        }
        else
        {
            skip = skipB.Value;
        }
 
        return new BadArray(str.Split(new[] { splitStr.Value },
                                      skip ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None
                                     )
                               .Select(x => (BadObject)x)
                               .ToList()
                           );
    }
 
 
    protected override void AddExtensions(BadInteropExtensionProvider provider)
    {
        provider.RegisterObject<string>("ToLower",
                                        o => new BadDynamicInteropFunction("ToLower",
                                                                           _ => o.ToLower(),
                                                                           BadNativeClassBuilder.GetNative("string")
                                                                          )
                                       );
 
        provider.RegisterObject<string>("ToUpper",
                                        o => new BadDynamicInteropFunction("ToUpper",
                                                                           _ => o.ToUpper(),
                                                                           BadNativeClassBuilder.GetNative("string")
                                                                          )
                                       );
 
        provider.RegisterObject<string>("IsLetters", s => s.All(char.IsLetter));
        provider.RegisterObject<string>("IsDigits", s => s.All(char.IsDigit));
        provider.RegisterObject<string>("IsWhiteSpace", s => s.All(char.IsWhiteSpace));
 
        provider.RegisterObject<string>(BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
                                        s => new BadDynamicInteropFunction<decimal>(BadStaticKeys
                                                 .ARRAY_ACCESS_OPERATOR_NAME,
                                             (_, i) => s[(int)i]
                                                 .ToString(),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "index"
                                            )
                                       );
        provider.RegisterObject<string>("Length", a => BadObject.Wrap((decimal)a.Length));
 
        provider.RegisterObject<string>("Format",
                                        s => new BadInteropFunction("Format",
                                                                    args => string.Format(s,
                                                                         args.Cast<object?>()
                                                                             .ToArray()
                                                                        ),
                                                                    false,
                                                                    BadNativeClassBuilder.GetNative("string"),
                                                                    new BadFunctionParameter("args", false, false, true)
                                                                   )
                                       );
 
        provider.RegisterObject<string>("Split",
                                        s => new BadInteropFunction("Split",
                                                                    args => StringSplit(s,
                                                                         args[0],
                                                                         args.Length == 2 ? args[1] : BadObject.Null
                                                                        ),
                                                                    false,
                                                                    BadNativeClassBuilder.GetNative("Array"),
                                                                    "splitStr",
                                                                    new BadFunctionParameter("skipEmpty",
                                                                         true,
                                                                         false,
                                                                         false
                                                                        )
                                                                   )
                                       );
 
        //Substring
        provider.RegisterObject<string>("Substring",
                                        s => new BadDynamicInteropFunction<decimal, decimal>("Substring",
                                             (_, start, end) => s.Substring((int)start, (int)end),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "start",
                                             "end"
                                            )
                                       );
 
        //IndexOf
        provider.RegisterObject<string>("IndexOf",
                                        s => new BadDynamicInteropFunction<string>("IndexOf",
                                             (_, str) => (decimal)s.IndexOf(str, StringComparison.Ordinal),
                                             BadNativeClassBuilder.GetNative("num")
                                            )
                                       );
 
        provider.RegisterObject<string>("Contains",
                                        s => new BadDynamicInteropFunction<string>("Contains",
                                             (_, str) => s.Contains(str),
                                             BadNativeClassBuilder.GetNative("bool")
                                            )
                                       );
 
        //LastIndexOf
        provider.RegisterObject<string>("LastIndexOf",
                                        s => new BadDynamicInteropFunction<string>("LastIndexOf",
                                             (_, str) => (decimal)s.LastIndexOf(str, StringComparison.Ordinal),
                                             BadNativeClassBuilder.GetNative("num")
                                            )
                                       );
 
        //Replace
        provider.RegisterObject<string>("Replace",
                                        s => new BadDynamicInteropFunction<string, string>("Replace",
                                             (_, oldStr, newStr) => s.Replace(oldStr, newStr),
                                             BadNativeClassBuilder.GetNative("string")
                                            )
                                       );
 
        //Trim
        provider.RegisterObject<string>("Trim",
                                        s => new BadDynamicInteropFunction("Trim",
                                                                           _ => s.Trim(),
                                                                           BadNativeClassBuilder.GetNative("string")
                                                                          )
                                       );
 
        //TrimStart
        provider.RegisterObject<string>("TrimStart",
                                        s => new BadDynamicInteropFunction("TrimStart",
                                                                           _ => s.TrimStart(),
                                                                           BadNativeClassBuilder.GetNative("string")
                                                                          )
                                       );
 
        //TrimEnd
        provider.RegisterObject<string>("TrimEnd",
                                        s => new BadDynamicInteropFunction("TrimEnd",
                                                                           _ => s.TrimEnd(),
                                                                           BadNativeClassBuilder.GetNative("string")
                                                                          )
                                       );
 
        //PadLeft
        provider.RegisterObject<string>("PadLeft",
                                        s => new BadDynamicInteropFunction<decimal>("PadLeft",
                                             (_, padding) => s.PadLeft((int)padding),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "padding"
                                            )
                                       );
 
        //PadRight
        provider.RegisterObject<string>("PadRight",
                                        s => new BadDynamicInteropFunction<decimal>("PadRight",
                                             (_, padding) => s.PadRight((int)padding),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "padding"
                                            )
                                       );
 
        //Remove
        provider.RegisterObject<string>("Remove",
                                        s => new BadDynamicInteropFunction<decimal, decimal>("Remove",
                                             (_, start, count) => s.Remove((int)start, (int)count),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "start",
                                             "count"
                                            )
                                       );
 
        //Insert
        provider.RegisterObject<string>("Insert",
                                        s => new BadDynamicInteropFunction<decimal, string>("Insert",
                                             (_, index, str) => s.Insert((int)index, str),
                                             BadNativeClassBuilder.GetNative("string"),
                                             "index",
                                             "str"
                                            )
                                       );
 
        //EndsWith
        provider.RegisterObject<string>("EndsWith",
                                        s => new BadDynamicInteropFunction<string>("EndsWith",
                                             (_, str) => s.EndsWith(str, StringComparison.Ordinal),
                                             BadNativeClassBuilder.GetNative("bool")
                                            )
                                       );
 
        //StartsWith
        provider.RegisterObject<string>("StartsWith",
                                        s => new BadDynamicInteropFunction<string>("StartsWith",
                                             (_, str) => s.StartsWith(str, StringComparison.Ordinal),
                                             BadNativeClassBuilder.GetNative("bool")
                                            )
                                       );
    }
}