refactor text value system

Author: Elektryk-Andrzej

Code/ArgumentSystem/Arguments/ValueArgument.cs

@@ -19,6 +19,6 @@ public DynamicTryGet<T> GetConvertSolution(BaseToken token)
             return $"Value '{token.RawRep}' cannot represent {InputDescription}";
         }
 
-        return new(() => get());
+        return new(get);
     }
 }

Code/ContextSystem/Contexts/VariableDefinition/LiteralVariableDefinitionContext.cs

@@ -14,7 +14,7 @@ public LiteralVariableDefinitionContext(VariableToken<LiteralVariable, LiteralVa
         {
             if (token is TextToken textToken)
             {
-                return () => new TextValue(textToken.ParsedValue());
+                return () => textToken.Value;
             }
 
             return null;

Code/MethodSystem/Methods/HTTPMethods/AppendJSONMethod.cs

@@ -35,6 +35,12 @@ public override void Execute()
         var jsonToAddValueTo = Args.GetReference<JObject>("JSON to add value to");
         var key = Args.GetText("key");
         var value = Args.GetValue<LiteralValue>("value");
+        
+        if (value is TextValue textValue)
+        {
+            jsonToAddValueTo[key] = textValue.ParsedValue(Script);
+            return;
+        }
 
         try
         {

Code/TokenSystem/Tokens/TextToken.cs

@@ -13,43 +13,6 @@ namespace SER.Code.TokenSystem.Tokens;
 
 public class TextToken : LiteralValueToken<TextValue>
 {
-    private static readonly Regex ExpressionRegex = new(@"~?\{.*?\}", RegexOptions.Compiled);
-
-    public string ParsedValue() => ContainsExpressions ? ParseValue(Value, Script) : Value;
-
-    public bool ContainsExpressions => ExpressionRegex.IsMatch(Value);
-
-    public static string ParseValue(string text, Script script) => ExpressionRegex.Replace(text, match =>
-    {
-        if (match.Value.StartsWith("~")) return match.Value.Substring(1);
-        
-        if (Tokenizer.SliceLine(match.Value).HasErrored(out var error, out var slices))
-        {
-            Log.Warn(script, error);
-            return "<error>";
-        }
-
-        if (slices.FirstOrDefault() is not CollectionSlice { Type: CollectionBrackets.Curly } collection)
-        {
-            throw new AndrzejFuckedUpException();
-        }
-        
-        // ReSharper disable once DuplicatedSequentialIfBodies
-        if (ExpressionToken.TryParse(collection, script).HasErrored(out error, out var token))
-        {
-            Log.Warn(script, error);
-            return "<error>";
-        }
-
-        if (((BaseToken)token).TryGet<LiteralValue>().HasErrored(out error, out var value))
-        {
-            Log.Warn(script, error);
-            return "<error>";
-        }
-            
-        return value.StringRep;
-    });
-
     protected override IParseResult InternalParse(Script scr)
     {
         if (Slice is not CollectionSlice { Type: CollectionBrackets.Quotes })
@@ -63,7 +26,9 @@ protected override IParseResult InternalParse(Script scr)
 
     public DynamicTryGet<string> GetDynamicResolver()
     {
-        if (ContainsExpressions) return new(() => TryGet<string>.Success(ParsedValue()));
+        if (Value.ContainsExpressions) 
+            return new(() => TryGet<string>.Success(Value.ParsedValue(Script)));
+        
         return DynamicTryGet.Success(Value.Value);
     }
 }

Code/ValueSystem/LiteralValue.cs

@@ -4,7 +4,7 @@ public abstract class LiteralValue(object value) : Value
 {
     public abstract string StringRep { get; }
 
-    public object Value => value;
+    public readonly object Value = value;
 
     public override bool EqualCondition(Value other) => other is LiteralValue otherP && Value.Equals(otherP.Value);
 

Code/ValueSystem/TextValue.cs

@@ -1,7 +1,25 @@
-namespace SER.Code.ValueSystem;
+using SER.Code.Helpers;
+using SER.Code.Helpers.Exceptions;
+using SER.Code.Helpers.Extensions;
+using SER.Code.ScriptSystem;
+using SER.Code.TokenSystem;
+using SER.Code.TokenSystem.Slices;
+using SER.Code.TokenSystem.Tokens;
+using SER.Code.TokenSystem.Tokens.ExpressionTokens;
+using System.Text.RegularExpressions;
+using SER.Code.TokenSystem.Structures;
 
-public class TextValue(string value) : LiteralValue<string>(value)
+namespace SER.Code.ValueSystem;
+
+public class TextValue(string rawValue) : LiteralValue<string>(rawValue)
 {
+    private readonly string _rawValue = rawValue;
+    private static readonly Regex ExpressionRegex = new(@"~?\{.*?\}", RegexOptions.Compiled);
+
+    public string ParsedValue(Script script) => ContainsExpressions ? ParseValue(_rawValue, script) : _rawValue;
+
+    public bool ContainsExpressions => ExpressionRegex.IsMatch(_rawValue);
+
     public static implicit operator TextValue(string value)
     {
         return new(value);
@@ -13,4 +31,35 @@ public static implicit operator string(TextValue value)
     }
 
     public override string StringRep => Value;
+    
+    public static string ParseValue(string text, Script script) => ExpressionRegex.Replace(text, match =>
+    {
+        if (match.Value.StartsWith("~")) return match.Value.Substring(1);
+        
+        if (Tokenizer.SliceLine(match.Value).HasErrored(out var error, out var slices))
+        {
+            Log.Warn(script, error);
+            return "<error>";
+        }
+
+        if (slices.FirstOrDefault() is not CollectionSlice { Type: CollectionBrackets.Curly } collection)
+        {
+            throw new AndrzejFuckedUpException();
+        }
+        
+        // ReSharper disable once DuplicatedSequentialIfBodies
+        if (ExpressionToken.TryParse(collection, script).HasErrored(out error, out var token))
+        {
+            Log.Warn(script, error);
+            return "<error>";
+        }
+
+        if (((BaseToken)token).TryGet<LiteralValue>().HasErrored(out error, out var value))
+        {
+            Log.Warn(script, error);
+            return "<error>";
+        }
+            
+        return value.StringRep;
+    });
 }