A Sequence supporting UNIX formatted text in byte[] format.
A Sequence supporting UNIX formatted text in byte[] format.

Elements of the sequence are the lines of the file, as delimited by the UNIX newline character ('\n'). The file content is treated as 8 bit binary text, with no assumptions or requirements on character encoding.

Note that the first line of the file is element 0, as defined by the Sequence interface API. Traditionally in a text editor a patch file the first line is line number 1. Callers may need to subtract 1 prior to invoking methods if they are converting from "line number" to "element index".

Inheritance: NGit.Diff.Sequence
Example #1
1
        public static IntList GetLines(RawText rawText)
        {
            if (_linesField == null)
                _linesField = typeof(RawText).GetField("lines", BindingFlags.NonPublic | BindingFlags.Instance);

            return (IntList)_linesField.GetValue(rawText);
        }
        public virtual void TestEqualsWithWhitespace()
        {
            RawText a = new RawText(Constants.EncodeASCII("foo-a\n         \n a b c\na      \n  foo\na  b  c\n"
                                                          ));
            RawText b = new RawText(Constants.EncodeASCII("foo-a        b\n\nab  c\na\nfoo\na b     c  \n"
                                                          ));

            // "foo-a" != "foo-a        b"
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
            // "         " == ""
            NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 1));
            NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 1, a, 1));
            // " a b c" != "ab  c"
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 2, b, 2));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 2, a, 2));
            // "a      " == "a"
            NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 3, b, 3));
            NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 3, a, 3));
            // "  foo" != "foo"
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 4, b, 4));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 4, a, 4));
            // "a  b  c" == "a b     c  "
            NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 5, b, 5));
            NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 5, a, 5));
        }
            public override bool Equals(RawText a, int ai, RawText b, int bi)
            {
                ai++;
                bi++;
                int @as = a.lines.Get(ai);
                int bs  = b.lines.Get(bi);
                int ae  = a.lines.Get(ai + 1);
                int be  = b.lines.Get(bi + 1);

                ae = RawCharUtil.TrimTrailingWhitespace(a.content, @as, ae);
                be = RawCharUtil.TrimTrailingWhitespace(b.content, bs, be);
                while (@as < ae && bs < be)
                {
                    byte ac = a.content[@as];
                    byte bc = b.content[bs];
                    while (@as < ae - 1 && RawCharUtil.IsWhitespace(ac))
                    {
                        @as++;
                        ac = a.content[@as];
                    }
                    while (bs < be - 1 && RawCharUtil.IsWhitespace(bc))
                    {
                        bs++;
                        bc = b.content[bs];
                    }
                    if (ac != bc)
                    {
                        return(false);
                    }
                    @as++;
                    bs++;
                }
                return(@as == ae && bs == be);
            }
Example #4
0
        public virtual void LineDelimiterStartingWithCharacterReturn()
        {
            var rt = new RawText(Constants.EncodeASCII("\nfoo"));

            NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
        }
Example #5
0
        public virtual void TestLineDelimiter()
        {
            RawText rt = new RawText(Constants.EncodeASCII("foo\n"));

            NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo\r\n"));
            NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo\nbar"));
            NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo\r\nbar"));
            NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo\nbar\r\n"));
            NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo\r\nbar\n"));
            NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("foo"));
            NUnit.Framework.Assert.IsNull(rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII(string.Empty));
            NUnit.Framework.Assert.IsNull(rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("\n"));
            NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
            rt = new RawText(Constants.EncodeASCII("\r\n"));
            NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
            NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
        }
		public virtual void TestEqualsWithWhitespace()
		{
			RawText a = new RawText(Constants.EncodeASCII("foo-a\n         \n a b c\na      \n  foo\na  b  c\n"
				));
			RawText b = new RawText(Constants.EncodeASCII("foo-a        b\n\nab  c\na\nfoo\na b     c  \n"
				));
			// "foo-a" != "foo-a        b"
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
			// "         " == ""
			NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 1));
			NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 1, a, 1));
			// " a b c" != "ab  c"
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 2, b, 2));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 2, a, 2));
			// "a      " == "a"
			NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 3, b, 3));
			NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 3, a, 3));
			// "  foo" != "foo"
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 4, b, 4));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 4, a, 4));
			// "a  b  c" == "a b     c  "
			NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 5, b, 5));
			NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 5, a, 5));
		}
Example #7
0
        public virtual void TestComparatorReduceCommonStartEnd()
        {
            RawTextComparator c = RawTextComparator.DEFAULT;
            Edit e;

            e = c.ReduceCommonStartEnd(T(string.Empty), T(string.Empty), new Edit(0, 0, 0, 0)
                                       );
            NUnit.Framework.Assert.AreEqual(new Edit(0, 0, 0, 0), e);
            e = c.ReduceCommonStartEnd(T("a"), T("b"), new Edit(0, 1, 0, 1));
            NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 1), e);
            e = c.ReduceCommonStartEnd(T("a"), T("a"), new Edit(0, 1, 0, 1));
            NUnit.Framework.Assert.AreEqual(new Edit(1, 1, 1, 1), e);
            e = c.ReduceCommonStartEnd(T("axB"), T("axC"), new Edit(0, 3, 0, 3));
            NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
            e = c.ReduceCommonStartEnd(T("Bxy"), T("Cxy"), new Edit(0, 3, 0, 3));
            NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 1), e);
            e = c.ReduceCommonStartEnd(T("bc"), T("Abc"), new Edit(0, 2, 0, 3));
            NUnit.Framework.Assert.AreEqual(new Edit(0, 0, 0, 1), e);
            e = new Edit(0, 5, 0, 5);
            e = c.ReduceCommonStartEnd(T("abQxy"), T("abRxy"), e);
            NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
            RawText a = new RawText(Sharpen.Runtime.GetBytesForString("p\na b\nQ\nc d\n", "UTF-8"
                                                                      ));
            RawText b = new RawText(Sharpen.Runtime.GetBytesForString("p\na  b \nR\n c  d \n"
                                                                      , "UTF-8"));

            e = new Edit(0, 4, 0, 4);
            e = RawTextComparator.WS_IGNORE_ALL.ReduceCommonStartEnd(a, b, e);
            NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
        }
Example #8
0
 public virtual void TestComparatorReduceCommonStartEnd()
 {
     RawTextComparator c = RawTextComparator.DEFAULT;
     Edit e;
     e = c.ReduceCommonStartEnd(T(string.Empty), T(string.Empty), new Edit(0, 0, 0, 0)
         );
     NUnit.Framework.Assert.AreEqual(new Edit(0, 0, 0, 0), e);
     e = c.ReduceCommonStartEnd(T("a"), T("b"), new Edit(0, 1, 0, 1));
     NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 1), e);
     e = c.ReduceCommonStartEnd(T("a"), T("a"), new Edit(0, 1, 0, 1));
     NUnit.Framework.Assert.AreEqual(new Edit(1, 1, 1, 1), e);
     e = c.ReduceCommonStartEnd(T("axB"), T("axC"), new Edit(0, 3, 0, 3));
     NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
     e = c.ReduceCommonStartEnd(T("Bxy"), T("Cxy"), new Edit(0, 3, 0, 3));
     NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 1), e);
     e = c.ReduceCommonStartEnd(T("bc"), T("Abc"), new Edit(0, 2, 0, 3));
     NUnit.Framework.Assert.AreEqual(new Edit(0, 0, 0, 1), e);
     e = new Edit(0, 5, 0, 5);
     e = c.ReduceCommonStartEnd(T("abQxy"), T("abRxy"), e);
     NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
     RawText a = new RawText(Sharpen.Runtime.GetBytesForString("p\na b\nQ\nc d\n", "UTF-8"
         ));
     RawText b = new RawText(Sharpen.Runtime.GetBytesForString("p\na  b \nR\n c  d \n"
         , "UTF-8"));
     e = new Edit(0, 4, 0, 4);
     e = RawTextComparator.WS_IGNORE_ALL.ReduceCommonStartEnd(a, b, e);
     NUnit.Framework.Assert.AreEqual(new Edit(2, 3, 2, 3), e);
 }
Example #9
0
        public static byte[] GetContent(RawText rawText)
        {
            if (_contentField == null)
                _contentField = typeof(RawText).GetField("content", BindingFlags.NonPublic | BindingFlags.Instance);

            return (byte[])_contentField.GetValue(rawText);
        }
Example #10
0
        /// <exception cref="System.IO.IOException"></exception>
        /// <exception cref="NGit.Errors.CorruptObjectException"></exception>
        /// <exception cref="NGit.Errors.MissingObjectException"></exception>
        private DiffFormatter.FormatResult CreateFormatResult(DiffEntry ent)
        {
            DiffFormatter.FormatResult res = new DiffFormatter.FormatResult();
            ByteArrayOutputStream      buf = new ByteArrayOutputStream();
            EditList editList;

            FileHeader.PatchType type;
            FormatHeader(buf, ent);
            if (ent.GetOldMode() == FileMode.GITLINK || ent.GetNewMode() == FileMode.GITLINK)
            {
                FormatOldNewPaths(buf, ent);
                WriteGitLinkDiffText(buf, ent);
                editList = new EditList();
                type     = FileHeader.PatchType.UNIFIED;
            }
            else
            {
                AssertHaveRepository();
                byte[] aRaw = Open(DiffEntry.Side.OLD, ent);
                byte[] bRaw = Open(DiffEntry.Side.NEW, ent);
                if (aRaw == BINARY || bRaw == BINARY || RawText.IsBinary(aRaw) || RawText.IsBinary
                        (bRaw))
                {
                    //
                    FormatOldNewPaths(buf, ent);
                    buf.Write(Constants.EncodeASCII("Binary files differ\n"));
                    editList = new EditList();
                    type     = FileHeader.PatchType.BINARY;
                }
                else
                {
                    res.a    = new RawText(aRaw);
                    res.b    = new RawText(bRaw);
                    editList = Diff(res.a, res.b);
                    type     = FileHeader.PatchType.UNIFIED;
                    switch (ent.GetChangeType())
                    {
                    case DiffEntry.ChangeType.RENAME:
                    case DiffEntry.ChangeType.COPY:
                    {
                        if (!editList.IsEmpty())
                        {
                            FormatOldNewPaths(buf, ent);
                        }
                        break;
                    }

                    default:
                    {
                        FormatOldNewPaths(buf, ent);
                        break;
                        break;
                    }
                    }
                }
            }
            res.header = new FileHeader(buf.ToByteArray(), editList, type);
            return(res);
        }
Example #11
0
		public virtual void TestWriteLine1()
		{
			RawText a = new RawText(Constants.EncodeASCII("foo-a\nfoo-b\n"));
			ByteArrayOutputStream o = new ByteArrayOutputStream();
			a.WriteLine(o, 0);
			byte[] r = o.ToByteArray();
			NUnit.Framework.Assert.AreEqual("foo-a", RawParseUtils.Decode(r));
		}
Example #12
0
        public virtual void TestWriteLine2()
        {
            RawText a = new RawText(Constants.EncodeASCII("foo-a\nfoo-b"));
            ByteArrayOutputStream o = new ByteArrayOutputStream();

            a.WriteLine(o, 1);
            byte[] r = o.ToByteArray();
            NUnit.Framework.Assert.AreEqual("foo-b", RawParseUtils.Decode(r));
        }
Example #13
0
        public virtual void TestWriteLine3()
        {
            RawText a = new RawText(Constants.EncodeASCII("a\n\nb\n"));
            ByteArrayOutputStream o = new ByteArrayOutputStream();

            a.WriteLineInternal(o, 1);
            byte[] r = o.ToByteArray();
            NUnit.Framework.Assert.AreEqual(string.Empty, RawParseUtils.Decode(r));
        }
Example #14
0
 /// <summary>Formats a list of edits in unified diff format</summary>
 /// <param name="edits">some differences which have been calculated between A and B</param>
 /// <param name="a">the text A which was compared</param>
 /// <param name="b">the text B which was compared</param>
 /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
 public virtual void Format(EditList edits, RawText a, RawText b)
 {
     for (int curIdx = 0; curIdx < edits.Count;)
     {
         Edit curEdit = edits[curIdx];
         int  endIdx  = FindCombinedEnd(edits, curIdx);
         Edit endEdit = edits[endIdx];
         int  aCur    = Math.Max(0, curEdit.GetBeginA() - context);
         int  bCur    = Math.Max(0, curEdit.GetBeginB() - context);
         int  aEnd    = Math.Min(a.Size(), endEdit.GetEndA() + context);
         int  bEnd    = Math.Min(b.Size(), endEdit.GetEndB() + context);
         WriteHunkHeader(aCur, aEnd, bCur, bEnd);
         while (aCur < aEnd || bCur < bEnd)
         {
             if (aCur < curEdit.GetBeginA() || endIdx + 1 < curIdx)
             {
                 WriteContextLine(a, aCur);
                 if (IsEndOfLineMissing(a, aCur))
                 {
                     @out.Write(noNewLine);
                 }
                 aCur++;
                 bCur++;
             }
             else
             {
                 if (aCur < curEdit.GetEndA())
                 {
                     WriteRemovedLine(a, aCur);
                     if (IsEndOfLineMissing(a, aCur))
                     {
                         @out.Write(noNewLine);
                     }
                     aCur++;
                 }
                 else
                 {
                     if (bCur < curEdit.GetEndB())
                     {
                         WriteAddedLine(b, bCur);
                         if (IsEndOfLineMissing(b, bCur))
                         {
                             @out.Write(noNewLine);
                         }
                         bCur++;
                     }
                 }
             }
             if (End(curEdit, aCur, bCur) && ++curIdx < edits.Count)
             {
                 curEdit = edits[curIdx];
             }
         }
     }
 }
Example #15
0
 public virtual void TestComparatorReduceCommonStartButLastLineNoEol()
 {
     RawText a;
     RawText b;
     Edit e;
     a = new RawText(Sharpen.Runtime.GetBytesForString("start", "UTF-8"));
     b = new RawText(Sharpen.Runtime.GetBytesForString("start of line", "UTF-8"));
     e = new Edit(0, 1, 0, 1);
     e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
     NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 1), e);
 }
Example #16
0
        public virtual void TestComparatorReduceCommonStartButLastLineNoEol_2()
        {
            RawText a;
            RawText b;
            Edit    e;

            a = new RawText(Sharpen.Runtime.GetBytesForString("start", "UTF-8"));
            b = new RawText(Sharpen.Runtime.GetBytesForString("start of\nlastline", "UTF-8"));
            e = new Edit(0, 1, 0, 2);
            e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
            NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 2), e);
        }
Example #17
0
		public virtual void TestEquals()
		{
			RawText a = new RawText(Constants.EncodeASCII("foo-a\nfoo-b\n"));
			RawText b = new RawText(Constants.EncodeASCII("foo-b\nfoo-c\n"));
			RawTextComparator cmp = RawTextComparator.DEFAULT;
			NUnit.Framework.Assert.AreEqual(2, a.Size());
			NUnit.Framework.Assert.AreEqual(2, b.Size());
			// foo-a != foo-b
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
			// foo-b == foo-b
			NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 0));
			NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 0, a, 1));
		}
Example #18
0
        public virtual void TestEquals()
        {
            RawText           a   = new RawText(Constants.EncodeASCII("foo-a\nfoo-b\n"));
            RawText           b   = new RawText(Constants.EncodeASCII("foo-b\nfoo-c\n"));
            RawTextComparator cmp = RawTextComparator.DEFAULT;

            NUnit.Framework.Assert.AreEqual(2, a.Size());
            NUnit.Framework.Assert.AreEqual(2, b.Size());
            // foo-a != foo-b
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
            // foo-b == foo-b
            NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 0));
            NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 0, a, 1));
        }
        public HunkRangeInfo(ITextSnapshot snapshot, Edit edit, RawText originalText, RawText workingText)
        {
            if (snapshot == null)
                throw new ArgumentNullException("snapshot");
            if (edit == null)
                throw new ArgumentNullException("edit");
            if (originalText == null)
                throw new ArgumentNullException("originalText");
            if (workingText == null)
                throw new ArgumentNullException("workingText");

            _snapshot = snapshot;
            _edit = edit;
            _originalText = originalText.GetString(edit.GetBeginA(), edit.GetEndA(), true).Split('\n').Select(i => i.TrimEnd('\r')).ToList();
            _canRollback = true;
        }
		public virtual void TestEqualsWithoutWhitespace()
		{
			RawText a = new RawText(Constants.EncodeASCII("foo-a\nfoo-b\nfoo\n"));
			RawText b = new RawText(Constants.EncodeASCII("foo-b\nfoo-c\nf\n"));
			NUnit.Framework.Assert.AreEqual(3, a.Size());
			NUnit.Framework.Assert.AreEqual(3, b.Size());
			// foo-a != foo-b
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
			// foo-b == foo-b
			NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 0));
			NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 0, a, 1));
			// foo != f
			NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 2, b, 2));
			NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 2, a, 2));
		}
Example #21
0
        public virtual void TestComparatorReduceCommonStartEnd_EmptyLine()
        {
            RawText a;
            RawText b;
            Edit    e;

            a = new RawText(Sharpen.Runtime.GetBytesForString("R\n y\n", "UTF-8"));
            b = new RawText(Sharpen.Runtime.GetBytesForString("S\n\n y\n", "UTF-8"));
            e = new Edit(0, 2, 0, 3);
            e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
            NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 2), e);
            a = new RawText(Sharpen.Runtime.GetBytesForString("S\n\n y\n", "UTF-8"));
            b = new RawText(Sharpen.Runtime.GetBytesForString("R\n y\n", "UTF-8"));
            e = new Edit(0, 3, 0, 2);
            e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
            NUnit.Framework.Assert.AreEqual(new Edit(0, 2, 0, 1), e);
        }
        public virtual void TestEqualsWithoutWhitespace()
        {
            RawText a = new RawText(Constants.EncodeASCII("foo-a\nfoo-b\nfoo\n"));
            RawText b = new RawText(Constants.EncodeASCII("foo-b\nfoo-c\nf\n"));

            NUnit.Framework.Assert.AreEqual(3, a.Size());
            NUnit.Framework.Assert.AreEqual(3, b.Size());
            // foo-a != foo-b
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 0, b, 0));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 0, a, 0));
            // foo-b == foo-b
            NUnit.Framework.Assert.IsTrue(cmp.Equals(a, 1, b, 0));
            NUnit.Framework.Assert.IsTrue(cmp.Equals(b, 0, a, 1));
            // foo != f
            NUnit.Framework.Assert.IsFalse(cmp.Equals(a, 2, b, 2));
            NUnit.Framework.Assert.IsFalse(cmp.Equals(b, 2, a, 2));
        }
Example #23
0
		/// <exception cref="System.Exception"></exception>
		private ApplyResult Init(string name, bool preExists, bool postExists)
		{
			Git git = new Git(db);
			if (preExists)
			{
				a = new RawText(ReadFile(name + "_PreImage"));
				Write(new FilePath(db.Directory.GetParent(), name), a.GetString(0, a.Size(), false
					));
				git.Add().AddFilepattern(name).Call();
				git.Commit().SetMessage("PreImage").Call();
			}
			if (postExists)
			{
				b = new RawText(ReadFile(name + "_PostImage"));
			}
			return git.Apply().SetPatch(typeof(DiffFormatterReflowTest).GetResourceAsStream(name
				 + ".patch")).Call();
		}
Example #24
0
 /// <param name="args">two filenames specifying the contents to be diffed</param>
 public static void Main(string[] args)
 {
     if (args.Length != 2)
     {
         System.Console.Error.WriteLine(JGitText.Get().need2Arguments);
         System.Environment.Exit(1);
     }
     try
     {
         RawText  a = new RawText(new FilePath(args[0]));
         RawText  b = new RawText(new FilePath(args[1]));
         EditList r = INSTANCE.Diff(RawTextComparator.DEFAULT, a, b);
         System.Console.Out.WriteLine(r.ToString());
     }
     catch (Exception e)
     {
         Sharpen.Runtime.PrintStackTrace(e);
     }
 }
Example #25
0
        public virtual void TestFallbackToMyersDiff()
        {
            HistogramDiff hd = new HistogramDiff();

            hd.SetMaxChainLength(4);
            RawTextComparator cmp = RawTextComparator.DEFAULT;
            RawText           ac  = T("bbbbb");
            RawText           bc  = T("AbCbDbEFbZ");
            EditList          r;

            // Without fallback our results are limited due to collisions.
            hd.SetFallbackAlgorithm(null);
            r = hd.Diff(cmp, ac, bc);
            NUnit.Framework.Assert.AreEqual(1, r.Count);
            // Results go up when we add a fallback for the high collision regions.
            hd.SetFallbackAlgorithm(MyersDiff <Sequence> .INSTANCE);
            r = hd.Diff(cmp, ac, bc);
            NUnit.Framework.Assert.AreEqual(5, r.Count);
        }
Example #26
0
        /// <summary>Format a patch script, reusing a previously parsed FileHeader.</summary>
        /// <remarks>
        /// Format a patch script, reusing a previously parsed FileHeader.
        /// <p>
        /// This formatter is primarily useful for editing an existing patch script
        /// to increase or reduce the number of lines of context within the script.
        /// All header lines are reused as-is from the supplied FileHeader.
        /// </remarks>
        /// <param name="head">existing file header containing the header lines to copy.</param>
        /// <param name="a">
        /// text source for the pre-image version of the content. This
        /// must match the content of
        /// <see cref="DiffEntry.GetOldId()">DiffEntry.GetOldId()</see>
        /// .
        /// </param>
        /// <param name="b">
        /// text source for the post-image version of the content. This
        /// must match the content of
        /// <see cref="DiffEntry.GetNewId()">DiffEntry.GetNewId()</see>
        /// .
        /// </param>
        /// <exception cref="System.IO.IOException">writing to the supplied stream failed.</exception>
        public virtual void Format(FileHeader head, RawText a, RawText b)
        {
            // Reuse the existing FileHeader as-is by blindly copying its
            // header lines, but avoiding its hunks. Instead we recreate
            // the hunks from the text instances we have been supplied.
            //
            int start = head.GetStartOffset();
            int end   = head.GetEndOffset();

            if (!head.GetHunks().IsEmpty())
            {
                end = head.GetHunks()[0].GetStartOffset();
            }
            @out.Write(head.GetBuffer(), start, end - start);
            if (head.GetPatchType() == FileHeader.PatchType.UNIFIED)
            {
                Format(head.ToEditList(), a, b);
            }
        }
            public override bool Equals(RawText a, int ai, RawText b, int bi)
            {
                ai++;
                bi++;
                int @as = a.lines.Get(ai);
                int bs  = b.lines.Get(bi);
                int ae  = a.lines.Get(ai + 1);
                int be  = b.lines.Get(bi + 1);

                if (ae - @as != be - bs)
                {
                    return(false);
                }
                while (@as < ae)
                {
                    if (a.content[@as++] != b.content[bs++])
                    {
                        return(false);
                    }
                }
                return(true);
            }
 public override bool Equals(RawText a, int ai, RawText b, int bi)
 {
     ai++;
     bi++;
     IntList a_lines = RawTextAccessor.GetLines(a);
     IntList b_lines = RawTextAccessor.GetLines(b);
     byte[] a_content = RawTextAccessor.GetContent(a);
     byte[] b_content = RawTextAccessor.GetContent(b);
     int @as = a_lines.Get(ai);
     int bs = b_lines.Get(bi);
     int ae = a_lines.Get(ai + 1);
     int be = b_lines.Get(bi + 1);
     ae = TrimTrailingSpace(a_content, @as, ae);
     be = TrimTrailingSpace(b_content, bs, be);
     while (@as < ae && bs < be)
     {
         byte ac = a_content[@as];
         byte bc = b_content[bs];
         while (@as < ae - 1 && ac == ' ')
         {
             @as++;
             ac = a_content[@as];
         }
         while (bs < be - 1 && bc == ' ')
         {
             bs++;
             bc = b_content[bs];
         }
         if (ac != bc)
         {
             return false;
         }
         @as++;
         bs++;
     }
     return @as == ae && bs == be;
 }
            public override bool Equals(RawText a, int ai, RawText b, int bi)
            {
                ai++;
                bi++;
                int @as = a.lines.Get(ai);
                int bs  = b.lines.Get(bi);
                int ae  = a.lines.Get(ai + 1);
                int be  = b.lines.Get(bi + 1);

                ae = RawCharUtil.TrimTrailingWhitespace(a.content, @as, ae);
                be = RawCharUtil.TrimTrailingWhitespace(b.content, bs, be);
                if (ae - @as != be - bs)
                {
                    return(false);
                }
                while (@as < ae)
                {
                    if (a.content[@as++] != b.content[bs++])
                    {
                        return(false);
                    }
                }
                return(true);
            }
Example #30
0
		static int SetBlameLines (NGit.Repository repo, RevCommit[] lines, RevCommit commit, RawText curText, RawText ancestorText)
		{
			int lineCount = 0;
			IEnumerable<Hunk> diffHunks = GetDiffHunks (curText, ancestorText);

			foreach (Hunk e in diffHunks) {
				int basePosition = e.InsertStart - 1;
				for (int i = 0; i < e.Inserted; i++) {
					int lineNum = basePosition + i;
					if (lines [lineNum] == null) {
						lines [lineNum] = commit;
						lineCount++;
					}
				}
			}
			
			return lineCount;
		}
Example #31
0
        public virtual void TestEmpty()
        {
            RawText r = new RawText(new byte[0]);

            NUnit.Framework.Assert.AreEqual(0, r.Size());
        }
 public virtual EditList Diff(RawText a, RawText b)
 {
     return(Algorithm().Diff(RawTextComparator.DEFAULT, a, b));
 }
Example #33
0
		/// <summary>
		/// Throw away the
		/// <see cref="GetResultContents()">GetResultContents()</see>
		/// .
		/// </summary>
		public virtual void DiscardResultContents()
		{
			resultContents = null;
		}
Example #34
0
 /// <exception cref="System.IO.IOException"></exception>
 private void Init(string name)
 {
     a    = new RawText(ReadFile(name + "_PreImage"));
     b    = new RawText(ReadFile(name + "_PostImage"));
     file = ParseTestPatchFile(name + ".patch").GetFiles()[0];
 }
Example #35
0
		static int SetBlameLines (NGit.Repository repo, RevCommit[] lines, RevCommit commit, RawText curText, RawText ancestorText)
		{
			int lineCount = 0;
			var differ = MyersDiff<RawText>.INSTANCE;
			
			foreach (Edit e in differ.Diff (RawTextComparator.DEFAULT, ancestorText, curText)) {
				for (int n = e.GetBeginB (); n < e.GetEndB (); n++) {
					if (lines [n] == null) {
						lines [n] = commit;
						lineCount ++;
					}
				}
			}
			
			return lineCount;
		}
Example #36
0
 public virtual void LineDelimiterStartingWithCharacterReturn()
 {
     var rt = new RawText(Constants.EncodeASCII("\nfoo"));
     NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
 }
Example #37
0
		static IEnumerable<Hunk> GetDiffHunks (RawText curText, RawText ancestorText)
		{
			Dictionary<string, int> codeDictionary = new Dictionary<string, int> ();
			int codeCounter = 0;
			int[] ancestorDiffCodes = GetDiffCodes (ref codeCounter, codeDictionary, ancestorText);
			int[] currentDiffCodes = GetDiffCodes (ref codeCounter, codeDictionary, curText);
			return Diff.GetDiff<int> (ancestorDiffCodes, currentDiffCodes);
		}
Example #38
0
		static string[] GetLineStrings (RawText text)
		{
			int lineCount = text.Size ();
			string[] lines = new string[lineCount];

			for (int i = 0; i < lineCount; i++) {
				lines [i] = text.GetString (i);
			}

			return lines;
		}
Example #39
0
 private EditList Diff(RawText a, RawText b)
 {
     return(diffAlgorithm.Diff(comparator, a, b));
 }
Example #40
0
 /// <exception cref="System.IO.IOException"></exception>
 private void Init(string name)
 {
     a = new RawText(ReadFile(name + "_PreImage"));
     b = new RawText(ReadFile(name + "_PostImage"));
     file = ParseTestPatchFile(name + ".patch").GetFiles()[0];
 }
        /// <summary>
        /// Diff working file with last commit
        /// </summary>
        /// <param name="fileName">Expect relative path</param>
        /// <returns>diff file in temp folder</returns>
        public string DiffFile(string fileName)
        {
            try
            {
                if (!this.HasGitRepository) return "";

                var tmpFileName = Path.ChangeExtension(Path.GetTempFileName(), ".diff");
                var status = GetFileStatus(fileName);
                if (head == null || status == GitFileStatus.New || status == GitFileStatus.Added)
                {
                    tmpFileName = Path.ChangeExtension(tmpFileName, Path.GetExtension(fileName));
                    File.Copy(GetFullPath(fileName), tmpFileName);
                    return tmpFileName;
                }

                if (GitBash.Exists)
                {
                    var fileNameRel = GetRelativeFileName(fileName);

                    GitBash.RunCmd(string.Format("diff HEAD -- \"{0}\" > \"{1}\"", fileNameRel, tmpFileName), this.GitWorkingDirectory);
                }
                else
                {
                    HistogramDiff hd = new HistogramDiff();
                    hd.SetFallbackAlgorithm(null);

                    var fullName = GetFullPath(fileName);

                    RawText b = new RawText(File.Exists(GetFullPath(fileName)) ?
                                            File.ReadAllBytes(fullName) : new byte[0]);
                    RawText a = new RawText(GetFileContent(fileName) ?? new byte[0]);

                    var list = hd.Diff(RawTextComparator.DEFAULT, a, b);

                    using (Stream stream = File.Create(tmpFileName))
                    {
                        DiffFormatter df = new DiffFormatter(stream);
                        df.Format(list, a, b);
                        df.Flush();
                    }

                    //using (Stream mstream = new MemoryStream(),
                    //              stream = new BufferedStream(mstream))
                    //{
                    //    DiffFormatter df = new DiffFormatter(stream);
                    //    df.Format(list, a, b);
                    //    df.Flush();
                    //    stream.Seek(0, SeekOrigin.Begin);
                    //    var ret = new StreamReader(stream).ReadToEnd();
                    //    File.WriteAllText(tmpFileName, ret);
                    //}
                }

                return tmpFileName;
            }
            catch (Exception ex)
            {
                Log.WriteLine("Refresh: {0}\r\n{1}", this.initFolder, ex.ToString());

                return "";
            }
        }
Example #42
0
		public static RevCommit[] Blame (NGit.Repository repo, RevCommit c, string file)
		{
			TreeWalk tw = TreeWalk.ForPath (repo, ToGitPath (repo, file), c.Tree);
			if (tw == null)
				return new RevCommit [0];
			ObjectId id = tw.GetObjectId (0);
			byte[] data = repo.ObjectDatabase.Open (id).GetBytes ();
			
			int lineCount = NGit.Util.RawParseUtils.LineMap (data, 0, data.Length).Size ();
			RevCommit[] lines = new RevCommit [lineCount];
			var curText = new RawText (data);
			RevCommit prevAncestor = c;
			
			ObjectId prevObjectId = null;
			RevCommit prevCommit = null;
			int emptyLines = lineCount;
			RevWalk rw = new RevWalk (repo);
			
			foreach (ObjectId ancestorId in c.Parents) {
				RevCommit ancestor = rw.ParseCommit (ancestorId);
				tw = TreeWalk.ForPath (repo, ToGitPath (repo, file), ancestor.Tree);
				if (prevCommit != null && (tw == null || tw.GetObjectId (0) != prevObjectId)) {
					if (prevObjectId == null)
						break;
					byte[] prevData = repo.ObjectDatabase.Open (prevObjectId).GetBytes ();
					var prevText = new RawText (prevData);
					var differ = MyersDiff<RawText>.INSTANCE;
					foreach (Edit e in differ.Diff (RawTextComparator.DEFAULT, prevText, curText)) {
						for (int n = e.GetBeginB (); n < e.GetEndB (); n++) {
							if (lines [n] == null) {
								lines [n] = prevCommit;
								emptyLines--;
							}
						}
					}
					if (tw == null || emptyLines <= 0)
						break;
				}
				prevCommit = ancestor;
				prevObjectId = tw != null ? tw.GetObjectId (0) : null;
			}
			for (int n=0; n<lines.Length; n++)
				if (lines [n] == null)
					lines [n] = prevAncestor;
			return lines;
		}
Example #43
0
 public virtual void TestWriteLine3()
 {
     RawText a = new RawText(Constants.EncodeASCII("a\n\nb\n"));
     ByteArrayOutputStream o = new ByteArrayOutputStream();
     a.WriteLine(o, 1);
     byte[] r = o.ToByteArray();
     NUnit.Framework.Assert.AreEqual(string.Empty, RawParseUtils.Decode(r));
 }
Example #44
0
		static int[] GetDiffCodes (ref int codeCounter, Dictionary<string, int> codeDictionary, RawText text)
		{
			int lineCount = text.Size ();
			int[] result = new int[lineCount];
			string[] lines = GetLineStrings (text);
			for (int i = 0; i < lineCount; i++) {
				string lineText = lines [i];
				int curCode;
				if (!codeDictionary.TryGetValue (lineText, out curCode)) {
					codeDictionary [lineText] = curCode = ++codeCounter;
				}
				result [i] = curCode;
			}
			return result;
		}
Example #45
0
 public virtual void TestLineDelimiter()
 {
     RawText rt = new RawText(Constants.EncodeASCII("foo\n"));
     NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo\r\n"));
     NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo\nbar"));
     NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo\r\nbar"));
     NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo\nbar\r\n"));
     NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo\r\nbar\n"));
     NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("foo"));
     NUnit.Framework.Assert.IsNull(rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII(string.Empty));
     NUnit.Framework.Assert.IsNull(rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsTrue(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("\n"));
     NUnit.Framework.Assert.AreEqual("\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
     rt = new RawText(Constants.EncodeASCII("\r\n"));
     NUnit.Framework.Assert.AreEqual("\r\n", rt.GetLineDelimiter());
     NUnit.Framework.Assert.IsFalse(rt.IsMissingNewlineAtEnd());
 }
        /// <summary>
        /// Diff working file with last commit
        /// </summary>
        /// <param name="fileName">Expect relative path</param>
        /// <returns>diff file in temp folder</returns>
        public string DiffFile(string fileName)
        {
            var tmpFileName = Path.ChangeExtension(Path.GetTempFileName(), ".diff");

            try
            {
                if (!this.HasGitRepository) return "";

                var status = GetFileStatus(fileName);
                if (head == null || status == GitFileStatus.New || status == GitFileStatus.Added)
                {
                    tmpFileName = Path.ChangeExtension(tmpFileName, Path.GetExtension(fileName));
                    File.Copy(GetFullPath(fileName), tmpFileName);

                    if (IsBinaryFile(tmpFileName))
                    {
                        File.Delete(tmpFileName);
                        File.WriteAllText(tmpFileName, "Binary file: " + fileName);
                    }
                    return tmpFileName;
                }

                if (GitBash.Exists)
                {
                    var fileNameRel = GetRelativeFileName(fileName);

                    GitBash.RunCmd(string.Format("diff HEAD -- \"{0}\" > \"{1}\"", fileNameRel, tmpFileName), this.GitWorkingDirectory);
                }
                else
                {
                    HistogramDiff hd = new HistogramDiff();
                    hd.SetFallbackAlgorithm(null);

                    var fullName = GetFullPath(fileName);

                    RawText b = new RawText(File.Exists(GetFullPath(fileName)) ?
                                            File.ReadAllBytes(fullName) : new byte[0]);
                    RawText a = new RawText(GetFileContent(fileName) ?? new byte[0]);

                    var list = hd.Diff(RawTextComparator.DEFAULT, a, b);

                    using (Stream stream = File.Create(tmpFileName))
                    {
                        DiffFormatter df = new DiffFormatter(stream);
                        df.Format(list, a, b);
                        df.Flush();
                    }
                }

                // normalize the line endings of the diff so VS doesn't ask to do it for us
                string text = File.ReadAllText(tmpFileName).Replace("\r\n", "\n").Replace('\r', '\n');
                // normalize to Environment.NewLine since this is only used for display in the IDE
                // and we want users to be able to copy from the diff and paste in a document without
                // changing line endings
                File.WriteAllText(tmpFileName, text.Replace("\n", Environment.NewLine));
            }
            catch (Exception ex)
            {
                Log.WriteLine("DiffFile: {0}\r\n{1}", this.initFolder, ex.ToString());
                //File.WriteAllText(tmpFileName, ex.ToString());
            }
            return tmpFileName;
        }
Example #47
0
 /// <summary>Output a line of context (unmodified line).</summary>
 /// <remarks>Output a line of context (unmodified line).</remarks>
 /// <param name="text">RawText for accessing raw data</param>
 /// <param name="line">the line number within text</param>
 /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
 protected internal virtual void WriteContextLine(RawText text, int line)
 {
     WriteLine(' ', text, line);
 }
Example #48
0
 public virtual void TestComparatorReduceCommonStartEnd_EmptyLine()
 {
     RawText a;
     RawText b;
     Edit e;
     a = new RawText(Sharpen.Runtime.GetBytesForString("R\n y\n", "UTF-8"));
     b = new RawText(Sharpen.Runtime.GetBytesForString("S\n\n y\n", "UTF-8"));
     e = new Edit(0, 2, 0, 3);
     e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
     NUnit.Framework.Assert.AreEqual(new Edit(0, 1, 0, 2), e);
     a = new RawText(Sharpen.Runtime.GetBytesForString("S\n\n y\n", "UTF-8"));
     b = new RawText(Sharpen.Runtime.GetBytesForString("R\n y\n", "UTF-8"));
     e = new Edit(0, 3, 0, 2);
     e = RawTextComparator.DEFAULT.ReduceCommonStartEnd(a, b, e);
     NUnit.Framework.Assert.AreEqual(new Edit(0, 2, 0, 1), e);
 }
Example #49
0
 private bool IsEndOfLineMissing(RawText text, int line)
 {
     return(line + 1 == text.Size() && text.IsMissingNewlineAtEnd());
 }
Example #50
0
		static string GenerateDiff (byte[] data1, byte[] data2)
		{
			if (RawText.IsBinary (data1) || RawText.IsBinary (data2)) {
				if (data1.Length != data2.Length)
					return GettextCatalog.GetString (" Binary files differ");
				if (data1.Length == data2.Length) {
					for (int n=0; n<data1.Length; n++) {
						if (data1[n] != data2[n])
							return GettextCatalog.GetString (" Binary files differ");
					}
				}
				return string.Empty;
			}
			var text1 = new RawText (data1);
			var text2 = new RawText (data2);

			var edits = DiffAlgorithm.GetAlgorithm (DiffAlgorithm.SupportedAlgorithm.MYERS)
					.Diff (RawTextComparator.DEFAULT, text1, text2);
			MemoryStream s = new MemoryStream ();
			var formatter = new DiffFormatter (s);
			formatter.Format (edits, text1, text2);
			return Encoding.UTF8.GetString (s.ToArray ());
		}
Example #51
0
 /// <summary>Output an added line.</summary>
 /// <remarks>Output an added line.</remarks>
 /// <param name="text">RawText for accessing raw data</param>
 /// <param name="line">the line number within text</param>
 /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
 protected internal virtual void WriteAddedLine(RawText text, int line)
 {
     WriteLine('+', text, line);
 }
Example #52
0
		internal BlameResult(BlameGenerator bg, string path, RawText text)
		{
			generator = bg;
			resultPath = path;
			resultContents = text;
			int cnt = text.Size();
			sourceCommits = new RevCommit[cnt];
			sourceAuthors = new PersonIdent[cnt];
			sourceCommitters = new PersonIdent[cnt];
			sourceLines = new int[cnt];
			sourcePaths = new string[cnt];
		}
Example #53
0
 /// <summary>Output a removed line</summary>
 /// <param name="text">RawText for accessing raw data</param>
 /// <param name="line">the line number within text</param>
 /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
 protected internal virtual void WriteRemovedLine(RawText text, int line)
 {
     WriteLine('-', text, line);
 }
Example #54
0
 /// <summary>Write a standard patch script line.</summary>
 /// <remarks>Write a standard patch script line.</remarks>
 /// <param name="prefix">prefix before the line, typically '-', '+', ' '.</param>
 /// <param name="text">the text object to obtain the line from.</param>
 /// <param name="cur">line number to output.</param>
 /// <exception cref="System.IO.IOException">the stream threw an exception while writing to it.
 ///     </exception>
 protected internal virtual void WriteLine(char prefix, RawText text, int cur)
 {
     @out.Write(prefix);
     text.WriteLine(@out, cur);
     @out.Write('\n');
 }
Example #55
0
 public virtual void TestEmpty()
 {
     RawText r = new RawText(new byte[0]);
     NUnit.Framework.Assert.AreEqual(0, r.Size());
 }
Example #56
0
		string GenerateDiff (byte[] data1, byte[] data2)
		{
			if (RawText.IsBinary (data1) || RawText.IsBinary (data2)) {
				if (data1.Length != data2.Length)
					return GettextCatalog.GetString (" Binary files differ");
				if (data1.Length == data2.Length) {
					for (int n=0; n<data1.Length; n++) {
						if (data1[n] != data2[n])
							return GettextCatalog.GetString (" Binary files differ");
					}
				}
				return string.Empty;
			}
			var text1 = new RawText (data1);
			var text2 = new RawText (data2);
			var edits = MyersDiff<RawText>.INSTANCE.Diff(RawTextComparator.DEFAULT, text1, text2);
			MemoryStream s = new MemoryStream ();
			var formatter = new NGit.Diff.DiffFormatter (s);
			formatter.Format (edits, text1, text2);
			return Encoding.UTF8.GetString (s.ToArray ());
		}
Example #57
0
		/// <exception cref="System.IO.IOException"></exception>
		internal virtual void LoadText(ObjectReader reader)
		{
			ObjectLoader ldr = reader.Open(sourceBlob, Constants.OBJ_BLOB);
			sourceText = new RawText(ldr.GetCachedBytes(int.MaxValue));
		}