1 files changed, 150 insertions, 79 deletions
diff --git a/org.eclipse.jgit.pgm.test/src/org/eclipse/jgit/pgm/CLIGitCommand.java b/org.eclipse.jgit.pgm.test/src/org/eclipse/jgit/pgm/CLIGitCommand.java
index d77b1505ae..ee98fc645b 100644
--- a/org.eclipse.jgit.pgm.test/src/org/eclipse/jgit/pgm/CLIGitCommand.java
+++ b/org.eclipse.jgit.pgm.test/src/org/eclipse/jgit/pgm/CLIGitCommand.java
@@ -1,112 +1,151 @@
 /*
- * Copyright (C) 2011-2012, IBM Corporation and others.
- * and other copyright owners as documented in the project's IP log.
+ * Copyright (C) 2011-2012, IBM Corporation and others. and others
  *
- * 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
+ * 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.
  *
- * 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.
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 package org.eclipse.jgit.pgm;
 
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertNull;
+
 import java.io.ByteArrayOutputStream;
-import java.text.MessageFormat;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.jgit.internal.storage.file.FileRepository;
 import org.eclipse.jgit.lib.Repository;
-import org.eclipse.jgit.pgm.internal.CLIText;
-import org.eclipse.jgit.pgm.opt.CmdLineParser;
-import org.eclipse.jgit.pgm.opt.SubcommandHandler;
+import org.eclipse.jgit.pgm.TextBuiltin.TerminatedByHelpException;
 import org.eclipse.jgit.util.IO;
-import org.kohsuke.args4j.Argument;
 
-public class CLIGitCommand {
-	@Argument(index = 0, metaVar = "metaVar_command", required = true, handler = SubcommandHandler.class)
-	private TextBuiltin subcommand;
+public class CLIGitCommand extends Main {
+
+	private final Result result;
 
-	@Argument(index = 1, metaVar = "metaVar_arg")
-	private List<String> arguments = new ArrayList<String>();
+	private final Repository db;
 
-	public TextBuiltin getSubcommand() {
-		return subcommand;
+	public CLIGitCommand(Repository db) {
+		super();
+		this.db = db;
+		result = new Result();
 	}
 
-	public List<String> getArguments() {
-		return arguments;
+	/**
+	 * Executes git commands (with arguments) specified on the command line. The
+	 * git repository (same for all commands) can be specified via system
+	 * property "-Dgit_work_tree=path_to_work_tree". If the property is not set,
+	 * current directory is used.
+	 *
+	 * @param args
+	 *            each element in the array must be a valid git command line,
+	 *            e.g. "git branch -h"
+	 * @throws Exception
+	 */
+	public static void main(String[] args) throws Exception {
+		String workDir = System.getProperty("git_work_tree");
+		if (workDir == null) {
+			workDir = ".";
+			System.out.println(
+					"System property 'git_work_tree' not specified, using current directory: "
+							+ new File(workDir).getAbsolutePath());
+		}
+		try (Repository db = new FileRepository(workDir + "/.git")) {
+			for (String cmd : args) {
+				List<String> result = execute(cmd, db);
+				for (String line : result) {
+					System.out.println(line);
+				}
+			}
+		}
 	}
 
 	public static List<String> execute(String str, Repository db)
 			throws Exception {
+		Result result = executeRaw(str, db);
+		return getOutput(result);
+	}
+
+	public static Result executeRaw(String str, Repository db)
+			throws Exception {
+		CLIGitCommand cmd = new CLIGitCommand(db);
+		cmd.run(str);
+		return cmd.result;
+	}
+
+	public static List<String> executeUnchecked(String str, Repository db)
+			throws Exception {
+		CLIGitCommand cmd = new CLIGitCommand(db);
+		try {
+			cmd.run(str);
+			return getOutput(cmd.result);
+		} catch (Throwable e) {
+			return cmd.result.errLines();
+		}
+	}
+
+	private static List<String> getOutput(Result result) {
+		if (result.ex instanceof TerminatedByHelpException) {
+			return result.errLines();
+		}
+		return result.outLines();
+	}
+
+	private void run(String commandLine) throws Exception {
+		String[] argv = convertToMainArgs(commandLine);
 		try {
-			return IO.readLines(new String(rawExecute(str, db)));
-		} catch (Die e) {
-			return IO.readLines(MessageFormat.format(CLIText.get().fatalError,
-					e.getMessage()));
+			super.run(argv);
+		} catch (TerminatedByHelpException e) {
+			// this is not a failure, super called exit() on help
+		} finally {
+			writer.flush();
 		}
 	}
 
-	public static byte[] rawExecute(String str, Repository db)
+	private static String[] convertToMainArgs(String str)
 			throws Exception {
 		String[] args = split(str);
-		if (!args[0].equalsIgnoreCase("git") || args.length < 2)
+		if (!args[0].equalsIgnoreCase("git") || args.length < 2) {
 			throw new IllegalArgumentException(
 					"Expected 'git <command> [<args>]', was:" + str);
+		}
 		String[] argv = new String[args.length - 1];
 		System.arraycopy(args, 1, argv, 0, args.length - 1);
+		return argv;
+	}
 
-		CLIGitCommand bean = new CLIGitCommand();
-		final CmdLineParser clp = new CmdLineParser(bean);
-		clp.parseArgument(argv);
-
-		final TextBuiltin cmd = bean.getSubcommand();
-		ByteArrayOutputStream baos = new ByteArrayOutputStream();
-		cmd.outs = baos;
-		if (cmd.requiresRepository())
-			cmd.init(db, null);
-		else
-			cmd.init(null, null);
-		try {
-			cmd.execute(bean.getArguments().toArray(
-					new String[bean.getArguments().size()]));
-		} finally {
-			if (cmd.outw != null)
-				cmd.outw.flush();
+	@Override
+	PrintWriter createErrorWriter() {
+		return new PrintWriter(new OutputStreamWriter(
+				result.err, UTF_8));
+	}
+
+	@Override
+	void init(TextBuiltin cmd) throws IOException {
+		cmd.outs = result.out;
+		cmd.errs = result.err;
+		super.init(cmd);
+	}
+
+	@Override
+	protected Repository openGitDir(String aGitdir) throws IOException {
+		assertNull(aGitdir);
+		return db;
+	}
+
+	@Override
+	void exit(int status, Exception t) throws Exception {
+		if (t == null) {
+			t = new IllegalStateException(Integer.toString(status));
 		}
-		return baos.toByteArray();
+		result.ex = t;
+		throw t;
 	}
 
 	/**
@@ -120,7 +159,7 @@ public class CLIGitCommand {
 	 * @return the array
 	 */
 	static String[] split(String commandLine) {
-		final List<String> list = new ArrayList<String>();
+		final List<String> list = new ArrayList<>();
 		boolean inquote = false;
 		boolean inDblQuote = false;
 		StringBuilder r = new StringBuilder();
@@ -149,7 +188,7 @@ public class CLIGitCommand {
 					inquote = !inquote;
 				continue;
 			case '\\':
-				if (inquote || ip == commandLine.length())
+				if (inDblQuote || inquote || ip == commandLine.length())
 					r.append(b); // literal within a quote
 				else
 					r.append(commandLine.charAt(ip++));
@@ -161,7 +200,39 @@ public class CLIGitCommand {
 		}
 		if (r.length() > 0)
 			list.add(r.toString());
-		return list.toArray(new String[list.size()]);
+		return list.toArray(new String[0]);
+	}
+
+	public static class Result {
+		public final ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+		public final ByteArrayOutputStream err = new ByteArrayOutputStream();
+
+		public Exception ex;
+
+		public byte[] outBytes() {
+			return out.toByteArray();
+		}
+
+		public byte[] errBytes() {
+			return err.toByteArray();
+		}
+
+		public String outString() {
+			return new String(out.toByteArray(), UTF_8);
+		}
+
+		public List<String> outLines() {
+			return IO.readLines(outString());
+		}
+
+		public String errString() {
+			return new String(err.toByteArray(), UTF_8);
+		}
+
+		public List<String> errLines() {
+			return IO.readLines(errString());
+		}
 	}
 
 }