Merge pull request #731 from github-for-unity/fixes/listing-locks-in-json

StanleyGoldman · web-flow · commit 93c921020ed7 · 2018-05-11T13:37:24.000-04:00
Listing locks in json format so they include the lock time
diff --git a/src/GitHub.Api/Git/GitClient.cs b/src/GitHub.Api/Git/GitClient.cs
@@ -171,7 +171,7 @@ public ITask<GitUser> SetConfigNameAndEmail(string username, string email)
 
         public ITask<List<GitLock>> ListLocks(bool local, BaseOutputListProcessor<GitLock> processor = null)
         {
-            return new GitListLocksTask(new GitObjectFactory(environment), local, cancellationToken, processor)
+            return new GitListLocksTask(local, cancellationToken, processor)
                 .Configure(processManager);
         }
 
@@ -342,8 +342,8 @@ public struct GitUser
         public string name;
         public string email;
 
-        public string Name { get { return name; } }
-        public string Email { get { return email; } }
+        public string Name => name;
+        public string Email { get { return String.IsNullOrEmpty(email) ? String.Empty : email; } }
 
         public GitUser(string name, string email)
         {
@@ -355,7 +355,7 @@ public override int GetHashCode()
         {
             int hash = 17;
             hash = hash * 23 + (name?.GetHashCode() ?? 0);
-            hash = hash * 23 + (email?.GetHashCode() ?? 0);
+            hash = hash * 23 + Email.GetHashCode();
             return hash;
         }
 
@@ -370,8 +370,7 @@ public bool Equals(GitUser other)
         {
             return
                 String.Equals(name, other.name) &&
-                String.Equals(email, other.email)
-                ;
+                Email.Equals(other.Email);
         }
 
         public static bool operator ==(GitUser lhs, GitUser rhs)
diff --git a/src/GitHub.Api/Git/GitLock.cs b/src/GitHub.Api/Git/GitLock.cs
@@ -7,50 +7,58 @@ public struct GitLock
     {
         public static GitLock Default = new GitLock();
 
-        public int ID;
-        public string Path;
-        public string FullPath;
-        public string User;
+        public int id;
+        public string path;
+        public GitUser owner;
+        public DateTimeOffset locked_at;
 
-        public GitLock(string path, string fullPath, string user, int id)
+        [NotSerialized] public int ID => id;
+        [NotSerialized] public NPath Path => path.ToNPath();
+        [NotSerialized] public GitUser Owner => owner;
+        [NotSerialized] public DateTimeOffset LockedAt => locked_at;
+
+        public GitLock(int id, NPath path, GitUser owner, DateTimeOffset locked_at)
         {
-            Path = path;
-            FullPath = fullPath;
-            User = user;
-            ID = id;
+            this.id = id;
+            this.path = path;
+            this.owner = owner;
+            this.locked_at = locked_at;
         }
 
         public override bool Equals(object other)
         {
             if (other is GitLock)
-            {
-                return this.Equals((GitLock)other);
-            }
+                return Equals((GitLock)other);
             return false;
         }
 
-        public bool Equals(GitLock p)
+        public bool Equals(GitLock other)
         {
-            return ID == p.ID;
+            return this == other;
         }
 
         public override int GetHashCode()
         {
-            return 17 * 23 + ID.GetHashCode();
+            int hash = 17;
+            hash = hash * 23 + id.GetHashCode();
+            hash = hash * 23 + Path.GetHashCode();
+            hash = hash * 23 + owner.GetHashCode();
+            hash = hash * 23 + locked_at.GetHashCode();
+            return hash;
         }
 
         public static bool operator ==(GitLock lhs, GitLock rhs)
         {
-            return lhs.Equals(rhs);
+            return lhs.id == rhs.id && lhs.Path == rhs.Path && lhs.owner == rhs.owner && lhs.locked_at == rhs.locked_at;
         }
 
         public static bool operator !=(GitLock lhs, GitLock rhs)
         {
-            return !(lhs.Equals(rhs));
+            return !(lhs == rhs);
         }
         public override string ToString()
         {
-            return $"{{GitLock ({User}) '{Path}'}}";
+            return $"{{id:{id}, path:{Path}, owner:{{{owner}}}, locked_at:'{locked_at}'}}";
         }
     }
 }
diff --git a/src/GitHub.Api/Git/GitObjectFactory.cs b/src/GitHub.Api/Git/GitObjectFactory.cs
@@ -20,13 +20,5 @@ public GitStatusEntry CreateGitStatusEntry(string path, GitFileStatus status, st
 
             return new GitStatusEntry(relativePath, absolutePath, projectPath, status, originalPath?.ToNPath(), staged);
         }
-
-        public GitLock CreateGitLock(string path, string user, int id)
-        {
-            var npath = new NPath(path).MakeAbsolute();
-            var fullPath = npath.RelativeTo(environment.RepositoryPath);
-
-            return new GitLock(path, fullPath, user, id);
-        }
     }
 }
diff --git a/src/GitHub.Api/Git/IGitObjectFactory.cs b/src/GitHub.Api/Git/IGitObjectFactory.cs
@@ -3,6 +3,5 @@ namespace GitHub.Unity
     interface IGitObjectFactory
     {
         GitStatusEntry CreateGitStatusEntry(string path, GitFileStatus status, string originalPath = null, bool staged = false);
-        GitLock CreateGitLock(string path, string user, int id);
     }
 }
diff --git a/src/GitHub.Api/Git/Tasks/GitListLocksTask.cs b/src/GitHub.Api/Git/Tasks/GitListLocksTask.cs
@@ -4,19 +4,18 @@ namespace GitHub.Unity
 {
     class GitListLocksTask : ProcessTaskWithListOutput<GitLock>
     {
-        private const string TaskName = "git lfs locks";
         private readonly string args;
 
-        public GitListLocksTask(IGitObjectFactory gitObjectFactory, bool local,
+        public GitListLocksTask(bool local,
             CancellationToken token, BaseOutputListProcessor<GitLock> processor = null)
-            : base(token, processor ?? new LockOutputProcessor(gitObjectFactory))
+            : base(token, processor ?? new LocksOutputProcessor())
         {
-            Name = TaskName;
-            args = "lfs locks";
+            args = "lfs locks --json";
             if (local)
             {
                 args += " --local";
             }
+            Name = args;
         }
 
         public override string ProcessArguments => args;
diff --git a/src/GitHub.Api/GitHub.Api.csproj b/src/GitHub.Api/GitHub.Api.csproj
@@ -166,7 +166,7 @@
     <Compile Include="Extensions\AsyncExtensions.cs" />
     <Compile Include="Platform\Settings.cs" />
     <Compile Include="OutputProcessors\BranchListOutputProcessor.cs" />
-    <Compile Include="OutputProcessors\LockOutputProcessor.cs" />
+    <Compile Include="OutputProcessors\LocksOutputProcessor.cs" />
     <Compile Include="OutputProcessors\LogEntryOutputProcessor.cs" />
     <Compile Include="OutputProcessors\ProcessManager.cs" />
     <Compile Include="OutputProcessors\StatusOutputProcessor.cs" />
diff --git a/src/GitHub.Api/Helpers/Constants.cs b/src/GitHub.Api/Helpers/Constants.cs
@@ -11,10 +11,12 @@ static class Constants
         public const string TraceLoggingKey = "EnableTraceLogging";
         public const string WebTimeoutKey = "WebTimeout";
         public const string Iso8601Format = @"yyyy-MM-dd\THH\:mm\:ss.fffzzz";
+        public const string Iso8601FormatZ = @"yyyy-MM-dd\THH\:mm\:ss\Z";
         public static readonly string[] Iso8601Formats = {
+            @"yyyy-MM-dd\THH\:mm\:ss\Z",
             @"yyyy-MM-dd\THH\:mm\:ss.fffffffzzz",
             @"yyyy-MM-dd\THH\:mm\:ss.fffzzz",
-            @"yyyy-MM-dd\THH\:mm\:sszzz"
+            @"yyyy-MM-dd\THH\:mm\:sszzz",
         };
         public const string SkipVersionKey = "SkipVersion";
 
diff --git a/src/GitHub.Api/Helpers/SimpleJson.cs b/src/GitHub.Api/Helpers/SimpleJson.cs
@@ -1255,9 +1255,11 @@ class PocoJsonSerializerStrategy : IJsonSerializerStrategy
                                                                 @"yyyy-MM-dd\THH\:mm\:sszzz",
                                                                 @"yyyy-MM-dd\THH\:mm\:ss.fffffffzzz",
                                                                 @"yyyy-MM-dd\THH\:mm\:ss.fffzzz",
+                                                                @"yyyy-MM-dd\THH\:mm\:ssZ",
                                                                 @"yyyy-MM-dd\THH:mm:ss.fffffffzzz",
                                                                 @"yyyy-MM-dd\THH:mm:ss.fffzzz",
                                                                 @"yyyy-MM-dd\THH:mm:sszzz",
+                                                                @"yyyy-MM-dd\THH:mm:ss\Z",
                                                              };
 
         public PocoJsonSerializerStrategy()
@@ -1364,6 +1366,8 @@ public virtual object DeserializeObject(object value, Type type)
             {
                 if (str.Length != 0) // We know it can't be null now.
                 {
+                    if (type == typeof(NPath) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(NPath)))
+                        return new NPath(str);
                     if (type == typeof(DateTime) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTime)))
                         return DateTime.ParseExact(str, Iso8601Format, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
                     if (type == typeof(DateTimeOffset) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTimeOffset)))
@@ -1495,7 +1499,9 @@ protected virtual object SerializeEnum(Enum p)
         protected virtual bool TrySerializeKnownTypes(object input, out object output)
         {
             bool returnValue = true;
-            if (input is DateTime)
+            if (input is NPath)
+                output = input.ToString();
+            else if (input is DateTime)
                 output = ((DateTime)input).ToUniversalTime().ToString(Iso8601Format[0], CultureInfo.InvariantCulture);
             else if (input is DateTimeOffset)
                 output = ((DateTimeOffset)input).ToUniversalTime().ToString(Iso8601Format[0], CultureInfo.InvariantCulture);
@@ -2158,6 +2164,8 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 
 namespace GitHub.Unity
 {
+    using GitHub.Unity.Json;
+    
     [System.AttributeUsage(System.AttributeTargets.Property |
                        System.AttributeTargets.Field)]
     public sealed class NotSerializedAttribute : Attribute
diff --git a/src/GitHub.Api/OutputProcessors/LockOutputProcessor.cs b/src/GitHub.Api/OutputProcessors/LockOutputProcessor.cs
diff --git a/src/GitHub.Api/OutputProcessors/LocksOutputProcessor.cs b/src/GitHub.Api/OutputProcessors/LocksOutputProcessor.cs
@@ -0,0 +1,29 @@
+using System;
+
+namespace GitHub.Unity
+{
+    class LocksOutputProcessor : BaseOutputListProcessor<GitLock>
+    {
+        public override void LineReceived(string line)
+        {
+            if (string.IsNullOrEmpty(line))
+            {
+                //Do Nothing
+                return;
+            }
+
+            try
+            {
+                var locks = line.FromJson<GitLock[]>(lowerCase: true);
+                foreach (var lck in locks)
+                {
+                    RaiseOnEntry(lck);
+                }
+            }
+            catch(Exception ex)
+            {
+                Logger.Error(ex, $"Failed to parse lock line {line}");
+            }
+        }
+    }
+}
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ChangesView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ChangesView.cs
@@ -32,7 +32,7 @@ class ChangesView : Subview
         [SerializeField] private Vector2 treeScroll;
         [SerializeField] private ChangesTree treeChanges = new ChangesTree { DisplayRootNode = false, IsCheckable = true, IsUsingGlobalSelection = true };
 
-        [SerializeField] private HashSet<string> gitLocks;
+        [SerializeField] private HashSet<NPath> gitLocks;
         [SerializeField] private List<GitStatusEntry> gitStatusEntries;
 
         [SerializeField] private string changedFilesText = NoChangedFilesLabel;
@@ -259,7 +259,7 @@ private void MaybeUpdateData()
                 currentStatusEntriesHasUpdate = false;
                 currentLocksHasUpdate = false;
 
-                gitLocks = new HashSet<string>(Repository.CurrentLocks.Select(gitLock => gitLock.Path));
+                gitLocks = new HashSet<NPath>(Repository.CurrentLocks.Select(gitLock => gitLock.Path));
                 gitStatusEntries = Repository.CurrentChanges.Where(x => x.Status != GitFileStatus.Ignored).ToList();
 
                 changedFilesText = gitStatusEntries.Count == 0
@@ -275,7 +275,7 @@ private void MaybeUpdateData()
         private void BuildTree()
         {
             treeChanges.PathSeparator = Environment.FileSystem.DirectorySeparatorChar.ToString();
-            treeChanges.Load(gitStatusEntries.Select(entry => new GitStatusEntryTreeData(entry, gitLocks.Contains(entry.Path))));
+            treeChanges.Load(gitStatusEntries.Select(entry => new GitStatusEntryTreeData(entry, gitLocks.Contains(entry.Path.ToNPath()))));
             Redraw();
         }
 
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/LfsLocksModificationProcessor.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/LfsLocksModificationProcessor.cs
@@ -12,7 +12,7 @@ class LfsLocksModificationProcessor : UnityEditor.AssetModificationProcessor
         private static IPlatform platform;
         private static IEnvironment environment;
 
-        private static Dictionary<string, GitLock> locks = new Dictionary<string, GitLock>();
+        private static Dictionary<NPath, GitLock> locks = new Dictionary<NPath, GitLock>();
         private static CacheUpdateEvent lastLocksChangedEvent;
         private static string loggedInUser;
 
@@ -48,7 +48,7 @@ public static AssetDeleteResult OnWillDeleteAsset(string assetPath, RemoveAssetO
         public static bool IsOpenForEdit(string assetPath, out string message)
         {
             var lck = GetLock(assetPath);
-            message = lck.HasValue ? "File is locked for editing by " + lck.Value.User : null;
+            message = lck.HasValue ? "File is locked for editing by " + lck.Value.Owner : null;
             return !lck.HasValue;
         }
 
@@ -78,7 +78,7 @@ private static bool IsLocked(string assetPath)
 
             GitLock lck;
             var repositoryPath = environment.GetRepositoryPath(assetPath.ToNPath());
-            if (!locks.TryGetValue(repositoryPath, out lck) || lck.User.Equals(loggedInUser))
+            if (!locks.TryGetValue(repositoryPath, out lck) || lck.Owner.Name.Equals(loggedInUser))
                 return null;
             return lck;
         }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ProjectWindowInterface.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ProjectWindowInterface.cs
@@ -81,11 +81,7 @@ private static bool ContextMenu_CanLock()
             NPath assetPath = AssetDatabase.GetAssetPath(selected.GetInstanceID()).ToNPath();
             NPath repositoryPath = EntryPoint.Environment.GetRepositoryPath(assetPath);
 
-            var alreadyLocked = locks.Any(x =>
-            {
-                return repositoryPath == x.Path.ToNPath();
-
-            });
+            var alreadyLocked = locks.Any(x => repositoryPath == x.Path);
             GitFileStatus status = GitFileStatus.None;
             if (entries != null)
             {
@@ -136,7 +132,7 @@ private static bool ContextMenu_CanUnlock()
             NPath assetPath = AssetDatabase.GetAssetPath(selected.GetInstanceID()).ToNPath();
             NPath repositoryPath = EntryPoint.Environment.GetRepositoryPath(assetPath);
 
-            var isLocked = locks.Any(x => repositoryPath == x.Path.ToNPath());
+            var isLocked = locks.Any(x => repositoryPath == x.Path);
             return isLocked;
         }
 
@@ -175,7 +171,7 @@ private static void OnLocksUpdate()
             guidsLocks.Clear();
             foreach (var lck in locks)
             {
-                NPath repositoryPath = lck.Path.ToNPath();
+                NPath repositoryPath = lck.Path;
                 NPath assetPath = EntryPoint.Environment.GetAssetPath(repositoryPath);
 
                 var g = AssetDatabase.AssetPathToGUID(assetPath);
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs
@@ -288,7 +288,7 @@ private void OnGitLfsLocksGUI()
 
                             GUILayout.BeginHorizontal();
                             {
-                                GUILayout.Label("Locked by " + lck.User);
+                                GUILayout.Label("Locked by " + lck.Owner.Name);
                                 GUILayout.FlexibleSpace();
                                 if (GUILayout.Button("Unlock"))
                                 {
diff --git a/src/tests/TestUtils/Helpers/AssertExtensions.cs b/src/tests/TestUtils/Helpers/AssertExtensions.cs
diff --git a/src/tests/TestUtils/Substitutes/SubstituteFactory.cs b/src/tests/TestUtils/Substitutes/SubstituteFactory.cs
diff --git a/src/tests/UnitTests/IO/LockOutputProcessorTests.cs b/src/tests/UnitTests/IO/LockOutputProcessorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ public ITask<GitUser> SetConfigNameAndEmail(string username, string email)`
`171`	`171`
`172`	`172`	`public ITask<List<GitLock>> ListLocks(bool local, BaseOutputListProcessor<GitLock> processor = null)`
`173`	`173`	`{`
`174`		`- return new GitListLocksTask(new GitObjectFactory(environment), local, cancellationToken, processor)`
	`174`	`+ return new GitListLocksTask(local, cancellationToken, processor)`
`175`	`175`	`.Configure(processManager);`
`176`	`176`	`}`
`177`	`177`
`@@ -342,8 +342,8 @@ public struct GitUser`
`342`	`342`	`public string name;`
`343`	`343`	`public string email;`
`344`	`344`
`345`		`- public string Name { get { return name; } }`
`346`		`- public string Email { get { return email; } }`
	`345`	`+ public string Name => name;`
	`346`	`+ public string Email { get { return String.IsNullOrEmpty(email) ? String.Empty : email; } }`
`347`	`347`
`348`	`348`	`public GitUser(string name, string email)`
`349`	`349`	`{`
`@@ -355,7 +355,7 @@ public override int GetHashCode()`
`355`	`355`	`{`
`356`	`356`	`int hash = 17;`
`357`	`357`	`hash = hash * 23 + (name?.GetHashCode() ?? 0);`
`358`		`- hash = hash * 23 + (email?.GetHashCode() ?? 0);`
	`358`	`+ hash = hash * 23 + Email.GetHashCode();`
`359`	`359`	`return hash;`
`360`	`360`	`}`
`361`	`361`
`@@ -370,8 +370,7 @@ public bool Equals(GitUser other)`
`370`	`370`	`{`
`371`	`371`	`return`
`372`	`372`	`String.Equals(name, other.name) &&`
`373`		`- String.Equals(email, other.email)`
`374`		`- ;`
	`373`	`+ Email.Equals(other.Email);`
`375`	`374`	`}`
`376`	`375`
`377`	`376`	`public static bool operator ==(GitUser lhs, GitUser rhs)`
Original file line number	Diff line number	Diff line change
`@@ -7,50 +7,58 @@ public struct GitLock`
`7`	`7`	`{`
`8`	`8`	`public static GitLock Default = new GitLock();`
`9`	`9`
`10`		`- public int ID;`
`11`		`- public string Path;`
`12`		`- public string FullPath;`
`13`		`- public string User;`
	`10`	`+ public int id;`
	`11`	`+ public string path;`
	`12`	`+ public GitUser owner;`
	`13`	`+ public DateTimeOffset locked_at;`
`14`	`14`
`15`		`- public GitLock(string path, string fullPath, string user, int id)`
	`15`	`+ [NotSerialized] public int ID => id;`
	`16`	`+ [NotSerialized] public NPath Path => path.ToNPath();`
	`17`	`+ [NotSerialized] public GitUser Owner => owner;`
	`18`	`+ [NotSerialized] public DateTimeOffset LockedAt => locked_at;`
	`19`	`+`
	`20`	`+ public GitLock(int id, NPath path, GitUser owner, DateTimeOffset locked_at)`
`16`	`21`	`{`
`17`		`- Path = path;`
`18`		`- FullPath = fullPath;`
`19`		`- User = user;`
`20`		`- ID = id;`
	`22`	`+ this.id = id;`
	`23`	`+ this.path = path;`
	`24`	`+ this.owner = owner;`
	`25`	`+ this.locked_at = locked_at;`
`21`	`26`	`}`
`22`	`27`
`23`	`28`	`public override bool Equals(object other)`
`24`	`29`	`{`
`25`	`30`	`if (other is GitLock)`
`26`		`- {`
`27`		`- return this.Equals((GitLock)other);`
`28`		`- }`
	`31`	`+ return Equals((GitLock)other);`
`29`	`32`	`return false;`
`30`	`33`	`}`
`31`	`34`
`32`		`- public bool Equals(GitLock p)`
	`35`	`+ public bool Equals(GitLock other)`
`33`	`36`	`{`
`34`		`- return ID == p.ID;`
	`37`	`+ return this == other;`
`35`	`38`	`}`
`36`	`39`
`37`	`40`	`public override int GetHashCode()`
`38`	`41`	`{`
`39`		`- return 17 * 23 + ID.GetHashCode();`
	`42`	`+ int hash = 17;`
	`43`	`+ hash = hash * 23 + id.GetHashCode();`
	`44`	`+ hash = hash * 23 + Path.GetHashCode();`
	`45`	`+ hash = hash * 23 + owner.GetHashCode();`
	`46`	`+ hash = hash * 23 + locked_at.GetHashCode();`
	`47`	`+ return hash;`
`40`	`48`	`}`
`41`	`49`
`42`	`50`	`public static bool operator ==(GitLock lhs, GitLock rhs)`
`43`	`51`	`{`
`44`		`- return lhs.Equals(rhs);`
	`52`	`+ return lhs.id == rhs.id && lhs.Path == rhs.Path && lhs.owner == rhs.owner && lhs.locked_at == rhs.locked_at;`
`45`	`53`	`}`
`46`	`54`
`47`	`55`	`public static bool operator !=(GitLock lhs, GitLock rhs)`
`48`	`56`	`{`
`49`		`- return !(lhs.Equals(rhs));`
	`57`	`+ return !(lhs == rhs);`
`50`	`58`	`}`
`51`	`59`	`public override string ToString()`
`52`	`60`	`{`
`53`		`- return $"{{GitLock ({User}) '{Path}'}}";`
	`61`	`+ return $"{{id:{id}, path:{Path}, owner:{{{owner}}}, locked_at:'{locked_at}'}}";`
`54`	`62`	`}`
`55`	`63`	`}`
`56`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,5 @@ public GitStatusEntry CreateGitStatusEntry(string path, GitFileStatus status, st`
`20`	`20`
`21`	`21`	`return new GitStatusEntry(relativePath, absolutePath, projectPath, status, originalPath?.ToNPath(), staged);`
`22`	`22`	`}`
`23`		`-`
`24`		`- public GitLock CreateGitLock(string path, string user, int id)`
`25`		`- {`
`26`		`- var npath = new NPath(path).MakeAbsolute();`
`27`		`- var fullPath = npath.RelativeTo(environment.RepositoryPath);`
`28`		`-`
`29`		`- return new GitLock(path, fullPath, user, id);`
`30`		`- }`
`31`	`23`	`}`
`32`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,5 @@ namespace GitHub.Unity`
`3`	`3`	`interface IGitObjectFactory`
`4`	`4`	`{`
`5`	`5`	`GitStatusEntry CreateGitStatusEntry(string path, GitFileStatus status, string originalPath = null, bool staged = false);`
`6`		`- GitLock CreateGitLock(string path, string user, int id);`
`7`	`6`	`}`
`8`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,19 +4,18 @@ namespace GitHub.Unity`
`4`	`4`	`{`
`5`	`5`	`class GitListLocksTask : ProcessTaskWithListOutput<GitLock>`
`6`	`6`	`{`
`7`		`- private const string TaskName = "git lfs locks";`
`8`	`7`	`private readonly string args;`
`9`	`8`
`10`		`- public GitListLocksTask(IGitObjectFactory gitObjectFactory, bool local,`
	`9`	`+ public GitListLocksTask(bool local,`
`11`	`10`	`CancellationToken token, BaseOutputListProcessor<GitLock> processor = null)`
`12`		`- : base(token, processor ?? new LockOutputProcessor(gitObjectFactory))`
	`11`	`+ : base(token, processor ?? new LocksOutputProcessor())`
`13`	`12`	`{`
`14`		`- Name = TaskName;`
`15`		`- args = "lfs locks";`
	`13`	`+ args = "lfs locks --json";`
`16`	`14`	`if (local)`
`17`	`15`	`{`
`18`	`16`	`args += " --local";`
`19`	`17`	`}`
	`18`	`+ Name = args;`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`public override string ProcessArguments => args;`