Merge branch 'cmn/refspec-transform'

carlosmn · carlosmn · commit 78a0f4b4d830 · 2016-03-07T10:56:55.000+01:00
diff --git a/LibGit2Sharp.Tests/RefSpecFixture.cs b/LibGit2Sharp.Tests/RefSpecFixture.cs
@@ -190,5 +190,43 @@ public void SettingInvalidRefSpecsThrows(string refSpec)
                 Assert.Equal(oldRefSpecs, newRemote.RefSpecs.Select(r => r.Specification).ToList());
             }
         }
+
+        [Theory]
+        [InlineData("refs/heads/master", true, false)]
+        [InlineData("refs/heads/some/master", true, false)]
+        [InlineData("refs/remotes/foo/master", false, true)]
+        [InlineData("refs/tags/foo", false, false)]
+        public void CanCheckForMatches(string reference, bool shouldMatchSource, bool shouldMatchDest)
+        {
+            var path = SandboxStandardTestRepo();
+            using (var repo = InitIsolatedRepository(path))
+            {
+                var remote = repo.Network.Remotes.Add("foo", "blahblah", "refs/heads/*:refs/remotes/foo/*");
+                var refspec = remote.RefSpecs.Single();
+
+                Assert.Equal(shouldMatchSource, refspec.SourceMatches(reference));
+                Assert.Equal(shouldMatchDest, refspec.DestinationMatches(reference));
+            }
+        }
+
+        [Theory]
+        [InlineData("refs/heads/master", "refs/remotes/foo/master")]
+        [InlineData("refs/heads/bar/master", "refs/remotes/foo/bar/master")]
+        [InlineData("refs/heads/master", "refs/remotes/foo/master")]
+        public void CanTransformRefspecs(string lhs, string rhs)
+        {
+            var path = SandboxStandardTestRepo();
+            using (var repo = InitIsolatedRepository(path))
+            {
+                var remote = repo.Network.Remotes.Add("foo", "blahblah", "refs/heads/*:refs/remotes/foo/*");
+                var refspec = remote.RefSpecs.Single();
+
+                var actualTransformed = refspec.Transform(lhs);
+                var actualReverseTransformed = refspec.ReverseTransform(rhs);
+
+                Assert.Equal(rhs, actualTransformed);
+                Assert.Equal(lhs, actualReverseTransformed);
+            }
+        }
     }
 }
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -1112,6 +1112,12 @@ internal static extern IntPtr git_reflog_entry_committer(
         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(LaxUtf8NoCleanupMarshaler))]
         internal static extern string git_reflog_entry_message(SafeHandle entry);
 
+        [DllImport(libgit2)]
+        internal static extern int git_refspec_transform(
+            GitBuf buf,
+            GitRefSpecHandle refspec,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string name);
+
         [DllImport(libgit2)]
         internal static extern int git_refspec_rtransform(
             GitBuf buf,
@@ -1139,6 +1145,16 @@ internal static extern string git_refspec_src(
         [DllImport(libgit2)]
         internal static extern bool git_refspec_force(GitRefSpecHandle refSpec);
 
+        [DllImport(libgit2)]
+        internal static extern bool git_refspec_src_matches(
+            GitRefSpecHandle resfpec,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string reference);
+
+        [DllImport(libgit2)]
+        internal static extern bool git_refspec_dst_matches(
+            GitRefSpecHandle resfpec,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string reference);
+
         [DllImport(libgit2)]
         internal static extern int git_remote_autotag(RemoteSafeHandle remote);
 
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -2017,6 +2017,17 @@ public static string git_reflog_entry_message(SafeHandle entry)
 
         #region git_refspec
 
+        public static string git_refspec_transform(GitRefSpecHandle refSpecPtr, string name)
+        {
+            using (var buf = new GitBuf())
+            {
+                int res = NativeMethods.git_refspec_transform(buf, refSpecPtr, name);
+                Ensure.ZeroResult(res);
+
+                return LaxUtf8Marshaler.FromNative(buf.ptr) ?? string.Empty;
+            }
+        }
+
         public static string git_refspec_rtransform(GitRefSpecHandle refSpecPtr, string name)
         {
             using (var buf = new GitBuf())
@@ -2053,6 +2064,16 @@ public static bool git_refspec_force(GitRefSpecHandle refSpec)
             return NativeMethods.git_refspec_force(refSpec);
         }
 
+        public static bool git_refspec_src_matches(GitRefSpecHandle refspec, string reference)
+        {
+            return NativeMethods.git_refspec_src_matches(refspec, reference);
+        }
+
+        public static bool git_refspec_dst_matches(GitRefSpecHandle refspec, string reference)
+        {
+            return NativeMethods.git_refspec_dst_matches(refspec, reference);
+        }
+
         #endregion
 
         #region git_remote_
diff --git a/LibGit2Sharp/RefSpec.cs b/LibGit2Sharp/RefSpec.cs
@@ -1,4 +1,5 @@
-﻿using System.Diagnostics;
+﻿using System;
+using System.Diagnostics;
 using System.Globalization;
 using LibGit2Sharp.Core;
 using LibGit2Sharp.Core.Handles;
@@ -11,17 +12,13 @@ namespace LibGit2Sharp
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class RefSpec
     {
-        private RefSpec(string refSpec, RefSpecDirection direction, string source, string destination, bool forceUpdate)
-        {
-            Ensure.ArgumentNotNullOrEmptyString(refSpec, "refSpec");
-            Ensure.ArgumentNotNull(source, "source");
-            Ensure.ArgumentNotNull(destination, "destination");
+        readonly Remote remote;
+        readonly GitRefSpecHandle handle;
 
-            Specification = refSpec;
-            Direction = direction;
-            Source = source;
-            Destination = destination;
-            ForceUpdate = forceUpdate;
+        internal RefSpec(Remote remote, GitRefSpecHandle handle)
+        {
+            this.remote = remote;
+            this.handle = handle;
         }
 
         /// <summary>
@@ -30,38 +27,100 @@ private RefSpec(string refSpec, RefSpecDirection direction, string source, strin
         protected RefSpec()
         { }
 
-        internal static RefSpec BuildFromPtr(GitRefSpecHandle handle)
-        {
-            Ensure.ArgumentNotNull(handle, "handle");
-
-            return new RefSpec(Proxy.git_refspec_string(handle), Proxy.git_refspec_direction(handle),
-                Proxy.git_refspec_src(handle), Proxy.git_refspec_dst(handle), Proxy.git_refspec_force(handle));
-        }
-
         /// <summary>
         /// Gets the pattern describing the mapping between remote and local references
         /// </summary>
-        public virtual string Specification { get; private set; }
+        public virtual string Specification
+        {
+            get
+            {
+                return Proxy.git_refspec_string(this.handle);
+            }
+        }
 
         /// <summary>
         /// Indicates whether this <see cref="RefSpec"/> is intended to be used during a Push or Fetch operation
         /// </summary>
-        public virtual RefSpecDirection Direction { get; private set; }
+        public virtual RefSpecDirection Direction
+        {
+            get
+            {
+                return Proxy.git_refspec_direction(this.handle);
+            }
+        }
 
         /// <summary>
         /// The source reference specifier
         /// </summary>
-        public virtual string Source { get; private set; }
+        public virtual string Source
+        {
+            get
+            {
+                return Proxy.git_refspec_src(this.handle);
+            }
+        }
 
         /// <summary>
         /// The target reference specifier
         /// </summary>
-        public virtual string Destination { get; private set; }
+        public virtual string Destination
+        {
+            get
+            {
+                return Proxy.git_refspec_dst(this.handle);
+            }
+        }
 
         /// <summary>
         /// Indicates whether the destination will be force-updated if fast-forwarding is not possible
         /// </summary>
-        public virtual bool ForceUpdate { get; private set; }
+        public virtual bool ForceUpdate
+        {
+            get
+            {
+                return Proxy.git_refspec_force(this.handle);
+            }
+        }
+
+        /// <summary>
+        /// Check whether the given reference matches the source (lhs) part of
+        /// this refspec.
+        /// </summary>
+        /// <param name="reference">The reference name to check</param>
+        public virtual bool SourceMatches(string reference)
+        {
+            return Proxy.git_refspec_src_matches(handle, reference);
+        }
+
+        /// <summary>
+        /// Check whether the given reference matches the target (rhs) part of
+        /// this refspec.
+        /// </summary>
+        /// <param name="reference">The reference name to check</param>
+        public virtual bool DestinationMatches(string reference)
+        {
+            return Proxy.git_refspec_dst_matches(handle, reference);
+        }
+
+        /// <summary>
+        /// Perform the transformation described by this refspec on the given
+        /// reference name (from source to destination).
+        /// </summary>
+        /// <param name="reference">The reference name to transform</param>
+        public virtual string Transform(string reference)
+        {
+            return Proxy.git_refspec_transform(handle, reference);
+        }
+
+        /// <summary>
+        /// Perform the reverse of the transformation described by this refspec
+        /// on the given reference name (from destination to source).
+        /// </summary>
+        /// <param name="reference">The reference name to transform</param>
+        public virtual string ReverseTransform(string reference)
+        {
+            return Proxy.git_refspec_rtransform(handle, reference);
+        }
 
         private string DebuggerDisplay
         {
diff --git a/LibGit2Sharp/RefSpecCollection.cs b/LibGit2Sharp/RefSpecCollection.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections;
+﻿using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -14,36 +15,37 @@ namespace LibGit2Sharp
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class RefSpecCollection : IEnumerable<RefSpec>
     {
-        readonly IList<RefSpec> refspecs;
+        readonly Remote remote;
+        readonly RemoteSafeHandle handle;
+        readonly Lazy<IList<RefSpec>> refspecs;
 
         /// <summary>
         /// Needed for mocking purposes.
         /// </summary>
         protected RefSpecCollection()
         { }
 
-        internal RefSpecCollection(RemoteSafeHandle handle)
+        internal RefSpecCollection(Remote remote, RemoteSafeHandle handle)
         {
             Ensure.ArgumentNotNull(handle, "handle");
 
-            refspecs = RetrieveRefSpecs(handle);
+            this.remote = remote;
+            this.handle = handle;
+
+            refspecs = new Lazy<IList<RefSpec>>(() => RetrieveRefSpecs(remote, handle));
         }
 
-        static IList<RefSpec> RetrieveRefSpecs(RemoteSafeHandle remoteHandle)
+        static IList<RefSpec> RetrieveRefSpecs(Remote remote, RemoteSafeHandle remoteHandle)
         {
             int count = Proxy.git_remote_refspec_count(remoteHandle);
             List<RefSpec> refSpecs = new List<RefSpec>();
 
             for (int i = 0; i < count; i++)
             {
-                using (GitRefSpecHandle handle = Proxy.git_remote_get_refspec(remoteHandle, i))
-                {
-                    refSpecs.Add(RefSpec.BuildFromPtr(handle));
-                }
+                refSpecs.Add(new RefSpec(remote, Proxy.git_remote_get_refspec(remoteHandle, i)));
             }
 
             return refSpecs;
-
         }
 
         /// <summary>
@@ -52,7 +54,7 @@ static IList<RefSpec> RetrieveRefSpecs(RemoteSafeHandle remoteHandle)
         /// <returns>An <see cref="IEnumerator{T}"/> object that can be used to iterate through the collection.</returns>
         public virtual IEnumerator<RefSpec> GetEnumerator()
         {
-            return refspecs.GetEnumerator();
+            return refspecs.Value.GetEnumerator();
         }
 
         /// <summary>
diff --git a/LibGit2Sharp/Remote.cs b/LibGit2Sharp/Remote.cs
@@ -12,7 +12,7 @@ namespace LibGit2Sharp
     /// A remote repository whose branches are tracked.
     /// </summary>
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public class Remote : IEquatable<Remote>, IBelongToARepository
+    public class Remote : IEquatable<Remote>, IBelongToARepository, IDisposable
     {
         private static readonly LambdaEqualityHelper<Remote> equalityHelper =
             new LambdaEqualityHelper<Remote>(x => x.Name, x => x.Url, x => x.PushUrl);
@@ -22,29 +22,58 @@ public class Remote : IEquatable<Remote>, IBelongToARepository
         private readonly RefSpecCollection refSpecs;
         private string pushUrl;
 
+        readonly RemoteSafeHandle handle;
+
         /// <summary>
         /// Needed for mocking purposes.
         /// </summary>
         protected Remote()
         { }
 
-        private Remote(RemoteSafeHandle handle, Repository repository)
+        internal Remote(RemoteSafeHandle handle, Repository repository)
         {
             this.repository = repository;
+            this.handle = handle;
             Name = Proxy.git_remote_name(handle);
             Url = Proxy.git_remote_url(handle);
             PushUrl = Proxy.git_remote_pushurl(handle);
             TagFetchMode = Proxy.git_remote_autotag(handle);
-            refSpecs = new RefSpecCollection(handle);
+            refSpecs = new RefSpecCollection(this, handle);
+        }
+
+        ~Remote()
+        {
+            Dispose(false);
+        }
+
+        #region IDisposable
+
+        bool disposedValue = false; // To detect redundant calls
+
+        /// <summary>
+        /// Release the unmanaged remote object
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
-        internal static Remote BuildFromPtr(RemoteSafeHandle handle, Repository repo)
+        void Dispose(bool disposing)
         {
-            var remote = new Remote(handle, repo);
+            if (!disposedValue)
+            {
+                if (handle != null)
+                {
+                    handle.Dispose();
+                }
 
-            return remote;
+                disposedValue = true;
+            }
         }
 
+        #endregion
+
         /// <summary>
         /// Gets the alias of this remote repository.
         /// </summary>
diff --git a/LibGit2Sharp/RemoteCollection.cs b/LibGit2Sharp/RemoteCollection.cs
