Abstract the hunk header testing into a method

[egit/graphgui.git] / org.spearce.jgit / src / org / spearce / jgit / patch / Patch.java

/*
 * Copyright (C) 2008, Google Inc.
 *
 * 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 Git Development Community 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.spearce.jgit.patch;

import static org.spearce.jgit.lib.Constants.encodeASCII;
import static org.spearce.jgit.patch.FileHeader.isHunkHdr;
import static org.spearce.jgit.patch.FileHeader.NEW_NAME;
import static org.spearce.jgit.patch.FileHeader.OLD_NAME;
import static org.spearce.jgit.util.RawParseUtils.match;
import static org.spearce.jgit.util.RawParseUtils.nextLF;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import org.spearce.jgit.util.TemporaryBuffer;

/** A parsed collection of {@link FileHeader}s from a unified diff patch file */
public class Patch {
        private static final byte[] DIFF_GIT = encodeASCII("diff --git ");

        private static final byte[] DIFF_CC = encodeASCII("diff --cc ");

        private static final byte[][] BIN_HEADERS = new byte[][] {
                        encodeASCII("Binary files "), encodeASCII("Files "), };

        private static final byte[] BIN_TRAILER = encodeASCII(" differ\n");

        private static final byte[] GIT_BINARY = encodeASCII("GIT binary patch\n");

        static final byte[] SIG_FOOTER = encodeASCII("-- \n");

        /** The files, in the order they were parsed out of the input. */
        private final List<FileHeader> files;

        /** Formatting errors, if any were identified. */
        private final List<FormatError> errors;

        /** Create an empty patch. */
        public Patch() {
                files = new ArrayList<FileHeader>();
                errors = new ArrayList<FormatError>(0);
        }

        /**
         * Add a single file to this patch.
         * <p>
         * Typically files should be added by parsing the text through one of this
         * class's parse methods.
         *
         * @param fh
         *            the header of the file.
         */
        public void addFile(final FileHeader fh) {
                files.add(fh);
        }

        /** @return list of files described in the patch, in occurrence order. */
        public List<FileHeader> getFiles() {
                return files;
        }

        /**
         * Add a formatting error to this patch script.
         *
         * @param err
         *            the error description.
         */
        public void addError(final FormatError err) {
                errors.add(err);
        }

        /** @return collection of formatting errors, if any. */
        public List<FormatError> getErrors() {
                return errors;
        }

        /**
         * Parse a patch received from an InputStream.
         * <p>
         * Multiple parse calls on the same instance will concatenate the patch
         * data, but each parse input must start with a valid file header (don't
         * split a single file across parse calls).
         *
         * @param is
         *            the stream to read the patch data from. The stream is read
         *            until EOF is reached.
         * @throws IOException
         *             there was an error reading from the input stream.
         */
        public void parse(final InputStream is) throws IOException {
                final byte[] buf = readFully(is);
                parse(buf, 0, buf.length);
        }

        private static byte[] readFully(final InputStream is) throws IOException {
                final TemporaryBuffer b = new TemporaryBuffer();
                try {
                        b.copy(is);
                        b.close();
                        return b.toByteArray();
                } finally {
                        b.destroy();
                }
        }

        /**
         * Parse a patch stored in a byte[].
         * <p>
         * Multiple parse calls on the same instance will concatenate the patch
         * data, but each parse input must start with a valid file header (don't
         * split a single file across parse calls).
         *
         * @param buf
         *            the buffer to parse.
         * @param ptr
         *            starting position to parse from.
         * @param end
         *            1 past the last position to end parsing. The total length to
         *            be parsed is <code>end - ptr</code>.
         */
        public void parse(final byte[] buf, int ptr, final int end) {
                while (ptr < end)
                        ptr = parseFile(buf, ptr, end);
        }

        private int parseFile(final byte[] buf, int c, final int end) {
                while (c < end) {
                        if (isHunkHdr(buf, c, end) >= 1) {
                                // If we find a disconnected hunk header we might
                                // have missed a file header previously. The hunk
                                // isn't valid without knowing where it comes from.
                                //
                                error(buf, c, "Hunk disconnected from file");
                                c = nextLF(buf, c);
                                continue;
                        }

                        // Valid git style patch?
                        //
                        if (match(buf, c, DIFF_GIT) >= 0)
                                return parseDiffGit(buf, c, end);
                        if (match(buf, c, DIFF_CC) >= 0)
                                return parseDiffCC(buf, c, end);

                        // Junk between files? Leading junk? Traditional
                        // (non-git generated) patch?
                        //
                        final int n = nextLF(buf, c);
                        if (n >= end) {
                                // Patches cannot be only one line long. This must be
                                // trailing junk that we should ignore.
                                //
                                return end;
                        }

                        if (n - c < 6) {
                                // A valid header must be at least 6 bytes on the
                                // first line, e.g. "--- a/b\n".
                                //
                                c = n;
                                continue;
                        }

                        if (match(buf, c, OLD_NAME) >= 0 && match(buf, n, NEW_NAME) >= 0) {
                                // Probably a traditional patch. Ensure we have at least
                                // a "@@ -0,0" smelling line next. We only check the "@@ -".
                                //
                                final int f = nextLF(buf, n);
                                if (f >= end)
                                        return end;
                                if (isHunkHdr(buf, f, end) == 1)
                                        return parseTraditionalPatch(buf, c, end);
                        }

                        c = n;
                }
                return c;
        }

        private int parseDiffGit(final byte[] buf, final int start, final int end) {
                final FileHeader fh = new FileHeader(buf, start);
                int ptr = fh.parseGitFileName(start + DIFF_GIT.length, end);
                if (ptr < 0)
                        return skipFile(buf, start, end);

                ptr = fh.parseGitHeaders(ptr, end);
                ptr = parseHunks(fh, ptr, end);
                fh.endOffset = ptr;
                addFile(fh);
                return ptr;
        }

        private int parseDiffCC(final byte[] buf, final int start, final int end) {
                final FileHeader fh = new FileHeader(buf, start);
                int ptr = fh.parseGitFileName(start + DIFF_CC.length, end);
                if (ptr < 0)
                        return skipFile(buf, start, end);

                // TODO Support parsing diff --cc headers
                // TODO parse diff --cc hunks
                warn(buf, start, "diff --cc format not supported");
                fh.endOffset = ptr;
                addFile(fh);
                return ptr;
        }

        private int parseTraditionalPatch(final byte[] buf, final int start,
                        final int end) {
                final FileHeader fh = new FileHeader(buf, start);
                int ptr = fh.parseTraditionalHeaders(start, end);
                ptr = parseHunks(fh, ptr, end);
                fh.endOffset = ptr;
                addFile(fh);
                return ptr;
        }

        private static int skipFile(final byte[] buf, int ptr, final int end) {
                ptr = nextLF(buf, ptr);
                if (match(buf, ptr, OLD_NAME) >= 0)
                        ptr = nextLF(buf, ptr);
                return ptr;
        }

        private int parseHunks(final FileHeader fh, int c, final int end) {
                final byte[] buf = fh.buf;
                while (c < end) {
                        // If we see a file header at this point, we have all of the
                        // hunks for our current file. We should stop and report back
                        // with this position so it can be parsed again later.
                        //
                        if (match(buf, c, DIFF_GIT) >= 0)
                                break;
                        if (match(buf, c, DIFF_CC) >= 0)
                                break;
                        if (match(buf, c, OLD_NAME) >= 0)
                                break;
                        if (match(buf, c, NEW_NAME) >= 0)
                                break;

                        if (isHunkHdr(buf, c, end) == 1) {
                                final HunkHeader h = new HunkHeader(fh, c);
                                h.parseHeader(end);
                                c = h.parseBody(this, end);
                                h.endOffset = c;
                                fh.addHunk(h);
                                if (c < end && buf[c] != '@' && buf[c] != 'd'
                                                && match(buf, c, SIG_FOOTER) < 0) {
                                        warn(buf, c, "Unexpected hunk trailer");
                                }
                                continue;
                        }

                        final int eol = nextLF(buf, c);
                        if (fh.getHunks().isEmpty() && match(buf, c, GIT_BINARY) >= 0) {
                                fh.patchType = FileHeader.PatchType.GIT_BINARY;
                                return parseGitBinary(fh, eol, end);
                        }

                        if (fh.getHunks().isEmpty() && BIN_TRAILER.length < eol - c
                                        && match(buf, eol - BIN_TRAILER.length, BIN_TRAILER) >= 0
                                        && matchAny(buf, c, BIN_HEADERS)) {
                                // The patch is a binary file diff, with no deltas.
                                //
                                fh.patchType = FileHeader.PatchType.BINARY;
                                return eol;
                        }

                        // Skip this line and move to the next. Its probably garbage
                        // after the last hunk of a file.
                        //
                        c = eol;
                }

                if (fh.getHunks().isEmpty()
                                && fh.getPatchType() == FileHeader.PatchType.UNIFIED
                                && !fh.hasMetaDataChanges()) {
                        // Hmm, an empty patch? If there is no metadata here we
                        // really have a binary patch that we didn't notice above.
                        //
                        fh.patchType = FileHeader.PatchType.BINARY;
                }

                return c;
        }

        private int parseGitBinary(final FileHeader fh, int c, final int end) {
                final BinaryHunk postImage = new BinaryHunk(fh, c);
                final int nEnd = postImage.parseHunk(c, end);
                if (nEnd < 0) {
                        // Not a binary hunk.
                        //
                        error(fh.buf, c, "Missing forward-image in GIT binary patch");
                        return c;
                }
                c = nEnd;
                postImage.endOffset = c;
                fh.forwardBinaryHunk = postImage;

                final BinaryHunk preImage = new BinaryHunk(fh, c);
                final int oEnd = preImage.parseHunk(c, end);
                if (oEnd >= 0) {
                        c = oEnd;
                        preImage.endOffset = c;
                        fh.reverseBinaryHunk = preImage;
                }

                return c;
        }

        void warn(final byte[] buf, final int ptr, final String msg) {
                addError(new FormatError(buf, ptr, FormatError.Severity.WARNING, msg));
        }

        void error(final byte[] buf, final int ptr, final String msg) {
                addError(new FormatError(buf, ptr, FormatError.Severity.ERROR, msg));
        }

        private static boolean matchAny(final byte[] buf, final int c,
                        final byte[][] srcs) {
                for (final byte[] s : srcs) {
                        if (match(buf, c, s) >= 0)
                                return true;
                }
                return false;
        }
}