org.eclipse.jgit/src/org/eclipse/jgit/util/io/AutoLFInputStream.java

/*
 * Copyright (C) 2010, 2013 Marc Strapetz <marc.strapetz@syntevo.com>
 * Copyright (C) 2015, 2020 Ivan Motsch <ivan.motsch@bsiag.com> and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.util.io;

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.Set;

import org.eclipse.jgit.diff.RawText;

/**
 * An InputStream that normalizes CRLF to LF.
 * <p>
 * Existing single CR are not changed to LF but are retained as is.
 * </p>
 * <p>
 * Optionally, a binary check on the first {@link RawText#getBufferSize()} bytes
 * is performed and in case of binary files, canonicalization is turned off (for
 * the complete file). If binary checking determines that the input is
 * CR/LF-delimited text and the stream has been created for checkout,
 * canonicalization is also turned off.
 * </p>
 *
 * @since 4.3
 */
public class AutoLFInputStream extends InputStream {

	// This is the former EolCanonicalizingInputStream with a new name in order
	// to have same naming for all LF / CRLF streams.

	/**
	 * Flags for controlling auto-detection of binary vs. text content (for
	 * text=auto).
	 *
	 * @since 5.9
	 */
	public enum StreamFlag {
		/**
		 * Check the first 8kB for binary content and switch off
		 * canonicalization off for the whole file if so.
		 */
		DETECT_BINARY,
		/**
		 * If {@link #DETECT_BINARY} is set, throw an {@link IsBinaryException}
		 * if binary content is detected.
		 */
		ABORT_IF_BINARY,
		/**
		 * If {@link #DETECT_BINARY} is set and content is found to be CR-LF
		 * delimited text, switch off canonicalization.
		 */
		FOR_CHECKOUT
	}

	private final byte[] single = new byte[1];

	private final byte[] buf = new byte[RawText.getBufferSize()];

	private final InputStream in;

	private int cnt;

	private int ptr;

	/**
	 * Set to {@code true} if no CR/LF processing is to be done: if the input is
	 * binary data, or CR/LF-delimited text and {@link StreamFlag#FOR_CHECKOUT}
	 * was given.
	 */
	private boolean passAsIs;

	/**
	 * Set to {@code true} if the input was detected to be binary data.
	 */
	private boolean isBinary;

	private boolean detectBinary;

	private final boolean abortIfBinary;

	private final boolean forCheckout;

	/**
	 * A special exception thrown when {@link AutoLFInputStream} is told to
	 * throw an exception when attempting to read a binary file. The exception
	 * may be thrown at any stage during reading.
	 *
	 * @since 3.3
	 */
	public static class IsBinaryException extends IOException {
		private static final long serialVersionUID = 1L;

		IsBinaryException() {
			super();
		}
	}

	/**
	 * Factory method for creating an {@link AutoLFInputStream} with the
	 * specified {@link StreamFlag flags}.
	 *
	 * @param in
	 *            raw input stream
	 * @param flags
	 *            {@link StreamFlag}s controlling the stream behavior
	 * @return a new {@link AutoLFInputStream}
	 * @since 5.9
	 */
	public static AutoLFInputStream create(InputStream in,
			StreamFlag... flags) {
		if (flags == null) {
			return new AutoLFInputStream(in, null);
		}
		EnumSet<StreamFlag> set = EnumSet.noneOf(StreamFlag.class);
		set.addAll(Arrays.asList(flags));
		return new AutoLFInputStream(in, set);
	}

	/**
	 * Creates a new InputStream, wrapping the specified stream.
	 *
	 * @param in
	 *            raw input stream
	 * @param flags
	 *            {@link StreamFlag}s controlling the stream behavior;
	 *            {@code null} is treated as an empty set
	 * @since 5.9
	 */
	public AutoLFInputStream(InputStream in, Set<StreamFlag> flags) {
		this.in = in;
		this.detectBinary = flags != null
				&& flags.contains(StreamFlag.DETECT_BINARY);
		this.abortIfBinary = flags != null
				&& flags.contains(StreamFlag.ABORT_IF_BINARY);
		this.forCheckout = flags != null
				&& flags.contains(StreamFlag.FOR_CHECKOUT);
	}

	/**
	 * Creates a new InputStream, wrapping the specified stream.
	 *
	 * @param in
	 *            raw input stream
	 * @param detectBinary
	 *            whether binaries should be detected
	 * @since 2.0
	 * @deprecated since 5.9, use {@link #create(InputStream, StreamFlag...)}
	 *             instead
	 */
	@Deprecated
	public AutoLFInputStream(InputStream in, boolean detectBinary) {
		this(in, detectBinary, false);
	}

	/**
	 * Creates a new InputStream, wrapping the specified stream.
	 *
	 * @param in
	 *            raw input stream
	 * @param detectBinary
	 *            whether binaries should be detected
	 * @param abortIfBinary
	 *            throw an IOException if the file is binary
	 * @since 3.3
	 * @deprecated since 5.9, use {@link #create(InputStream, StreamFlag...)}
	 *             instead
	 */
	@Deprecated
	public AutoLFInputStream(InputStream in, boolean detectBinary,
			boolean abortIfBinary) {
		this.in = in;
		this.detectBinary = detectBinary;
		this.abortIfBinary = abortIfBinary;
		this.forCheckout = false;
	}

	@Override
	public int read() throws IOException {
		final int read = read(single, 0, 1);
		return read == 1 ? single[0] & 0xff : -1;
	}

	@Override
	public int read(byte[] bs, int off, int len)
			throws IOException {
		if (len == 0)
			return 0;

		if (cnt == -1)
			return -1;

		int i = off;
		final int end = off + len;

		while (i < end) {
			if (ptr == cnt && !fillBuffer()) {
				break;
			}

			byte b = buf[ptr++];
			if (passAsIs || b != '\r') {
				// Logic for binary files ends here
				bs[i++] = b;
				continue;
			}

			if (ptr == cnt && !fillBuffer()) {
				bs[i++] = '\r';
				break;
			}

			if (buf[ptr] == '\n') {
				bs[i++] = '\n';
				ptr++;
			} else
				bs[i++] = '\r';
		}

		return i == off ? -1 : i - off;
	}

	/**
	 * Whether the stream has detected as a binary so far.
	 *
	 * @return true if the stream has detected as a binary so far.
	 * @since 3.3
	 */
	public boolean isBinary() {
		return isBinary;
	}

	@Override
	public void close() throws IOException {
		in.close();
	}

	private boolean fillBuffer() throws IOException {
		cnt = 0;
		while (cnt < buf.length) {
			int n = in.read(buf, cnt, buf.length - cnt);
			if (n < 0) {
				break;
			}
			cnt += n;
		}
		if (cnt < 1) {
			cnt = -1;
			return false;
		}
		if (detectBinary) {
			isBinary = RawText.isBinary(buf, cnt, cnt < buf.length);
			passAsIs = isBinary;
			detectBinary = false;
			if (isBinary && abortIfBinary) {
				throw new IsBinaryException();
			}
			if (!passAsIs && forCheckout) {
				passAsIs = RawText.isCrLfText(buf, cnt, cnt < buf.length);
			}
		}
		ptr = 0;
		return true;
	}
}