DYN-5965: introduce new string from nodes that accept numeric format specifiers

src/DynamoCoreWpf/ViewModels/Preview/WatchViewModel.cs

@@ -271,10 +271,6 @@ private static string GetStringFromObject(object obj)
                 case TypeCode.Object:
                     return ObjectToLabelString(obj);
                 default:
-                    if (double.TryParse(obj.ToString(), out double d))
-                    {
-                        return Convert.ToDouble(obj).ToString(ProtoCore.Mirror.MirrorData.PrecisionFormat, CultureInfo.InvariantCulture);
-                    }
                     return (string)obj;
             };
         }

src/Engine/ProtoCore/DSASM/Mirror/ExecutionMirror.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text;
 using ProtoCore.Lang;
@@ -44,15 +45,55 @@ public ExecutionMirror(ProtoCore.DSASM.Executive exec, ProtoCore.RuntimeCore cor
             MirrorTarget = exec;
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="val"></param>
+        /// <param name="heap"></param>
+        /// <param name="langblock"></param>
+        /// <param name="forPrint"></param>
+        /// <param name="useNumericFormat"></param>
+        /// <returns></returns>
+        public string GetStringValue2(StackValue val, Heap heap, int langblock, bool forPrint = false,
+            bool useNumericFormat = false)
+        {
+            return GetStringValueImplementation(val, heap, langblock, -1, -1, forPrint, useNumericFormat);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="val"></param>
+        /// <param name="heap"></param>
+        /// <param name="langblock"></param>
+        /// <param name="forPrint"></param>
+        /// <returns></returns>
+        [Obsolete]
         public string GetStringValue(StackValue val, Heap heap, int langblock, bool forPrint = false)
         {
             return GetStringValue(val, heap, langblock, -1, -1, forPrint);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="val"></param>
+        /// <param name="heap"></param>
+        /// <param name="langblock"></param>
+        /// <param name="maxArraySize"></param>
+        /// <param name="maxOutputDepth"></param>
+        /// <param name="forPrint"></param>
+        /// <returns></returns>
+        [Obsolete]
         public string GetStringValue(StackValue val, Heap heap, int langblock, int maxArraySize, int maxOutputDepth, bool forPrint = false)
         {
-            if (formatParams == null)
-                formatParams = new OutputFormatParameters(maxArraySize, maxOutputDepth);
+            return GetStringValueImplementation(val, heap, langblock, maxArraySize, maxOutputDepth, forPrint, false);
+        }
+
+        private string GetStringValueImplementation(StackValue val, Heap heap, int langblock, int maxArraySize,
+           int maxOutputDepth, bool forPrint = false, bool useNumericFormat = false)
+        {
+            formatParams ??= new OutputFormatParameters(maxArraySize, maxOutputDepth);
 
             if (val.IsInteger)
             {
@@ -61,6 +102,10 @@ public string GetStringValue(StackValue val, Heap heap, int langblock, int maxAr
 
             if (val.IsDouble)
             {
+                if (useNumericFormat)
+                {
+                    return val.DoubleValue.ToString(ProtoCore.Mirror.MirrorData.PrecisionFormat);
+                } 
                 return val.DoubleValue.ToString("F6");
             }
 
@@ -77,7 +122,7 @@ public string GetStringValue(StackValue val, Heap heap, int langblock, int maxAr
             if (val.IsArray)
             {
                 HashSet<int> pointers = new HashSet<int> { val.ArrayPointer };
-                string arrTrace = GetArrayTrace(val, heap, langblock, pointers, forPrint);
+                string arrTrace = GetArrayTrace(val, heap, langblock, pointers, forPrint, useNumericFormat);
                 if (forPrint)
                     return "[" + arrTrace + "]";
 
@@ -212,7 +257,7 @@ public string GetClassTrace(StackValue val, Heap heap, int langblock, bool forPr
             }
         }
 
-        private string GetPointerTrace(StackValue ptr, Heap heap, int langblock, HashSet<int> pointers, bool forPrint)
+        private string GetPointerTrace(StackValue ptr, Heap heap, int langblock, HashSet<int> pointers, bool forPrint, bool useNumericFormat)
         {
             if (pointers.Contains(ptr.ArrayPointer))
             {
@@ -223,13 +268,13 @@ private string GetPointerTrace(StackValue ptr, Heap heap, int langblock, HashSet
 
             if (forPrint)
             {
-                return "[" + GetArrayTrace(ptr, heap, langblock, pointers, forPrint) + "]";
+                return "[" + GetArrayTrace(ptr, heap, langblock, pointers, forPrint,useNumericFormat) + "]";
             }
 
-            return "[ " + GetArrayTrace(ptr, heap, langblock, pointers, forPrint) + " ]";
+            return "[ " + GetArrayTrace(ptr, heap, langblock, pointers, forPrint,useNumericFormat) + " ]";
         }
 
-        private string GetArrayTrace(StackValue svArray, Heap heap, int langblock, HashSet<int> pointers, bool forPrint)
+        private string GetArrayTrace(StackValue svArray, Heap heap, int langblock, HashSet<int> pointers, bool forPrint, bool useNumericFormat)
         {
             if (!formatParams.ContinueOutputTrace())
                 return "...";
@@ -264,11 +309,11 @@ private string GetArrayTrace(StackValue svArray, Heap heap, int langblock, HashS
                 StackValue sv = array.GetValueFromIndex(n, runtimeCore);
                 if (sv.IsArray)
                 {
-                    arrayElements.Append(GetPointerTrace(sv, heap, langblock, pointers, forPrint));
+                    arrayElements.Append(GetPointerTrace(sv, heap, langblock, pointers, forPrint,useNumericFormat));
                 }
                 else
                 {
-                    arrayElements.Append(GetStringValue(array.GetValueFromIndex(n, runtimeCore), heap, langblock, forPrint));
+                    arrayElements.Append(GetStringValue2(array.GetValueFromIndex(n, runtimeCore), heap, langblock, forPrint,useNumericFormat));
                 }
 
                 // If we need to truncate this array (halfArraySize > 0), and we have 

src/Engine/ProtoCore/Lang/BuiltInFunctionEndPoint.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -373,7 +373,9 @@ public override StackValue Execute(ProtoCore.Runtime.Context c, List<StackValue>
                 case BuiltInMethods.MethodID.ToString:
                 case BuiltInMethods.MethodID.ToStringFromObject:
                 case BuiltInMethods.MethodID.ToStringFromArray:
-                    ret = StringUtils.ConvertToString(formalParameters[0], runtimeCore, rmem);
+                    {
+                        ret = StringUtils.ConvertToString(formalParameters, runtimeCore, rmem);
+                    }
                     break;
                 case BuiltInMethods.MethodID.ImportData:
                     ret = ContextDataBuiltIns.ImportData(formalParameters[0], formalParameters[1], runtimeCore, interpreter, c);

src/Engine/ProtoCore/Lang/BuiltInMethods.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using ProtoCore.AST.AssociativeAST;
 using ProtoCore.DSASM;
@@ -795,6 +795,17 @@ public BuiltInMethods(Core core)
                     Parameters = new List<KeyValuePair<string, ProtoCore.Type>> 
                     {
                         new KeyValuePair<string, ProtoCore.Type>("object", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0)),
+                        new KeyValuePair<string, ProtoCore.Type>("useNumericFormat", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Bool, 0)),
+                    },
+                    ID = BuiltInMethods.MethodID.ToStringFromObject,
+                },
+                new BuiltInMethod
+                {
+                    ReturnType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.String, 0),
+                    Parameters = new List<KeyValuePair<string, ProtoCore.Type>>
+                    {
+                        new KeyValuePair<string, ProtoCore.Type>("object", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, 0)),
+                        new KeyValuePair<string, ProtoCore.Type>("useNumericFormat", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Bool, 0)),
                     },
                     ID = BuiltInMethods.MethodID.ToStringFromObject,
                 },
@@ -806,6 +817,7 @@ public BuiltInMethods(Core core)
                     Parameters = new [] 
                     {
                         new KeyValuePair<string, Type>("list", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var)),
+                        new KeyValuePair<string, ProtoCore.Type>("useNumericFormat", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Bool, 0)),
                     }.ToList(),
                     ID = BuiltInMethods.MethodID.ToStringFromArray
                 },
@@ -915,4 +927,4 @@ public BuiltInMethods(Core core)
             };
         }
     }
-}
+}

src/Engine/ProtoCore/Reflection/MirrorData.cs

@@ -224,36 +224,21 @@ public string StringData
                     {
                         return "null";
                     }
-                    else if (Data is bool)
+                    if (Data is bool)
                     {
                         return Data.ToString().ToLower();
                     }
-                    else if (Data is IFormattable)
+                    if (Data is IFormattable)
                     {
                         // Object.ToString() by default will use the current 
                         // culture to do formatting. For example, Double.ToString()
                         // https://msdn.microsoft.com/en-us/library/3hfd35ad(v=vs.110).aspx
                         // We should always use invariant culture format for formattable 
                         // object.
 
-                        //TODO: uncomment this once https://jira.autodesk.com/browse/DYN-5101 is complete
-                        //if (Data is double)
-                        //{
-                        //    return (Data as IFormattable).ToString(PrecisionFormat, CultureInfo.InvariantCulture);
-                        //}
-                        //else
-                        //{
                         return (Data as IFormattable).ToString(null, CultureInfo.InvariantCulture);
-                        //}
-                    }
-                    else
-                    {
-                        if (double.TryParse(Data.ToString(), out double d))
-                        {
-                            return Convert.ToDouble(Data).ToString(PrecisionFormat, CultureInfo.InvariantCulture);
-                        }
-                        return Data.ToString();
                     }
+                    return Data.ToString();
                 }
             }
 

src/Engine/ProtoCore/Utils/StringUtils.cs

@@ -1,5 +1,6 @@
 using ProtoCore.DSASM;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 
@@ -27,14 +28,33 @@ public static string GetStringValue(StackValue sv, RuntimeCore runtimeCore)
         }
 
         public static StackValue ConvertToString(StackValue sv, RuntimeCore runtimeCore, ProtoCore.Runtime.RuntimeMemory rmem)
+        {
+            return ConvertToStringInternal(sv, runtimeCore,false);
+        }
+        internal static StackValue ConvertToString(IEnumerable<StackValue> args, RuntimeCore runtimeCore, ProtoCore.Runtime.RuntimeMemory rmem)
+        {
+            var useNumericFormat = false;
+            var sv = args.ElementAt(0);
+            if (args.Count() > 1)
+            {
+                useNumericFormat = args.ElementAt(1).BooleanValue;
+            }
+            return ConvertToStringInternal(sv, runtimeCore, useNumericFormat);
+        }
+
+        private static StackValue ConvertToStringInternal(StackValue sv, RuntimeCore runtimeCore,bool useNumericFormat)
         {
             StackValue returnSV;
             //TODO: Change Execution mirror class to have static methods, so that an instance does not have to be created
-            ProtoCore.DSASM.Mirror.ExecutionMirror mirror = new DSASM.Mirror.ExecutionMirror(new ProtoCore.DSASM.Executive(runtimeCore), runtimeCore);
-            returnSV = ProtoCore.DSASM.StackValue.BuildString(mirror.GetStringValue(sv, runtimeCore.RuntimeMemory.Heap, 0, true), runtimeCore.RuntimeMemory.Heap);
+            ProtoCore.DSASM.Mirror.ExecutionMirror mirror =
+                new DSASM.Mirror.ExecutionMirror(new ProtoCore.DSASM.Executive(runtimeCore), runtimeCore);
+            returnSV = ProtoCore.DSASM.StackValue.BuildString(
+                mirror.GetStringValue2(sv, runtimeCore.RuntimeMemory.Heap, 0, true, useNumericFormat), runtimeCore.RuntimeMemory.Heap);
             return returnSV;
         }
 
+
+
         public static StackValue ConcatString(StackValue op1, StackValue op2, RuntimeCore runtimeCore)
         {
             var v1 = runtimeCore.RuntimeMemory.Heap.ToHeapObject<DSString>(op1).Value;

src/Libraries/CoreNodeModels/String.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Linq;
 using CoreNodeModels.Properties;
 using Dynamo.Graph.Nodes;
 using Newtonsoft.Json;
@@ -8,7 +9,7 @@ namespace CoreNodeModels
 {
     /// <summary>
     /// Base class to represent a single input string node. It supports 
-    /// partiallied applied function. 
+    /// partially applied function. 
     /// </summary>
     public class ToStringNodeBase : NodeModel
     {
@@ -72,13 +73,18 @@ public class FromObject: ToStringNodeBase
         private FromObject(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : 
             base("__ToStringFromObject",inPorts, outPorts)
         {
+            if (inPorts.Count() < 2)
+            {
+                InPorts.Add(new PortModel(PortType.Input, this, new PortData("useNumericFormat", "should the numeric precision format be used when converting doubles", AstFactory.BuildBooleanNode(false))));
+            }
             ArgumentLacing = LacingStrategy.Disabled;
         }
 
         public FromObject() : base("__ToStringFromObject")
         {
             ArgumentLacing = LacingStrategy.Disabled;
             InPorts.Add(new PortModel(PortType.Input, this, new PortData("object", Resources.FromObjectPortDataObjToolTip)));
+            InPorts.Add(new PortModel(PortType.Input, this, new PortData("useNumericFormat", "should the numeric precision format be used when converting doubles",AstFactory.BuildBooleanNode(false))));
             OutPorts.Add(new PortModel(PortType.Output, this, new PortData("string", Resources.FromObjectPortDataResultToolTip)));
             RegisterAllPorts();
         }