MERGE

1 files changed, 171 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/Utils.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/Utils.cs
new file mode 100644
index 000000000..f8cc7072d
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/Utils.cs
@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace Tango.Scripting.Editors.Intellisense
+{
+    public static class Utils
+    {
+        private static String dotNetXmlFolder = @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.X";
+        private static Dictionary<Assembly, XmlDocument> _assemblies_docs_cache;
+
+        static Utils()
+        {
+            _assemblies_docs_cache = new Dictionary<Assembly, XmlDocument>();
+        }
+
+        public static void LoadKnownTypeDocs(KnownType knownType)
+        {
+            XmlDocument xmlDoc = null;
+
+            if (_assemblies_docs_cache.ContainsKey(knownType.Type.Assembly))
+            {
+                xmlDoc = _assemblies_docs_cache[knownType.Type.Assembly];
+            }
+
+            if (xmlDoc == null)
+            {
+                String dllPath = knownType.Type.Assembly.Location;
+
+                string docuPath = dllPath.Substring(0, dllPath.LastIndexOf(".")) + ".XML";
+
+                if (File.Exists(docuPath))
+                {
+                    xmlDoc = new XmlDocument();
+                    xmlDoc.Load(docuPath);
+                }
+                else if (File.Exists(System.IO.Path.Combine(dotNetXmlFolder, System.IO.Path.GetFileName(docuPath))))
+                {
+                    xmlDoc = new XmlDocument();
+                    xmlDoc.Load(System.IO.Path.Combine(dotNetXmlFolder, System.IO.Path.GetFileName(docuPath)));
+                }
+
+                if (xmlDoc != null)
+                {
+                    _assemblies_docs_cache.Add(knownType.Type.Assembly, xmlDoc);
+                }
+            }
+
+            if (xmlDoc == null)
+            {
+                xmlDoc = new XmlDocument();
+            }
+
+            //Load Type Summary
+            {
+                string path = "T:" + knownType.Type.FullName;
+                XmlNode xmlDocuOfType = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + path + "')]");
+
+                if (xmlDocuOfType != null)
+                {
+                    XmlNode summaryNode = xmlDocuOfType.SelectSingleNode("summary");
+                    knownType.Summary = summaryNode.InnerText;
+                }
+            }
+
+            //Load Constructors...
+            {
+                string path = "M:" + knownType.Type.FullName + ".#ctor";
+
+                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+
+                for (int i = 0; i < knownType.Constructors.Count; i++)
+                {
+                    var constructor = knownType.Constructors[i];
+                    XmlNode cDoc = null;
+
+                    if (i < docNodes.Count)
+                    {
+                        cDoc = docNodes[i];
+                    }
+
+                    constructor.Summary = cDoc != null ? cDoc.SelectSingleNode("summary").InnerXml : $"Initializes a new instance of {knownType.FriendlyName}.";
+
+                    var parameters = constructor.Parameters.ToList();
+                    var parametersNodes = cDoc != null ? cDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
+
+                    for (int j = 0; j < parameters.Count; j++)
+                    {
+                        var parameter = parameters[j];
+                        XmlNode pNode = null;
+
+                        if (j < parametersNodes.Count)
+                        {
+                            pNode = parametersNodes[j];
+                        }
+
+                        parameter.Description = pNode != null ? pNode.InnerText : null;
+                    }
+                }
+            }
+
+            //Load Methods...
+            {
+                string path = "M:" + knownType.Type.FullName;
+
+                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+
+                for (int i = 0; i < knownType.Methods.Count; i++)
+                {
+                    var method = knownType.Methods[i];
+                    XmlNode mDoc = null;
+
+                    mDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(knownType.Type.Name + "." + method.Name));
+                    method.Summary = mDoc != null ? mDoc.SelectSingleNode("summary").InnerXml.Remove("(<see cref=\".:)|(\" \\/>)") : "No documentation";
+
+                    var parameters = method.Parameters.ToList();
+                    var parametersNodes = mDoc != null ? mDoc.SelectNodes("param").OfType<XmlNode>().ToList() : new List<XmlNode>();
+
+                    bool isLinq = knownType.Type == typeof(Enumerable);
+
+                    for (int j = 0; j < parameters.Count; j++)
+                    {
+                        var parameter = parameters[j];
+
+                        XmlNode pNode = null;
+
+                        if (j < parametersNodes.Count)
+                        {
+                            pNode = parametersNodes[j];
+                        }
+
+                        parameter.Description = pNode != null ? pNode.InnerText.Remove("(<see cref=\".:)|(\" \\/>)") : null;
+                    }
+                }
+            }
+
+            //Load Properties
+            {
+                string path = "P:" + knownType.Type.FullName;
+
+                var docNodes = xmlDoc.SelectNodes("//member[starts-with(@name, '" + path + "')]").OfType<XmlNode>().ToList();
+
+                for (int i = 0; i < knownType.Properties.Count; i++)
+                {
+                    var property = knownType.Properties[i];
+                    var pDoc = docNodes.FirstOrDefault(x => x.Attributes["name"].InnerText.Contains(knownType.Type.Name + "." + property.Name));
+
+                    property.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
+                }
+            }
+
+            //Load Enum Values
+            {
+                if (knownType.Type.IsEnum)
+                {
+                    for (int i = 0; i < knownType.Fields.Count; i++)
+                    {
+                        var field = knownType.Fields[i];
+                        var pDoc = xmlDoc.SelectSingleNode("//member[starts-with(@name, '" + $"F:{knownType.Type.FullName}.{field.Name}" + "')]");
+                        field.Summary = pDoc != null ? pDoc.SelectSingleNode("summary").InnerXml : "No documentation";
+                    }
+                }
+            }
+        }
+    }
+}