Custom filter Streams

LibGit2Sharp.Tests/FilterFixture.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using LibGit2Sharp.Core;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
 
@@ -13,7 +12,7 @@ public class FilterFixture : BaseFixture
         private const int GitPassThrough = -30;
 
         readonly Func<FilterSource, IEnumerable<string>, int> checkPassThrough = (source, attr) => GitPassThrough;
-        readonly Func<GitBufReader, GitBufWriter, int> successCallback = (reader, writer) => 0;
+        readonly Func<Stream, Stream, int> successCallback = (reader, writer) => 0;
         readonly Func<FilterSource, IEnumerable<string>, int> checkSuccess = (source, attr) => 0;
 
         private const string FilterName = "the-filter";
@@ -106,7 +105,7 @@ public void ApplyCallbackMadeWhenCheckCallbackReturnsZero()
         {
             bool called = false;
 
-            Func<GitBufReader, GitBufWriter, int> applyCallback = (reader, writer) =>
+            Func<Stream, Stream, int> applyCallback = (reader, writer) =>
             {
                 called = true;
                 return 0; //successCallback
@@ -131,7 +130,7 @@ public void ApplyCallbackNotMadeWhenCheckCallbackReturnsPassThrough()
         {
             bool called = false;
 
-            Func<GitBufReader, GitBufWriter, int> applyCallback = (reader, writer) =>
+            Func<Stream, Stream, int> applyCallback = (reader, writer) =>
             {
                 called = true;
                 return 0;
@@ -271,7 +270,7 @@ public void WhenStagingFileApplyIsCalledWithCleanForCorrectPath()
             string repoPath = InitNewRepository();
             bool called = false;
 
-            Func<GitBufReader, GitBufWriter, int> clean = (reader, writer) =>
+            Func<Stream, Stream, int> clean = (reader, writer) =>
             {
                 called = true;
                 return GitPassThrough;
@@ -297,7 +296,7 @@ public void CleanFilterWritesOutputToObjectTree()
 
             string repoPath = InitNewRepository();
 
-            Func<GitBufReader, GitBufWriter, int> cleanCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
+            Func<Stream, Stream, int> cleanCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
 
             var filter = new FakeFilter(FilterName + 16, attributes, checkSuccess, cleanCallback);
 
@@ -327,7 +326,7 @@ public void WhenCheckingOutAFileFileSmudgeWritesCorrectFileToWorkingDirectory()
             const string branchName = "branch";
             string repoPath = InitNewRepository();
 
-            Func<GitBufReader, GitBufWriter, int> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
+            Func<Stream, Stream, int> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
 
             var filter = new FakeFilter(FilterName + 17, attributes, checkSuccess, null, smudgeCallback);
             GlobalSettings.RegisterFilter(filter);
@@ -341,6 +340,54 @@ public void WhenCheckingOutAFileFileSmudgeWritesCorrectFileToWorkingDirectory()
             GlobalSettings.DeregisterFilter(filter.Name);
         }
 
+        [Fact]
+        public void FilterStreamsAreCoherent()
+        {
+            string repoPath = InitNewRepository();
+
+            bool? inputCanWrite = null, inputCanRead = null, inputCanSeek = null;
+            bool? outputCanWrite = null, outputCanRead = null, outputCanSeek = null;
+
+            Func<Stream, Stream, int> assertor = (input, output) =>
+            {
+                inputCanRead = input.CanRead;
+                inputCanWrite = input.CanWrite;
+                inputCanSeek = input.CanSeek;
+
+                outputCanRead = output.CanRead;
+                outputCanWrite = output.CanWrite;
+                outputCanSeek = output.CanSeek;
+
+                return GitPassThrough;
+            };
+
+            var filter = new FakeFilter(FilterName + 18, attributes, checkSuccess, assertor, assertor);
+
+            GlobalSettings.RegisterFilter(filter);
+
+            using (var repo = CreateTestRepository(repoPath))
+            {
+                StageNewFile(repo);
+            }
+
+            GlobalSettings.DeregisterFilter(filter.Name);
+
+            Assert.True(inputCanRead.HasValue);
+            Assert.True(inputCanWrite.HasValue);
+            Assert.True(inputCanSeek.HasValue);
+            Assert.True(outputCanRead.HasValue);
+            Assert.True(outputCanWrite.HasValue);
+            Assert.True(outputCanSeek.HasValue);
+
+            Assert.True(inputCanRead.Value);
+            Assert.False(inputCanWrite.Value);
+            Assert.False(inputCanSeek.Value);
+
+            Assert.False(outputCanRead.Value);
+            Assert.True(outputCanWrite.Value);
+            Assert.False(outputCanSeek.Value);
+        }
+
         private FileInfo CheckoutFileForSmudge(string repoPath, string branchName, string content)
         {
             FileInfo expectedPath;
@@ -394,14 +441,14 @@ public EmptyFilter(string name, IEnumerable<string> attributes)
         class FakeFilter : Filter
         {
             private readonly Func<FilterSource, IEnumerable<string>, int> checkCallBack;
-            private readonly Func<GitBufReader, GitBufWriter, int> cleanCallback;
-            private readonly Func<GitBufReader, GitBufWriter, int> smudgeCallback;
+            private readonly Func<Stream, Stream, int> cleanCallback;
+            private readonly Func<Stream, Stream, int> smudgeCallback;
             private readonly Func<int> initCallback;
 
             public FakeFilter(string name, IEnumerable<string> attributes,
                 Func<FilterSource, IEnumerable<string>, int> checkCallBack = null,
-                Func<GitBufReader, GitBufWriter, int> cleanCallback = null,
-                Func<GitBufReader, GitBufWriter, int> smudgeCallback = null,
+                Func<Stream, Stream, int> cleanCallback = null,
+                Func<Stream, Stream, int> smudgeCallback = null,
                 Func<int> initCallback = null)
                 : base(name, attributes)
             {
@@ -416,12 +463,12 @@ protected override int Check(IEnumerable<string> attributes, FilterSource filter
                 return checkCallBack != null ? checkCallBack(filterSource, attributes) : base.Check(attributes, filterSource);
             }
 
-            protected override int Clean(string path, GitBufReader input, GitBufWriter output)
+            protected override int Clean(string path, Stream input, Stream output)
             {
                 return cleanCallback != null ? cleanCallback(input, output) : base.Clean(path, input, output);
             }
 
-            protected override int Smudge(string path, GitBufReader input, GitBufWriter output)
+            protected override int Smudge(string path, Stream input, Stream output)
             {
                 return smudgeCallback != null ? smudgeCallback(input, output) : base.Smudge(path, input, output);
             }

LibGit2Sharp.Tests/SubstitutionCipherFilterFixture.cs

@@ -96,4 +96,4 @@ private static Blob CommitOnBranchAndReturnDatabaseBlob(Repository repo, string
             return blob;
         }
     }
-}
+}

LibGit2Sharp.Tests/TestHelpers/SubstitutionCipherFilter.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
-using LibGit2Sharp.Core;
 
 namespace LibGit2Sharp.Tests.TestHelpers
 {
@@ -21,34 +21,41 @@ protected override int Check(IEnumerable<string> attributes, FilterSource filter
             return base.Check(attributes, filterSource);
         }
 
-        protected override int Clean(string path, GitBufReader input, GitBufWriter output)
+        protected override int Clean(string path, Stream input, Stream output)
         {
             CleanCalledCount++;
             return RotateByThirteenPlaces(input, output);
         }
 
-        protected override int Smudge(string path, GitBufReader input, GitBufWriter output)
+        protected override int Smudge(string path, Stream input, Stream output)
         {
             SmudgeCalledCount++;
             return RotateByThirteenPlaces(input, output);
         }
 
-        public static int RotateByThirteenPlaces(GitBufReader input, GitBufWriter output)
+        public static int RotateByThirteenPlaces(Stream input, Stream output)
         {
-            var inputString = Encoding.UTF8.GetString(input.ReadAll());
-            char[] array = inputString.ToCharArray();
-            char value;
-            for (int i = 0; i < inputString.Length; i++)
+
+            using (var streamReader = new StreamReader(input, Encoding.UTF8))
             {
-                value = inputString[i];
-                if ((value >= 'a' && value <= 'm') || (value >= 'A' && value <= 'M'))
-                    array[i] = (char)(value + 13);
-                else if ((value >= 'n' && value <= 'z') || (value >= 'N' && value <= 'Z'))
-                    array[i] = (char)(value - 13);
+                var inputString = streamReader.ReadToEnd();
+                char[] array = inputString.ToCharArray();
+                for (int i = 0; i < inputString.Length; i++)
+                {
+                    var value = inputString[i];
+                    if ((value >= 'a' && value <= 'm') || (value >= 'A' && value <= 'M'))
+                        array[i] = (char)(value + 13);
+                    else if ((value >= 'n' && value <= 'z') || (value >= 'N' && value <= 'Z'))
+                        array[i] = (char)(value - 13);
+                }
+
+                using (var streamWriter = new StreamWriter(output, Encoding.UTF8))
+                {
+                    streamWriter.Write(array);
+                }
+
+                return 0;
             }
-            var outputString = new string(array);
-            output.Write(Encoding.UTF8.GetBytes(outputString));
-            return 0;
         }
     }
-}
+}

LibGit2Sharp/Core/GitBufReadStream.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Globalization;
+using System.IO;
+using LibGit2Sharp.Core.Handles;
+
+namespace LibGit2Sharp.Core
+{
+    /// <summary>
+    /// Reads data from a <see cref="GitBuf"/> pointer
+    /// </summary>
+    internal class GitBufReadStream : UnmanagedMemoryStream
+    {
+        internal GitBufReadStream(IntPtr gitBufPointer)
+            : this(gitBufPointer.MarshalAs<GitBuf>())
+        { }
+
+        private unsafe GitBufReadStream(GitBuf gitBuf)
+            : base((byte*)gitBuf.ptr,
+                   ConvertToLong(gitBuf.size),
+                   ConvertToLong(gitBuf.asize),
+                   FileAccess.Read)
+        { }
+
+        private static long ConvertToLong(UIntPtr len)
+        {
+            if (len.ToUInt64() > long.MaxValue)
+            {
+                throw new InvalidOperationException(
+                    string.Format(
+                        CultureInfo.InvariantCulture,
+                        "Provided length ({0}) exceeds long.MaxValue ({1}).",
+                        len.ToUInt64(), long.MaxValue));
+            }
+
+            return (long)len.ToUInt64();
+        }
+
+        public override long Seek(long offset, SeekOrigin loc)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+    }
+}

LibGit2Sharp/Core/GitBufWriteStream.cs

@@ -0,0 +1,91 @@
+using System;
+using System.IO;
+using LibGit2Sharp.Core.Handles;
+
+namespace LibGit2Sharp.Core
+{
+    internal class GitBufWriteStream : Stream
+    {
+        private readonly IntPtr gitBufPointer;
+
+        internal GitBufWriteStream(IntPtr gitBufPointer)
+        {
+            this.gitBufPointer = gitBufPointer;
+
+            //Preallocate the buffer
+            Proxy.git_buf_grow(gitBufPointer, 1024);
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            AutoGrowBuffer(count);
+
+            Proxy.git_buf_put(gitBufPointer, buffer, offset, count);
+        }
+
+        private void AutoGrowBuffer(int count)
+        {
+            var gitBuf = gitBufPointer.MarshalAs<GitBuf>();
+
+            var asize = (uint)gitBuf.asize;
+            var size = (uint)gitBuf.size;
+
+            var isBufferLargeEnoughToHoldTheNewData = (asize - size) > count;
+            var filledBufferPercentage = (100.0 * size / asize);
+
+            if (isBufferLargeEnoughToHoldTheNewData && filledBufferPercentage < 90)
+            {
+                return;
+            }
+
+            var targetSize = (uint)(1.5 * (asize + count));
+
+            Proxy.git_buf_grow(gitBufPointer, targetSize);
+        }
+
+        public override bool CanRead
+        {
+            get { return false; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+    }
+}

LibGit2Sharp/Core/NativeDllName.cs

@@ -2,6 +2,6 @@ namespace LibGit2Sharp.Core
 {
 	internal static class NativeDllName
 	{
-		public const string Name = "git2-e0902fb";
+		public const string Name = "git2-a2012c4";
 	}
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -219,10 +219,10 @@ internal static extern int git_branch_remote_name(
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string canonical_branch_name);
 
         [DllImport(libgit2)]
-        internal static extern int git_buf_grow(GitBuf buffer, UIntPtr targetSize);
+        internal static extern int git_buf_grow(IntPtr buffer, UIntPtr targetSize);
 
         [DllImport(libgit2)]
-        internal static extern int git_buf_set(GitBuf buffer, IntPtr data, UIntPtr targetSize);
+        internal static extern int git_buf_put(IntPtr buffer, IntPtr data, UIntPtr len);
 
         [DllImport(libgit2)]
         internal static extern int git_remote_rename(