]> source.dussan.org Git - jgit.git/commitdiff
Added further support for whitespace ignoring during diff 79/979/2
authorJeff Schumacher <jeffschu@google.com>
Mon, 28 Jun 2010 20:03:44 +0000 (13:03 -0700)
committerJeff Schumacher <jeffschu@google.com>
Tue, 29 Jun 2010 00:25:19 +0000 (17:25 -0700)
Added code to support ignoring leading, trailing, and changed
whitespace when performing a diff operation. I also added command
line options to Diff to enable the various whitespace ignoring
methods. These match the flags for git diff.

Change-Id: Ie56301aafad59ee3f0fe5de62719f5023cd702c8

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Diff.java
org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespaceTest.java [new file with mode: 0644]
org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespaceTest.java [new file with mode: 0644]
org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChangeTest.java [new file with mode: 0644]
org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespace.java [new file with mode: 0644]
org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespace.java [new file with mode: 0644]
org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChange.java [new file with mode: 0644]

index a5db453688e26981170ac4025fd2cdeb16eeb9dc..931c46d333eefbecbb9b365d4e3e9a9f81ba30e5 100644 (file)
@@ -56,6 +56,10 @@ import org.kohsuke.args4j.Option;
 import org.eclipse.jgit.diff.DiffFormatter;
 import org.eclipse.jgit.diff.MyersDiff;
 import org.eclipse.jgit.diff.RawText;
+import org.eclipse.jgit.diff.RawTextIgnoreAllWhitespace;
+import org.eclipse.jgit.diff.RawTextIgnoreLeadingWhitespace;
+import org.eclipse.jgit.diff.RawTextIgnoreTrailingWhitespace;
+import org.eclipse.jgit.diff.RawTextIgnoreWhitespaceChange;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.pgm.opt.PathTreeFilterHandler;
@@ -77,6 +81,18 @@ class Diff extends TextBuiltin {
        @Option(name = "--", metaVar = "metaVar_port", multiValued = true, handler = PathTreeFilterHandler.class)
        private TreeFilter pathFilter = TreeFilter.ALL;
 
+       @Option(name = "--ignore-space-at-eol")
+       private boolean ignoreWsTrailing;
+
+       @Option(name = "--ignore-leading-space")
+       private boolean ignoreWsLeading;
+
+       @Option(name = "-b", aliases = { "--ignore-space-change" })
+       private boolean ignoreWsChange;
+
+       @Option(name = "-w", aliases = { "--ignore-all-space" })
+       private boolean ignoreWsAll;
+
        private DiffFormatter fmt = new DiffFormatter();
 
        @Override
@@ -124,8 +140,18 @@ class Diff extends TextBuiltin {
 
        private RawText getRawText(ObjectId id) throws IOException {
                if (id.equals(ObjectId.zeroId()))
-                       return new RawText(new byte[] { });
-               return new RawText(db.openBlob(id).getCachedBytes());
+                       return new RawText(new byte[] {});
+               byte[] raw = db.openBlob(id).getCachedBytes();
+               if (ignoreWsAll)
+                       return new RawTextIgnoreAllWhitespace(raw);
+               else if (ignoreWsTrailing)
+                       return new RawTextIgnoreTrailingWhitespace(raw);
+               else if (ignoreWsChange)
+                       return new RawTextIgnoreWhitespaceChange(raw);
+               else if (ignoreWsLeading)
+                       return new RawTextIgnoreLeadingWhitespace(raw);
+               else
+                       return new RawText(raw);
        }
 }
 
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespaceTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespaceTest.java
new file mode 100644 (file)
index 0000000..9ab1887
--- /dev/null
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import org.eclipse.jgit.lib.Constants;
+
+import junit.framework.TestCase;
+
+public class RawTextIgnoreLeadingWhitespaceTest extends TestCase {
+       public void testEqualsWithoutWhitespace() {
+               final RawText a = new RawTextIgnoreLeadingWhitespace(Constants
+                               .encodeASCII("foo-a\nfoo-b\nfoo\n"));
+               final RawText b = new RawTextIgnoreLeadingWhitespace(Constants
+                               .encodeASCII("foo-b\nfoo-c\nf\n"));
+
+               assertEquals(3, a.size());
+               assertEquals(3, b.size());
+
+               // foo-a != foo-b
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // foo-b == foo-b
+               assertTrue(a.equals(1, b, 0));
+               assertTrue(b.equals(0, a, 1));
+
+               // foo != f
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+       }
+
+       public void testEqualsWithWhitespace() {
+               final RawText a = new RawTextIgnoreLeadingWhitespace(Constants
+                               .encodeASCII("foo-a\n         \n a b c\n      a\nb    \n"));
+               final RawText b = new RawTextIgnoreLeadingWhitespace(Constants
+                               .encodeASCII("foo-a        b\n\nab  c\na\nb\n"));
+
+               // "foo-a" != "foo-a        b"
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // "         " == ""
+               assertTrue(a.equals(1, b, 1));
+               assertTrue(b.equals(1, a, 1));
+
+               // " a b c" != "ab  c"
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+
+               // "      a" == "a"
+               assertTrue(a.equals(3, b, 3));
+               assertTrue(b.equals(3, a, 3));
+
+               // "b    " != "b"
+               assertFalse(a.equals(4, b, 4));
+               assertFalse(b.equals(4, a, 4));
+       }
+}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespaceTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespaceTest.java
new file mode 100644 (file)
index 0000000..ad6a239
--- /dev/null
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import org.eclipse.jgit.lib.Constants;
+
+import junit.framework.TestCase;
+
+public class RawTextIgnoreTrailingWhitespaceTest extends TestCase {
+       public void testEqualsWithoutWhitespace() {
+               final RawText a = new RawTextIgnoreTrailingWhitespace(Constants
+                               .encodeASCII("foo-a\nfoo-b\nfoo\n"));
+               final RawText b = new RawTextIgnoreTrailingWhitespace(Constants
+                               .encodeASCII("foo-b\nfoo-c\nf\n"));
+
+               assertEquals(3, a.size());
+               assertEquals(3, b.size());
+
+               // foo-a != foo-b
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // foo-b == foo-b
+               assertTrue(a.equals(1, b, 0));
+               assertTrue(b.equals(0, a, 1));
+
+               // foo != f
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+       }
+
+       public void testEqualsWithWhitespace() {
+               final RawText a = new RawTextIgnoreTrailingWhitespace(Constants
+                               .encodeASCII("foo-a\n         \n a b c\na      \n    b\n"));
+               final RawText b = new RawTextIgnoreTrailingWhitespace(Constants
+                               .encodeASCII("foo-a        b\n\nab  c\na\nb\n"));
+
+               // "foo-a" != "foo-a        b"
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // "         " == ""
+               assertTrue(a.equals(1, b, 1));
+               assertTrue(b.equals(1, a, 1));
+
+               // " a b c" != "ab  c"
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+
+               // "a      " == "a"
+               assertTrue(a.equals(3, b, 3));
+               assertTrue(b.equals(3, a, 3));
+
+               // "    b" != "b"
+               assertFalse(a.equals(4, b, 4));
+               assertFalse(b.equals(4, a, 4));
+       }
+}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChangeTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChangeTest.java
new file mode 100644 (file)
index 0000000..4a71c44
--- /dev/null
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import org.eclipse.jgit.lib.Constants;
+
+import junit.framework.TestCase;
+
+public class RawTextIgnoreWhitespaceChangeTest extends TestCase {
+       public void testEqualsWithoutWhitespace() {
+               final RawText a = new RawTextIgnoreWhitespaceChange(Constants
+                               .encodeASCII("foo-a\nfoo-b\nfoo\n"));
+               final RawText b = new RawTextIgnoreWhitespaceChange(Constants
+                               .encodeASCII("foo-b\nfoo-c\nf\n"));
+
+               assertEquals(3, a.size());
+               assertEquals(3, b.size());
+
+               // foo-a != foo-b
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // foo-b == foo-b
+               assertTrue(a.equals(1, b, 0));
+               assertTrue(b.equals(0, a, 1));
+
+               // foo != f
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+       }
+
+       public void testEqualsWithWhitespace() {
+               final RawText a = new RawTextIgnoreWhitespaceChange(
+                               Constants
+                                               .encodeASCII("foo-a\n         \n a b c\na      \n  foo\na  b  c\n"));
+               final RawText b = new RawTextIgnoreWhitespaceChange(Constants
+                               .encodeASCII("foo-a        b\n\nab  c\na\nfoo\na b     c  \n"));
+
+               // "foo-a" != "foo-a        b"
+               assertFalse(a.equals(0, b, 0));
+               assertFalse(b.equals(0, a, 0));
+
+               // "         " == ""
+               assertTrue(a.equals(1, b, 1));
+               assertTrue(b.equals(1, a, 1));
+
+               // " a b c" != "ab  c"
+               assertFalse(a.equals(2, b, 2));
+               assertFalse(b.equals(2, a, 2));
+
+               // "a      " == "a"
+               assertTrue(a.equals(3, b, 3));
+               assertTrue(b.equals(3, a, 3));
+
+               // "  foo" != "foo"
+               assertFalse(a.equals(4, b, 4));
+               assertFalse(b.equals(4, a, 4));
+
+               // "a  b  c" == "a b     c  "
+               assertTrue(a.equals(5, b, 5));
+               assertTrue(b.equals(5, a, 5));
+       }
+}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespace.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreLeadingWhitespace.java
new file mode 100644 (file)
index 0000000..1d92876
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2008-2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import static org.eclipse.jgit.util.RawCharUtil.trimLeadingWhitespace;
+
+/**
+ * A version of {@link RawText} that ignores leading whitespace.
+ */
+public class RawTextIgnoreLeadingWhitespace extends RawText {
+
+       /**
+        * Create a new sequence from an existing content byte array.
+        * <p>
+        * The entire array (indexes 0 through length-1) is used as the content.
+        *
+        * @param input
+        *            the content array. The array is never modified, so passing
+        *            through cached arrays is safe.
+        */
+       public RawTextIgnoreLeadingWhitespace(byte[] input) {
+               super(input);
+       }
+
+       @Override
+       public boolean equals(final int i, final Sequence other, final int j) {
+               return equals(this, i + 1, (RawText) other, j + 1);
+       }
+
+       private static boolean equals(final RawText a, final int ai,
+                       final RawText b, final int bi) {
+               if (a.hashes.get(ai) != b.hashes.get(bi))
+                       return false;
+
+               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);
+
+               as = trimLeadingWhitespace(a.content, as, ae);
+               bs = trimLeadingWhitespace(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;
+       }
+
+       @Override
+       protected int hashLine(final byte[] raw, int ptr, int end) {
+               int hash = 5381;
+               ptr = trimLeadingWhitespace(raw, ptr, end);
+               for (; ptr < end; ptr++) {
+                       hash = (hash << 5) ^ (raw[ptr] & 0xff);
+               }
+               return hash;
+       }
+}
\ No newline at end of file
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespace.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreTrailingWhitespace.java
new file mode 100644 (file)
index 0000000..b909594
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2008-2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import static org.eclipse.jgit.util.RawCharUtil.trimTrailingWhitespace;
+
+/**
+ * A version of {@link RawText} that ignores trailing whitespace.
+ */
+public class RawTextIgnoreTrailingWhitespace extends RawText {
+
+       /**
+        * Create a new sequence from an existing content byte array.
+        * <p>
+        * The entire array (indexes 0 through length-1) is used as the content.
+        *
+        * @param input
+        *            the content array. The array is never modified, so passing
+        *            through cached arrays is safe.
+        */
+       public RawTextIgnoreTrailingWhitespace(byte[] input) {
+               super(input);
+       }
+
+       @Override
+       public boolean equals(final int i, final Sequence other, final int j) {
+               return equals(this, i + 1, (RawText) other, j + 1);
+       }
+
+       private static boolean equals(final RawText a, final int ai,
+                       final RawText b, final int bi) {
+               if (a.hashes.get(ai) != b.hashes.get(bi))
+                       return false;
+
+               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 = trimTrailingWhitespace(a.content, as, ae);
+               be = 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;
+       }
+
+       @Override
+       protected int hashLine(final byte[] raw, int ptr, int end) {
+               int hash = 5381;
+               end = trimTrailingWhitespace(raw, ptr, end);
+               for (; ptr < end; ptr++) {
+                       hash = (hash << 5) ^ (raw[ptr] & 0xff);
+               }
+               return hash;
+       }
+}
\ No newline at end of file
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChange.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/RawTextIgnoreWhitespaceChange.java
new file mode 100644 (file)
index 0000000..399f038
--- /dev/null
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2009-2010, Google Inc.
+ * Copyright (C) 2008-2009, Johannes E. Schindelin <johannes.schindelin@gmx.de>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import static org.eclipse.jgit.util.RawCharUtil.isWhitespace;
+import static org.eclipse.jgit.util.RawCharUtil.trimTrailingWhitespace;
+import static org.eclipse.jgit.util.RawCharUtil.trimLeadingWhitespace;
+
+/**
+ * A version of {@link RawText} that ignores changes in the amount of
+ * whitespace, as well as trailing whitespace.
+ */
+public class RawTextIgnoreWhitespaceChange extends RawText {
+
+       /**
+        * Create a new sequence from an existing content byte array.
+        * <p>
+        * The entire array (indexes 0 through length-1) is used as the content.
+        *
+        * @param input
+        *            the content array. The array is never modified, so passing
+        *            through cached arrays is safe.
+        */
+       public RawTextIgnoreWhitespaceChange(byte[] input) {
+               super(input);
+       }
+
+       @Override
+       public boolean equals(final int i, final Sequence other, final int j) {
+               return equals(this, i + 1, (RawText) other, j + 1);
+       }
+
+       private static boolean equals(final RawText a, final int ai,
+                       final RawText b, final int bi) {
+               if (a.hashes.get(ai) != b.hashes.get(bi))
+                       return false;
+
+               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 = trimTrailingWhitespace(a.content, as, ae);
+               be = trimTrailingWhitespace(b.content, bs, be);
+
+               while (as < ae && bs < be) {
+                       byte ac = a.content[as];
+                       byte bc = b.content[bs];
+
+                       if (ac != bc)
+                               return false;
+
+                       if (isWhitespace(ac))
+                               as = trimLeadingWhitespace(a.content, as, ae);
+                       else
+                               as++;
+
+                       if (isWhitespace(bc))
+                               bs = trimLeadingWhitespace(b.content, bs, be);
+                       else
+                               bs++;
+               }
+               return as == ae && bs == be;
+       }
+
+       @Override
+       protected int hashLine(final byte[] raw, int ptr, int end) {
+               int hash = 5381;
+               end = trimTrailingWhitespace(raw, ptr, end);
+               while (ptr < end) {
+                       byte c = raw[ptr];
+                       hash = (hash << 5) ^ (c & 0xff);
+                       if (isWhitespace(c))
+                               ptr = trimLeadingWhitespace(raw, ptr, end);
+                       else
+                               ptr++;
+               }
+               return hash;
+       }
+}
\ No newline at end of file