plugins/git4idea/src/git4idea/history/GitLogParser.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2010 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package git4idea.history;

 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.Function;
 import git4idea.GitFormatException;
 import git4idea.GitVcs;
 import git4idea.config.GitVersionSpecialty;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /**
  * <p>Parses the 'git log' output basing on the given number of options.
  * Doesn't execute of prepare the command itself, performs only parsing.</p>
  *
  * <p>
  * Usage:
  * 1. Pass options you want to have in the output to the constructor using the {@link GitLogOption} enum constants.
  * 2. Get the custom format pattern for 'git log' by calling {@link #getPretty()}
  * 3. Call the command and retrieve the output.
  * 4. Parse the output via {@link #parse(String)} or {@link #parseOneRecord(String)} (if you want the output to be parsed line by line).</p>
  *
  * <p>The class is package visible, since it's used only in GitHistoryUtils - the class which retrieve various pieced of history information
  * in different formats from 'git log'</p>
  *
  * <p>Note that you may pass one set of options to the GitLogParser constructor and then execute git log with other set of options.
  * In that case {@link #parse(String)} will parse only those options which you've specified in the constructor.
  * Others will be ignored since the parser knows nothing about them: it just gets the 'git log' output to parse.
  * Moreover you really <b>must</b> use {@link #getPretty()} to pass "--pretty=format" pattern to 'git log' - otherwise the parser won't be able
  * to parse output of 'git log' (because special separator characters are used for that).</p>
  *
  * <p>If you use '--name-status' or '--name-only' flags in 'git log' you also <b>must</b> call {@link #parseStatusBeforeName(boolean)} with
  * true or false respectively, because it also affects the output.</p>
  *
  * @see git4idea.history.GitLogRecord
  */
 public class GitLogParser {
   // Single records begin with %x01, end with %03. Items of commit information (hash, committer, subject, etc.) are separated by %x02.
   // each character is declared twice - for Git pattern format and for actual character in the output.
   public static final String RECORD_START = "\u0001";
   public static final String ITEMS_SEPARATOR = "\u0002";
   public static final String RECORD_END = "\u0003";
   public static final String RECORD_START_GIT = "%x01";
   private static final String ITEMS_SEPARATOR_GIT = "%x02";
   private static final String RECORD_END_GIT = "%x03";

   private final String myFormat;  // pretty custom format generated in the constructor
   private final GitLogOption[] myOptions;
   private final boolean mySupportsRawBody;
   private final NameStatus myNameStatusOption;

   /**
    * Record format:
    *
    * One git log record.
    * RECORD_START - optional: it is split out when calling parse() but it is not when calling parseOneRecord() directly.
    * commit information separated by ITEMS_SEPARATOR.
    * RECORD_END
    * Optionally: changed paths or paths with statuses (if --name-only or --name-status options are given).
    *
    * Example:
    * 2c815939f45fbcfda9583f84b14fe9d393ada790<ITEM_SEPARATOR>sample commit<RECORD_END>
    * D       a.txt
    */
   private static final Pattern ONE_RECORD = Pattern.compile(RECORD_START + "?(.*)" + RECORD_END + "\n*(.*)", Pattern.DOTALL);
   private static final String SINGLE_PATH = "([^\t\r\n]+)"; // something not empty, not a tab or newline.
   private static final String EOL = "\\s*(?:\r|\n|\r\n)";
   private static final String PATHS =
     SINGLE_PATH +                    // First path - required.
     "(?:\t" + SINGLE_PATH + ")?" +   // Second path - optional. Paths are separated by tab.
     "(?:" + EOL + ")?";                             // Path(s) information ends with a line terminator (possibly except the last path in the output).

   private static Pattern NAME_ONLY = Pattern.compile(PATHS);
   private static Pattern NAME_STATUS = Pattern.compile("([\\S]+)\t" + PATHS);

   // --name-only, --name-status or no flag
   enum NameStatus {
     /** No flag. */
     NONE,
     /** --name-only */
     NAME,
     /** --name-status */
     STATUS
   }

   /**
    * Options which may be passed to 'git log --pretty=format:' as placeholders and then parsed from the result.
    * These are the pieces of information about a commit which we want to get from 'git log'.
    */
   enum GitLogOption {
     HASH("H"), COMMIT_TIME("ct"), AUTHOR_NAME("an"), AUTHOR_TIME("at"), AUTHOR_EMAIL("ae"), COMMITTER_NAME("cn"),
     COMMITTER_EMAIL("ce"), SUBJECT("s"), BODY("b"), PARENTS("P"), REF_NAMES("d"), SHORT_REF_LOG_SELECTOR("gd"),
     RAW_BODY("B");

     private String myPlaceholder;
     GitLogOption(String placeholder) { myPlaceholder = placeholder; }
     private String getPlaceholder() { return myPlaceholder; }
   }

   /**
    * Constructs new parser with the given options and no names of changed files in the output.
    */
   GitLogParser(Project project, GitLogOption... options) {
     this(project, NameStatus.NONE, options);
   }

   /**
    * Constructs new parser with the specified options.
    * Only these options will be parsed out and thus will be available from the GitLogRecord.
    */
   GitLogParser(Project project, NameStatus nameStatusOption, GitLogOption... options) {
     myFormat = makeFormatFromOptions(options);
     myOptions = options;
     myNameStatusOption = nameStatusOption;
     GitVcs vcs = GitVcs.getInstance(project);
     mySupportsRawBody = vcs != null && GitVersionSpecialty.STARTED_USING_RAW_BODY_IN_FORMAT.existsIn(vcs.getVersion());
   }

   private static String makeFormatFromOptions(GitLogOption[] options) {
     Function<GitLogOption,String> function = new Function<GitLogOption, String>() {
       @Override public String fun(GitLogOption option) {
         return "%" + option.getPlaceholder();
       }
     };
     return RECORD_START_GIT + StringUtil.join(options, function, ITEMS_SEPARATOR_GIT) + RECORD_END_GIT;
   }

   String getPretty() {
     return "--pretty=format:" + myFormat;
   }

   /**
    * Parses the output returned from 'git log' which was executed with '--pretty=format:' pattern retrieved from {@link #getPretty()}.
    * @param output 'git log' output to be parsed.
    * @return The list of {@link GitLogRecord GitLogRecords} with information for each revision.
    *         The list is sorted as usual for git log - the first is the newest, the last is the oldest.
    */
   @NotNull
   List<GitLogRecord> parse(@NotNull String output) {
     // Here is what git log returns for --pretty=tformat:^%H#%s$
     // ^2c815939f45fbcfda9583f84b14fe9d393ada790#sample commit$
     //
     // D       a.txt
     // ^b71477e9738168aa67a8d41c414f284255f81e8a#moved out$
     //
     // R100    dir/anew.txt    anew.txt
     final String[] records = output.split(RECORD_START); // split by START, because END is the end of information, but not the end of the record: file status and path follow.
     final List<GitLogRecord> res = new ArrayList<GitLogRecord>(records.length);
     for (String record : records) {
       if (!record.trim().isEmpty()) {  // record[0] is empty for sure, because we're splitting on RECORD_START. Just to play safe adding the check for all records.
         res.add(parseOneRecord(record));
       }
     }
     return res;
   }

   /**
    * Parses a single record returned by 'git log'. The record contains information from pattern and file status and path (if respective
    * flags --name-only or name-status were provided).
    * @param line record to be parsed.
    * @return GitLogRecord with information about the revision or {@code null} if the given line is empty.
    * @throws GitFormatException if the line is given in unexpected format.
    */
   @Nullable
   GitLogRecord parseOneRecord(@NotNull String line) {
     if (line.isEmpty()) {
       return null;
     }
     Matcher matcher = ONE_RECORD.matcher(line);
     if (!matcher.matches()) {
       throwGFE("ONE_RECORD didn't match", line);
     }
     String commitInfo = matcher.group(1);
     if (commitInfo == null) {
       throwGFE("No match for group#1 in", line);
     }

     final Map<GitLogOption, String> res = parseCommitInfo(commitInfo);

     // parsing status and path (if given)
     final List<String> paths = new ArrayList<String>(1);
     final List<GitLogStatusInfo> statuses = new ArrayList<GitLogStatusInfo>();

     if (myNameStatusOption != NameStatus.NONE) {
       String pathsAndStatuses = matcher.group(2);
       if (pathsAndStatuses == null) {
         throwGFE("No match for group#2 in", line);
       }

       if (myNameStatusOption == NameStatus.NAME) {
         Matcher pathsMatcher = NAME_ONLY.matcher(pathsAndStatuses);
         while (pathsMatcher.find()) {
           String path1 = pathsMatcher.group(1);
           String path2 = pathsMatcher.group(2);
           assertNotNull(path1, "path", pathsAndStatuses);
           paths.add(path1);
           if (path2 != null) { // null is perfectly legal here: second path is given only in case of rename
             paths.add(path2);
           }
         }
       }
       else {
         Matcher nameStatusMatcher = NAME_STATUS.matcher(pathsAndStatuses);
         while (nameStatusMatcher.find()) {
           String status = nameStatusMatcher.group(1);
           String path1 = nameStatusMatcher.group(2);
           String path2 = nameStatusMatcher.group(3);
           assertNotNull(status, "status", pathsAndStatuses);
           assertNotNull(path1, "path1", pathsAndStatuses);
           paths.add(path1);
           if (path2 != null) {
             paths.add(path2);
           }
           statuses.add(new GitLogStatusInfo(GitChangeType.fromString(status), path1, path2));
         }
       }
     }
     return new GitLogRecord(res, paths, statuses, mySupportsRawBody);
   }


   @NotNull
   private Map<GitLogOption, String> parseCommitInfo(@NotNull String commitInfo) {
     // parsing revision information
     // we rely on the order of options
     final String[] values = commitInfo.split(ITEMS_SEPARATOR);
     final Map<GitLogOption, String> res = new HashMap<GitLogOption, String>(values.length);
     int i = 0;
     for (; i < values.length && i < myOptions.length; i++) {  // fill valid values
       res.put(myOptions[i], values[i]);
     }
     for (; i < myOptions.length; i++) {  // options which were not returned are set to blank string, extra options are ignored.
       res.put(myOptions[i], "");
     }
     return res;
   }

   private static void assertNotNull(String value, String valueName, String line) {
     if (value == null) {
       throwGFE("Unexpectedly null " + valueName + " in ", line);
     }
   }

   private static void throwGFE(String message, String line) {
     throw new GitFormatException(message + " [" + StringUtil.escapeStringCharacters(line) + "]");
   }

 }
	/*
	* Copyright 2000-2010 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package git4idea.history;

	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.util.Function;
	import git4idea.GitFormatException;
	import git4idea.GitVcs;
	import git4idea.config.GitVersionSpecialty;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	/**
	* <p>Parses the 'git log' output basing on the given number of options.
	* Doesn't execute of prepare the command itself, performs only parsing.</p>
	*
	* <p>
	* Usage:
	* 1. Pass options you want to have in the output to the constructor using the {@link GitLogOption} enum constants.
	* 2. Get the custom format pattern for 'git log' by calling {@link #getPretty()}
	* 3. Call the command and retrieve the output.
	* 4. Parse the output via {@link #parse(String)} or {@link #parseOneRecord(String)} (if you want the output to be parsed line by line).</p>
	*
	* <p>The class is package visible, since it's used only in GitHistoryUtils - the class which retrieve various pieced of history information
	* in different formats from 'git log'</p>
	*
	* <p>Note that you may pass one set of options to the GitLogParser constructor and then execute git log with other set of options.
	* In that case {@link #parse(String)} will parse only those options which you've specified in the constructor.
	* Others will be ignored since the parser knows nothing about them: it just gets the 'git log' output to parse.
	* Moreover you really <b>must</b> use {@link #getPretty()} to pass "--pretty=format" pattern to 'git log' - otherwise the parser won't be able
	* to parse output of 'git log' (because special separator characters are used for that).</p>
	*
	* <p>If you use '--name-status' or '--name-only' flags in 'git log' you also <b>must</b> call {@link #parseStatusBeforeName(boolean)} with
	* true or false respectively, because it also affects the output.</p>
	*
	* @see git4idea.history.GitLogRecord
	*/
	public class GitLogParser {
	// Single records begin with %x01, end with %03. Items of commit information (hash, committer, subject, etc.) are separated by %x02.
	// each character is declared twice - for Git pattern format and for actual character in the output.
	public static final String RECORD_START = "\u0001";
	public static final String ITEMS_SEPARATOR = "\u0002";
	public static final String RECORD_END = "\u0003";
	public static final String RECORD_START_GIT = "%x01";
	private static final String ITEMS_SEPARATOR_GIT = "%x02";
	private static final String RECORD_END_GIT = "%x03";

	private final String myFormat; // pretty custom format generated in the constructor
	private final GitLogOption[] myOptions;
	private final boolean mySupportsRawBody;
	private final NameStatus myNameStatusOption;

	/**
	* Record format:
	*
	* One git log record.
	* RECORD_START - optional: it is split out when calling parse() but it is not when calling parseOneRecord() directly.
	* commit information separated by ITEMS_SEPARATOR.
	* RECORD_END
	* Optionally: changed paths or paths with statuses (if --name-only or --name-status options are given).
	*
	* Example:
	* 2c815939f45fbcfda9583f84b14fe9d393ada790<ITEM_SEPARATOR>sample commit<RECORD_END>
	* D a.txt
	*/
	private static final Pattern ONE_RECORD = Pattern.compile(RECORD_START + "?(.)" + RECORD_END + "\n(.*)", Pattern.DOTALL);
	private static final String SINGLE_PATH = "([^\t\r\n]+)"; // something not empty, not a tab or newline.
	private static final String EOL = "\\s*(?:\r\|\n\|\r\n)";
	private static final String PATHS =
	SINGLE_PATH + // First path - required.
	"(?:\t" + SINGLE_PATH + ")?" + // Second path - optional. Paths are separated by tab.
	"(?:" + EOL + ")?"; // Path(s) information ends with a line terminator (possibly except the last path in the output).

	private static Pattern NAME_ONLY = Pattern.compile(PATHS);
	private static Pattern NAME_STATUS = Pattern.compile("([\\S]+)\t" + PATHS);

	// --name-only, --name-status or no flag
	enum NameStatus {
	/** No flag. */
	NONE,
	/** --name-only */
	NAME,
	/** --name-status */
	STATUS
	}

	/**
	* Options which may be passed to 'git log --pretty=format:' as placeholders and then parsed from the result.
	* These are the pieces of information about a commit which we want to get from 'git log'.
	*/
	enum GitLogOption {
	HASH("H"), COMMIT_TIME("ct"), AUTHOR_NAME("an"), AUTHOR_TIME("at"), AUTHOR_EMAIL("ae"), COMMITTER_NAME("cn"),
	COMMITTER_EMAIL("ce"), SUBJECT("s"), BODY("b"), PARENTS("P"), REF_NAMES("d"), SHORT_REF_LOG_SELECTOR("gd"),
	RAW_BODY("B");

	private String myPlaceholder;
	GitLogOption(String placeholder) { myPlaceholder = placeholder; }
	private String getPlaceholder() { return myPlaceholder; }
	}

	/**
	* Constructs new parser with the given options and no names of changed files in the output.
	*/
	GitLogParser(Project project, GitLogOption... options) {
	this(project, NameStatus.NONE, options);
	}

	/**
	* Constructs new parser with the specified options.
	* Only these options will be parsed out and thus will be available from the GitLogRecord.
	*/
	GitLogParser(Project project, NameStatus nameStatusOption, GitLogOption... options) {
	myFormat = makeFormatFromOptions(options);
	myOptions = options;
	myNameStatusOption = nameStatusOption;
	GitVcs vcs = GitVcs.getInstance(project);
	mySupportsRawBody = vcs != null && GitVersionSpecialty.STARTED_USING_RAW_BODY_IN_FORMAT.existsIn(vcs.getVersion());
	}

	private static String makeFormatFromOptions(GitLogOption[] options) {
	Function<GitLogOption,String> function = new Function<GitLogOption, String>() {
	@Override public String fun(GitLogOption option) {
	return "%" + option.getPlaceholder();
	}
	};
	return RECORD_START_GIT + StringUtil.join(options, function, ITEMS_SEPARATOR_GIT) + RECORD_END_GIT;
	}

	String getPretty() {
	return "--pretty=format:" + myFormat;
	}

	/**
	* Parses the output returned from 'git log' which was executed with '--pretty=format:' pattern retrieved from {@link #getPretty()}.
	* @param output 'git log' output to be parsed.
	* @return The list of {@link GitLogRecord GitLogRecords} with information for each revision.
	* The list is sorted as usual for git log - the first is the newest, the last is the oldest.
	*/
	@NotNull
	List<GitLogRecord> parse(@NotNull String output) {
	// Here is what git log returns for --pretty=tformat:^%H#%s$
	// ^2c815939f45fbcfda9583f84b14fe9d393ada790#sample commit$
	//
	// D a.txt
	// ^b71477e9738168aa67a8d41c414f284255f81e8a#moved out$
	//
	// R100 dir/anew.txt anew.txt
	final String[] records = output.split(RECORD_START); // split by START, because END is the end of information, but not the end of the record: file status and path follow.
	final List<GitLogRecord> res = new ArrayList<GitLogRecord>(records.length);
	for (String record : records) {
	if (!record.trim().isEmpty()) { // record[0] is empty for sure, because we're splitting on RECORD_START. Just to play safe adding the check for all records.
	res.add(parseOneRecord(record));
	}
	}
	return res;
	}

	/**
	* Parses a single record returned by 'git log'. The record contains information from pattern and file status and path (if respective
	* flags --name-only or name-status were provided).
	* @param line record to be parsed.
	* @return GitLogRecord with information about the revision or {@code null} if the given line is empty.
	* @throws GitFormatException if the line is given in unexpected format.
	*/
	@Nullable
	GitLogRecord parseOneRecord(@NotNull String line) {
	if (line.isEmpty()) {
	return null;
	}
	Matcher matcher = ONE_RECORD.matcher(line);
	if (!matcher.matches()) {
	throwGFE("ONE_RECORD didn't match", line);
	}
	String commitInfo = matcher.group(1);
	if (commitInfo == null) {
	throwGFE("No match for group#1 in", line);
	}

	final Map<GitLogOption, String> res = parseCommitInfo(commitInfo);

	// parsing status and path (if given)
	final List<String> paths = new ArrayList<String>(1);
	final List<GitLogStatusInfo> statuses = new ArrayList<GitLogStatusInfo>();

	if (myNameStatusOption != NameStatus.NONE) {
	String pathsAndStatuses = matcher.group(2);
	if (pathsAndStatuses == null) {
	throwGFE("No match for group#2 in", line);
	}

	if (myNameStatusOption == NameStatus.NAME) {
	Matcher pathsMatcher = NAME_ONLY.matcher(pathsAndStatuses);
	while (pathsMatcher.find()) {
	String path1 = pathsMatcher.group(1);
	String path2 = pathsMatcher.group(2);
	assertNotNull(path1, "path", pathsAndStatuses);
	paths.add(path1);
	if (path2 != null) { // null is perfectly legal here: second path is given only in case of rename
	paths.add(path2);
	}
	}
	}
	else {
	Matcher nameStatusMatcher = NAME_STATUS.matcher(pathsAndStatuses);
	while (nameStatusMatcher.find()) {
	String status = nameStatusMatcher.group(1);
	String path1 = nameStatusMatcher.group(2);
	String path2 = nameStatusMatcher.group(3);
	assertNotNull(status, "status", pathsAndStatuses);
	assertNotNull(path1, "path1", pathsAndStatuses);
	paths.add(path1);
	if (path2 != null) {
	paths.add(path2);
	}
	statuses.add(new GitLogStatusInfo(GitChangeType.fromString(status), path1, path2));
	}
	}
	}
	return new GitLogRecord(res, paths, statuses, mySupportsRawBody);
	}


	@NotNull
	private Map<GitLogOption, String> parseCommitInfo(@NotNull String commitInfo) {
	// parsing revision information
	// we rely on the order of options
	final String[] values = commitInfo.split(ITEMS_SEPARATOR);
	final Map<GitLogOption, String> res = new HashMap<GitLogOption, String>(values.length);
	int i = 0;
	for (; i < values.length && i < myOptions.length; i++) { // fill valid values
	res.put(myOptions[i], values[i]);
	}
	for (; i < myOptions.length; i++) { // options which were not returned are set to blank string, extra options are ignored.
	res.put(myOptions[i], "");
	}
	return res;
	}

	private static void assertNotNull(String value, String valueName, String line) {
	if (value == null) {
	throwGFE("Unexpectedly null " + valueName + " in ", line);
	}
	}

	private static void throwGFE(String message, String line) {
	throw new GitFormatException(message + " [" + StringUtil.escapeStringCharacters(line) + "]");
	}

	}