Example #1
0
        public void CanGetFilteredContentInBareRepo()
        {
            ObjectId          id      = new ObjectId("799770d1cff46753a57db7a066159b5610da6e3a");
            BlobFilterOptions options = new BlobFilterOptions()
            {
                Flags = BlobFilterFlags.CheckForBinary |
                        BlobFilterFlags.NoSystemAttributes |
                        BlobFilterFlags.AttributesFromHead
            };

            using (Repository repo = SandboxRepository("crlf.git"))
                using (Blob b = repo.Objects.Lookup <Blob>(id))
                {
                    using (GitBuffer buf = b.GetFilteredContent("file.bin", options))
                    {
                        Assert.Equal(15, buf.Length);
                        Assert.True(buf.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a })));
                        Assert.Equal(15, buf.Content.Length);
                    }

                    using (GitBuffer buf = b.GetFilteredContent("file.crlf", options))
                    {
                        Assert.Equal(20, buf.Length);
                        Assert.True(buf.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a })));
                        Assert.Equal(20, buf.Content.Length);
                    }

                    using (GitBuffer buf = b.GetFilteredContent("file.lf", options))
                    {
                        Assert.Equal(15, buf.Length);
                        Assert.True(buf.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a })));
                        Assert.Equal(15, buf.Content.Length);
                    }
                }
        }
Example #2
0
        public void CanFilterFileToOdb()
        {
            var id    = new ObjectId("a8233120f6ad708f843d861ce2b7228ec4e3dec6");
            var flags = FilterFlags.NoSystemAttributes;

            using (Repository repo = SandboxRepository("testrepo"))
            {
                string attributesPath = string.Format("{0}/.gitattributes", repo.Workdir);
                File.WriteAllLines(attributesPath, new string[] { "* text eol=crlf" });

                string filePath = string.Format("{0}/foo.txt", repo.Workdir);
                File.WriteAllBytes(filePath, new byte[] { 0x68, 0x65, 0x79, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x0d, 0x0a });

                using (Blob b = repo.Objects.Lookup <Blob>(id))
                    using (FilterList cleanFilter = repo.LoadFilterList(b, "foo.txt", FilterMode.ToObjectDatabase, flags))
                    {
                        using (GitBuffer outputBuffer = cleanFilter.Apply("foo.txt"))
                        {
                            Assert.Equal(10, outputBuffer.Length);
                            Assert.True(outputBuffer.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x68, 0x65, 0x79, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x0a })));
                            Assert.Equal(10, outputBuffer.Content.Length);
                        }
                    }
            }
        }
Example #3
0
        public void CanGetFilteredContent()
        {
            ObjectId id = new ObjectId("a8233120f6ad708f843d861ce2b7228ec4e3dec6");

            using (Repository repo = SandboxRepository("testrepo"))
                using (Blob b = repo.Objects.Lookup <Blob>(id))
                {
                    using (GitBuffer buf = b.GetFilteredContent("foo.txt"))
                    {
                        Assert.Equal(10, buf.Length);
                        Assert.True(buf.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x68, 0x65, 0x79, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x0a })));
                        Assert.Equal(10, buf.Content.Length);
                    }

                    string attributesPath = string.Format("{0}/.gitattributes", repo.Workdir);
                    File.WriteAllLines(attributesPath, new string[] { "* text eol=crlf" });

                    using (GitBuffer buf = b.GetFilteredContent("foo.txt"))
                    {
                        Assert.Equal(11, buf.Length);
                        Assert.True(buf.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x68, 0x65, 0x79, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x0d, 0x0a })));
                        Assert.Equal(11, buf.Content.Length);
                    }
                }
        }
Example #4
0
        public void CanFilterBufferToOdbInBareRepository()
        {
            var id    = new ObjectId("799770d1cff46753a57db7a066159b5610da6e3a");
            var flags = FilterFlags.NoSystemAttributes | FilterFlags.AttributesFromHead;

            var blobFilterOptions = new BlobFilterOptions();

            blobFilterOptions.Flags = BlobFilterFlags.NoSystemAttributes | BlobFilterFlags.AttributesFromHead;

            using (Repository repo = SandboxRepository("crlf.git"))
                using (Blob b = repo.Objects.Lookup <Blob>(id))
                    using (FilterList cleanFilter = repo.LoadFilterList(b, "file.crlf", FilterMode.ToObjectDatabase, flags))
                    {
                        using (GitBuffer inputBuffer = b.GetFilteredContent("file.crlf", blobFilterOptions))
                        {
                            Assert.Equal(20, inputBuffer.Length);
                            Assert.True(inputBuffer.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a })));
                            Assert.Equal(20, inputBuffer.Content.Length);

                            // No filtering is configured
                            using (GitBuffer outputBuffer = cleanFilter.Apply(inputBuffer))
                            {
                                Assert.Equal(15, outputBuffer.Length);
                                Assert.True(outputBuffer.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a, 0x6c, 0x66, 0x0a })));
                                Assert.Equal(15, outputBuffer.Content.Length);
                            }
                        }
                    }
        }
Example #5
0
    public unsafe GitBuffer Apply(string path)
    {
        Ensure.ArgumentNotNull(path, "path");
        GitBuffer ret = new GitBuffer();

        Ensure.NativeSuccess(() => libgit2.git_filter_list_apply_to_file(ret.NativeBuffer, nativeFilterList, repository.NativeRepository, path), this);
        return(ret);
    }
Example #6
0
    public unsafe GitBuffer Apply(GitBuffer buffer)
    {
        Ensure.ArgumentNotNull(buffer, "buffer");
        GitBuffer ret = new GitBuffer();

        Ensure.NativeSuccess(() => libgit2.git_filter_list_apply_to_data(ret.NativeBuffer, nativeFilterList, buffer.NativeBuffer), this);
        return(ret);
    }
Example #7
0
    public unsafe GitBuffer Apply(Blob blob)
    {
        Ensure.ArgumentNotNull(blob, "blob");
        GitBuffer ret = new GitBuffer();

        Ensure.NativeSuccess(() => libgit2.git_filter_list_apply_to_blob(ret.NativeBuffer, nativeFilterList, (git_blob *)blob.NativeObject), this);
        return(ret);
    }
Example #8
0
        public void CanFilterBlobToWorkdirInBareRepository()
        {
            var id    = new ObjectId("799770d1cff46753a57db7a066159b5610da6e3a");
            var flags = FilterFlags.NoSystemAttributes | FilterFlags.AttributesFromHead;

            using (Repository repo = SandboxRepository("crlf.git"))
                using (Blob b = repo.Objects.Lookup <Blob>(id))
                    using (FilterList smudgeFilter = repo.LoadFilterList(b, "file.crlf", FilterMode.ToWorktree, flags))
                        using (GitBuffer outputBuffer = smudgeFilter.Apply(b))
                        {
                            Assert.Equal(20, outputBuffer.Length);
                            Assert.True(outputBuffer.Content.SequenceEqual(new ReadOnlySpan <byte>(new byte[] { 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a, 0x6c, 0x66, 0x0d, 0x0a })));
                            Assert.Equal(20, outputBuffer.Content.Length);
                        }
        }