CommitConfig.java
/*
* Copyright (c) 2020, 2022 Julian Ruppel <julian.ruppel@sap.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.lib;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.text.MessageFormat;
import java.util.Locale;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Config.ConfigEnum;
import org.eclipse.jgit.lib.Config.SectionParser;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
import org.eclipse.jgit.util.StringUtils;
/**
* The standard "commit" configuration parameters.
*
* @since 5.13
*/
public class CommitConfig {
/**
* Key for {@link Config#get(SectionParser)}.
*/
public static final Config.SectionParser<CommitConfig> KEY = CommitConfig::new;
private static final String CUT = " ------------------------ >8 ------------------------\n"; //$NON-NLS-1$
private static final char[] COMMENT_CHARS = { '#', ';', '@', '!', '$', '%',
'^', '&', '|', ':' };
/**
* How to clean up commit messages when committing.
*
* @since 6.1
*/
public enum CleanupMode implements ConfigEnum {
/**
* {@link #WHITESPACE}, additionally remove comment lines.
*/
STRIP,
/**
* Remove trailing whitespace and leading and trailing empty lines;
* collapse multiple empty lines to a single one.
*/
WHITESPACE,
/**
* Make no changes.
*/
VERBATIM,
/**
* Omit everything from the first "scissor" line on, then apply
* {@link #WHITESPACE}.
*/
SCISSORS,
/**
* Use {@link #STRIP} for user-edited messages, otherwise
* {@link #WHITESPACE}, unless overridden by a git config setting other
* than DEFAULT.
*/
DEFAULT;
@Override
public String toConfigValue() {
return name().toLowerCase(Locale.ROOT);
}
@Override
public boolean matchConfigValue(String in) {
return toConfigValue().equals(in);
}
}
private final static Charset DEFAULT_COMMIT_MESSAGE_ENCODING = StandardCharsets.UTF_8;
private String i18nCommitEncoding;
private String commitTemplatePath;
private CleanupMode cleanupMode;
private char commentCharacter = '#';
private boolean autoCommentChar = false;
private CommitConfig(Config rc) {
commitTemplatePath = rc.getString(ConfigConstants.CONFIG_COMMIT_SECTION,
null, ConfigConstants.CONFIG_KEY_COMMIT_TEMPLATE);
i18nCommitEncoding = rc.getString(ConfigConstants.CONFIG_SECTION_I18N,
null, ConfigConstants.CONFIG_KEY_COMMIT_ENCODING);
cleanupMode = rc.getEnum(ConfigConstants.CONFIG_COMMIT_SECTION, null,
ConfigConstants.CONFIG_KEY_CLEANUP, CleanupMode.DEFAULT);
String comment = rc.getString(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_COMMENT_CHAR);
if (!StringUtils.isEmptyOrNull(comment)) {
if ("auto".equalsIgnoreCase(comment)) { //$NON-NLS-1$
autoCommentChar = true;
} else {
char first = comment.charAt(0);
if (first > ' ' && first < 127) {
commentCharacter = first;
}
}
}
}
/**
* Get the path to the commit template as defined in the git
* {@code commit.template} property.
*
* @return the path to commit template or {@code null} if not present.
*/
@Nullable
public String getCommitTemplatePath() {
return commitTemplatePath;
}
/**
* Get the encoding of the commit as defined in the git
* {@code i18n.commitEncoding} property.
*
* @return the encoding or {@code null} if not present.
*/
@Nullable
public String getCommitEncoding() {
return i18nCommitEncoding;
}
/**
* Retrieves the comment character set by git config
* {@code core.commentChar}.
*
* @return the character to use for comments in commit messages
* @since 6.2
*/
public char getCommentChar() {
return commentCharacter;
}
/**
* Determines the comment character to use for a particular text. If
* {@code core.commentChar} is "auto", tries to determine an unused
* character; if none is found, falls back to '#'. Otherwise returns the
* character given by {@code core.commentChar}.
*
* @param text
* existing text
*
* @return the character to use
* @since 6.2
*/
public char getCommentChar(String text) {
if (isAutoCommentChar()) {
char toUse = determineCommentChar(text);
if (toUse > 0) {
return toUse;
}
return '#';
}
return getCommentChar();
}
/**
* Tells whether the comment character should be determined by choosing a
* character not occurring in a commit message.
*
* @return {@code true} if git config {@code core.commentChar} is "auto"
* @since 6.2
*/
public boolean isAutoCommentChar() {
return autoCommentChar;
}
/**
* Retrieves the {@link CleanupMode} as given by git config
* {@code commit.cleanup}.
*
* @return the {@link CleanupMode}; {@link CleanupMode#DEFAULT} if the git
* config is not set
* @since 6.1
*/
@NonNull
public CleanupMode getCleanupMode() {
return cleanupMode;
}
/**
* Computes a non-default {@link CleanupMode} from the given mode and the
* git config.
*
* @param mode
* {@link CleanupMode} to resolve
* @param defaultStrip
* if {@code true} return {@link CleanupMode#STRIP} if the git
* config is also "default", otherwise return
* {@link CleanupMode#WHITESPACE}
* @return the {@code mode}, if it is not {@link CleanupMode#DEFAULT},
* otherwise the resolved mode, which is never
* {@link CleanupMode#DEFAULT}
* @since 6.1
*/
@NonNull
public CleanupMode resolve(@NonNull CleanupMode mode,
boolean defaultStrip) {
if (CleanupMode.DEFAULT == mode) {
CleanupMode defaultMode = getCleanupMode();
if (CleanupMode.DEFAULT == defaultMode) {
return defaultStrip ? CleanupMode.STRIP
: CleanupMode.WHITESPACE;
}
return defaultMode;
}
return mode;
}
/**
* Get the content to the commit template as defined in
* {@code commit.template}. If no {@code i18n.commitEncoding} is specified,
* UTF-8 fallback is used.
*
* @param repository
* to resolve relative path in local git repo config
*
* @return content of the commit template or {@code null} if not present.
* @throws IOException
* if the template file can not be read
* @throws FileNotFoundException
* if the template file does not exists
* @throws ConfigInvalidException
* if a {@code commitEncoding} is specified and is invalid
* @since 6.0
*/
@Nullable
public String getCommitTemplateContent(@NonNull Repository repository)
throws FileNotFoundException, IOException, ConfigInvalidException {
if (commitTemplatePath == null) {
return null;
}
File commitTemplateFile;
FS fileSystem = repository.getFS();
if (commitTemplatePath.startsWith("~/")) { //$NON-NLS-1$
commitTemplateFile = fileSystem.resolve(fileSystem.userHome(),
commitTemplatePath.substring(2));
} else {
commitTemplateFile = fileSystem.resolve(null, commitTemplatePath);
}
if (!commitTemplateFile.isAbsolute()) {
commitTemplateFile = fileSystem.resolve(
repository.getWorkTree().getAbsoluteFile(),
commitTemplatePath);
}
Charset commitMessageEncoding = getEncoding();
return RawParseUtils.decode(commitMessageEncoding,
IO.readFully(commitTemplateFile));
}
private Charset getEncoding() throws ConfigInvalidException {
Charset commitMessageEncoding = DEFAULT_COMMIT_MESSAGE_ENCODING;
if (i18nCommitEncoding == null) {
return null;
}
try {
commitMessageEncoding = Charset.forName(i18nCommitEncoding);
} catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
throw new ConfigInvalidException(MessageFormat.format(
JGitText.get().invalidEncoding, i18nCommitEncoding), e);
}
return commitMessageEncoding;
}
/**
* Processes a text according to the given {@link CleanupMode}.
*
* @param text
* text to process
* @param mode
* {@link CleanupMode} to use
* @param commentChar
* comment character (normally {@code #}) to use if {@code mode}
* is {@link CleanupMode#STRIP} or {@link CleanupMode#SCISSORS}
* @return the processed text
* @throws IllegalArgumentException
* if {@code mode} is {@link CleanupMode#DEFAULT} (use
* {@link #resolve(CleanupMode, boolean)} first)
* @since 6.1
*/
public static String cleanText(@NonNull String text,
@NonNull CleanupMode mode, char commentChar) {
String toProcess = text;
boolean strip = false;
switch (mode) {
case VERBATIM:
return text;
case SCISSORS:
String cut = commentChar + CUT;
if (text.startsWith(cut)) {
return ""; //$NON-NLS-1$
}
int cutPos = text.indexOf('\n' + cut);
if (cutPos >= 0) {
toProcess = text.substring(0, cutPos + 1);
}
break;
case STRIP:
strip = true;
break;
case WHITESPACE:
break;
case DEFAULT:
default:
// Internal error; no translation
throw new IllegalArgumentException("Invalid clean-up mode " + mode); //$NON-NLS-1$
}
// WHITESPACE
StringBuilder result = new StringBuilder();
boolean lastWasEmpty = true;
for (String line : toProcess.split("\n")) { //$NON-NLS-1$
line = line.stripTrailing();
if (line.isEmpty()) {
if (!lastWasEmpty) {
result.append('\n');
lastWasEmpty = true;
}
} else if (!strip || !isComment(line, commentChar)) {
lastWasEmpty = false;
result.append(line).append('\n');
}
}
int bufferSize = result.length();
if (lastWasEmpty && bufferSize > 0) {
bufferSize--;
result.setLength(bufferSize);
}
if (bufferSize > 0 && !toProcess.endsWith("\n")) { //$NON-NLS-1$
if (result.charAt(bufferSize - 1) == '\n') {
result.setLength(bufferSize - 1);
}
}
return result.toString();
}
private static boolean isComment(String text, char commentChar) {
int len = text.length();
for (int i = 0; i < len; i++) {
char ch = text.charAt(i);
if (!Character.isWhitespace(ch)) {
return ch == commentChar;
}
}
return false;
}
/**
* Determines a comment character by choosing one from a limited set of
* 7-bit ASCII characters that do not occur in the given text at the
* beginning of any line. If none can be determined, {@code (char) 0} is
* returned.
*
* @param text
* to get a comment character for
* @return the comment character, or {@code (char) 0} if none could be
* determined
* @since 6.2
*/
public static char determineCommentChar(String text) {
if (StringUtils.isEmptyOrNull(text)) {
return '#';
}
final boolean[] inUse = new boolean[127];
for (String line : text.split("\n")) { //$NON-NLS-1$
int len = line.length();
for (int i = 0; i < len; i++) {
char ch = line.charAt(i);
if (!Character.isWhitespace(ch)) {
if (ch >= 0 && ch < inUse.length) {
inUse[ch] = true;
}
break;
}
}
}
for (char candidate : COMMENT_CHARS) {
if (!inUse[candidate]) {
return candidate;
}
}
return (char) 0;
}
}