remove dependency on Newtonsoft.Json

Author: gasparnagy

src/GitExtensions.AzureDevOpsCommitMessage/GitExtensions.AzureDevOpsCommitMessage.csproj

@@ -38,7 +38,6 @@
     <PackageReference Include="System.ComponentModel.Composition" Version="6.0.0" />
     <PackageReference Include="GitExtensions.Extensibility" Version="7.0.0.135" />
     <PackageReference Include="Microsoft.VisualStudio.Threading" Version="17.13.61" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.401" PrivateAssets="All" />
   </ItemGroup>
 

src/GitExtensions.AzureDevOpsCommitMessage/Plugin.cs

@@ -17,7 +17,8 @@
 using GitUIPluginInterfaces;
 using GitExtensions.Extensibility.Plugins;
 using GitExtensions.Extensibility.Settings; 
-using Newtonsoft.Json.Linq;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 using ResourceManager;
 using GitExtensions.Extensibility.Git;
 using GitExtensions.Extensibility.Settings.UserControls;
@@ -397,16 +398,23 @@ private async Task<IList<CommitTemplate>> GetCommitTemplatesAsync(HttpClient cli
                 return new[] { new CommitTemplate($"{Description} {Error}", ex.ToString()) };
             }
         }
-
         private IEnumerable<(string id, string url)> GetWorkitems(string jsonWorkitems)
         {
-            var workItems = JObject.Parse(jsonWorkitems)["workItems"];
-            if (workItems == null)
+            using var doc = JsonDocument.Parse(jsonWorkitems);
+            if (!doc.RootElement.TryGetProperty("workItems", out var workItemsElement) || workItemsElement.ValueKind != JsonValueKind.Array)
             {
                 return Enumerable.Empty<(string id, string url)>();
             }
 
-            return workItems.Select(w => (w["id"].ToString(), w["url"].ToString()));
+            var result = new List<(string id, string url)>();
+            foreach (var item in workItemsElement.EnumerateArray())
+            {
+                var id = item.TryGetProperty("id", out var idEl) ? (idEl.ValueKind == JsonValueKind.String ? idEl.GetString() : idEl.GetRawText()) : string.Empty;
+                var url = item.TryGetProperty("url", out var urlEl) ? urlEl.GetString() ?? urlEl.GetRawText() : string.Empty;
+                result.Add((id ?? string.Empty, url ?? string.Empty));
+            }
+
+            return result;
         }
 
         private async Task<CommitTemplate> GetWorkItemAsync(HttpClient client, string id, string url, string template)
@@ -433,7 +441,12 @@ private async Task<CommitTemplate> GetWorkItemAsync(HttpClient client, string id
 
         private CommitTemplate GetCommitTemplateFromWorkitemData(string id, string template, string jsonWorkitem)
         {
-            var workItemData = JObject.Parse(jsonWorkitem)["fields"];
+            using var doc = JsonDocument.Parse(jsonWorkitem);
+            if (!doc.RootElement.TryGetProperty("fields", out var workItemData))
+            {
+                workItemData = default;
+            }
+
             if (_btnPreview != null)
             {
                 _allFieldsAndValues = ExtractAllFields(workItemData);
@@ -459,81 +472,96 @@ private string Elide(string value)
             return value.Length > 80 ? value.Substring(0, 80) + "[...]" : value;
         }
 
-        private string ExtractAllFields(JToken fields)
+        private string ExtractAllFields(JsonElement fields)
         {
-            List<string> allFields = new List<string>();
-            foreach (var pair in (JObject)fields)
+            var allFields = new List<string>();
+            if (fields.ValueKind != JsonValueKind.Object)
             {
-                if (!pair.Value.HasValues)
+                return string.Empty;
+            }
+
+            foreach (var prop in fields.EnumerateObject())
+            {
+                if (prop.Value.ValueKind != JsonValueKind.Object)
                 {
-                    allFields.Add($"{{{pair.Key}}}: {Elide(pair.Value.ToString())}");
+                    allFields.Add($"{{{prop.Name}}}: {Elide(ElementToString(prop.Value))}");
                 }
                 else
                 {
-                    allFields.AddRange(FlattenFieldsHierarchy(pair.Key, pair.Value));
+                    allFields.AddRange(FlattenFieldsHierarchy(prop.Name, prop.Value));
                 }
             }
 
             return string.Join(Environment.NewLine, allFields.OrderBy(s => s));
         }
 
-        private IEnumerable<string> FlattenFieldsHierarchy(string key, JToken fields)
+        private IEnumerable<string> FlattenFieldsHierarchy(string key, JsonElement fields)
         {
-            foreach (var pair in (JObject)fields)
+            if (fields.ValueKind != JsonValueKind.Object)
+            {
+                yield break;
+            }
+
+            foreach (var prop in fields.EnumerateObject())
             {
-                if (!pair.Value.HasValues)
+                if (prop.Value.ValueKind != JsonValueKind.Object)
                 {
-                    yield return $"{{{key}|{pair.Key}}}: {Elide(pair.Value.ToString())}";
+                    yield return $"{{{key}|{prop.Name}}}: {Elide(ElementToString(prop.Value))}";
                 }
                 else
                 {
-                    foreach (string value in FlattenFieldsHierarchy(key + "|" + pair.Key, pair.Value))
+                    foreach (var value in FlattenFieldsHierarchy(key + "|" + prop.Name, prop.Value))
                     {
                         yield return value;
                     }
                 }
             }
         }
 
-        private string PopulateTemplate(string titleTemplate, string id, JToken workitem)
+        private string PopulateTemplate(string titleTemplate, string id, JsonElement workitem)
         {
             return ExtractWorkItemField(titleTemplate.Replace("{id}", id), workitem);
         }
 
-        private static bool TryGetWorkItemValue(JToken workitem, string workItemField, out string value)
+        private static bool TryGetWorkItemValue(JsonElement workitem, string workItemField, out string value)
         {
+            value = null;
             if (workItemField.Contains('|'))
             {
                 var fields = workItemField.Split('|');
+                var current = workitem;
                 foreach (var field in fields)
                 {
-                    var foundValue = workitem[field];
-                    if (foundValue == null)
+                    if (current.ValueKind != JsonValueKind.Object || !current.TryGetProperty(field, out var foundValue))
                     {
                         value = null;
                         return false;
                     }
 
-                    workitem = foundValue;
+                    current = foundValue;
                 }
 
-                value = workitem.ToString();
+                value = ElementToString(current);
                 return true;
             }
             else
             {
-                var foundValue = workitem[workItemField];
-                value = foundValue?.ToString();
-                if (workItemField == "System.Description")
+                if (workitem.ValueKind == JsonValueKind.Object && workitem.TryGetProperty(workItemField, out var foundValue))
                 {
-                    value = ExtractTextFromHtml(value);
+                    value = ElementToString(foundValue);
+                    if (workItemField == "System.Description")
+                    {
+                        value = ExtractTextFromHtml(value);
+                    }
+
+                    return value != null;
                 }
 
-                return value != null;
+                return false;
             }
         }
 
-        public static string ExtractWorkItemField(string pattern, JToken workitem)
+        public static string ExtractWorkItemField(string pattern, JsonElement workitem)
         {
             if (string.IsNullOrWhiteSpace(pattern))
             {
@@ -557,6 +585,21 @@ public static string ExtractWorkItemField(string pattern, JToken workitem)
             return pattern;
         }
 
+        private static string ElementToString(JsonElement el)
+        {
+            if (el.ValueKind == JsonValueKind.String)
+            {
+                return el.GetString();
+            }
+
+            if (el.ValueKind == JsonValueKind.Null || el.ValueKind == JsonValueKind.Undefined)
+            {
+                return null;
+            }
+
+            return el.GetRawText();
+        }
+
         public static string ExtractTextFromHtml(string html)
         {
             if (string.IsNullOrWhiteSpace(html))