[] getAdapterList() {
return new Class[] { IHistoryPageSource.class };
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/DefaultConfiguration.java 0000664 0000000 0000000 00000007306 11737135005 0033355 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan - implementation
* Andrei Loskutov - bug fixes
* Philip Graf - use default timeout from preferences
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import com.vectrace.MercurialEclipse.commands.IConfiguration;
import com.vectrace.MercurialEclipse.commands.IConsole;
import com.vectrace.MercurialEclipse.commands.IErrorHandler;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.preferences.TimeoutPreferencePage;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.views.console.HgConsoleHolder;
/**
* @author Stefan
*/
public class DefaultConfiguration implements IConsole, IErrorHandler, IConfiguration {
public DefaultConfiguration() {
}
public String getExecutable() {
if (!MercurialEclipsePlugin.getDefault().isHgUsable()) {
MercurialUtilities.configureHgExecutable();
MercurialEclipsePlugin.getDefault().checkHgInstallation();
}
return MercurialEclipsePlugin.getDefault().getPreferenceStore()
.getString(MercurialPreferenceConstants.MERCURIAL_EXECUTABLE);
}
public String getPreference(String preferenceConstant,
String defaultIfNotSet) {
return MercurialUtilities.getPreference(preferenceConstant,
defaultIfNotSet);
}
public void logError(Throwable e) {
MercurialEclipsePlugin.logError(e);
}
public void logWarning(String message, Throwable e) {
MercurialEclipsePlugin.logWarning(message, e);
}
public int getTimeOut(String commandId) {
int timeout = TimeoutPreferencePage.DEFAULT_TIMEOUT;
String pref = getPreference(commandId, String.valueOf(timeout));
try {
timeout = Integer.parseInt(pref);
if (timeout < 0) {
throw new NumberFormatException(Messages.getString("DefaultConfiguration.timoutLessThanEqual")); //$NON-NLS-1$
}
} catch (NumberFormatException e) {
logWarning(Messages.getString("DefaultConfiguration.timeoutForCommand") + commandId //$NON-NLS-1$
+ Messages.getString("DefaultConfiguration.notCorrectlyConfigured"), e); //$NON-NLS-1$
}
return timeout;
}
/*
* ======================================================
*
* IConsole methods below
*
* ======================================================
*/
public void commandCompleted(final int exitCode, final long timeInMillis, final String message, final Throwable error) {
int severity = IStatus.OK;
switch (exitCode) {
case 0:
severity = IStatus.OK;
break;
case 1:
severity = IStatus.OK;
break;
default:
severity = IStatus.ERROR;
}
HgConsoleHolder
.getInstance()
.getConsole()
.commandCompleted(timeInMillis,
new Status(severity, MercurialEclipsePlugin.ID, message), error);
}
public void commandInvoked(final String command) {
HgConsoleHolder.getInstance().getConsole().commandInvoked(command);
}
public void printError(final String message, final Throwable root) {
HgConsoleHolder.getInstance().getConsole().errorLineReceived(root.getMessage());
}
public void printMessage(final String message, final Throwable root) {
HgConsoleHolder.getInstance().getConsole().messageLineReceived(message);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/HgFeatures.java 0000664 0000000 0000000 00000016173 11737135005 0031300 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import org.eclipse.jface.preference.IPreferenceStore;
import org.osgi.framework.Version;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
/**
* Features of the underlined mercurial executable. HgFeatures are version dependent and so will be
* enabled/disabled based on the currently used mercurial binaries.
*
* Note that the right enablement state will be set some time after plugin startup, so that in a
* short time between plugin activation and {@link MercurialEclipsePlugin#checkHgInstallation()}
* features might be not yet initialized properly. Initially all features are disabled.
*
* @author andrei
*/
public enum HgFeatures {
BRANCH (new Version(1,5,0), "--branch", true),
NEW_BRANCH (new Version(1,6,0), "--new-branch", false, MercurialPreferenceConstants.PREF_PUSH_NEW_BRANCH),
LISTFILE (new Version(1,8,0), "listfile:", false),
INSECURE (new Version(1,7,5), "--insecure", false);
private final Version required;
private final String[] optionalPreferenceKeys;
private boolean enabled;
private final String cmd;
private final boolean mandatory;
private HgFeatures(Version required, String cmd, boolean mandatory, String ... optionalPreferenceKeys) {
this.required = required;
this.cmd = cmd;
this.mandatory = mandatory;
this.optionalPreferenceKeys = optionalPreferenceKeys;
}
@Override
public String toString() {
return getHgCmd() + (isEnabled() ? "(enabled)" : "(disabled)") + ", requires "
+ getRequired() + " hg version";
}
/**
* @return true if this is a mandatory command and there is no chance to
* workaround the absence of the required mercurial version
*/
public boolean isMandatory() {
return mandatory;
}
public String getHgCmd() {
return cmd;
}
/**
* @return the (smallest) required version, never null
*/
public Version getRequired() {
return required;
}
public void applyTo(IPreferenceStore store) {
for (String key : optionalPreferenceKeys) {
store.setDefault(key, enabled);
if(!enabled) {
store.setValue(key, false);
}
}
}
/**
* @param enabled true if the option should be enabled
*/
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
/**
* Note that the right enablement state will be set some time after plugin startup, so that in a
* short time between plugin activation and {@link MercurialEclipsePlugin#checkHgInstallation()}
* features might be not yet initialized properly. Initially all features are disabled.
*
* @return true if the option is enabled (supported by mercurial)
*/
public boolean isEnabled() {
return enabled;
}
/**
* @param current observed mercurial version
*/
public static void setToVersion(Version current) {
HgFeatures[] values = HgFeatures.values();
for (HgFeatures feature : values) {
feature.setEnabled(doCompare(feature.getRequired(), current)<= 0);
}
}
/**
* @param current
* observed mercurial version
* @return true if mandatory options are satisfied with given version, false if at
* least one requires greater mercurial version
*/
public static boolean isSupported(Version current) {
HgFeatures[] values = HgFeatures.values();
boolean result = true;
for (HgFeatures feature : values) {
if(!feature.isMandatory()) {
continue;
}
result &= doCompare(feature.getRequired(), current)<= 0;
}
return result;
}
/**
* @param current
* observed mercurial version
* @return true if all features are satisfied with given version, false if at
* least one requires greater mercurial version
*/
public static boolean isHappyWith(Version current) {
HgFeatures[] values = HgFeatures.values();
boolean result = true;
for (HgFeatures feature : values) {
result &= doCompare(feature.getRequired(), current)<= 0;
}
return result;
}
public static void applyAllTo(IPreferenceStore store) {
HgFeatures[] values = HgFeatures.values();
for (HgFeatures feature : values) {
feature.applyTo(store);
}
}
public static Version getPreferredVersion() {
return Collections.max(Arrays.asList(HgFeatures.values()), new Comparator() {
public int compare(HgFeatures o1, HgFeatures o2) {
return doCompare(o1.getRequired(), o2.getRequired());
}
}).getRequired();
}
public static Version getLowestWorkingVersion() {
return Collections.min(Arrays.asList(HgFeatures.values()), new Comparator() {
public int compare(HgFeatures o1, HgFeatures o2) {
if(o1.isMandatory() && !o2.isMandatory()) {
return -1;
} else if(!o1.isMandatory() && o2.isMandatory()){
return 1;
}
return doCompare(o1.getRequired(), o2.getRequired());
}
}).getRequired();
}
public static String printSummary() {
StringBuilder sb = new StringBuilder();
HgFeatures[] values = HgFeatures.values();
for (HgFeatures feature : values) {
sb.append(feature.toString()).append("\n");
}
return sb.toString();
}
/**
* Support comparing versions without requiring a particular version of OSGi.
*
* See: http://computerfloss.com/2011/11/a-little-problem-in-the-osgi-version-class/
*
* Remove after Eclipse 3.6 is not supported.
*
* @param v1 The left version
* @param v2 The right version
* @return The result of left.compareTo(right)
* @see Version#compareTo(Version)
* @see Version#compareTo(Object)
*/
protected static int doCompare(Version v1, Version v2) {
Class versionClass = Version.class;
Method compareToMethod = null;
try {
// Works on Eclipse 3.7
compareToMethod = versionClass.getMethod("compareTo", Version.class);
} catch (NoSuchMethodException e1) {
// "We're on Eclipse 3.6 or earlier. Fall back compareTo(Object).";
try {
// Works on Eclipse 3.6 and earlier
compareToMethod = versionClass.getMethod("compareTo", Object.class);
} catch (NoSuchMethodException e2) {
MercurialEclipsePlugin.logError("Unexpected error: cannot find compareTo() in Version", e2);
return 0;
}
}
try {
return ((Integer)compareToMethod.invoke(v1, v2)).intValue();
} catch (IllegalArgumentException e) {
MercurialEclipsePlugin.logError("Unexpected error: comparing version", e);
} catch (IllegalAccessException e) {
MercurialEclipsePlugin.logError("Unexpected error: comparing version", e);
} catch (InvocationTargetException e) {
MercurialEclipsePlugin.logError("Unexpected error: comparing version", e);
}
return 0;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/HgRevision.java 0000664 0000000 0000000 00000003137 11737135005 0031314 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
public class HgRevision {
public static final HgRevision TIP = new HgRevision("tip"); //$NON-NLS-1$
private final String changeset;
private final int revision;
protected HgRevision(String changeset) {
this(changeset, -1);
}
public HgRevision(String changeset, int revision) {
this.changeset = changeset;
this.revision = revision;
}
public String getChangeset() {
return changeset;
}
public int getRevision() {
return revision;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof HgRevision) {
HgRevision r = (HgRevision) obj;
return r.revision == revision || r.changeset.equals(changeset);
}
return false;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return changeset.hashCode();
}
@Override
public String toString() {
return revision + ":" + changeset; //$NON-NLS-1$
}
public static HgRevision parse(String s) {
int i = s.indexOf(':');
return new HgRevision(s.substring(i + 1), Integer.parseInt(s.substring(
0, i)));
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/MercurialEclipsePlugin.java 0000664 0000000 0000000 00000054557 11737135005 0033662 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* VecTrace (Zingo Andersen) - implementation
* Stefan Groschupf - logError
* Jérôme Nègre - some fixes
* Stefan C - Code cleanup
* Andrei Loskutov - bug fixes
* Zsolt Koppany (Intland)
* Adam Berkes (Intland) - default encoding
* Philip Graf - proxy support
* Bastian Doetsch - bug fixes and implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import java.lang.reflect.InvocationTargetException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.DecorationOverlayIcon;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.statushandlers.StatusManager;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Version;
import org.osgi.util.tracker.ServiceTracker;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgClients;
import com.vectrace.MercurialEclipse.commands.HgDebugInstallClient;
import com.vectrace.MercurialEclipse.commands.RootlessHgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.storage.HgCommitMessageManager;
import com.vectrace.MercurialEclipse.storage.HgRepositoryLocationManager;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.utils.StringUtils;
import com.vectrace.MercurialEclipse.views.console.HgConsoleHolder;
/**
* The main plugin class to be used in the desktop.
*/
public class MercurialEclipsePlugin extends AbstractUIPlugin {
public static final String ID = "com.vectrace.MercurialEclipse"; //$NON-NLS-1$
public static final String ID_CHANGELOG_VIEW = "com.vectrace.MercurialEclipse.views.ChangeLogView"; //$NON-NLS-1$
public static final String BUNDLE_FILE_PREFIX = "bundlefile"; //$NON-NLS-1$
// The shared instance.
private static MercurialEclipsePlugin plugin;
private static final String HGENCODING;
static {
// next in line is HGENCODING in environment
String enc = System.getProperty("HGENCODING");
// next is platform encoding as available in JDK
if (!StringUtils.isEmpty(enc) && Charset.isSupported(enc)) {
HGENCODING = enc;
} else {
if(Charset.isSupported("UTF-8")){
HGENCODING = Charset.forName("UTF-8").name();
} else {
HGENCODING = Charset.defaultCharset().name();
}
}
}
// the repository manager
private static HgRepositoryLocationManager repoManager = new HgRepositoryLocationManager();
// the commit message manager
private static HgCommitMessageManager commitMessageManager = new HgCommitMessageManager();
private boolean hgUsable = true;
private ServiceTracker proxyServiceTracker;
/** Observed hg version */
public /*final*/ Version hgVersion = Version.emptyVersion;
private static final Pattern VERSION_PATTERN = Pattern.compile(".*version\\s+(\\d(\\.\\d)+)+.*", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$
public MercurialEclipsePlugin() {
// should NOT do anything until started by OSGI
}
/**
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
@Override
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
DefaultConfiguration cfg = new DefaultConfiguration();
HgClients.initialize(cfg, cfg, cfg);
proxyServiceTracker = new ServiceTracker(context, IProxyService.class.getName(), null);
proxyServiceTracker.open();
final Job job = new Job(Messages.getString("MercurialEclipsePlugin.startingMercurialEclipse")) { //$NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
monitor.beginTask(Messages
.getString("MercurialEclipsePlugin.startingMercurialEclipse"), 3); //$NON-NLS-1$
monitor.subTask(Messages
.getString("MercurialEclipsePlugin.checkingMercurialInstallation")); //$NON-NLS-1$
checkHgInstallation();
monitor.worked(1);
// read known repositories
monitor.subTask(Messages
.getString("MercurialEclipsePlugin.loadingKnownMercurialRepositories")); //$NON-NLS-1$
repoManager.start();
monitor.worked(1);
// read in commit messages from disk
monitor.subTask(Messages
.getString("MercurialEclipsePlugin.startingCommitMessageManager")); //$NON-NLS-1$
commitMessageManager.start();
monitor.worked(1);
monitor.done();
return new Status(IStatus.OK, ID, Messages
.getString("MercurialEclipsePlugin.startedSuccessfully")); //$NON-NLS-1$
} catch (Throwable e) {
hgUsable = false;
logError(Messages.getString("MercurialEclipsePlugin.unableToStart"), e); //$NON-NLS-1$
return new Status(IStatus.ERROR, ID, e.getLocalizedMessage(), e);
}
finally {
// show console on startup if configured
if (getPreferenceStore().getBoolean(
MercurialPreferenceConstants.PREF_CONSOLE_SHOW_ON_STARTUP)) {
// open console in SWT GUI Thread
new SafeUiJob(
Messages.getString("MercurialEclipsePlugin.openingMercurialConsole")) { //$NON-NLS-1$
@Override
protected IStatus runSafe(IProgressMonitor monitor2) {
HgConsoleHolder.getInstance().showConsole(true);
return super.runSafe(monitor2);
}
}.schedule();
}
}
}
};
job.setPriority(Job.SHORT);
job.schedule();
// Image registry must be initialized. See first stack trace in http://www.javaforge.com/issue/14327
// Why JFaceResources wasn't initialized I don't know.
/*new SafeUiJob(Messages.getString("MercurialEclipsePlugin.startingMercurialEclipse")) {
@Override
protected IStatus runSafe(IProgressMonitor monitor) {
try {
getImageRegistry();
} finally {
job.schedule();
}
return super.runSafe(monitor);
}
}.schedule();*/
}
/**
* Checks if Mercurial is configured properly by issuing the hg debuginstall command.
*/
public void checkHgInstallation() {
try {
hgUsable = true;
MercurialUtilities.getHGExecutable(true);
String result = HgDebugInstallClient.debugInstall();
hgVersion = checkHgVersion();
if (!result.endsWith("No problems detected")) { //$NON-NLS-1$
logInfo(result, null);
}
} catch (Throwable e) {
hgUsable = false;
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
hgVersion = Version.emptyVersion;
} finally {
AbstractShellCommand.hgInitDone();
if(isDebugging()) {
System.out.println(HgFeatures.printSummary());
}
}
}
/**
* Plugin depends on native mercurial installation, which has to be checked at plugin startup.
* Note that the right plugin state will be set only some time after plugin startup, so that in
* a short time between plugin activation and
* {@link MercurialEclipsePlugin#checkHgInstallation()} call plugin state might be not yet
* initialized properly.
*
* @return true if we have already tried to identify mercurial version (independently if the
* check fails or not), false if plugin is still not yet initialized properly
*/
public static boolean isVersionCheckDone() {
MercurialEclipsePlugin mep = MercurialEclipsePlugin.getDefault();
return !mep.isHgUsable() || !mep.getHgVersion().equals(Version.emptyVersion);
}
private Version checkHgVersion() throws HgException {
AbstractShellCommand command = new RootlessHgCommand("version", "Checking for required version") {
{
isInitialCommand = startSignal.getCount() > 0;
}
};
Version preferredVersion = HgFeatures.getPreferredVersion();
String version = new String(command.executeToBytes(Integer.MAX_VALUE)).trim();
String[] split = version.split("\\n"); //$NON-NLS-1$
version = split.length > 0 ? split[0] : ""; //$NON-NLS-1$
Matcher matcher = VERSION_PATTERN.matcher(version);
boolean failedToParse = !matcher.matches() || matcher.groupCount() <= 0
|| (version = matcher.group(1)) == null;
if (failedToParse) {
HgFeatures.setToVersion(preferredVersion);
HgFeatures.applyAllTo(getPreferenceStore());
logWarning("Can't uderstand Mercurial version string: '" + version
+ "'. Assume that at least " + preferredVersion + " is available.", null);
return preferredVersion;
}
Version detectedVersion = new Version(version);
HgFeatures.setToVersion(detectedVersion);
HgFeatures.applyAllTo(getPreferenceStore());
if (!HgFeatures.isSupported(detectedVersion)) {
throw new HgException(Messages.getString("MercurialEclipsePlugin.unsupportedHgVersion") //$NON-NLS-1$
+ version + Messages.getString("MercurialEclipsePlugin.expectedAtLeast") //$NON-NLS-1$
+ HgFeatures.getLowestWorkingVersion() + "."); //$NON-NLS-1$
}
if (!HgFeatures.isHappyWith(detectedVersion)) {
logWarning("Can not use some of the new Mercurial features, "
+ "hg version greater equals " + preferredVersion + " required, but "
+ detectedVersion + " found. Features state:\n" + HgFeatures.printSummary() + ".",
null);
}
return detectedVersion;
}
/**
* @return the observer hg version, never null. Returns {@link Version#emptyVersion} in case the
* hg version is either not detected yet or can't be parsed properly
*/
public Version getHgVersion() {
return hgVersion;
}
/**
* Gets the repository manager
*/
public static HgRepositoryLocationManager getRepoManager() {
return repoManager;
}
public static HgCommitMessageManager getCommitMessageManager() {
return commitMessageManager;
}
@Override
public void stop(BundleContext context) throws Exception {
try {
repoManager.stop();
// save commit messages to disk
commitMessageManager.stop();
proxyServiceTracker.close();
MercurialUtilities.disposeColorsAndFonts();
} finally {
super.stop(context);
}
}
/**
* Returns the shared instance.
*/
public static MercurialEclipsePlugin getDefault() {
return plugin;
}
/**
* Returns an image descriptor for the image file at the given plug-in relative path.
*
* @param path
* the path
* @return the image descriptor
*/
public static ImageDescriptor getImageDescriptor(String path) {
ImageDescriptor descriptor = getDefault().getImageRegistry().getDescriptor(path);
if (descriptor == null) {
descriptor = AbstractUIPlugin.imageDescriptorFromPlugin(ID, "icons/" + path); //$NON-NLS-1$
getDefault().getImageRegistry().put(path, descriptor);
}
return descriptor;
}
/**
* Returns an image at the given plug-in relative path.
*
* @param path
* the path
* @return the image
*/
public static Image getImage(String path) {
// make sure descriptor is created
getImageDescriptor(path);
return getDefault().getImageRegistry().get(path);
}
/**
* Returns an image with overlay at given place at the given plug-in relative path.
*
* @param basePath
* the base image plug-in relative path.
* @param overlayPath
* the overlay image plug-in relative path.
* @param quadrant
* the quadrant (one of {@link IDecoration} ({@link IDecoration#TOP_LEFT},
* {@link IDecoration#TOP_RIGHT}, {@link IDecoration#BOTTOM_LEFT},
* {@link IDecoration#BOTTOM_RIGHT} or {@link IDecoration#UNDERLAY})
* @return the image
*/
public static Image getImage(String basePath, String overlayPath, int quadrant) {
getImageDescriptor(basePath, overlayPath, quadrant);
return getDefault().getImageRegistry().get(basePath + overlayPath + quadrant);
}
/**
* Returns an image with overlay at given place at the given plug-in relative path.
*
* @param basePath
* the base image plug-in relative path.
* @param overlayPath
* the overlay image plug-in relative path.
* @param quadrant
* the quadrant (one of {@link IDecoration} ({@link IDecoration#TOP_LEFT},
* {@link IDecoration#TOP_RIGHT}, {@link IDecoration#BOTTOM_LEFT},
* {@link IDecoration#BOTTOM_RIGHT} or {@link IDecoration#UNDERLAY})
* @return the image
*/
public static ImageDescriptor getImageDescriptor(String basePath, String overlayPath, int quadrant) {
String key = basePath + overlayPath + quadrant;
ImageDescriptor descriptor = getDefault().getImageRegistry().getDescriptor(key);
if(descriptor == null) {
Image base = getImage(basePath);
ImageDescriptor overlay = getImageDescriptor(overlayPath);
descriptor = new DecorationOverlayIcon(base, overlay, quadrant);
getDefault().getImageRegistry().put(key, descriptor);
}
return descriptor;
}
public static final void logError(String message, Throwable error) {
getDefault().getLog().log(createStatus(message, 0, IStatus.ERROR, error));
}
public static void showError(final Throwable error) {
new ErrorJob(error).schedule(100);
}
public static final void logWarning(String message, Throwable error) {
getDefault().getLog().log(createStatus(message, 0, IStatus.WARNING, error));
}
public static final void logInfo(String message, Throwable error) {
getDefault().getLog().log(createStatus(message, 0, IStatus.INFO, error));
}
public static IStatus createStatus(String msg, int code, int severity, Throwable ex) {
return new Status(severity, ID, code, msg, ex);
}
public static final void logError(Throwable ex) {
logError(ex.getMessage(), ex);
}
/**
* Creates a busy cursor and runs the specified runnable. May be called from a non-UI thread.
*
* @param parent
* the parent Shell for the dialog
* @param cancelable
* if true, the dialog will support cancelation
* @param runnable
* the runnable
*
* @exception InvocationTargetException
* when an exception is thrown from the runnable
* @exception InterruptedException
* when the progress monitor is cancelled
*/
public static void runWithProgress(Shell parent, boolean cancelable,
final IRunnableWithProgress runnable) throws InvocationTargetException,
InterruptedException {
boolean createdShell = false;
Shell myParent = parent;
try {
if (myParent == null || myParent.isDisposed()) {
Display display = Display.getCurrent();
if (display == null) {
// cannot provide progress (not in UI thread)
runnable.run(new NullProgressMonitor());
return;
}
// get the active shell or a suitable top-level shell
myParent = display.getActiveShell();
if (myParent == null) {
myParent = new Shell(display);
createdShell = true;
}
}
// pop up progress dialog after a short delay
final Exception[] holder = new Exception[1];
BusyIndicator.showWhile(myParent.getDisplay(), new Runnable() {
public void run() {
try {
runnable.run(new NullProgressMonitor());
} catch (InvocationTargetException e) {
holder[0] = e;
} catch (InterruptedException e) {
holder[0] = e;
}
}
});
if (holder[0] != null) {
if (holder[0] instanceof InvocationTargetException) {
throw (InvocationTargetException) holder[0];
}
throw (InterruptedException) holder[0];
}
// new TimeoutProgressMonitorDialog(parent, TIMEOUT).run(true
// /*fork*/, cancelable, runnable);
} finally {
if (createdShell) {
parent.dispose();
}
}
}
/**
* Convenience method to get the currently active workbench page. Note that the active page may
* not be the one that the usr perceives as active in some situations so this method of
* obtaining the activae page should only be used if no other method is available.
*
* @return the active workbench page
*/
public static IWorkbenchPage getActivePage() {
return getActiveWindow().getActivePage();
}
/**
* Convenience method to get the currently active shell.
*
* @return the active workbench shell. Never null, if there is at least one window open.
*/
public static Shell getActiveShell() {
return getActiveWindow().getShell();
}
/**
* Convenience method to get the currently active workbench window.
*
* @return the active workbench window. Never null, if there is at least one window open.
*/
public static IWorkbenchWindow getActiveWindow() {
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window != null) {
return window;
}
return PlatformUI.getWorkbench().getWorkbenchWindows()[0];
}
public boolean isHgUsable() {
return hgUsable;
}
public static Display getStandardDisplay() {
return PlatformUI.getWorkbench().getDisplay();
}
public IProxyService getProxyService() {
return (IProxyService) proxyServiceTracker.getService();
}
/**
* Show a dialog only if the user hasn't selected "don't show again" for it.
*
* @param title The title
* @param message The message
* @param type The type, for example MessageDialog.CONFIRM
* @param key The preference key
* @param shell The shell to use
* @return True of ok was pressed
*/
public static boolean showDontShowAgainConfirmDialog(final String title,
final String message, int type, String key, Shell shell) {
IPreferenceStore store = getDefault().getPreferenceStore();
String pref = store.getString(key);
if (MessageDialogWithToggle.PROMPT.equals(pref)) {
String toggleMessage = Messages.getString("Dialogs.DontShowAgain");
MessageDialogWithToggle confirmDialog = MessageDialogWithToggle.open(type, shell, title, message, toggleMessage, false, store, key, SWT.NONE);
int returnCode = confirmDialog.getReturnCode();
return returnCode == Window.OK;
}
return true;
}
/**
* The default encoding which is used by the current environment.
*
* Note: you probably want use {@link HgRoot#getEncoding()} instead, as each repository
* may use it's own encoding
*
* Note: Python's encoding isn't 1-1 with Charset.name() so do not store
* {@link java.nio.charset.Charset}.
*
* @return a valid encoding name, never null.
*/
public static String getDefaultEncoding() {
return HGENCODING;
}
/**
* Job to show error dialogs. Avoids to show hunderts of dialogs by ussing an exclusive rule.
*
* @author Andrei
*/
private static final class ErrorJob extends SafeUiJob {
static class ExclusiveRule implements ISchedulingRule {
public boolean isConflicting(ISchedulingRule rule) {
return contains(rule);
}
public boolean contains(ISchedulingRule rule) {
return rule instanceof ExclusiveRule;
}
}
final IStatus status;
private ErrorJob(Throwable error) {
super(Messages.getString("MercurialEclipsePlugin.showError")); //$NON-NLS-1$
if (error instanceof CoreException) {
status = ((CoreException) error).getStatus();
} else {
status = createStatus(error.getMessage(), 0, IStatus.ERROR, error);
}
setRule(new ExclusiveRule());
}
@Override
protected IStatus runSafe(IProgressMonitor monitor) {
IJobManager jobManager = Job.getJobManager();
String title;
IStatus errStatus;
if (jobManager.find(plugin).length == 1) {
// it's me alone there
errStatus = status;
} else {
// o-ho, we have multiple errors waiting to be displayed...
title = Messages.getString("MercurialEclipsePlugin.unexpectedErrors"); //$NON-NLS-1$
String message = Messages
.getString("MercurialEclipsePlugin.unexpectedErrorsOccured"); //$NON-NLS-1$
// get the latest state
Job[] jobs = jobManager.find(plugin);
// discard all waiting now (we are not affected)
jobManager.cancel(plugin);
List stati = new ArrayList();
for (Job job : jobs) {
if (job instanceof ErrorJob) {
ErrorJob errorJob = (ErrorJob) job;
stati.add(errorJob.status);
}
}
IStatus[] array = stati.toArray(new IStatus[stati.size()]);
errStatus = new MultiStatus(title, 0, array, message, null);
}
StatusManager.getManager().handle(errStatus, StatusManager.SHOW);
return super.runSafe(monitor);
}
@Override
public boolean belongsTo(Object family) {
return plugin == family;
}
}
/**
* Find the object associated with the given object that is adapted to
* the provided class.
*
* @param anyObject might be null
* @param clazz class to get the adapter for
* @return adapted object or null if no adapter provided or the given object is null
*/
public static V getAdapter(Object anyObject, Class clazz) {
if (clazz.isInstance(anyObject)) {
return clazz.cast(anyObject);
}
if (anyObject instanceof IAdaptable) {
IAdaptable a = (IAdaptable) anyObject;
return clazz.cast(a.getAdapter(clazz));
}
return null;
}
/**
* Unwrap and throw as a CoreException. Note: Never returns
* @param e The exception to use
* @throws CoreException
*/
public static void rethrow(Throwable e) throws CoreException {
if (e instanceof CoreException) {
throw (CoreException)e;
} else if (e instanceof InvocationTargetException) {
rethrow(((InvocationTargetException) e).getTargetException());
}
throw new HgException(e.getLocalizedMessage(), e);
}
} eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/Messages.java 0000664 0000000 0000000 00000002107 11737135005 0031002 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* @author bastian
*
*/
public final class Messages {
private static final String BUNDLE_NAME = "com.vectrace.MercurialEclipse.messages"; //$NON-NLS-1$
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
private Messages() {
}
public static String getString(String key) {
try {
return RESOURCE_BUNDLE.getString(key);
} catch (MissingResourceException e) {
return '!' + key + '!';
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/SafeUiJob.java 0000664 0000000 0000000 00000002552 11737135005 0031046 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2007-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* StefanC - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.progress.UIJob;
public class SafeUiJob extends UIJob {
/**
* @param name
*/
public SafeUiJob(String name) {
super(name);
}
/**
* @param jobDisplay
* @param name
*/
public SafeUiJob(Display jobDisplay, String name) {
super(jobDisplay, name);
}
@Override
public final IStatus runInUIThread(IProgressMonitor monitor) {
try {
return runSafe(monitor);
} catch (RuntimeException error) {
MercurialEclipsePlugin.logError(error);
return Status.CANCEL_STATUS;
}
}
/**
* @param monitor
* @return
*/
protected IStatus runSafe(IProgressMonitor monitor) {
return Status.OK_STATUS;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/SafeWorkspaceJob.java 0000664 0000000 0000000 00000002761 11737135005 0032431 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2007-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* StefanC - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
/**
* @author StefanC
*
*/
public class SafeWorkspaceJob extends WorkspaceJob {
/**
* @param name
*/
public SafeWorkspaceJob(String name) {
super(name);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.resources.WorkspaceJob#runInWorkspace(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public IStatus runInWorkspace(IProgressMonitor monitor)
throws CoreException {
try {
return runSafe(monitor);
} catch (RuntimeException ex) {
handleException(ex);
return Status.CANCEL_STATUS;
}
}
/**
* @return
*/
protected IStatus runSafe(IProgressMonitor monitor) {
return Status.OK_STATUS;
}
protected void handleException(Throwable ex) {
MercurialEclipsePlugin.logError(ex);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/TableColumnSorter.java 0000664 0000000 0000000 00000006742 11737135005 0032650 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) See next comment
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan C - Copy code
*******************************************************************************/
/*******************************************************************************
* TableViewerSorting Example
*
* Adam Cabler
*
* revised example by Tom Schindl
* http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jface.snippets/Eclipse%20JFace%20Snippets/org/eclipse/jface/snippets/viewers/Snippet040TableViewerSorting.java?view=markup
*
* removed ColumnViewer references
* added ITableLabelProvider
* used label provider for text compare
*
* minor change by Stefan Chysser
* - only cycle between ASC and DESC, the go-back to None is confusing
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
*
*******************************************************************************/
package com.vectrace.MercurialEclipse;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.TableColumn;
public abstract class TableColumnSorter extends ViewerComparator {
public static final int ASC = 1;
public static final int NONE = 0;
public static final int DESC = -1;
private int direction;
private final TableColumn column;
private final TableViewer viewer;
public TableColumnSorter(TableViewer viewer, TableColumn column) {
this.column = column;
this.viewer = viewer;
this.column.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (TableColumnSorter.this.viewer.getComparator() != null) {
if (TableColumnSorter.this.viewer.getComparator() == TableColumnSorter.this) {
int tdirection = TableColumnSorter.this.direction;
if (tdirection == ASC) {
setSorter(TableColumnSorter.this, DESC);
} else if (tdirection == DESC) {
setSorter(TableColumnSorter.this, ASC);
}
} else {
setSorter(TableColumnSorter.this, ASC);
}
} else {
setSorter(TableColumnSorter.this, ASC);
}
}
});
}
public void setSorter(TableColumnSorter sorter, int direction) {
if (direction == NONE) {
column.getParent().setSortColumn(null);
column.getParent().setSortDirection(SWT.NONE);
viewer.setComparator(null);
} else {
column.getParent().setSortColumn(column);
sorter.direction = direction;
if (direction == ASC) {
column.getParent().setSortDirection(SWT.DOWN);
} else {
column.getParent().setSortDirection(SWT.UP);
}
if (viewer.getComparator() == sorter) {
viewer.refresh();
} else {
viewer.setComparator(sorter);
}
}
}
@Override
public int compare(Viewer cViewer, Object e1, Object e2) {
return direction * doCompare(cViewer, e1, e2);
}
protected abstract int doCompare(Viewer tableViewer, Object e1, Object e2);
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions/ 0000775 0000000 0000000 00000000000 11737135005 0030030 5 ustar 00root root 0000000 0000000 AddToWorkspaceAction.java 0000664 0000000 0000000 00000011767 11737135005 0034640 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2006-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - Implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.HgCloneClient;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.storage.HgRepositoryLocationManager;
import com.vectrace.MercurialEclipse.team.MercurialProjectSetCapability;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
/**
* This action adds projects to the workspace using their unique Mercurial
* reference strings from projectsets
*
* @author Bastian Doetsch
*/
public class AddToWorkspaceAction extends WorkspaceModifyOperation {
private String[] referenceStrings;
private IProject[] projectsCreated;
public AddToWorkspaceAction() {
super();
}
public AddToWorkspaceAction(ISchedulingRule rule) {
super(rule);
}
@Override
protected void execute(IProgressMonitor monitor) throws CoreException,
InvocationTargetException, InterruptedException {
try {
monitor.beginTask("Adding projects to workspace...", referenceStrings.length);
IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
ArrayList projects = new ArrayList(referenceStrings.length);
/*
* iterate over all reference strings and use them to create
* projects in the current workspace.
*
* A reference string uses underscore as delimiter and looks like
* this:
*
* "MercurialEclipseProjectSet|ProjectName|RepositoryURLForClone"
*
*/
for (String reference : referenceStrings) {
if (monitor.isCanceled()) {
break;
}
MercurialProjectSetCapability psc = MercurialProjectSetCapability.getInstance();
// Project name is stored in part 1
String projectName = psc.getProject(reference);
IProject proj = wsRoot.getProject(projectName);
// only new projects
if (proj.exists() || proj.getLocation() != null) {
MercurialEclipsePlugin.logInfo("Project" + proj.getName()
+ " not imported. Already exists.", null);
monitor.worked(1);
continue;
}
String rootRelativePath = psc.getRootRelativePath(reference);
if(rootRelativePath != null){
MercurialEclipsePlugin.logInfo("Project" + proj.getName()
+ " not imported, as it was only a part of the hg repo.", null);
// TODO somehow allow to clone multiple projects from ONE hg root
break;
}
// Repository-URL is stored in part 2
HgRepositoryLocationManager repoManager = MercurialEclipsePlugin.getRepoManager();
IHgRepositoryLocation location = repoManager.getRepoLocation(psc
.getPullRepo(reference), null, null);
HgCloneClient.clone(wsRoot.getLocation().toFile(), location, false, false, false,
false, null, projectName);
proj.create(monitor);
proj.open(monitor);
// Register the project with Team.
RepositoryProvider.map(proj, MercurialTeamProvider.class.getName());
RepositoryProvider.getProvider(proj, MercurialTeamProvider.class.getName());
projects.add(proj);
HgRoot hgRoot = MercurialTeamProvider.getHgRoot(proj);
if (hgRoot != null) {
// store repo (will be set as default automatically)
repoManager.addRepoLocation(hgRoot, location);
}
// refresh project to get decorations
proj.refreshLocal(IResource.DEPTH_INFINITE, monitor);
// increase monitor so we see at least a bit of a progress when
// importing multiple projects
monitor.worked(1);
}
projectsCreated = projects.toArray(new IProject[projects.size()]);
} finally {
monitor.done();
}
}
public String[] getReferenceStrings() {
return referenceStrings;
}
public void setReferenceStrings(String[] referenceStrings) {
this.referenceStrings = referenceStrings;
}
public IProject[] getProjectsCreated() {
return projectsCreated;
}
public void setProjectsCreated(IProject[] projectsCreated) {
this.projectsCreated = projectsCreated;
}
}
CompareWithCurrentDelegate.java 0000664 0000000 0000000 00000005464 11737135005 0036045 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Ilya Ivanov implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.FileFromChangeSet;
import com.vectrace.MercurialEclipse.team.MercurialRevisionStorage;
import com.vectrace.MercurialEclipse.utils.CompareUtils;
/**
* This delegate is used for object contribution to context menus.
* Object class must be FileFromChangeSet or be adaptable to it.
*/
public class CompareWithCurrentDelegate implements IObjectActionDelegate {
private FileFromChangeSet fileFromChangeSet;
public void run(IAction action) {
if (fileFromChangeSet == null) {
return;
}
ChangeSet cs = fileFromChangeSet.getChangeset();
MercurialRevisionStorage left = new MercurialRevisionStorage(fileFromChangeSet.getFile());
// TODO handle cases when file was renamed/copied
// see com.vectrace.MercurialEclipse.history.CompareRevisionAction.getStorage()
MercurialRevisionStorage right = new MercurialRevisionStorage(fileFromChangeSet.getFile(), cs.getChangeset());
CompareUtils.openEditor(left, right, false);
}
/**
* @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
*/
public void selectionChanged(IAction action, ISelection newSelection) {
action.setEnabled(false);
if (newSelection instanceof IStructuredSelection) {
IStructuredSelection sel = (IStructuredSelection) newSelection;
if (sel.getFirstElement() instanceof FileFromChangeSet) {
this.fileFromChangeSet = (FileFromChangeSet) sel.getFirstElement();
int diffKind = fileFromChangeSet.getDiffKind();
if ((diffKind & Differencer.CHANGE_TYPE_MASK) != Differencer.DELETION
&& fileFromChangeSet.getFile().exists()) {
action.setEnabled(true);
}
}
} else {
this.fileFromChangeSet = null;
}
}
/**
* @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
*/
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
}
}
CompareWithParentDelegate.java 0000664 0000000 0000000 00000005760 11737135005 0035653 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Ilya Ivanov implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.FileFromChangeSet;
import com.vectrace.MercurialEclipse.team.MercurialRevisionStorage;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.utils.CompareUtils;
/**
* This delegate is used for object contribution to context menus.
* Object class must be FileFromChangeSet or be adaptable to it.
*/
public class CompareWithParentDelegate implements IObjectActionDelegate {
private FileFromChangeSet fileFromChangeSet;
public void run(IAction action) {
if (fileFromChangeSet == null) {
return;
}
ChangeSet cs = fileFromChangeSet.getChangeset();
MercurialRevisionStorage left = new MercurialRevisionStorage(fileFromChangeSet.getFile(), cs.getChangeset());
try {
MercurialRevisionStorage right = MercurialUtilities.getParentRevision(cs, fileFromChangeSet.getFile());
CompareUtils.openEditor(left, right, false);
} catch (HgException e) {
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
}
}
/**
* @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
*/
public void selectionChanged(IAction action, ISelection newSelection) {
action.setEnabled(false);
if (newSelection instanceof IStructuredSelection) {
IStructuredSelection sel = (IStructuredSelection) newSelection;
if (sel.getFirstElement() instanceof FileFromChangeSet) {
this.fileFromChangeSet = (FileFromChangeSet) sel.getFirstElement();
int diffKind = fileFromChangeSet.getDiffKind();
if ((diffKind & Differencer.CHANGE_TYPE_MASK) != Differencer.CHANGE) {
// parent or child is not available
} else {
action.setEnabled(true);
}
}
} else {
this.fileFromChangeSet = null;
}
}
/**
* @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
*/
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
}
}
ExportAsBundleAction.java 0000664 0000000 0000000 00000012445 11737135005 0034657 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.HgBundleClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.history.MercurialHistoryPage;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
/**
* @author Bastian
*/
public class ExportAsBundleAction extends Action {
private final class ExportBundleJob extends Job {
private final MercurialRevision rev;
private ExportBundleJob(String name, MercurialRevision rev) {
super(name);
this.rev = rev;
}
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
monitor
.beginTask(
Messages.getString("ExportAsBundleAction.exportingRevision") + rev.getContentIdentifier() //$NON-NLS-1$
+ Messages.getString("ExportAsBundleAction.toBundle"), 3); //$NON-NLS-1$
monitor.subTask(Messages
.getString("ExportAsBundleAction.determiningRepositoryRoot")); //$NON-NLS-1$
HgRoot root = MercurialTeamProvider.getHgRoot(rev.getResource());
if(root == null) {
MercurialEclipsePlugin.logError(new IllegalStateException("Hg root not found for: " + rev));
return Status.CANCEL_STATUS;
}
monitor.worked(1);
monitor.subTask(Messages.getString("ExportAsBundleAction.callingMercurial")); //$NON-NLS-1$
determineFileAndBase();
if (file == null) {
// user cancel
monitor.setCanceled(true);
return Status.CANCEL_STATUS;
}
HgBundleClient.bundle(root, rev.getChangeSet(), null, file, false, base);
monitor.worked(1);
final String message = Messages.getString("ExportAsBundleAction.theRevision") //$NON-NLS-1$
+ rev.getContentIdentifier()
+ Messages
.getString("ExportAsBundleAction.andAllPreviousRevisionsHaveBeenExported") //$NON-NLS-1$
+ file;
showMessage(message);
} catch (HgException e) {
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
}
private final MercurialHistoryPage mhp;
private String file;
private String base;
private static final ImageDescriptor IMAGE_DESC = MercurialEclipsePlugin
.getImageDescriptor("export.gif"); //$NON-NLS-1$
private void determineFileAndBase() {
final Display display = MercurialEclipsePlugin.getStandardDisplay();
display.syncExec(new Runnable() {
public void run() {
Shell shell = MercurialEclipsePlugin.getActiveShell();
FileDialog fileDialog = new FileDialog(shell);
fileDialog.setText(Messages
.getString("ExportAsBundleAction.pleaseEnterTheNameOfTheBundleFile")); //$NON-NLS-1$
file = fileDialog.open();
if(file == null){
// user cancel
return;
}
InputDialog d = new InputDialog(shell, "Please specify the base revision",
"Please specify the base revision e.g. 1333", "0", null);
d.open();
base = d.getValue();
}
});
}
private static void showMessage(final String message) {
final Display display = MercurialEclipsePlugin.getStandardDisplay();
display.asyncExec(new Runnable() {
public void run() {
MessageDialog.openInformation(null, Messages
.getString("ExportAsBundleAction.createdSuccessfully"), message); //$NON-NLS-1$
}
});
}
public ExportAsBundleAction(MercurialHistoryPage mhp) {
super(Messages.getString("ExportAsBundleAction.exportSelectedRevisionAsBundle"), IMAGE_DESC);
this.mhp = mhp;
}
@Override
public void run() {
final MercurialRevision rev = getRevision();
if (rev == null) {
return;
}
new ExportBundleJob(Messages.getString("ExportAsBundleAction.exportingRevision")
+ rev.getContentIdentifier() + Messages.getString("ExportAsBundleAction.toBundle"),
rev).schedule();
}
private MercurialRevision getRevision() {
MercurialRevision[] selectedRevisions = mhp.getSelectedRevisions();
if (selectedRevisions != null && selectedRevisions.length == 1) {
return selectedRevisions[0];
}
ChangeSet cs = mhp.getCurrentWorkdirChangeset();
return (MercurialRevision) mhp.getMercurialHistory().getFileRevision(cs.getChangeset());
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions/HgOperation.java 0000664 0000000 0000000 00000003100 11737135005 0033104 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2006-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Software Balm Consulting Inc (Peter Hunnisett ) - implementation
* VecTrace (Zingo Andersen) - some updates
* Stefan Groschupf - logError
* Stefan C - Code cleanup
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.team.ui.TeamOperation;
import org.eclipse.ui.IWorkbenchPart;
public abstract class HgOperation extends TeamOperation {
protected String result;
// constructors
public HgOperation(IWorkbenchPart part) {
super(part);
}
public HgOperation(IRunnableContext context) {
super(context);
}
public HgOperation(IWorkbenchPart part, IRunnableContext context) {
super(part, context);
}
// operations
public String getResult() {
return result;
}
// TODO: No background for now.
@Override
protected boolean canRunAsJob() {
return false;
}
@Override
protected String getJobName() {
return getActionDescription();
}
protected abstract String getActionDescription();
}
MergeWithCurrentChangesetAction.java 0000664 0000000 0000000 00000010546 11737135005 0037040 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.widgets.Shell;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.SafeUiJob;
import com.vectrace.MercurialEclipse.SafeWorkspaceJob;
import com.vectrace.MercurialEclipse.commands.HgStatusClient;
import com.vectrace.MercurialEclipse.history.MercurialHistoryPage;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.menu.MergeHandler;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
/**
* @author Bastian
*
*/
public class MergeWithCurrentChangesetAction extends Action {
private final MercurialHistoryPage mhp;
private static final ImageDescriptor IMAGE_DESC = MercurialEclipsePlugin
.getImageDescriptor("actions/merge.gif"); //$NON-NLS-1$
/**
*
*/
public MergeWithCurrentChangesetAction(MercurialHistoryPage mhp) {
super(Messages.getString("MergeWithCurrentChangesetAction.mergeSelectedChangesetWithCurrentChangeset"), IMAGE_DESC); //$NON-NLS-1$
this.mhp = mhp;
}
@Override
public void run() {
final MercurialRevision rev = getRevision();
new SafeWorkspaceJob(Messages.getString("MergeWithCurrentChangesetAction.0") + rev.getContentIdentifier() //$NON-NLS-1$
+ Messages.getString("MergeWithCurrentChangesetAction.1")) { //$NON-NLS-1$
@Override
protected org.eclipse.core.runtime.IStatus runSafe(
org.eclipse.core.runtime.IProgressMonitor monitor) {
try {
monitor.beginTask(Messages.getString("MergeWithCurrentChangesetAction.2") + rev.getContentIdentifier() //$NON-NLS-1$
+ Messages.getString("MergeWithCurrentChangesetAction.3"), 3); //$NON-NLS-1$
monitor.subTask(Messages.getString("MergeWithCurrentChangesetAction.4")); //$NON-NLS-1$
final HgRoot root = MercurialTeamProvider.getHgRoot(rev.getResource());
if(root == null) {
MercurialEclipsePlugin.logError(new IllegalStateException("Hg root not found for: " + rev));
return Status.CANCEL_STATUS;
}
monitor.worked(1);
monitor.subTask(Messages.getString("MergeWithCurrentChangesetAction.5")); //$NON-NLS-1$
new SafeUiJob("Merging...") { //$NON-NLS-1$
@Override
protected IStatus runSafe(IProgressMonitor m) {
Shell activeShell = getDisplay().getActiveShell();
try {
if (HgStatusClient.isDirty(root)) {
if (!MessageDialog
.openQuestion(activeShell,
Messages.getString("MergeWithCurrentChangesetAction.6"), //$NON-NLS-1$
Messages.getString("MergeWithCurrentChangesetAction.7"))) { //$NON-NLS-1$
return super.runSafe(m);
}
}
MergeHandler.mergeAndCommit(root, activeShell, m, true, rev
.getChangeSet(), true);
} catch (Exception e) {
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
}
return super.runSafe(m);
}
}.schedule();
} catch (Exception e) {
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
}
monitor.done();
return super.runSafe(monitor);
}
}.schedule();
super.run();
}
/**
* @return
*/
private MercurialRevision getRevision() {
MercurialRevision[] selectedRevisions = mhp.getSelectedRevisions();
if (selectedRevisions != null && selectedRevisions.length == 1) {
return selectedRevisions[0];
}
ChangeSet cs = mhp.getCurrentWorkdirChangeset();
return (MercurialRevision) mhp.getMercurialHistory().getFileRevision(cs.getChangeset());
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions/Messages.java 0000664 0000000 0000000 00000002127 11737135005 0032444 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* @author bastian
*
*/
public final class Messages {
private static final String BUNDLE_NAME = "com.vectrace.MercurialEclipse.actions.messages"; //$NON-NLS-1$
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
private Messages() {
}
public static String getString(String key) {
try {
return RESOURCE_BUNDLE.getString(key);
} catch (MissingResourceException e) {
return '!' + key + '!';
}
}
}
OpenCurrentVersionDelegate.java 0000664 0000000 0000000 00000004011 11737135005 0036055 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Ilya Ivanov implementation
* Andrei Loskutov - bugfixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import com.vectrace.MercurialEclipse.model.FileFromChangeSet;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* This delegate is used for object contribution to context menus.
* Object class must be FileFromChangeSet or be adaptable to it.
*/
public class OpenCurrentVersionDelegate implements IObjectActionDelegate {
private FileFromChangeSet fileFromChangeSet;
private IWorkbenchPart targetPart;
public void run(IAction action) {
ResourceUtils.openEditor(targetPart.getSite().getPage(), fileFromChangeSet.getFile());
}
public void selectionChanged(IAction action, ISelection newSelection) {
action.setEnabled(false);
if (newSelection instanceof IStructuredSelection) {
IStructuredSelection sel = (IStructuredSelection) newSelection;
if (sel.getFirstElement() instanceof FileFromChangeSet) {
this.fileFromChangeSet = (FileFromChangeSet) sel.getFirstElement();
IFile file = fileFromChangeSet.getFile();
if (file.exists()) {
action.setEnabled(true);
}
}
} else {
this.fileFromChangeSet = null;
}
}
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
this.targetPart = targetPart;
}
}
OpenMercurialRevisionAction.java 0000664 0000000 0000000 00000021377 11737135005 0036250 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2007-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* VecTrace (Zingo Andersen) - implementation
* Stefan Groschupf - logError
* Stefan C - Code cleanup
* Andrei Loskutov - bug fixes
*******************************************************************************/
/**
* Open an "old" revision in an editor from like "History" view.
*/
package com.vectrace.MercurialEclipse.actions;
import java.io.IOException;
import java.io.InputStream;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.content.IContentTypeManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.core.history.IFileRevision;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IPersistableElement;
import org.eclipse.ui.IStorageEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.BaseSelectionListenerAction;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.model.IWorkbenchAdapter;
import org.eclipse.ui.part.Page;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.SafeUiJob;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.team.MercurialRevisionStorage;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class OpenMercurialRevisionAction extends BaseSelectionListenerAction {
public static class MercurialRevisionEditorInput extends PlatformObject implements
IWorkbenchAdapter, IStorageEditorInput {
private final IFileRevision fileRevision;
private final MercurialRevisionStorage storage;
private final IEditorDescriptor descriptor;
private final String fileName;
public MercurialRevisionEditorInput(IFileRevision revision) {
this.fileRevision = revision;
MercurialRevisionStorage tmpStore = null;
try {
tmpStore = (MercurialRevisionStorage) revision.getStorage(new NullProgressMonitor());
} catch (CoreException e) {
MercurialEclipsePlugin.logError(e);
} finally {
storage = tmpStore;
}
if(storage != null){
IFile file = storage.getResource();
if(file != null){
fileName = file.getName();
} else {
fileName = storage.getName();
}
} else {
fileName = fileRevision.getName();
}
IEditorDescriptor tmpId = null;
try {
tmpId = initDescriptor();
} catch (CoreException e) {
MercurialEclipsePlugin.logError(e);
} finally {
descriptor = tmpId;
}
}
public Object[] getChildren(Object o) {
return new Object[0];
}
public ImageDescriptor getImageDescriptor(Object object) {
return descriptor.getImageDescriptor();
}
public String getLabel(Object o) {
if (storage != null) {
return storage.getName();
}
return fileRevision.getName();
}
public Object getParent(Object o) {
return null;
}
public IStorage getStorage() throws CoreException {
return storage;
}
public boolean exists() {
return true;
}
public ImageDescriptor getImageDescriptor() {
return descriptor.getImageDescriptor();
}
public String getName() {
return fileName;
}
public IPersistableElement getPersistable() {
return null; // Can to save editor changes
}
public String getToolTipText() {
if (storage != null) {
return "" + storage.getFullPath();
}
return getName();
}
@SuppressWarnings("unchecked")
@Override
public Object getAdapter(Class adapter) {
if (adapter == IWorkbenchAdapter.class) {
return this;
}
if (adapter == IFileRevision.class) {
return fileRevision;
}
return super.getAdapter(adapter);
}
public String getEditorID() {
if (descriptor == null || descriptor.isOpenExternal()) {
return EditorsUI.DEFAULT_TEXT_EDITOR_ID;
}
return descriptor.getId();
}
private IEditorDescriptor initDescriptor() throws CoreException {
IContentType type = null;
IContentTypeManager typeManager = Platform.getContentTypeManager();
if(storage != null){
InputStream contents = storage.getContents();
if (contents != null) {
try {
type = typeManager.findContentTypeFor(contents, fileName);
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
} finally {
try {
contents.close();
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
}
if (type == null) {
type = typeManager.findContentTypeFor(fileName);
}
IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();
return registry.getDefaultEditor(fileName, type);
}
}
private IStructuredSelection selection;
private Shell shell;
private IWorkbenchPage wPage;
public OpenMercurialRevisionAction(String text) {
super(text);
}
@Override
public void run() {
IStructuredSelection structSel = selection;
Object[] objArray = structSel.toArray();
for (int i = 0; i < objArray.length; i++) {
Object tempRevision = objArray[i];
final IFileRevision revision = (IFileRevision) tempRevision;
if (revision == null || !revision.exists()) {
MessageDialog.openError(shell,
Messages.getString("OpenMercurialRevisionAction.error.deletedRevision"), Messages.getString("OpenMercurialRevisionAction.error.cantOpen")); //$NON-NLS-1$ //$NON-NLS-2$
} else {
SafeUiJob runnable = new SafeUiJob(Messages.getString("OpenMercurialRevisionAction.job.openingEditor")) { //$NON-NLS-1$
@Override
public IStatus runSafe(IProgressMonitor monitor) {
IStorage file;
try {
file = revision.getStorage(monitor);
if (file instanceof IFile) {
// if this is the current workspace file, open it
ResourceUtils.openEditor(wPage, (IFile) file);
} else {
// not current revision
MercurialRevisionEditorInput fileRevEditorInput =
new MercurialRevisionEditorInput(revision);
if (!editorAlreadyOpenOnContents(fileRevEditorInput)) {
String id = fileRevEditorInput.getEditorID();
wPage.openEditor(fileRevEditorInput, id);
}
}
return super.runSafe(monitor);
} catch (CoreException e) {
MercurialEclipsePlugin.logError(e);
return e.getStatus();
}
}
};
runnable.schedule();
}
}
}
@Override
protected boolean updateSelection(IStructuredSelection selection1) {
this.selection = selection1;
return shouldShow();
}
public void setPage(Page page) {
this.shell = page.getSite().getShell();
this.wPage = page.getSite().getPage();
}
public void setPart(IWorkbenchPart part) {
this.shell = part.getSite().getShell();
this.wPage = part.getSite().getPage();
}
private boolean shouldShow() {
if (selection.isEmpty()) {
return false;
}
Object[] objArray = selection.toArray();
for (int i = 0; i < objArray.length; i++) {
MercurialRevision revision = (MercurialRevision) objArray[i];
// check to see if any of the selected revisions are deleted revisions
if (revision != null && (!revision.isFile() || !revision.exists())) {
return false;
}
}
return true;
}
private boolean editorAlreadyOpenOnContents(
MercurialRevisionEditorInput input) {
IEditorReference[] editorRefs = wPage.getEditorReferences();
IFileRevision inputRevision = (IFileRevision) input.getAdapter(IFileRevision.class);
for (IEditorReference editorRef : editorRefs) {
IEditorPart part = editorRef.getEditor(false);
if (part != null
&& part.getEditorInput() instanceof MercurialRevisionEditorInput) {
IFileRevision editorRevision = (IFileRevision) part
.getEditorInput().getAdapter(IFileRevision.class);
if (inputRevision.equals(editorRevision)) {
// make the editor that already contains the revision
// current
wPage.activate(part);
return true;
}
}
}
return false;
}
}
OpenSelectedRevisionDelegate.java 0000664 0000000 0000000 00000005715 11737135005 0036350 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Ilya Ivanov implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.actions;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.FileFromChangeSet;
import com.vectrace.MercurialEclipse.wizards.Messages;
/**
* This delegate is used for object contribution to context menus.
* Object class must be FileFromChangeSet or be adaptable to it.
*/
public class OpenSelectedRevisionDelegate implements IObjectActionDelegate {
private FileFromChangeSet fileFromChangeSet;
private final OpenMercurialRevisionAction openMercurialRevisionAction;
public OpenSelectedRevisionDelegate() {
openMercurialRevisionAction = new OpenMercurialRevisionAction(
Messages.getString("MercurialHistoryPage.openSelectedVersion"));
}
public void run(IAction action) {
openMercurialRevisionAction.run();
}
/**
* @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
*/
public void selectionChanged(IAction action, ISelection newSelection) {
action.setEnabled(false);
if (newSelection instanceof IStructuredSelection) {
IStructuredSelection sel = (IStructuredSelection) newSelection;
if (sel.getFirstElement() instanceof FileFromChangeSet) {
this.fileFromChangeSet = (FileFromChangeSet) sel.getFirstElement();
IFile file = fileFromChangeSet.getFile();
ChangeSet cs = fileFromChangeSet.getChangeset();
MercurialRevision rev = new MercurialRevision(cs, null, file, null, null);
int diffKind = fileFromChangeSet.getDiffKind();
if ((diffKind & Differencer.CHANGE_TYPE_MASK) != Differencer.DELETION) {
openMercurialRevisionAction.selectionChanged(new StructuredSelection(rev));
action.setEnabled(true);
}
}
} else {
this.fileFromChangeSet = null;
}
}
/**
* @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
*/
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
openMercurialRevisionAction.setPart(targetPart);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/actions/messages.properties 0000664 0000000 0000000 00000003512 11737135005 0033756 0 ustar 00root root 0000000 0000000 ExportAsBundleAction.andAllPreviousRevisionsHaveBeenExported=\ and all previous changesets have been exported to: \n\n
ExportAsBundleAction.callingMercurial=Calling Mercurial bundle command...
ExportAsBundleAction.createdSuccessfully=Bundle has been created successfully.
ExportAsBundleAction.determineLocationForBundleFile=Determine location for bundle file
ExportAsBundleAction.determiningRepositoryRoot=Determining repository root...
ExportAsBundleAction.exportingRevision=Exporting changeset
ExportAsBundleAction.exportSelectedRevisionAsBundle=Export All Changesets up to Selected as Bundle
ExportAsBundleAction.pleaseEnterTheNameOfTheBundleFile=Please enter the name of the bundle file.
ExportAsBundleAction.theRevision=The changeset
ExportAsBundleAction.toBundle=\ to bundle...
HgOperation.failed=\ failed:
MergeWithCurrentChangesetAction.0=Merging changeset
MergeWithCurrentChangesetAction.1=\ with current working directory changeset
MergeWithCurrentChangesetAction.2=Merging changeset
MergeWithCurrentChangesetAction.3=\ with current working directory changeset
MergeWithCurrentChangesetAction.4=Getting repository information from changeset...
MergeWithCurrentChangesetAction.5=Calling Mercurial merge command...
MergeWithCurrentChangesetAction.6=Do you really want to switch changesets?
MergeWithCurrentChangesetAction.7=The Mercurial repository has uncommitted changes. Do you want to continue and discard them?
MergeWithCurrentChangesetAction.mergeSelectedChangesetWithCurrentChangeset=Merge Current with Selected
OpenMercurialRevisionAction.error.cantOpen=Can't open a deleted changeset
OpenMercurialRevisionAction.error.deletedRevision=Deleted Changeset
OpenMercurialRevisionAction.job.openingEditor=Opening editor...
StatusContainerAction.job.description.2=\ from the Mercurial repository.
StatusContainerAction.job.description1=Mercurial get status
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations/ 0000775 0000000 0000000 00000000000 11737135005 0030725 5 ustar 00root root 0000000 0000000 AnnotateBlock.java 0000664 0000000 0000000 00000004131 11737135005 0034234 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.util.Date;
import com.vectrace.MercurialEclipse.HgRevision;
public class AnnotateBlock {
private HgRevision revision = new HgRevision("", -1); //$NON-NLS-1$
private String user = ""; //$NON-NLS-1$
private final int startLine;
private int endLine;
private Date date;
public AnnotateBlock(HgRevision revision, String user, Date date, int startLine, int endLine) {
this.revision = revision;
this.user = user;
this.date = date;
this.startLine = startLine;
this.endLine = endLine;
}
/**
* @return int the last source line of the receiver
*/
public int getEndLine() {
return endLine;
}
/**
* @param line
*/
public void setEndLine(int line) {
endLine = line;
}
/**
* @return the revision the receiver occured in.
*/
public HgRevision getRevision() {
return revision;
}
/**
* @return the first source line number of the receiver
*/
public int getStartLine() {
return startLine;
}
/**
* Answer true if the receiver contains the given line number, false otherwise.
* @param i a line number
* @return true if receiver contains a line number.
*/
public boolean contains(int i) {
return i >= startLine && i <= endLine;
}
/**
* @return Returns the date.
*/
public Date getDate() {
return this.date;
}
/**
* @param date The date to set.
*/
public void setDate(Date date) {
this.date = date;
}
/**
* @return Returns the user.
*/
public String getUser() {
return this.user;
}
/**
* @param user The user to set.
*/
public void setUser(String user) {
this.user = user;
}
}
AnnotateBlocks.java 0000664 0000000 0000000 00000002446 11737135005 0034426 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c)
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation (based on subclipse)
* Stefan C - Code cleanup
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.util.LinkedList;
import java.util.List;
public class AnnotateBlocks {
private final List blocks = new LinkedList();
/**
* Add an annotate block merging this block with the previous block if it is part of the same
* change.
*
* @param aBlock
*/
public void add(AnnotateBlock aBlock) {
int size = blocks.size();
if (size == 0) {
blocks.add(aBlock);
} else {
AnnotateBlock lastBlock = blocks.get(size - 1);
if (lastBlock.getRevision().equals(aBlock.getRevision())) {
lastBlock.setEndLine(aBlock.getStartLine());
} else {
blocks.add(aBlock);
}
}
}
public List getAnnotateBlocks() {
return blocks;
}
}
CommitterColors.java 0000664 0000000 0000000 00000004602 11737135005 0034640 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c)
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation (based on subclipse)
* Stefan C - Code cleanup
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.swt.graphics.RGB;
/**
* This was copied from internal CVS UI code
*
* Default implementation, assigns random colors to revisions based on committer id.
*
* @since 3.2
*/
final class CommitterColors {
private static CommitterColors fInstance;
/**
* Returns the committer color singleton.
*
* @return the committer color singleton
*/
public static CommitterColors getDefault() {
if (fInstance == null) {
fInstance= new CommitterColors();
}
return fInstance;
}
/** The color map. */
private final Map fColors = new HashMap();
/** The number of colors that have been issued. */
private int fCount;
private CommitterColors() {
}
/**
* Returns a unique color description for each string passed in. Colors for new committers are
* allocated to be as different as possible from the existing colors.
*
* @param committer the committers unique name
* @return the corresponding color
*/
public RGB getCommitterRGB(String committer) {
RGB rgb= fColors.get(committer);
if (rgb == null) {
rgb= computeRGB(fCount++);
fColors.put(committer, rgb);
}
return rgb;
}
private RGB computeRGB(int ordinal) {
float hue= computeHue(ordinal);
RGB rgb= new RGB(hue, 1.0f, 1.0f);
return rgb;
}
private float computeHue(int ordinal) {
int base= 3;
int l = ordinal < base
? 0
: (int) Math.floor(Math.log(ordinal / (double) base) / Math.log(2));
int m= ((int) Math.pow(2, l)) * base;
int j= ordinal < base ? ordinal : ordinal - m;
float offset= ordinal < base ? 0.0f : (float) (180.0f / base / Math.pow(2, l));
float delta= ordinal < base ? 120.0f : 2 * offset;
float hue= (offset + j * delta) % 360;
return hue;
}
}
HgPristineCopyQuickDiffProvider.java 0000664 0000000 0000000 00000024661 11737135005 0037732 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c) Subclipse and others
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation (based on subclipse)
* StefanC - jobs framework code cleenup
* Bastian Doetsch - refactoring
* Andrei Loskutov - made it finally working
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.io.BufferedReader;
import java.io.CharArrayWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.editors.text.IStorageDocumentProvider;
import org.eclipse.ui.ide.ResourceUtil;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.IElementStateListener;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.quickdiff.IQuickDiffReferenceProvider;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.team.MercurialRevisionStorage;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
import com.vectrace.MercurialEclipse.team.cache.MercurialStatusCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
*
* A QuickDiff provider that provides a reference to the pristine copy of a file
* managed in the Hg repository. The provider notifies when the file's sync
* state changes and the diff should be recalculated (e.g. commit, update...) or
* when the file is changed (e.g. replace with).
*
* Here are the file states and what this provider does for each:
*
* 1. File is unmanaged : reference == empty document 2. Unmanaged file
* transitions to managed : empty reference updated with new remote revision 3.
* A managed file has new remote (commit, refresh remote) : reference updated
* with new remote revision 4. A managed file cleaned, remote is the same
* (replace with, update) : refresh diff bar with existing reference
*
* [Note: Currently an empty document must be returned for an unmanaged file.
* This results in the entire document appearing as outgoing changes in the
* quickdiff bar. This is required because the quickdiff support relies on
* IDocument change events to update the quickdiff, and returning null for the
* reference document doesn't allow the transition to later return a IDocument.]
*
* @since 3.0
*/
public class HgPristineCopyQuickDiffProvider implements IQuickDiffReferenceProvider {
public static final String HG_REFERENCE_PROVIDER = "com.vectrace.MercurialEclipse.annotatations.HgReferenceProvider"; //$NON-NLS-1$
// The editor showing this quickdiff and provides access to the editor input
// and ultimatly the IFile.
private ITextEditor editor;
// The document containing the remote file. Can be null if the assigned
// editor doesn't have a Hg remote resource associated with it.
private IDocument referenceDocument;
// Will be true when the document has been read and initialized.
private boolean isReferenceInitialized;
// Document provider allows us to register/deregister the element state
// change listener.
private IDocumentProvider documentProvider;
// Unique id for this reference provider as set via setId().
private String id;
// Job that re-creates the reference document.
private Job fUpdateJob;
/**
* Updates the document if the document is changed (e.g. replace with)
*/
private final IElementStateListener documentListener = new IElementStateListener() {
public void elementDirtyStateChanged(Object element, boolean isDirty) {
}
public void elementContentAboutToBeReplaced(Object element) {
}
public void elementContentReplaced(Object element) {
if (editor != null && editor.getEditorInput() == element) {
fetchContentsInJob();
}
}
public void elementDeleted(Object element) {
}
public void elementMoved(Object originalElement, Object movedElement) {
}
};
public IDocument getReference(IProgressMonitor monitor)
throws CoreException {
if (!isReferenceInitialized) {
return null;
}
if (referenceDocument == null) {
readDocument(monitor);
}
return referenceDocument;
}
public void setActiveEditor(ITextEditor targetEditor) {
IEditorInput editorInput = targetEditor.getEditorInput();
if (editorInput == null || ResourceUtil.getFile(editorInput) == null) {
return;
}
editor = targetEditor;
documentProvider = editor.getDocumentProvider();
if (documentProvider != null) {
documentProvider.addElementStateListener(documentListener);
}
isReferenceInitialized = true;
}
public boolean isEnabled() {
if (!isReferenceInitialized) {
return false;
}
return getManagedHgFile() != null;
}
public void dispose() {
isReferenceInitialized = false;
// stop update job
if (fUpdateJob != null && fUpdateJob.getState() != Job.NONE) {
fUpdateJob.cancel();
}
// remove listeners
if (documentProvider != null) {
documentProvider.removeElementStateListener(documentListener);
}
}
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
/**
* Determine if the file represented by this quickdiff provider has changed
* with respect to it's remote state. Return true if the remote contents
* should be refreshed, and false if not.
*/
private boolean computeChange(IProgressMonitor monitor) {
boolean needToUpdateReferenceDocument = false;
if (isReferenceInitialized) {
needToUpdateReferenceDocument = getFileFromEditor().isSynchronized(
IResource.DEPTH_ONE);
}
return needToUpdateReferenceDocument;
}
/**
* Creates a document and initializes it with the contents of a Hg file
* resource.
*
* @param monitor
* the progress monitor
* @throws CoreException
*/
private void readDocument(IProgressMonitor monitor) throws CoreException {
if (!isReferenceInitialized) {
return;
}
if (referenceDocument == null) {
referenceDocument = new Document();
}
if (computeChange(monitor)) {
IFile remoteFile = getFileFromEditor();
if (remoteFile != null && documentProvider instanceof IStorageDocumentProvider) {
IStorageDocumentProvider provider = (IStorageDocumentProvider) documentProvider;
String encoding = provider.getEncoding(editor.getEditorInput());
if (encoding == null) {
encoding = provider.getDefaultEncoding();
}
if (monitor.isCanceled()) {
return;
}
InputStream stream;
// if file is unchanged, simply read the content from current version on the disk
if(MercurialStatusCache.getInstance().isClean(remoteFile)){
stream = remoteFile.getContents();
} else {
// fetch the file version matching to the current hg root changeset
MercurialRevisionStorage revision = new MercurialRevisionStorage(remoteFile);
stream = revision.getContents();
}
if (stream == null || monitor.isCanceled() || !isReferenceInitialized) {
return;
}
setDocumentContent(referenceDocument, stream, encoding);
} else {
// the remote is null, so ensure that the document is null
if (monitor.isCanceled()) {
return;
}
referenceDocument.set(""); //$NON-NLS-1$
}
}
}
/**
* Intitializes the given document with the given stream using the given
* encoding.
*
* @param document
* the document to be initialized
* @param contentStream
* the stream which delivers the document content
* @param encoding
* the character encoding for reading the given stream
* @exception CoreException
* if the given stream can not be read
*/
private static void setDocumentContent(IDocument document,
InputStream contentStream, String encoding) throws CoreException {
Reader in = null;
try {
final int defaultFileSize = 15 * 1024;
in = new BufferedReader(new InputStreamReader(contentStream,
encoding), defaultFileSize);
CharArrayWriter caw = new CharArrayWriter(defaultFileSize);
char[] readBuffer = new char[2048];
int n = in.read(readBuffer);
while (n > 0) {
caw.write(readBuffer, 0, n);
n = in.read(readBuffer);
}
document.set(caw.toString());
} catch (IOException x) {
throw new HgException("Failed to read file content", x); //$NON-NLS-1$
} finally {
if (in != null) {
try {
in.close();
} catch (IOException x) {
throw new HgException("Failed to close stream", x); //$NON-NLS-1$
}
}
}
}
/**
* Returns the HgFile associated with he active editor or null
* if the provider doesn't not have access to a Hg managed file.
*
* @return the handle to a Hg file
*/
private File getManagedHgFile() {
if (editor != null) {
IFile file = getFileFromEditor();
if (file != null && MercurialTeamProvider.isHgTeamProviderFor(file)) {
File hgFile = ResourceUtils.getFileHandle(file);
if (hgFile.exists()) {
return hgFile;
}
return null;
}
}
return null;
}
private IFile getFileFromEditor() {
if (editor != null) {
IEditorInput input = editor.getEditorInput();
if (input != null) {
return ResourceUtil.getFile(input);
}
}
return null;
}
/**
* Runs a job that updates the document. If a previous job is already
* running it is stopped before the new job can start.
*/
private void fetchContentsInJob() {
if (!isReferenceInitialized) {
return;
}
if (fUpdateJob != null && fUpdateJob.getState() != Job.NONE) {
fUpdateJob.cancel();
}
fUpdateJob = new Job("Fetching last versioned file state") { //$NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
readDocument(monitor);
} catch (CoreException e) {
// continue and return ok for now. The error will be reported
// when the quick diff supports calls getReference() again.
}
return Status.OK_STATUS;
}
};
fUpdateJob.schedule();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations/Messages.java 0000664 0000000 0000000 00000002137 11737135005 0033342 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* @author bastian
*
*/
public final class Messages {
private static final String BUNDLE_NAME = "com.vectrace.MercurialEclipse.annotations.messages"; //$NON-NLS-1$
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
private Messages() {
}
public static String getString(String key) {
try {
return RESOURCE_BUNDLE.getString(key);
} catch (MissingResourceException e) {
return '!' + key + '!';
}
}
}
ShowAnnotationOperation.java 0000664 0000000 0000000 00000025670 11737135005 0036357 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c) ?
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation (based on subclipse)
* StefanC - jobs framework, code cleanup
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.lang.reflect.InvocationTargetException;
import java.text.DateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.revisions.Revision;
import org.eclipse.jface.text.revisions.RevisionInformation;
import org.eclipse.jface.text.source.LineRange;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.ui.TeamOperation;
import org.eclipse.team.ui.TeamUI;
import org.eclipse.team.ui.history.IHistoryPage;
import org.eclipse.team.ui.history.IHistoryView;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorExtension4;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.SafeUiJob;
import com.vectrace.MercurialEclipse.commands.HgAnnotateClient;
import com.vectrace.MercurialEclipse.commands.HgLogClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.history.MercurialHistoryPage;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.team.cache.LocalChangesetCache;
import com.vectrace.MercurialEclipse.team.cache.MercurialRootCache;
import com.vectrace.MercurialEclipse.team.cache.MercurialStatusCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class ShowAnnotationOperation extends TeamOperation {
public static final class MercurialRevision extends Revision {
private final CommitterColors colors;
private final ChangeSet entry;
private final String id;
private final AnnotateBlock block;
private MercurialRevision(CommitterColors colors, ChangeSet entry,
String string, AnnotateBlock block) {
this.colors = colors;
this.entry = entry;
this.id = string;
this.block = block;
Assert.isNotNull(colors);
Assert.isNotNull(entry);
Assert.isNotNull(string);
Assert.isNotNull(block);
}
@Override
public Object getHoverInfo() {
return entry.getAuthor()
+ " " + id + " " + DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.SHORT).format(block.getDate()) + "\n\n" + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
(entry.getComment() != null ? entry.getComment() : ""); //$NON-NLS-1$
}
/**
* @return the entry
*/
public ChangeSet getChangeSet() {
return entry;
}
@Override
public String getAuthor() {
return block.getUser();
}
@Override
public String getId() {
return id;
}
@Override
public Date getDate() {
return block.getDate();
}
@Override
public RGB getColor() {
return colors.getCommitterRGB(getAuthor());
}
}
private static final String DEFAULT_TEXT_EDITOR_ID = EditorsUI.DEFAULT_TEXT_EDITOR_ID;
private final IResource res;
public ShowAnnotationOperation(IWorkbenchPart part, IResource remoteFile) {
super(part);
this.res = remoteFile;
}
public void run(IProgressMonitor monitor) throws InvocationTargetException,
InterruptedException {
monitor.beginTask(null, 100);
try {
if (!MercurialStatusCache.getInstance().isSupervised(res)) {
return;
}
final AnnotateBlocks annotateBlocks = HgAnnotateClient.execute(res);
// this is not needed if there is no live annotate
final RevisionInformation information = createRevisionInformation(
annotateBlocks, monitor);
// We aren't running from a UI thread
new SafeUiJob(Messages.getString("ShowAnnotationOperation.job.name")) { //$NON-NLS-1$
@Override
protected IStatus runSafe(IProgressMonitor moni) {
moni.beginTask(Messages.getString("ShowAnnotationOperation.beginAnnotation"), //$NON-NLS-1$
IProgressMonitor.UNKNOWN);
final ITextEditorExtension4 editor = getEditor();
if (editor != null) {
editor
.showRevisionInformation(
information,
HgPristineCopyQuickDiffProvider.HG_REFERENCE_PROVIDER);
final IWorkbenchPage page= getPart().getSite().getPage();
showHistoryView(page, (ITextEditor)editor);
page.activate((ITextEditor)editor);
}
moni.done();
return super.runSafe(moni);
}
}.schedule();
} catch (Exception e) {
MercurialEclipsePlugin.logError(e);
} finally {
monitor.done();
}
}
/**
* Shows the history view, creating it if necessary, but does not give it focus.
*
* @param page the workbench page to operate in
* @param editor the editor that is showing the file
* @return the history view
* @throws PartInitException
*/
private IHistoryView showHistoryView(IWorkbenchPage page, ITextEditor editor) {
Object object = res;
if (object == null) {
object = editor.getEditorInput();
}
IHistoryView historyView= TeamUI.showHistoryFor(page, object, null);
IHistoryPage historyPage = historyView.getHistoryPage();
if (historyPage instanceof MercurialHistoryPage){
MercurialHistoryPage mercurialHistoryPage = (MercurialHistoryPage) historyPage;
// We need to call link to ensure that the history page gets linked
// even if the page input did not change
mercurialHistoryPage.linkWithEditor();
}
return historyView;
}
@Override
protected IAction getGotoAction() {
return super.getGotoAction();
}
private ITextEditorExtension4 getEditor() {
IEditorReference[] references = MercurialEclipsePlugin.getActivePage()
.getEditorReferences();
IResource resource = res;
if (resource == null) {
return null;
}
IWorkbenchPage page = getPart().getSite().getPage();
for (int i = 0; i < references.length; i++) {
IEditorReference reference = references[i];
try {
if (resource.equals(reference.getEditorInput()
.getAdapter(IFile.class))) {
IEditorPart editor = reference.getEditor(false);
if (editor instanceof ITextEditorExtension4) {
return (ITextEditorExtension4) editor;
}
// editor opened is not a text editor - reopen file using
// the
// defualt text editor
IEditorPart part = page
.openEditor(new FileEditorInput((IFile) resource),
DEFAULT_TEXT_EDITOR_ID, true,
IWorkbenchPage.MATCH_NONE);
if (part instanceof ITextEditorExtension4) {
return (ITextEditorExtension4) part;
}
}
} catch (PartInitException e) {
MercurialEclipsePlugin.logError(e);
}
}
// no existing editor references found, try to open a new editor for the
// file
try {
IEditorDescriptor descrptr = IDE.getEditorDescriptor((IFile) resource);
// try to open the associated editor only if its an internal
// editor
if (descrptr.isInternal()) {
IEditorPart part = ResourceUtils.openEditor(page, (IFile) resource);
if (part instanceof ITextEditorExtension4) {
return (ITextEditorExtension4) part;
}
// editor opened is not a text editor - close it
// NB: editor should not be closed as it could be opened by user before
// page.closeEditor(part, false);
}
// open file in default text editor
IEditorPart part = IDE.openEditor(page, (IFile) resource, DEFAULT_TEXT_EDITOR_ID);
if (part instanceof ITextEditorExtension4) {
return (ITextEditorExtension4) part;
}
} catch (PartInitException e) {
MercurialEclipsePlugin.logError(e);
}
return null;
}
private RevisionInformation createRevisionInformation(
final AnnotateBlocks annotateBlocks, IProgressMonitor monitor)
throws HgException {
Map logEntriesByRevision = new HashMap();
LocalChangesetCache.getInstance().refreshAllLocalRevisions(
res, true);
Iterable revisions = LocalChangesetCache.getInstance()
.getOrFetchChangeSets(res);
for (ChangeSet changeSet : revisions) {
logEntriesByRevision.put(Integer.valueOf(changeSet.getRevision()
.getRevision()),
changeSet);
}
RevisionInformation info = new RevisionInformation();
final class AnnotationControlCreator implements IInformationControlCreator {
private final String statusFieldText;
public AnnotationControlCreator(String statusFieldText) {
this.statusFieldText = statusFieldText;
}
public IInformationControl createInformationControl(Shell parent) {
return new SourceViewerInformationControl(parent, SWT.TOOL, SWT.NONE,
JFaceResources.DEFAULT_FONT, statusFieldText);
}
}
info.setHoverControlCreator(new AnnotationControlCreator(Messages
.getString("ShowAnnotationOperation.pressF2ForFocus"))); //$NON-NLS-1$
info.setInformationPresenterControlCreator(new AnnotationControlCreator(null));
final CommitterColors colors = CommitterColors.getDefault();
HashMap sets = new HashMap();
for (final AnnotateBlock block : annotateBlocks.getAnnotateBlocks()) {
final String revisionString = block.getRevision().toString();
ChangeSet logEntry = logEntriesByRevision.get(
Integer.valueOf(block.getRevision().getRevision()));
// logEntriesByRevision may not contain transplanted changesets
if (logEntry == null) {
HgRoot root = MercurialRootCache.getInstance().getHgRoot(res);
logEntry = HgLogClient.getChangeset(root, block.getRevision().getChangeset());
Assert.isNotNull(logEntry);
logEntriesByRevision.put(Integer.valueOf(logEntry.getRevision().getRevision()),
logEntry);
}
block.setUser(logEntry.getPerson());
Revision revision = sets.get(revisionString);
if (revision == null) {
revision = new MercurialRevision(colors, logEntry,
revisionString, block);
sets.put(revisionString, revision);
info.addRevision(revision);
}
revision.addRange(new LineRange(block.getStartLine(), block
.getEndLine()
- block.getStartLine() + 1));
}
return info;
}
}
SourceViewerInformationControl.java 0000664 0000000 0000000 00000024776 11737135005 0037722 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations /*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Charles O'Farrell - copy from subclipse
* StefanC - code cleanup
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.annotations;
import java.util.Collections;
import java.util.Map;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlExtension;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
/**
* Source viewer based implementation of {@link org.eclipse.jface.text.IInformationControl}.
* Displays information in a source viewer.
*
* @since 3.0
*
* This class is copied from org.eclipse.jface.text.source.projection.SourceViewerInformationControl
* Several changes are made in order to handle hover for H annotations
*/
class SourceViewerInformationControl implements IInformationControl, IInformationControlExtension, DisposeListener {
private static final class HgTextSourceViewerConfiguration extends TextSourceViewerConfiguration {
private HgTextSourceViewerConfiguration(IPreferenceStore store) {
super(store);
}
@Override
protected Map getHyperlinkDetectorTargets(ISourceViewer sourceViewer) {
return Collections.singletonMap("org.eclipse.ui.DefaultTextEditor", //$NON-NLS-1$
null);
// new IAdaptable() {
// public Object getAdapter(Class adapter) {
// // return Platform.getAdapterManager().getAdapter(CVSHistoryPage.this, adapter);
// return null;
// }
// });
}
}
/** Border thickness in pixels. */
private static final int BORDER= 1;
/** The control's shell */
private Shell fShell;
/** The control's text widget */
private StyledText fText;
/** The control's source viewer */
private final SourceViewer fViewer;
/** The optional status field. */
private Label fStatusField;
/** The separator for the optional status field. */
private Label fSeparator;
/** The font of the optional status text label.*/
private Font fStatusTextFont;
/** The maximal widget width. */
private int fMaxWidth;
/** The maximal widget height. */
private int fMaxHeight;
/**
* Creates a source viewer information control with the given shell as
* parent and the given font.
*
* @param parent the parent shell
* @param symbolicFontName the symbolic font name
*/
public SourceViewerInformationControl(Shell parent, String symbolicFontName) {
this(parent, SWT.NO_TRIM | SWT.TOOL, SWT.NONE, symbolicFontName, null);
}
/**
* Creates a source viewer information control with the given shell as
* parent. The given shell styles are applied to the created shell. The
* given styles are applied to the created styled text widget. The text
* widget will be initialized with the given font. The status field will
* contain the given text or be hidden.
*
* @param parent the parent shell
* @param shellStyle the additional styles for the shell
* @param style the additional styles for the styled text widget
* @param symbolicFontName the symbolic font name
* @param statusFieldText the text to be used in the optional status field
* or null if the status field should be hidden
*/
public SourceViewerInformationControl(Shell parent, int shellStyle, int style, String symbolicFontName, String statusFieldText) {
GridLayout layout;
GridData gd;
fShell= new Shell(parent, SWT.NO_FOCUS | SWT.ON_TOP | shellStyle);
Display display= fShell.getDisplay();
fShell.setBackground(display.getSystemColor(SWT.COLOR_BLACK));
Composite composite= fShell;
layout= new GridLayout(1, false);
int border= ((shellStyle & SWT.NO_TRIM) == 0) ? 0 : BORDER;
layout.marginHeight= border;
layout.marginWidth= border;
composite.setLayout(layout);
gd= new GridData(GridData.FILL_HORIZONTAL);
composite.setLayoutData(gd);
if (statusFieldText != null) {
composite= new Composite(composite, SWT.NONE);
layout= new GridLayout(1, false);
layout.marginHeight= 0;
layout.marginWidth= 0;
composite.setLayout(layout);
gd= new GridData(GridData.FILL_BOTH);
composite.setLayoutData(gd);
composite.setForeground(display.getSystemColor(SWT.COLOR_INFO_FOREGROUND));
composite.setBackground(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND));
}
// Source viewer
fViewer= new SourceViewer(composite, null, style);
fViewer.setEditable(false);
// configure hyperlink detectors
// fViewer.configure(new SourceViewerConfiguration());
fViewer.configure(new HgTextSourceViewerConfiguration(EditorsUI.getPreferenceStore()));
fText= fViewer.getTextWidget();
gd= new GridData(GridData.BEGINNING | GridData.FILL_BOTH);
fText.setLayoutData(gd);
fText.setForeground(parent.getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND));
fText.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));
fText.setFont(JFaceResources.getFont(symbolicFontName));
fText.addKeyListener(new KeyListener() {
public void keyPressed(KeyEvent e) {
if (e.character == 0x1B) {
fShell.dispose();
}
}
public void keyReleased(KeyEvent e) {}
});
// Status field
if (statusFieldText != null) {
// Horizontal separator line
fSeparator= new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL | SWT.LINE_DOT);
fSeparator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
// Status field label
fStatusField= new Label(composite, SWT.RIGHT);
fStatusField.setText(statusFieldText);
Font font= fStatusField.getFont();
FontData[] fontDatas= font.getFontData();
for (int i= 0; i < fontDatas.length; i++) {
fontDatas[i].setHeight(fontDatas[i].getHeight() * 9 / 10);
}
fStatusTextFont= new Font(fStatusField.getDisplay(), fontDatas);
fStatusField.setFont(fStatusTextFont);
GridData gd2= new GridData(GridData.FILL_VERTICAL | GridData.FILL_HORIZONTAL | GridData.HORIZONTAL_ALIGN_BEGINNING | GridData.VERTICAL_ALIGN_BEGINNING);
fStatusField.setLayoutData(gd2);
// Regarding the color see bug 41128
fStatusField.setForeground(display.getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW));
fStatusField.setBackground(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND));
}
addDisposeListener(this);
}
public void setInput(Object input) {
if (input instanceof String) {
setInformation((String) input);
} else {
setInformation(null);
}
}
public void setInformation(String content) {
if (content == null) {
fViewer.setInput(null);
return;
}
IDocument doc= new Document(content);
fViewer.setInput(doc);
// decorate text
StyleRange styleRange = new StyleRange();
styleRange.start = 0;
styleRange.length = content.indexOf('\n');
styleRange.fontStyle = SWT.BOLD;
fViewer.getTextWidget().setStyleRange(styleRange);
}
public void setVisible(boolean visible) {
fShell.setVisible(visible);
}
public void widgetDisposed(DisposeEvent event) {
if (fStatusTextFont != null && !fStatusTextFont.isDisposed()) {
fStatusTextFont.dispose();
}
fStatusTextFont= null;
fShell= null;
fText= null;
}
public final void dispose() {
if (fShell != null && !fShell.isDisposed()) {
fShell.dispose();
} else {
widgetDisposed(null);
}
}
public void setSize(int width, int height) {
if (fStatusField != null) {
GridData gd= (GridData) fViewer.getTextWidget().getLayoutData();
Point statusSize= fStatusField.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
Point separatorSize= fSeparator.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
gd.heightHint= height - statusSize.y - separatorSize.y;
}
fShell.setSize(width, height);
if (fStatusField != null) {
fShell.pack(true);
}
}
public void setLocation(Point location) {
fShell.setLocation(location);
}
public void setSizeConstraints(int maxWidth, int maxHeight) {
fMaxWidth= maxWidth;
fMaxHeight= maxHeight;
}
public Point computeSizeHint() {
// compute the preferred size
int x= SWT.DEFAULT;
int y= SWT.DEFAULT;
Point size= fShell.computeSize(x, y);
if (size.x > fMaxWidth) {
x= fMaxWidth;
}
if (size.y > fMaxHeight) {
y= fMaxHeight;
}
// recompute using the constraints if the preferred size is larger than the constraints
if (x != SWT.DEFAULT || y != SWT.DEFAULT) {
size= fShell.computeSize(x, y, false);
}
return size;
}
public void addDisposeListener(DisposeListener listener) {
fShell.addDisposeListener(listener);
}
public void removeDisposeListener(DisposeListener listener) {
fShell.removeDisposeListener(listener);
}
public void setForegroundColor(Color foreground) {
fText.setForeground(foreground);
}
public void setBackgroundColor(Color background) {
fText.setBackground(background);
}
public boolean isFocusControl() {
return fText.isFocusControl();
}
public void setFocus() {
fShell.forceFocus();
fText.setFocus();
}
public void addFocusListener(FocusListener listener) {
fText.addFocusListener(listener);
}
public void removeFocusListener(FocusListener listener) {
fText.removeFocusListener(listener);
}
public boolean hasContents() {
return fText.getCharCount() > 0;
}
}
messages.properties 0000664 0000000 0000000 00000000245 11737135005 0034574 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/annotations ShowAnnotationOperation.beginAnnotation=Applying Annotation
ShowAnnotationOperation.job.name=Hg Annotate
ShowAnnotationOperation.pressF2ForFocus=Press F2 for focus.
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/ 0000775 0000000 0000000 00000000000 11737135005 0030171 5 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/AbstractClient.java0000664 0000000 0000000 00000021621 11737135005 0033740 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
* Philip Graf - proxy support
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.eclipse.core.net.proxy.IProxyData;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import com.vectrace.MercurialEclipse.HgFeatures;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.MercurialRootCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* Base client class
* @author bastian
*
*/
public abstract class AbstractClient {
private static final String HTTP_PATTERN_STRING = "[hH][tT][tT][pP]:.*[@]"; //$NON-NLS-1$
private static final String HTTPS_PATTERN_STRING = "[hH][tT][tT][pP][sS]:.*[@]"; //$NON-NLS-1$
private static final String SSH_PATTERN_STRING = "[sS][sS][hH]:.*[@]"; //$NON-NLS-1$
private static final String SVN_PATTERN_STRING = "[sS][vV][nN]:.*[@]"; //$NON-NLS-1$
private static final Pattern HTTP_PATTERN = Pattern.compile(HTTP_PATTERN_STRING);
private static final Pattern HTTPS_PATTERN = Pattern.compile(HTTPS_PATTERN_STRING);
private static final Pattern SSH_PATTERN = Pattern.compile(SSH_PATTERN_STRING);
private static final Pattern SVN_PATTERN = Pattern.compile(SVN_PATTERN_STRING);
protected AbstractClient() {
super();
}
public static String obfuscateLoginData(String line) {
String myLine = line == null? "" : line;
myLine = HTTP_PATTERN.matcher(myLine).replaceAll("http://***@"); //$NON-NLS-1$
if (myLine.equals(line)) {
myLine = HTTPS_PATTERN.matcher(line).replaceAll("https://***@"); //$NON-NLS-1$
}
if (myLine.equals(line)) {
myLine = SSH_PATTERN.matcher(line).replaceAll("ssh://***@"); //$NON-NLS-1$
}
if (myLine.equals(line)) {
myLine = SVN_PATTERN.matcher(line).replaceAll("svn://***@"); //$NON-NLS-1$
}
return myLine;
}
/**
* @param resource
* @return hg root as canonical file (see {@link File#getCanonicalFile()})
* @throws HgException
*/
static HgRoot getHgRoot(IResource resource) throws HgException {
Assert.isNotNull(resource);
return MercurialRootCache.getInstance().getHgRoot(resource);
}
/**
* Checks if the specified resource is an HgRoot. If it is, the HgRoot is returned, otherwise null is returned.
*/
public static HgRoot isHgRoot(IResource res) throws HgException {
Assert.isNotNull(res);
if(!(res instanceof IContainer)){
return null;
}
IContainer container = (IContainer)res;
if(container.findMember(".hg") != null){
return getHgRoot(container);
}
return null;
}
static List toFiles(List files) {
List toFiles = new ArrayList();
for (IResource r : files) {
IPath path = ResourceUtils.getPath(r);
if(!path.isEmpty()) {
toFiles.add(path.toFile());
}
}
return toFiles;
}
/**
* Checks whether a command is available in installed Mercurial version by
* issuing hg help . If Mercurial doesn't answer with
* "hg: unknown command", it's available
*
* @param commandName
* the name of the command, e.g. "rebase"
* @param extensionEnabler
* the enablement string for an extension, e.g.
* "hgext.bookmarks="
* @return true, if command is available
*/
public static boolean isCommandAvailable(String commandName,
String extensionEnabler) {
boolean returnValue = false;
// see bug http://bitbucket.org/mercurialeclipse/main/issue/224/
// If hg command uses non-null directory, which is NOT under the hg control,
// MercurialTeamProvider.getAndStoreHgRoot() throws an exception
AbstractShellCommand command = new RootlessHgCommand("help", "Checking availablility of "
+ commandName);
if (extensionEnabler != null && extensionEnabler.length() != 0) {
command.addOptions("--config", "extensions." + extensionEnabler); //$NON-NLS-1$ //$NON-NLS-2$
}
command.addOptions(commandName);
String result;
try {
result = new String(command.executeToBytes(10000, false));
if (result.startsWith("hg: unknown command")) { //$NON-NLS-1$
returnValue = false;
} else {
returnValue = true;
}
} catch (HgException e) {
returnValue = false;
}
return returnValue;
}
public static String getHgResourceSearchPattern(IResource resource) throws HgException {
HgRoot hgRoot = getHgRoot(resource);
String pattern = null;
IPath relPath = ResourceUtils.getPath(resource).makeRelativeTo(hgRoot.getIPath());
if (resource instanceof IStorage) {
pattern = "glob:" + relPath.toOSString();
} else {
String pathString = relPath.toOSString();
if (pathString.length() > 0) {
pattern = "glob:" + pathString + System.getProperty("file.separator") + "**";
} else {
pattern = "glob:**";
}
}
return pattern;
}
/**
* Add the proxy-aware repository location to the command
* @param repo not null
* @param cmd not null
* @throws HgException
*/
protected static void addRepoToHgCommand(IHgRepositoryLocation repo, AbstractShellCommand cmd) throws HgException {
URI uri = repo.getUri();
String location;
if (uri != null && uri.getHost() != null) {
location = uri.toASCIIString();
addProxyToHgCommand(uri, cmd);
} else {
location = repo.getLocation();
}
cmd.addOptions(location);
}
/**
* If a proxy server is necessary to access the pull or push location, this method will add the
* respective command options.
*
* @param repository
* The URI of the repository, never null
* @param command
* not null
*/
protected static void addProxyToHgCommand(URI repository, AbstractShellCommand command) {
IProxyService proxyService = MercurialEclipsePlugin.getDefault().getProxyService();
// Host can be null URI is a local path
final String host = repository.getHost();
if (proxyService == null || host == null) {
return;
}
// check if there is an applicable proxy for the location
// TODO the method we calling is deprecated, but we have to use it
// to be compatible with Eclipse 3.4 API...
IProxyData proxy = proxyService.getProxyDataForHost(host, repository.getScheme());
if (proxy == null || proxy.getHost() == null) {
return;
}
// set the host incl. port
command.addOptions("--config", "http_proxy.host=" + getProxyHost(proxy)); //$NON-NLS-1$ //$NON-NLS-2$
// check if authentication is required
if (proxy.isRequiresAuthentication()) {
// set the user name if available
if (proxy.getUserId() != null) {
command.addOptions("--config", "http_proxy.user=" + proxy.getUserId()); //$NON-NLS-1$ //$NON-NLS-2$
}
// set the password if available
if (proxy.getPassword() != null) {
command.addOptions("--config", "http_proxy.passwd=" //$NON-NLS-1$ //$NON-NLS-2$
+ proxy.getPassword());
}
}
}
/**
* Returns the proxy host parameter for the {@code http_proxy.host} configuration.
*
* @param proxy
* The proxy data.
* @return The proxy host.
*/
private static String getProxyHost(IProxyData proxy) {
StringBuilder host = new StringBuilder(proxy.getHost());
if (proxy.getPort() >= 0) {
host.append(':').append(proxy.getPort());
}
return host.toString();
}
protected static void addMergeToolPreference(AbstractShellCommand command) {
boolean useExternalMergeTool = Boolean.valueOf(
HgClients.getPreference(MercurialPreferenceConstants.PREF_USE_EXTERNAL_MERGE,
"false")).booleanValue(); //$NON-NLS-1$
if (!useExternalMergeTool) {
command.addOptions("--config", "ui.merge=simplemerge"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
protected static void addInsecurePreference(AbstractShellCommand command) {
if(HgFeatures.INSECURE.isEnabled()) {
boolean verify = Boolean.valueOf(
HgClients.getPreference(MercurialPreferenceConstants.PREF_VERIFY_SERVER_CERTIFICATE,
"true")).booleanValue(); //$NON-NLS-1$
if (!verify) {
command.addOptions("--insecure"); //$NON-NLS-1$
}
}
}
}
AbstractParseChangesetClient.java 0000664 0000000 0000000 00000022060 11737135005 0036474 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bugfixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.ChangeSet.Direction;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
import com.vectrace.MercurialEclipse.team.cache.RemoteData;
import com.vectrace.MercurialEclipse.team.cache.RemoteKey;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* This class helps HgClients to parse the changeset output of hg to Changeset objects.
*
* @author Bastian Doetsch
*/
public abstract class AbstractParseChangesetClient extends AbstractClient {
private static final String OPEN_TAG = "";
private static final String CLOSE_TAG = "";
private static final int OPEN_CLOSE_TAG_SIZE = OPEN_TAG.length() + CLOSE_TAG.length();
private static final String STYLES = "/styles";
private static final String DEFAULT = "/log_style"; //$NON-NLS-1$
private static final String WITH_FILES = "/log_style_with_files"; //$NON-NLS-1$
private static final String WITH_FILES_FAST = "/log_style_fast"; //$NON-NLS-1$
private static final String TEMP_EXTN = ".tmpl"; //$NON-NLS-1$
public static final int STYLE_DEFAULT = 0;
public static final int STYLE_WITH_FILES = 1;
public static final int STYLE_WITH_FILES_FAST = 2;
/**
* Return a File reference to a copy of the required mercurial style file.
* Two types are available, one that includes the files and one that
* doesn't. Using the one with files can be very slow on large repos.
*
* These style files are included in the plugin jar file and need to be
* copied out of there into the plugin state area so a path can be given to
* the hg command.
*
* @param styleBit
* return one of the STYLE_ constants
* @return a File reference to an existing file
*/
public static File getStyleFile(int styleBit) throws HgException {
String style;
switch (styleBit) {
case STYLE_WITH_FILES:
style = WITH_FILES;
break;
case STYLE_WITH_FILES_FAST:
style = WITH_FILES_FAST;
break;
default:
style = DEFAULT;
break;
}
String styleTemplate = style + TEMP_EXTN;
IPath sl = MercurialEclipsePlugin.getDefault().getStateLocation();
File stylefile = sl.append(style).toFile();
File tmplfile = sl.append(styleTemplate).toFile();
if (stylefile.canRead() && tmplfile.canRead()) {
// Already have copies, return the file reference to the style file
stylefile.deleteOnExit();
tmplfile.deleteOnExit();
return stylefile;
}
ClassLoader cl = AbstractParseChangesetClient.class.getClassLoader();
// Need to make copies into the state directory from the jar file.
// set delete on exit so a new copy is made each time eclipse is started
// so we don't use stale copies on plugin updates.
InputStream styleistr = cl.getResourceAsStream(STYLES + style);
InputStream tmplistr = cl.getResourceAsStream(STYLES + styleTemplate);
OutputStream styleostr = null;
OutputStream tmplostr = null;
try {
styleostr = new FileOutputStream(stylefile);
tmplostr = new FileOutputStream(tmplfile);
tmplfile.deleteOnExit();
byte[] buffer = new byte[1024];
int n;
while ((n = styleistr.read(buffer)) != -1) {
styleostr.write(buffer, 0, n);
}
while ((n = tmplistr.read(buffer)) != -1) {
tmplostr.write(buffer, 0, n);
}
return stylefile;
} catch (IOException e) {
throw new HgException("Failed to setup hg style file", e); //$NON-NLS-1$
} finally {
try {
if(styleostr != null) {
styleostr.close();
}
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
try {
if(tmplostr != null) {
tmplostr.close();
}
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
/**
* Parse log output into a set of changesets.
*
* Format of input is defined in the two style files in /styles directory
*
* @param input
* output from the hg log command
* @param direction
* Incoming, Outgoing or Local changesets
* @param repository
* @param bundleFile
* @return map where the key is an absolute file path, never null
* @throws HgException
*/
protected static Map> createLocalRevisions(
IResource res, String input,
Direction direction, IHgRepositoryLocation repository,
File bundleFile, String branch) throws HgException {
HgRoot hgRoot = MercurialTeamProvider.getHgRoot(res);
IPath path = ResourceUtils.getPath(res);
return createLocalRevisions(path, input, direction, repository, bundleFile, branch, hgRoot);
}
protected static RemoteData createRemoteRevisions(RemoteKey key, String input,
Direction direction, File bundleFile)
throws HgException {
if (input == null || input.length() == 0){
return new RemoteData(key, direction);
}
IPath path = new Path(key.getRoot().getAbsolutePath());
ChangesetContentHandler xmlHandler = parseInput(path, false, input, direction, key.getRepo(),
bundleFile, key.getBranch(), key.getRoot());
return xmlHandler.createRemoteData();
}
/**
* @param path full absolute file path, which MAY NOT EXIST in the local file system
* (because it is the original path of moved or renamed file)
*
* @return map where the key is an absolute file path, never null
* @throws HgException
*/
protected static Map> createLocalRevisions(IPath path, String input,
Direction direction, IHgRepositoryLocation repository, File bundleFile, String branch, HgRoot hgRoot)
throws HgException {
Map> fileRevisions = new HashMap>();
if (input == null || input.length() == 0 || hgRoot == null) {
return fileRevisions;
}
ChangesetContentHandler xmlHandler = parseInput(path, true, input, direction, repository,
bundleFile, branch, hgRoot);
return xmlHandler.getFileRevisions();
}
private static ChangesetContentHandler parseInput(IPath path, boolean withFiles, String input,
Direction direction, IHgRepositoryLocation repository, File bundleFile, String branch, HgRoot hgRoot)
throws HgException {
StringBuilder sb = new StringBuilder(input.length() + OPEN_CLOSE_TAG_SIZE);
sb.append(OPEN_TAG);
sb.append(input);
sb.append(CLOSE_TAG);
String myInput = sb.toString();
ChangesetContentHandler xmlHandler = new ChangesetContentHandler(path, withFiles, direction, repository,
bundleFile, branch, hgRoot);
try {
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(xmlHandler);
reader.parse(new InputSource(new StringReader(myInput)));
} catch (Exception e) {
String nextTry = cleanControlChars(myInput);
try {
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(xmlHandler);
reader.parse(new InputSource(new StringReader(nextTry)));
} catch (Exception e1) {
MercurialEclipsePlugin.logError(e);
throw new HgException(e1.getLocalizedMessage(), e1);
}
}
return xmlHandler;
}
/**
* Clean the string of special chars that might be invalid for the XML
* parser. Return the cleaned string (special chars replaced by ordinary
* spaces).
*
* @param str
* the string to clean
* @return the cleaned string
*/
private static String cleanControlChars(String str) {
final StringBuilder buf = new StringBuilder();
final int len = str.length();
boolean inString=false;
for (int i = 0; i < len; i++) {
final int ch = str.codePointAt(i);
if (ch == '\r' || ch == '\n' || ch == '\t') {
buf.appendCodePoint(ch);
} else if (Character.isISOControl(ch)) {
buf.append(' ');
} else if (ch == '&') {
buf.append("&");
} else if (ch == '"') {
buf.append("\"");
inString = !inString;
} else if ((ch == '<') && inString) {
buf.append("<");
} else if ((ch == '>') && inString) {
buf.append(">");
} else {
buf.appendCodePoint(ch);
}
}
return buf.toString();
}
}
AbstractShellCommand.java 0000664 0000000 0000000 00000061562 11737135005 0035021 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation (with lots of stuff pulled up from HgCommand)
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes/restructure
* Zsolt Koppany (Intland) - enhancements
* Philip Graf - use default timeout from preferences
* John Peberdy - refactoring
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import static com.vectrace.MercurialEclipse.MercurialEclipsePlugin.*;
import static com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants.*;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import com.vectrace.MercurialEclipse.HgFeatures;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* @author bastian
*/
public abstract class AbstractShellCommand extends AbstractClient {
private static final int BUFFER_SIZE = 32768;
/**
* File encoding to use. If not specified falls back to {@link HgRoot}'s encoding.
*/
private String encoding;
/**
* Should not be used by any command except commands needed for the initialization of hg
* (debuginstall and version)
*
* @see MercurialEclipsePlugin#checkHgInstallation()
*/
protected boolean isInitialCommand;
/**
* should not be used by any code except initialization of hg
* @see MercurialEclipsePlugin#checkHgInstallation()
*/
protected static final CountDownLatch startSignal = new CountDownLatch(1);
/**
* See http://msdn.microsoft.com/en-us/library/ms682425(VS.85).aspx The maximum command line
* length for the CreateProcess function is 32767 characters. This limitation comes from the
* UNICODE_STRING structure.
*
* See also http://support.microsoft.com/kb/830473: On computers running Microsoft Windows XP or
* later, the maximum length of the string that you can use at the command prompt is 8191
* characters. On computers running Microsoft Windows 2000 or Windows NT 4.0, the maximum length
* of the string that you can use at the command prompt is 2047 characters.
*
* So here we simply allow maximal 100 file paths to be used in one command. Why 100? Why not?
* TODO The right way would be to construct the command and then check if the full command line
* size is >= 32767.
*
* @deprecated for the new features please check {@link HgFeatures#LISTFILE} enablement
*/
@Deprecated
public static final int MAX_PARAMS = 100;
static {
// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=298795
// we must run this stupid code in the UI thread
Display.getDefault().asyncExec(new Runnable() {
public void run() {
PlatformUI.getWorkbench().getProgressService().registerIconForFamily(
getImageDescriptor("mercurialeclipse.png"),
AbstractShellCommand.class);
}
});
}
/**
* This rule disallows hg commands run in parallel if the hg root is specified.
* If the hg root is not set, then this rule allows parallel job execution.
*/
public static class DefaultExecutionRule implements ISchedulingRule {
protected volatile HgRoot hgRoot;
public DefaultExecutionRule() {
super();
}
public boolean isConflicting(ISchedulingRule rule) {
return contains(rule);
}
public boolean contains(ISchedulingRule rule) {
if(this == rule){
return true;
}
if(!(rule instanceof DefaultExecutionRule)){
return false;
}
DefaultExecutionRule rule2 = (DefaultExecutionRule) rule;
return hgRoot != null && hgRoot.equals(rule2.hgRoot);
}
}
/**
* This rule disallows hg commands run in parallel on the same hg root
*/
public static class ExclusiveExecutionRule extends DefaultExecutionRule {
/**
* @param hgRoot must be not null
*/
public ExclusiveExecutionRule(HgRoot hgRoot) {
super();
Assert.isNotNull(hgRoot);
this.hgRoot = hgRoot;
}
}
// should not extend threads directly, should use thread pools or jobs.
// In case many threads created at same time, VM can crash or at least get OOM
class ProzessWrapper extends Job {
private final OutputStream output;
private final ProcessBuilder builder;
private final DefaultExecutionRule execRule;
volatile IProgressMonitor monitor2;
volatile boolean started;
private Process process;
long startTime;
int exitCode = -1;
Throwable error;
public ProzessWrapper(String name, ProcessBuilder builder, OutputStream output) {
super(name);
execRule = getExecutionRule();
setRule(execRule);
this.builder = builder;
this.output = output;
}
@Override
protected IStatus run(IProgressMonitor monitor) {
if (monitor.isCanceled()) {
return Status.CANCEL_STATUS;
}
if(debugExecTime) {
startTime = System.currentTimeMillis();
} else {
startTime = 0;
}
started = true;
monitor2 = monitor;
waitForHgInitDone();
InputStream stream = null;
try {
process = builder.start();
stream = process.getInputStream();
int length;
byte[] buffer = new byte[BUFFER_SIZE];
while ((length = stream.read(buffer)) != -1) {
output.write(buffer, 0, length);
if(monitor.isCanceled()){
break;
}
}
exitCode = process.waitFor();
} catch (IOException e) {
if (!monitor.isCanceled()) {
error = e;
}
return Status.CANCEL_STATUS;
} catch (InterruptedException e) {
if (!monitor.isCanceled()) {
error = e;
}
return Status.CANCEL_STATUS;
} finally {
if(stream != null) {
try {
stream.close();
} catch (IOException e) {
HgClients.logError(e);
}
}
try {
output.close();
} catch (IOException e) {
HgClients.logError(e);
}
monitor.done();
monitor2 = null;
if(process != null) {
process.destroy();
}
}
return monitor.isCanceled()? Status.CANCEL_STATUS : Status.OK_STATUS;
}
/**
* Waits until the gate is open (hg installation is checked etc)
*/
private void waitForHgInitDone() {
if(!isInitialCommand) {
try {
startSignal.await();
} catch (InterruptedException e1) {
MercurialEclipsePlugin.logError(e1);
}
}
}
private boolean isAlive() {
// job is either not started yet (is scheduled and waiting), or it is not finished or cancelled yet
return (!started && getResult() == null) || (monitor2 != null);
}
@Override
public boolean belongsTo(Object family) {
return AbstractShellCommand.class == family;
}
@Override
protected void canceling() {
super.canceling();
if(process != null) {
process.destroy();
}
// remove exclusive lock on the hg root
execRule.hgRoot = null;
}
}
protected String command;
/**
* Calculated commands. See {@link #getCommands()}
*/
private List commands;
/**
* Whether files should be preceded by "--" on the command line.
* @see #files
*/
private final boolean escapeFiles;
protected List options;
/**
* The working directory. May be null for default working directory.
*/
protected final File workingDir;
protected final List files;
private String timeoutConstant;
private ProzessWrapper processWrapper;
private boolean showOnConsole;
private final boolean debugMode;
private final boolean isDebugging;
private final boolean debugExecTime;
/**
* Though this command might not invoke hg, it might get encoding information from it. May be
* null.
*/
protected final HgRoot hgRoot;
private DefaultExecutionRule executionRule;
/**
* Human readable name for this operation
*/
private final String uiName;
/**
* @param uiName
* Human readable name for this command
* @param hgRoot
* Though this command might not invoke hg, it might get encoding information from
* it. May be null.
*/
protected AbstractShellCommand(String uiName, HgRoot hgRoot, File workingDir, boolean escapeFiles) {
super();
this.hgRoot = hgRoot;
this.workingDir = workingDir;
this.escapeFiles = escapeFiles;
this.uiName = uiName;
options = new ArrayList();
files = new ArrayList();
showOnConsole = true;
isDebugging = Boolean.valueOf(Platform.getDebugOption(MercurialEclipsePlugin.ID + "/debug/commands")).booleanValue();
debugMode = Boolean.valueOf(HgClients.getPreference(PREF_CONSOLE_DEBUG, "false")).booleanValue(); //$NON-NLS-1$
debugExecTime = Boolean.valueOf(HgClients.getPreference(PREF_CONSOLE_DEBUG_TIME, "false")).booleanValue(); //$NON-NLS-1$
timeoutConstant = MercurialPreferenceConstants.DEFAULT_TIMEOUT;
Assert.isNotNull(uiName);
}
protected AbstractShellCommand(String uiName, HgRoot hgRoot, List commands, File workingDir, boolean escapeFiles) {
this(uiName, hgRoot, workingDir, escapeFiles);
this.commands = commands;
}
/**
* Should not be called by any code except for hg initialization job
* Opens the command execution gate after hg installation is checked etc
* @see MercurialEclipsePlugin#checkHgInstallation()
*/
public static void hgInitDone() {
startSignal.countDown();
}
/**
* Per default, a non-exclusive rule is created
* @return rule for hg job execution, never null
*/
protected DefaultExecutionRule getExecutionRule() {
if(executionRule == null) {
executionRule = new DefaultExecutionRule();
}
return executionRule;
}
public void setExecutionRule(DefaultExecutionRule rule){
executionRule = rule;
}
public void addOptions(String... optionsToAdd) {
for (String option : optionsToAdd) {
options.add(option);
}
}
public byte[] executeToBytes() throws HgException {
return executeToBytes(getTimeOut());
}
public byte[] executeToBytes(int timeout) throws HgException {
return executeToBytes(timeout, true);
}
/**
* Execute a command.
*
* @param timeout
* -1 if no timeout, else the timeout in ms.
*/
public byte[] executeToBytes(int timeout, boolean expectPositiveReturnValue) throws HgException {
ByteArrayOutputStream bos = new ByteArrayOutputStream(BUFFER_SIZE);
if (executeToStream(bos, timeout, expectPositiveReturnValue)) {
return bos.toByteArray();
}
return null;
}
protected final boolean executeToStream(OutputStream output, int timeout, boolean expectPositiveReturnValue)
throws HgException {
List cmd = getCommands();
String jobName = obfuscateLoginData(getCommandInvoked(cmd));
File tmpFile = setupTmpFile(cmd);
ProcessBuilder builder = setupProcess(cmd);
try {
// I see sometimes that hg has errors if it runs in parallel
// using a job with exclusive rule here serializes all hg access from plugin.
processWrapper = createProcessWrapper(output, uiName, builder);
logConsoleCommandInvoked(jobName);
// will start hg command as soon as job manager allows us to do it
processWrapper.schedule();
try {
waitForConsumer(timeout);
} catch (InterruptedException e) {
processWrapper.cancel();
throw new HgException("Process cancelled: " + jobName, e);
}
if (processWrapper.isAlive()) {
// command timeout
processWrapper.cancel();
throw new HgException("Process timeout: " + jobName);
}
IStatus result = processWrapper.getResult();
if (processWrapper.process == null) {
// process is either not started or we failed to create it
if(result == null){
// was not started at all => timeout?
throw new HgException("Process timeout: " + jobName);
}
if(processWrapper.error == null && result == Status.CANCEL_STATUS) {
throw new HgException(HgException.OPERATION_CANCELLED,
"Process cancelled: " + jobName, null);
}
throw new HgException("Process start failed: " + jobName, processWrapper.error);
}
final String msg = getMessage(output);
final int exitCode = processWrapper.exitCode;
long timeInMillis = debugExecTime? System.currentTimeMillis() - processWrapper.startTime : 0;
// everything fine
if (exitCode != 0 && expectPositiveReturnValue) {
Throwable rootCause = result != null ? result.getException() : null;
final HgException hgex = new HgException(exitCode,
msg, jobName, rootCause);
logConsoleCompleted(timeInMillis, msg, exitCode, hgex);
throw hgex;
}
if (debugExecTime || debugMode) {
logConsoleCompleted(timeInMillis, msg, exitCode, null);
}
return true;
} finally {
if (tmpFile != null && tmpFile.isFile()) {
tmpFile.delete();
}
}
}
protected ProzessWrapper createProcessWrapper(OutputStream output, String jobName, ProcessBuilder builder) {
return new ProzessWrapper(jobName, builder, output);
}
/**
* @param cmd hg commands to run
* @return temporary file path used to write {@link HgFeatures#LISTFILE} arguments
*/
private static File setupTmpFile(List cmd) {
for (String line : cmd) {
if (line.startsWith(HgFeatures.LISTFILE.getHgCmd())) {
return new File(line.substring(HgFeatures.LISTFILE.getHgCmd().length()));
}
}
return null;
}
private ProcessBuilder setupProcess(List cmd) {
ProcessBuilder builder = new ProcessBuilder(cmd);
// set locale to english have deterministic output
Map env = builder.environment();
// From wiki: http://mercurial.selenic.com/wiki/UpgradeNotes
// "If your tools look for particular English messages in Mercurial output,
// they should disable translations with LC_ALL=C"
env.put("LC_ALL", "C"); //$NON-NLS-1$ //$NON-NLS-2$
env.put("LANG", "C"); //$NON-NLS-1$ //$NON-NLS-2$
env.put("LANGUAGE", "C"); //$NON-NLS-1$ //$NON-NLS-2$
// HGPLAIN normalizes output in Mercurial 1.5+
env.put("HGPLAIN", "set by MercurialEclipse"); //$NON-NLS-1$ //$NON-NLS-2$
String charset = setupEncoding(cmd);
if (charset != null) {
env.put("HGENCODING", charset); //$NON-NLS-1$
}
env.put("HGE_RUNDIR", getRunDir());
// removing to allow using eclipse merge editor
builder.environment().remove("HGMERGE");
builder.redirectErrorStream(true); // makes my life easier
if (workingDir != null) {
builder.directory(workingDir);
}
return builder;
}
/**
* Template method to add encoding options
* @param cmd The list of commands to add to
* @return The encoding for HGENCODING env var, or null
*/
protected String setupEncoding(List cmd) {
return null;
}
private void waitForConsumer(int timeout) throws InterruptedException {
if (timeout <= 0) {
timeout = 1;
}
long start = System.currentTimeMillis();
long now = 0;
while (processWrapper.isAlive()) {
long delay = timeout - now;
if (delay <= 0) {
break;
}
synchronized (this){
wait(10);
}
now = System.currentTimeMillis() - start;
}
}
protected void logConsoleCommandInvoked(final String commandInvoked) {
if(isDebugging){
System.out.println(commandInvoked);
}
if (showOnConsole) {
getConsole().commandInvoked(commandInvoked);
}
}
private void logConsoleCompleted(final long timeInMillis, final String msg, final int exitCode, final HgException hgex) {
if(isDebugging){
System.out.println(msg);
if(hgex != null){
hgex.printStackTrace();
}
}
if (showOnConsole) {
getConsole().commandCompleted(exitCode, timeInMillis, msg, hgex);
}
}
private String getMessage(OutputStream output) {
String msg = null;
if (output instanceof FileOutputStream) {
return null;
} else if (output instanceof ByteArrayOutputStream) {
ByteArrayOutputStream baos = (ByteArrayOutputStream) output;
try {
msg = baos.toString(getEncoding());
} catch (UnsupportedEncodingException e) {
logError(e);
msg = baos.toString();
}
if(msg != null){
msg = msg.trim();
}
}
return msg;
}
/**
* Sets the command output charset if the charset is available in the VM.
*/
public void setEncoding(String charset) {
encoding = charset;
}
/**
* @return never returns null
*/
private String getEncoding() {
if(encoding == null){
if (hgRoot != null) {
encoding = hgRoot.getEncoding();
} else {
encoding = getDefaultEncoding();
}
}
return encoding;
}
public String executeToString() throws HgException {
return executeToString(true);
}
public String executeToString(boolean expectPositiveReturnValue) throws HgException {
byte[] bytes = executeToBytes(getTimeOut(), expectPositiveReturnValue);
if (bytes != null && bytes.length > 0) {
try {
return new String(bytes, getEncoding());
} catch (UnsupportedEncodingException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
return ""; //$NON-NLS-1$
}
/**
* Executes a command and writes its output to a file.
*
* @param file
* The file to which the output is written.
* @param expectPositiveReturnValue
* If set to {@code true}, an {@code HgException} will be thrown if the command's
* exit code is not zero.
* @return Returns {@code true} iff the command was executed successfully.
* @throws HgException
* Thrown when the command could not be executed successfully.
*/
public boolean executeToFile(File file, boolean expectPositiveReturnValue) throws HgException {
int timeout = HgClients.getTimeOut(MercurialPreferenceConstants.DEFAULT_TIMEOUT);
FileOutputStream fos = null;
try {
fos = new FileOutputStream(file, false);
return executeToStream(fos, timeout, expectPositiveReturnValue);
} catch (FileNotFoundException e) {
throw new HgException(e.getMessage(), e);
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
throw new HgException(e.getMessage(), e);
}
}
}
}
private List getCommands() {
if (commands != null) {
return commands;
}
List result = new ArrayList();
result.add(getExecutable());
result.add(command);
result.addAll(options);
String listFilesFile = null;
if (HgFeatures.LISTFILE.isEnabled() && getCommandLineLength(files) > 8000) {
listFilesFile = createListFilesFile(files);
}
if(listFilesFile != null){
result.add(listFilesFile);
} else {
if (escapeFiles && !files.isEmpty()) {
result.add("--"); //$NON-NLS-1$
}
result.addAll(files);
}
customizeCommands(result);
return commands = result;
}
private static String createListFilesFile(List paths) {
BufferedWriter bw = null;
try {
File listFile = File.createTempFile("listfile_", "txt");
bw = new BufferedWriter(new FileWriter(listFile));
for (String file : paths) {
bw.write(file);
bw.newLine();
}
bw.flush();
return HgFeatures.LISTFILE.getHgCmd() + listFile.getAbsolutePath();
} catch (IOException ioe) {
MercurialEclipsePlugin.logError(ioe);
return null;
} finally {
if(bw != null) {
try {
bw.close();
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
}
private static int getCommandLineLength(List cmds) {
int length = 0;
for (String f : cmds) {
length += f.getBytes().length;
}
return length;
}
/**
* Can be used after execution to get a list of paths needed to be updated
* @return a copy of file paths affected by this command, if any. Never returns null,
* but may return empty list. The elements of the set are absolute file paths.
*/
public Set getAffectedFiles(){
Set fileSet = new HashSet();
fileSet.addAll(files);
return fileSet;
}
/**
* Template method to customize the commands to execute
* @param cmd The list of commands to execute.
*/
protected void customizeCommands(List cmd) {
}
protected abstract String getExecutable();
private String getRunDir()
{
String sDir = getExecutable();
int i;
if (sDir != null)
{
i = Math.max(sDir.lastIndexOf('\\'), sDir.lastIndexOf('/'));
if (i >= 0)
{
return sDir.substring(0, i);
}
}
return "";
}
/**
* Add a file. Need not be canonical, but will try transform to canonical.
*
* @param myfiles The files to add
*/
public void addFiles(Collection myfiles) {
for (File file : myfiles) {
addFile(file);
}
}
/**
* Add a file. Looks like we must keep the file path (do not resolve),
* see issue #20854.
* Mercurial can deal with links by itself, but only if the link target is
* under the hg root. resolving the link can move the path outside the hg root
* and so hg will deny to collaborate :-)
*
* @param file The file to add
*/
public void addFile(File file) {
files.add(file.getAbsolutePath());
}
public void addFiles(IResource... resources) {
for (IResource resource : resources) {
addResource(resource);
}
}
public void addFiles(List resources) {
for (IResource resource : resources) {
addResource(resource);
}
}
/**
* Add all resources that are of type IResource.FILE
*/
public void addFilesWithoutFolders(List resources) {
for (IResource resource : resources) {
if (resource.getType() == IResource.FILE) {
addResource(resource);
}
}
}
private void addResource(IResource resource) {
// TODO This can be done faster without any file system calls by saving uncanonicalized hg
// root locations (?).
// files.add(resource.getLocation().toOSString());
IPath location = ResourceUtils.getPath(resource);
if(!location.isEmpty()) {
addFile(location.toFile());
}
}
public void setUsePreferenceTimeout(String cloneTimeout) {
this.timeoutConstant = cloneTimeout;
}
public void terminate() {
if (processWrapper != null) {
processWrapper.cancel();
}
}
private static IConsole getConsole() {
return HgClients.getConsole();
}
public void setShowOnConsole(boolean b) {
showOnConsole = b;
}
private String getCommandInvoked(List cmd) {
if(cmd.isEmpty()){
// paranoia
return "";
}
StringBuilder sb = new StringBuilder();
if(workingDir != null){
sb.append(workingDir);
sb.append(':');
}
String exec = cmd.get(0);
exec = exec.replace('\\', '/');
int lastSep = exec.lastIndexOf('/');
if(lastSep <= 0){
sb.append(exec);
} else {
// just the exec. name, not the full path
if(exec.endsWith(".exe")){
sb.append(exec.substring(lastSep + 1, exec.length() - 4));
} else {
sb.append(exec.substring(lastSep + 1));
}
}
for (int i = 1; i < cmd.size(); i++) {
sb.append(" ").append(cmd.get(i));
}
return sb.toString();
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder(getClass().getSimpleName());
builder.append(" [");
if (command != null) {
builder.append("command=");
builder.append(command);
builder.append(", ");
}
if (commands != null) {
builder.append("commands=");
builder.append(commands);
builder.append(", ");
}
if (options != null) {
builder.append("options=");
builder.append(options);
builder.append(", ");
}
if (workingDir != null) {
builder.append("workingDir=");
builder.append(workingDir);
builder.append(", ");
}
if (files != null) {
builder.append("files=");
builder.append(files);
builder.append(", ");
}
builder.append("escapeFiles=");
builder.append(escapeFiles);
builder.append(", ");
if (processWrapper != null) {
builder.append("processWrapper=");
builder.append(processWrapper);
builder.append(", ");
}
builder.append("showOnConsole=");
builder.append(showOnConsole);
builder.append(", ");
if (timeoutConstant != null) {
builder.append("timeoutConstant=");
builder.append(timeoutConstant);
}
builder.append("]");
return builder.toString();
}
private int getTimeOut() {
int timeout;
if (timeoutConstant == null) {
timeoutConstant = MercurialPreferenceConstants.DEFAULT_TIMEOUT;
}
timeout = HgClients.getTimeOut(timeoutConstant);
return timeout;
}
}
ChangesetContentHandler.java 0000664 0000000 0000000 00000026620 11737135005 0035515 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
* Andrei Loskutov - bugfixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import com.vectrace.MercurialEclipse.model.Branch;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.FileStatus;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.model.ChangeSet.Direction;
import com.vectrace.MercurialEclipse.model.FileStatus.Action;
import com.vectrace.MercurialEclipse.team.cache.RemoteData;
/**
* This class helps HgClients to parse the changeset output of hg to Changeset
* objects.
*
* @author Bastian Doetsch
*/
final class ChangesetContentHandler implements ContentHandler {
private static final String[] EMPTY = new String[0];
private static final Pattern LT = Pattern.compile("<");
private static final Pattern GT = Pattern.compile(">");
private static final Pattern AMP = Pattern.compile("&");
private static final Pattern NEWLINE_TAB = Pattern.compile("\n\t");
private static final Pattern WORDS = Pattern.compile(" ");
private String branchStr;
private String tags;
private int rev;
private String nodeShort;
private String nodeLong;
private String dateIso;
private String author;
private String parents;
private String description;
private StringBuilder cDataChars;
private boolean readCdata;
private final IPath res;
private final Direction direction;
private final IHgRepositoryLocation repository;
private final File bundleFile;
private final HgRoot hgRoot;
private final Map> fileRevisions;
private Set filesModified;
private Set filesAdded;
private Set filesRemoved;
private Map filesCopied; // destination -> source
private Map filesMoved; // destination -> source
private Action action;
private String prevNodeShort;
private int prevRev;
private final String expectedBranch;
private final IPath repoPath;
private final boolean withFiles;
ChangesetContentHandler(IPath res, boolean withFiles, Direction direction, IHgRepositoryLocation repository,
File bundleFile, String branch, HgRoot hgRoot) {
this.res = res;
this.withFiles = withFiles;
this.direction = direction;
this.repository = repository;
this.bundleFile = bundleFile;
this.hgRoot = hgRoot;
this.expectedBranch = branch;
repoPath = new Path(hgRoot.getPath());
fileRevisions = new HashMap>();
}
private boolean hasFileData()
{
return filesModified != null;
}
private void initFileData()
{
if (!hasFileData())
{
filesModified = new TreeSet();
filesAdded = new TreeSet();
filesRemoved = new TreeSet();
filesCopied = new TreeMap();
filesMoved = new TreeMap();
}
}
private static String replaceAll(Pattern p, String source, String replacement){
return p.matcher(source).replaceAll(replacement);
}
private static String unescape(String string) {
String result = replaceAll(LT, string, "<");
result = replaceAll(GT, result, ">");
return replaceAll(AMP, result, "&");
}
/**
* Remove a leading tab on each line in the string.
*
* @param string
* @return
*/
private static String untab(String string) {
return replaceAll(NEWLINE_TAB, string, "\n");
}
private static String[] splitWords(String string) {
if (string == null || string.length() == 0) {
return EMPTY;
}
return WORDS.split(string);
}
public void characters(char[] ch, int start, int length) {
if(readCdata) {
cDataChars.append(ch, start, length);
}
}
public void endDocument() throws SAXException {
}
public void endElement(String uri, String localName, String name) throws SAXException {
if ("de".equals(name)) {
description = cDataChars.toString();
} else if ("br".equals(name)) {
branchStr = cDataChars.toString();
} else if ("tg".equals(name)) {
tags = cDataChars.toString();
} else if ("cs".equals(name)) {
// only collect changesets from requested branch. Null is: collect everything.
if(expectedBranch == null || Branch.same(branchStr, expectedBranch)){
ChangeSet.Builder csb = new ChangeSet.Builder(rev, nodeLong, branchStr, dateIso, unescape(author), hgRoot);
csb.tags(tags);
csb.nodeShort(nodeShort);
csb.description(untab(unescape(description)));
addParentsInfo(csb);
csb.bundleFile(bundleFile);
csb.direction(direction);
csb.repository(repository);
if (hasFileData())
{
List list = new ArrayList(
filesModified.size() + filesAdded.size() + filesRemoved.size());
for (String file : filesModified) {
list.add(new FileStatus(FileStatus.Action.MODIFIED, file, hgRoot));
}
for (String file : filesAdded) {
list.add(new FileStatus(FileStatus.Action.ADDED, file, hgRoot));
}
for (String file : filesRemoved) {
list.add(new FileStatus(FileStatus.Action.REMOVED, file, hgRoot));
}
for(Map.Entry entry : filesCopied.entrySet()){
list.add(new FileStatus(FileStatus.Action.COPIED, entry.getKey(), entry.getValue(), hgRoot));
}
for(Map.Entry entry : filesMoved.entrySet()){
list.add(new FileStatus(FileStatus.Action.MOVED, entry.getKey(), entry.getValue(), hgRoot));
}
csb.changedFiles(list.toArray(new FileStatus[list.size()]));
}
ChangeSet changeSet = csb.build();
// changeset to resources & project
addChangesetToResourceMap(changeSet);
}
if (hasFileData()) {
filesModified.clear();
filesAdded.clear();
filesRemoved.clear();
filesCopied.clear();
filesMoved.clear();
}
prevRev = rev;
prevNodeShort = nodeShort;
}
}
/**
* It seems that hg do not report parents if the parent changeset is printed out in
* the same command output. So we guess: if parents are empty, we have to create them
* from the revision + short node of the previous run.
* @param csb
*/
private void addParentsInfo(ChangeSet.Builder csb) {
String[] myParents = splitWords(parents);
if(myParents.length == 0 && prevRev == rev - 1 && prevNodeShort != null){
myParents = new String[]{prevRev + ":" + prevNodeShort};
}
csb.parents(myParents);
}
/**
*
* Format of input is defined in the two style files in /styles and is as
* follows for each changeset.
*
*
* <cs>
* <br v="{branches}"/>
* <tg v="{tags}"/>
* <rv v="{rev}"/>
* <ns v="{node|short}"/>
* <nl v="{node}"/>
* <di v="{date|isodate}"/>
* <da v="{date|age}"/>
* <au v="{author|person}"/>
* <pr v="{parents}"/>
* <de v="{desc|escape|tabindent}"/>
* <fl v="{files}"/>
* <fa v="{file_adds}"/>
* <fd v="{file_dels}"/>
* <f v="{root relative path}"/>
* </cs>
*
* {@inheritDoc}
*/
public void startElement(String uri, String localName, String name, Attributes atts)
throws SAXException {
/*
*
* {desc|escape|tabindent}
*/
readCdata = false;
if ("br".equals(name)) {
branchStr = null;
cDataChars = new StringBuilder(42);
readCdata = true;
} else if ("tg".equals(name)) {
tags = null;
cDataChars = new StringBuilder(42);
readCdata = true;
} else if ("rv".equals(name)) {
rev = Integer.parseInt(atts.getValue(0));
} else if ("ns".equals(name)) {
nodeShort = atts.getValue(0);
} else if ("nl".equals(name)) {
nodeLong = atts.getValue(0);
} else if ("di".equals(name)) {
dateIso = atts.getValue(0);
} else if ("au".equals(name)) {
author = atts.getValue(0);
} else if ("pr".equals(name)) {
parents = atts.getValue(0);
} else if ("de".equals(name)) {
description = null;
cDataChars = new StringBuilder(42);
readCdata = true;
} else if ("fl".equals(name)) {
initFileData();
action = FileStatus.Action.MODIFIED;
} else if ("fa".equals(name)) {
initFileData();
action = FileStatus.Action.ADDED;
} else if ("fd".equals(name)) {
initFileData();
action = FileStatus.Action.REMOVED;
} else if ("fc".equals(name)) {
initFileData();
action = FileStatus.Action.COPIED;
} else if ("f".equals(name)) {
if (action == Action.MODIFIED) {
filesModified.add(atts.getValue("", "v"));
} else if (action == Action.ADDED) {
String value = atts.getValue("", "v");
filesAdded.add(value);
} else if (action == Action.REMOVED) {
String value = atts.getValue("", "v");
filesRemoved.add(value);
} else if(action == Action.COPIED) {
String dest = atts.getValue("", "v");
String src = atts.getValue("", "s");
if(filesRemoved.contains(src)){
filesMoved.put(dest, src);
}else{
filesCopied.put(dest, src);
}
filesAdded.remove(dest);
filesRemoved.remove(src);
}
}
}
private void addChangesetToResourceMap(final ChangeSet cs) {
if(withFiles) {
if (cs.getChangedFiles() != null) {
for (FileStatus file : cs.getChangedFiles()) {
IPath fileAbsPath = file.getAbsolutePath();
mapPathToChangeset(fileAbsPath, cs);
}
}
mapPathToChangeset(res, cs);
} else {
mapPathToChangeset(repoPath, cs);
}
}
private void mapPathToChangeset(IPath path, ChangeSet cs) {
Set fileRevs = fileRevisions.get(path);
if (fileRevs == null) {
fileRevs = new HashSet();
}
fileRevs.add(cs);
fileRevisions.put(path, fileRevs);
}
/**
* @return never null
*/
public Map> getFileRevisions() {
return fileRevisions;
}
public RemoteData createRemoteData() {
return new RemoteData(repository, hgRoot, expectedBranch, direction, fileRevisions);
}
//####################################################################################
public void endPrefixMapping(String prefix) throws SAXException {
}
public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
}
public void processingInstruction(String target, String data) throws SAXException {
}
public void setDocumentLocator(Locator locator) {
}
public void skippedEntity(String name) throws SAXException {
}
public void startDocument() throws SAXException {
}
public void startPrefixMapping(String prefix, String uri) throws SAXException {
}
} eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/GpgCommand.java 0000664 0000000 0000000 00000002444 11737135005 0033054 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.util.List;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
/**
* @author bastian
*
*/
public class GpgCommand extends AbstractShellCommand {
public GpgCommand(HgRoot hgRoot, String uiName, List commands, File workingDir) {
super(uiName, hgRoot, commands, workingDir, false);
}
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#getExecutable()
*/
@Override
protected String getExecutable() {
return MercurialEclipsePlugin.getDefault().getPreferenceStore()
.getString(MercurialPreferenceConstants.GPG_EXECUTABLE);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgAddClient.java 0000664 0000000 0000000 00000005132 11737135005 0033143 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.HgFeatures;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgAddClient extends AbstractClient {
public static void addResources(List resources,
IProgressMonitor monitor) throws HgException {
Map> resourcesByRoot = ResourceUtils.groupByRoot(resources);
for (Map.Entry> mapEntry : resourcesByRoot.entrySet()) {
HgRoot hgRoot = mapEntry.getKey();
if (monitor != null) {
monitor.subTask(Messages.getString("HgAddClient.addingResourcesFrom") + hgRoot.getName()); //$NON-NLS-1$
}
// if there are too many resources, do several calls
// From 1.8 hg can do it in one call
if(!HgFeatures.LISTFILE.isEnabled()) {
int size = mapEntry.getValue().size();
@SuppressWarnings("deprecation")
int delta = AbstractShellCommand.MAX_PARAMS - 1;
for (int i = 0; i < size; i += delta) {
final int j = Math.min(i + delta, size);
AbstractShellCommand command = new HgCommand("add", //$NON-NLS-1$
"Adding " + j + " resources", hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.ADD_TIMEOUT);
command.addFiles(mapEntry.getValue().subList(i, j));
command.executeToBytes();
}
} else {
AbstractShellCommand command = new HgCommand("add", //$NON-NLS-1$
"Adding resources", hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.ADD_TIMEOUT);
command.addFiles(mapEntry.getValue());
command.executeToBytes();
}
}
}
}
HgAnnotateClient.java 0000664 0000000 0000000 00000006101 11737135005 0034142 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) Subclipse and others
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Charles O'Farrell - implementation (based on subclipse)
* StefanC - remove empty lines, code cleenup
* Jérôme Nègre - make it work
* Bastian Doetsch - refactorings
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.annotations.AnnotateBlock;
import com.vectrace.MercurialEclipse.annotations.AnnotateBlocks;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
public class HgAnnotateClient {
private static final Pattern ANNOTATE = Pattern
.compile("^\\s*(.+?)\\s+(\\d+)\\s+(\\w+)\\s+(\\w+ \\w+ \\d+ \\d+:\\d+:\\d+ \\d+ [\\+\\-]\\d+)"); //$NON-NLS-1$
private static final DateFormat DATE_FORMAT = new SimpleDateFormat(
"EEE MMM dd HH:mm:ss yyyy Z", Locale.ENGLISH); //$NON-NLS-1$
public static AnnotateBlocks execute(IResource file) throws HgException {
if (!MercurialTeamProvider.isHgTeamProviderFor(file)) {
return null;
}
HgCommand command = new HgCommand("annotate", "Fetching annotations for resource", file, true);
command.addOptions("--follow", "--user", "--number", "--changeset", "--date");
command.addFiles(file);
return createFromStdOut(new StringReader(command.executeToString()));
}
public static AnnotateBlocks createFromStdOut(InputStream contents) {
return createFromStdOut(new InputStreamReader(contents));
}
protected static synchronized AnnotateBlocks createFromStdOut(Reader contents) {
AnnotateBlocks blocks = new AnnotateBlocks();
try {
BufferedReader reader = new BufferedReader(contents);
int count = 0;
String line;
while ((line = reader.readLine()) != null) {
Matcher matcher = ANNOTATE.matcher(line);
if (!matcher.find()) {
// ignore empty lines
continue;
}
String author = matcher.group(1);
int revision = Integer.parseInt(matcher.group(2));
String changeset = matcher.group(3);
Date date = DATE_FORMAT.parse(matcher.group(4));
blocks.add(new AnnotateBlock(
new HgRevision(changeset, revision), author, date,
count, count));
count++;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return blocks;
}
}
HgBackoutClient.java 0000664 0000000 0000000 00000004245 11737135005 0033770 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgBackoutClient extends AbstractClient {
/**
* Backout of a changeset
*
* @param hgRoot
* the project
* @param backoutRevision
* revision to backout
* @param merge
* flag if merge with a parent is wanted
* @param msg
* commit message
*/
public static String backout(final HgRoot hgRoot, ChangeSet backoutRevision,
boolean merge, String msg, String user) throws HgException {
HgCommand command = new HgCommand("backout", //$NON-NLS-1$
"Backing out changeset " + backoutRevision.getChangeset(), hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
addMergeToolPreference(command);
command.addOptions("-r", backoutRevision.getChangeset(), "-m", msg); //$NON-NLS-1$ //$NON-NLS-2$
command.addUserName(user);
if (merge) {
command.addOptions("--merge"); //$NON-NLS-1$
}
String result = command.executeToString();
command.rememberUserName();
return result;
}
public static boolean isMergeError(HgException e) {
// eg: (without --merge)
// reverting src/file1.text
// adding src/file2.txt
// removing src/file22.txt
// 0 files updated, 0 files merged, 0 files removed, 1 files unresolved
// use 'hg resolve' to retry unresolved file merges.
return HgUpdateClient.isWorkspaceUpdateConflict(e);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgBisectClient.java0000664 0000000 0000000 00000010604 11737135005 0033664 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan Chyssler implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author Stefan Chyssler
*
*/
public final class HgBisectClient extends AbstractClient {
public enum Status { GOOD, BAD }
/**
* Marks the specified changeset as a good revision. If no changeset is specified
* bisect will use the "current" changeset.
*
* @param repository the repository to bisect
* @param good the changeset to mark as good, or null for current
* @return a message from the command
* @throws HgException
*/
public static String markGood(HgRoot repository, ChangeSet good)
throws HgException {
AbstractShellCommand cmd = new HgCommand("bisect", "Bisect: marking revision as good", repository, true); //$NON-NLS-1$
cmd.addOptions("-g"); //$NON-NLS-1$
if(good != null) {
cmd.addOptions(getRevision(good));
}
return cmd.executeToString();
}
/**
* Marks the specified changeset as a bad revision. If no changeset is specified
* bisect will use teh "current" changeset.
*
* @param repository the repository to bisect
* @param bad the changeset to mark as bad, or null for current
* @return a message from the command
* @throws HgException
*/
public static String markBad(HgRoot repository, ChangeSet bad)
throws HgException {
AbstractShellCommand cmd = new HgCommand("bisect", //$NON-NLS-1$
"Bisect: marking revision as bad", repository, true);
cmd.addOptions("-b"); //$NON-NLS-1$
if(bad != null) {
cmd.addOptions(getRevision(bad));
}
return cmd.executeToString();
}
/**
* Resets the bisect status for this repository. This command will not update the repository
* to the head.
* @param repository the repository to reset bisect status for
* @return
* @throws HgException
*/
public static String reset(HgRoot repository) throws HgException {
AbstractShellCommand cmd = new HgCommand("bisect", //$NON-NLS-1$
"Reseting bisect", repository, true);
cmd.addOptions("-r"); //$NON-NLS-1$
return cmd.executeToString();
}
/**
* Checks if the repository is currently being bisected
*/
public static boolean isBisecting(HgRoot hgRoot) {
return getStatusFile(hgRoot).exists();
}
/**
* Gets a Status by Changeset map containing marked bisect statuses.
* @param hgRoot
* @return
* @throws HgException
*/
public static Map getBisectStatus(HgRoot hgRoot) throws HgException {
HashMap statusByRevision = new HashMap();
if(!isBisecting(hgRoot)) {
return statusByRevision;
}
BufferedReader reader = null;
try {
File file = getStatusFile(hgRoot);
reader = new BufferedReader(new FileReader(file));
String line = null;
while(null != (line = reader.readLine())) {
String[] statusChangeset = line.split("\\s"); //$NON-NLS-1$
if(statusChangeset[0].equalsIgnoreCase("bad")) { //$NON-NLS-1$
statusByRevision.put(statusChangeset[1].trim(), Status.BAD);
} else {
statusByRevision.put(statusChangeset[1].trim(), Status.GOOD);
}
}
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
} finally {
try {
if (reader != null) {
reader.close();
}
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
}
return statusByRevision;
}
private static File getStatusFile(HgRoot hgRoot) {
return new File(hgRoot, ".hg" + File.separator + "bisect.state"); //$NON-NLS-1$ //$NON-NLS-2$
}
private static String getRevision(ChangeSet change) {
return Integer.toString(change.getRevision().getRevision());
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgBranchClient.java0000664 0000000 0000000 00000014777 11737135005 0033667 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2009 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
* Zsolt Koppany (Intland)
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.Branch;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RemoteKey;
import com.vectrace.MercurialEclipse.utils.StringUtils;
public class HgBranchClient extends AbstractClient {
/**
* matches branch names which may also contain spaces or consist of only one letter.
* Valid examples:
* "a test 3:066ee3f79d2a"
* "* 2:5a953790aa12 (inactive)"
* "default 0:fd83cc49d230 (inactive)"
*/
private static final Pattern GET_BRANCHES_PATTERN = Pattern.compile(
// (branch name) (version):(hash) (optional "inactive" flag)
"^(.*[^ ]+) +([0-9]+):([a-f0-9]+)( +(.+))?$"); //$NON-NLS-1$
private static final Map KNOWN_BRANCHES = new ConcurrentHashMap();
/**
* Returns all available (not closed) branches
* @param hgRoot non null
* @return never null, but possibly empty array
* @throws HgException
*/
public static Branch[] getBranches(HgRoot hgRoot) throws HgException {
AbstractShellCommand command = new HgCommand("branches", "Listing branches", hgRoot, false); //$NON-NLS-1$
command.addOptions("-v"); //$NON-NLS-1$
String[] lines = command.executeToString().split("\n"); //$NON-NLS-1$
List branches = new ArrayList();
for (String line : lines) {
if(StringUtils.isEmpty(line)){
continue;
}
Branch branch = parseBranch(line);
if (branch != null) {
branches.add(branch);
} else {
HgException ex = new HgException("Failed to parse branch from '" + line + "'"); //$NON-NLS-1$ //$NON-NLS-2$
MercurialEclipsePlugin.logWarning("Failed to parse branch", ex); //$NON-NLS-1$
}
}
Collections.sort(branches, Branch.COMPARATOR);
return branches.toArray(new Branch[branches.size()]);
}
protected static Branch parseBranch(String line) {
Matcher m = GET_BRANCHES_PATTERN.matcher(line.trim());
if (m.matches()) {
Branch branch = new Branch(m.group(1), Integer.parseInt(m.group(2)), m.group(3), !"(inactive)".equals(m.group(5))); //$NON-NLS-1$
return branch;
}
return null;
}
/**
* @param user
* if null, uses the default user
* @throws HgException
*/
public static String addBranch(HgRoot hgRoot, String name, String user, boolean force) throws HgException {
HgCommand command = new HgCommand("branch", "Creating branch " + name, hgRoot, false); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
if (force) {
command.addOptions("-f"); //$NON-NLS-1$
}
command.addOptions(name);
return command.executeToString();
}
/**
* Get active branch of working directory
*
* @param workingDir
* a file or a directory within the local repository
* @return the branch name, never null
* @throws HgException
* if a hg error occurred
*/
public static String getActiveBranch(HgRoot workingDir) throws HgException {
AbstractShellCommand command = new HgCommand("branch", "Retrieving current branch name", workingDir, false); //$NON-NLS-1$
return command.executeToString().replaceAll("\n", "");
}
/**
* @param key non null
* @return true if the given branch is known at remote repository
*/
public static boolean isKnownRemote(RemoteKey key) {
String branch = key.getBranch();
if(Branch.isDefault(branch)){
// default is always there
return true;
}
Boolean result = KNOWN_BRANCHES.get(key);
if(Boolean.TRUE.equals(result)){
return true;
}
// we are using "hg incoming" to check if remote repository knows the given branch
// unfortunately I didn't found more elegant way to get this infor from hg for
// REMOTE repository, because neither "hg branch" nor "hg branches" works then
AbstractShellCommand command = new HgCommand("incoming", //$NON-NLS-1$
"Querying remote branch existence", key.getRoot(), false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
// limit to one version
command.addOptions("-l", "1");
// try to access the the branch
command.addOptions("-r", branch);
IHgRepositoryLocation repository = key.getRepo();
URI uri;
try {
uri = repository.getUri();
} catch (HgException e) {
MercurialEclipsePlugin.logError(e);
return false;
}
if (uri != null) {
command.addOptions(uri.toASCIIString());
} else {
command.addOptions(repository.getLocation());
}
try {
command.executeToString();
// remember branch, don't ask each time. The probability that somebody "closes" it is very low
KNOWN_BRANCHES.put(key, Boolean.TRUE);
return true;
} catch (HgException e) {
String message = e.getMessage();
// not sure how reliable this is. On non-default language systems the first
// part won't work. The second part (exit code) may rely on different OS implementations...
// Incoming responds with an exception if there are no incoming changesets...
// but exception is different if no branch exists on remote. So trying to
// distinguish between "no changesets" and "unknown branch (== unknown revision)"
if (message.contains("no changes found") && !message.contains("unknown revision") && e.getStatus().getCode() == 1) {
KNOWN_BRANCHES.put(key, Boolean.TRUE);
return true;
}
// TODO we should improve it later, if we can keep the "unknown branches" state up to date
// right now don't save "unknown" state, as it may change at any time
return false;
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgBundleClient.java0000664 0000000 0000000 00000004045 11737135005 0033666 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others. All rights
* reserved. This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0 which accompanies this
* distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: Bastian Doetsch - implementation
******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
public class HgBundleClient extends AbstractClient {
public static String bundle(HgRoot root, ChangeSet rev, String targetRepo,
String file, boolean all, String base) throws HgException {
AbstractShellCommand cmd = new HgCommand("bundle", "Exporting revisions to bundle", root, true);
cmd.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(
root));
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.PUSH_TIMEOUT);
if (rev != null) {
cmd.addOptions("-r", rev.getChangeset());
}
if (all) {
cmd.addOptions("-a");
} else if (base != null && base.length() > 0) {
cmd.addOptions("--base", base);
}
cmd.addOptions(file);
if (targetRepo != null && targetRepo.length() > 0) {
cmd.addOptions(targetRepo);
}
return cmd.executeToString();
}
public static String unbundle(HgRoot root, boolean update, String file)
throws HgException {
AbstractShellCommand cmd = new HgCommand("unbundle", "Importing revisions from bundle", root, true);
cmd.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(
root));
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
if (update) {
cmd.addOptions("-u");
}
cmd.addOptions(file);
return cmd.executeToString();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgCatClient.java 0000664 0000000 0000000 00000006346 11737135005 0033172 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.IOException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgFile;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgCatClient extends AbstractClient {
public static byte[] getContent(IFile resource, String revision) throws HgException {
HgRoot hgRoot = getHgRoot(resource);
File file = ResourceUtils.getFileHandle(resource);
AbstractShellCommand command = new HgCommand("cat", "Retrieving file contents", hgRoot, true);
if (revision != null && revision.length() != 0) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
command.addOptions("--decode"); //$NON-NLS-1$
command.addOptions(hgRoot.toRelative(file));
return command.executeToBytes();
}
public static byte[] getContent(IHgFile hgfile) throws HgException {
HgRoot hgRoot = hgfile.getHgRoot();
AbstractShellCommand command = new HgCommand("cat", "Retrieving file contents", hgRoot, true);
String revision = hgfile.getChangeSet() == null? null : hgfile.getChangeSet().getChangeset();
if (revision != null && revision.length() != 0) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
command.addOptions("--decode"); //$NON-NLS-1$
command.addOptions(hgfile.getHgRootRelativePath());
return command.executeToBytes();
}
public static byte[] getContentFromBundle(IFile resource, String revision, File overlayBundle)
throws HgException, IOException {
Assert.isNotNull(overlayBundle);
HgRoot hgRoot = getHgRoot(resource);
File file = ResourceUtils.getFileHandle(resource);
HgCommand hgCommand = new HgCommand("cat", "Retrieving file contents from bundle", hgRoot, true);
hgCommand.setBundleOverlay(overlayBundle);
if (revision != null && revision.length() != 0) {
hgCommand.addOptions("-r", revision);
}
hgCommand.addOptions("--decode", hgRoot.toRelative(file));
return hgCommand.executeToBytes();
}
public static byte[] getContentFromBundle(IHgFile hgfile, String revision, File overlayBundle)
throws HgException, IOException {
Assert.isNotNull(overlayBundle);
HgRoot hgRoot = hgfile.getHgRoot();
HgCommand hgCommand = new HgCommand("cat", "Retrieving file contents from bundle", hgRoot, true);
hgCommand.setBundleOverlay(overlayBundle);
if (revision != null && revision.length() != 0) {
hgCommand.addOptions("-r", revision);
}
hgCommand.addOptions("--decode", hgfile.getHgRootRelativePath());
return hgCommand.executeToBytes();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgClients.java 0000664 0000000 0000000 00000003742 11737135005 0032722 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
/**
* @author Stefan
*
*/
public final class HgClients {
private static IConsole console;
private static IConfiguration config;
private static IErrorHandler error;
private HgClients() {
// hide constructor of utility class.
}
public static void initialize(IConsole c, IErrorHandler errorHandler,
IConfiguration configuration) {
HgClients.config = configuration;
HgClients.console = c;
HgClients.error = errorHandler;
}
public static String getExecutable() {
if (config == null) {
throw new IllegalStateException(
Messages.getString("HgClients.error.notInitializedWithConfig")); //$NON-NLS-1$
}
return config.getExecutable();
}
public static IConsole getConsole() {
if (console == null) {
throw new IllegalStateException(
Messages.getString("HgClients.error.notInitializedWithConsole")); //$NON-NLS-1$
}
return console;
}
public static void logError(Throwable e) {
error.logError(e);
}
public static void logWarning(String message, Throwable e) {
error.logWarning(message, e);
MercurialEclipsePlugin.logWarning(message, e);
}
public static int getTimeOut(String commandId) {
return config.getTimeOut(commandId);
}
public static String getPreference(String preferenceConstant,
String defaultIfNotSet) {
return config.getPreference(preferenceConstant, defaultIfNotSet);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgCloneClient.java 0000664 0000000 0000000 00000003606 11737135005 0033517 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Andrei Loskutov - bug fixes
* Philip Graf - proxy support
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
public class HgCloneClient extends AbstractClient {
public static void clone(File parentDirectory, IHgRepositoryLocation repo,
boolean noUpdate, boolean pull, boolean uncompressed,
boolean timeout, String rev, String cloneName) throws HgException {
AbstractShellCommand command = new RootlessHgCommand("clone", "Cloning", parentDirectory); //$NON-NLS-1$
addInsecurePreference(command);
if (noUpdate) {
command.addOptions("--noupdate"); //$NON-NLS-1$
}
if (pull) {
command.addOptions("--pull"); //$NON-NLS-1$
}
if (uncompressed) {
command.addOptions("--uncompressed"); //$NON-NLS-1$
}
if (rev != null && rev.length() > 0) {
command.addOptions("--rev", rev); //$NON-NLS-1$
}
addRepoToHgCommand(repo, command);
if (cloneName != null) {
command.addOptions(cloneName);
}
if (timeout) {
command
.setUsePreferenceTimeout(MercurialPreferenceConstants.CLONE_TIMEOUT);
command.executeToBytes();
} else {
command.executeToBytes(Integer.MAX_VALUE);
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgCommand.java 0000664 0000000 0000000 00000014334 11737135005 0032676 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Bastian Doetsch
* Andrei Loskutov - bug fixes
* John Peberdy - refactoring
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.storage.HgCommitMessageManager;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
*
* @author Jerome Negre
*/
public class HgCommand extends AbstractShellCommand {
private static final Set COMMANDS_CONFLICTING_WITH_USER_ARG =
Collections.unmodifiableSet(new HashSet(Arrays.asList(
"clone", "pull", "resolve", "showconfig", "status", "unbundle"
)));
private String lastUserName;
private String bundleFile;
// constructors
public HgCommand(String command, String uiName, HgRoot root, boolean escapeFiles) {
super(uiName, root, root, escapeFiles);
this.command = command;
Assert.isNotNull(command);
Assert.isNotNull(hgRoot);
}
/**
* Invoke a hg command in the directory of the given resource using the resource to find the HgRoot.
*
* @param command The command to execute
* @param uiName Human readable name for this command
* @param resource The resource to use for working directory
* @param escapeFiles Whether to escape files
* @throws HgException
*/
public HgCommand(String command, String uiName, IResource resource, boolean escapeFiles) throws HgException {
super(uiName, AbstractClient.getHgRoot(resource), ResourceUtils.getFirstExistingDirectory(ResourceUtils.getFileHandle(resource)), escapeFiles);
this.command = command;
Assert.isNotNull(command);
Assert.isNotNull(hgRoot);
}
// operations
public HgRoot getHgRoot() {
return hgRoot;
}
/**
* NOTE! this method works only for hg commands which knows "-u" argument
* AND which understood "-u" as user name. There are commands which accept "-u" but
* treat is differently: like "resolve" or "status" (see {@link #isConflictingWithUserArg()}).
*
* @param user might be null or empty. In such case, a default user name will be used.
* @throws IllegalArgumentException if the command uses "-u" NOT as user name parameter
*/
public void addUserName(String user) throws IllegalArgumentException {
// avoid empty user
user = user != null ? user : MercurialUtilities.getDefaultUserName();
if(user != null) {
user = user.trim();
if (user.length() == 0) {
user = null;
} else {
user = quote(user);
}
}
if(user != null) {
if (isConflictingWithUserArg()) {
throw new IllegalArgumentException("Command '" + command
+ "' uses '-u' argument NOT as user name!");
}
options.add("-u"); //$NON-NLS-1$
options.add(user);
this.lastUserName = user;
} else {
this.lastUserName = null;
}
}
public void addStyleFile(int style) throws HgException {
try {
addOptions("--style", //$NON-NLS-1$
AbstractParseChangesetClient.getStyleFile(style).getCanonicalPath());
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
/**
* Remembers the user name given as option (see {@link #addUserName(String)}) as the default
* user name for current hg root. Should be called only after the command was successfully
* executed. If no hg root or no user name option was given, does nothing.
*/
public void rememberUserName(){
if (lastUserName == null){
return;
}
String commitName = HgCommitMessageManager.getDefaultCommitName(hgRoot);
if(!commitName.equals(lastUserName)) {
HgCommitMessageManager.setDefaultCommitName(hgRoot, lastUserName);
}
}
private boolean isConflictingWithUserArg() {
if(command == null){
// TODO can it happen???
return false;
}
return COMMANDS_CONFLICTING_WITH_USER_ARG.contains(command);
}
public void setBundleOverlay(File file) throws IOException {
if (file != null) {
bundleFile = file.getCanonicalPath();
} else {
bundleFile = null;
}
}
/**
* @param str non null, non empty string
* @return non null string with escaped quotes (depending on the OS)
*/
private static String quote(String str) {
if (!MercurialUtilities.isWindows()) {
return str;
}
// escape quotes, otherwise commit will fail at least on windows
return str.replace("\"", "\\\""); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#customizeCommands(java.util.List)
*/
@Override
protected void customizeCommands(List cmd) {
if (bundleFile != null) {
// Add -R
cmd.add(1, bundleFile);
cmd.add(1, "-R");
}
cmd.add(1, "-y");
}
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#getExecutable()
*/
@Override
protected String getExecutable() {
return HgClients.getExecutable();
}
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#setupEncoding(java.util.List)
*/
@Override
protected String setupEncoding(List cmd) {
String charset = hgRoot.getEncoding();
// Enforce strict command line encoding
cmd.add(1, charset);
cmd.add(1, "--encoding");
// Enforce fallback encoding for UI (command output)
// Note: base encoding is UTF-8 for mercurial, fallback is only take into account
// if actual platfrom don't support it.
cmd.add(1, "ui.fallbackencoding=" + hgRoot.getFallbackencoding().name()); //$NON-NLS-1$
cmd.add(1, "--config"); //$NON-NLS-1$
return charset;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgCommitClient.java0000664 0000000 0000000 00000015323 11737135005 0033706 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Bastian Doetsch
* StefanC
* Zsolt Koppany (Intland)
* Adam Berkes (Intland)
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgCommitClient extends AbstractClient {
/**
* Commit given resources and refresh the caches for the associated projects
*/
public static String commitResources(List resources, String user, String message, IProgressMonitor monitor, boolean closeBranch) throws HgException {
Map> resourcesByRoot = ResourceUtils.groupByRoot(resources);
StringBuilder commit = new StringBuilder();
for (Map.Entry> mapEntry : resourcesByRoot.entrySet()) {
HgRoot root = mapEntry.getKey();
if (monitor != null) {
if (monitor.isCanceled()) {
break;
}
monitor.subTask(Messages.getString("HgCommitClient.commitJob.committing") + root.getName()); //$NON-NLS-1$
}
List files = mapEntry.getValue();
commit.append(commit(root, AbstractClient.toFiles(files), user, message, closeBranch));
}
for (HgRoot root : resourcesByRoot.keySet()) {
new RefreshRootJob(root, RefreshRootJob.LOCAL_AND_OUTGOING).schedule();
}
return commit.toString();
}
/**
* Commit given hg root with all checked out/added/deleted changes and refresh the caches for the assotiated projects
*/
public static String commitResources(HgRoot root, boolean closeBranch, String user, String message, IProgressMonitor monitor) throws HgException {
monitor.subTask(Messages.getString("HgCommitClient.commitJob.committing") + root.getName()); //$NON-NLS-1$
List emptyList = Collections.emptyList();
try {
return commit(root, emptyList, user, message, closeBranch);
} finally {
new RefreshRootJob(root, RefreshRootJob.LOCAL_AND_OUTGOING).schedule();
}
}
/**
* Performs commit. No refresh of any cashes is done afterwards.
*
* Note clients should not use this method directly, it is NOT private
* for tests only
*/
protected static String commit(HgRoot hgRoot, List files, String user, String message,
boolean closeBranch) throws HgException {
HgCommand command = new HgCommand("commit", "Committing resources", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.COMMIT_TIMEOUT);
command.addUserName(user);
if (closeBranch) {
command.addOptions("--close-branch");
}
File messageFile = addMessage(command, message);
try {
command.addFiles(files);
String result = command.executeToString();
command.rememberUserName();
return result;
} finally {
deleteMessage(messageFile);
}
}
/**
* Add the message to the command. If possible a file is created to do this (assumes the command
* accepts the -l parameter)
*
* @return The file that must be deleted
* @see #deleteMessage(File)
*/
public static File addMessage(HgCommand command, String message) {
File messageFile = saveMessage(message, command);
if (messageFile != null && messageFile.isFile()) {
command.addOptions("-l", messageFile.getAbsolutePath());
return messageFile;
}
// fallback in case of unavailable message file
message = quote(message.trim());
if (message.length() != 0) {
command.addOptions("-m", message);
} else {
command.addOptions("-m",
com.vectrace.MercurialEclipse.dialogs.Messages
.getString("CommitDialog.defaultCommitMessage"));
}
return messageFile;
}
/**
* Commit given project after the merge and refresh the caches.
* Implementation note: after merge, no files should be specified.
*/
public static String commit(HgRoot hgRoot, String user, String message) throws HgException {
HgCommand command = new HgCommand("commit", "Committing all changes", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.COMMIT_TIMEOUT);
command.addUserName(user);
File messageFile = addMessage(command, message);
try {
String result = command.executeToString();
command.rememberUserName();
new RefreshRootJob(hgRoot, RefreshRootJob.LOCAL_AND_OUTGOING).schedule();
return result;
} finally {
deleteMessage(messageFile);
}
}
private static String quote(String str) {
if (str != null) {
str = str.trim();
}
if (str == null || str.length() == 0 || !MercurialUtilities.isWindows()) {
return str;
}
// escape quotes, otherwise commit will fail at least on windows
return str.replace("\"", "\\\""); //$NON-NLS-1$ //$NON-NLS-2$
}
private static File saveMessage(String message, HgCommand command) {
Writer writer = null;
try {
File messageFile = File.createTempFile("hgcommitmsg", ".txt");
writer = new OutputStreamWriter(new FileOutputStream(messageFile),
command.getHgRoot().getEncoding());
writer.write(message.trim());
return messageFile;
} catch (IOException ex) {
MercurialEclipsePlugin.logError(ex);
return null;
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException ex) {
MercurialEclipsePlugin.logError(ex);
}
}
}
}
public static void deleteMessage(File messageFile) {
// Try to delete normally, and if not successful
// leave it for the JVM exit - I use it in case
// mercurial accidentally locks the file.
if (messageFile != null && !messageFile.delete()) {
messageFile.deleteOnExit();
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgConfigClient.java0000664 0000000 0000000 00000002162 11737135005 0033660 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 Bastian Doetsch and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.exception.HgException;
/**
* @author bastian
*
*/
public class HgConfigClient extends AbstractClient {
public static String getHgConfigLine(String key)
throws HgException {
String[] lines = getHgConfigLines(key);
return lines[0];
}
private static String[] getHgConfigLines(String key)
throws HgException {
AbstractShellCommand cmd = new RootlessHgCommand("showconfig", "Getting configuration information");
cmd.addOptions(key);
String[] lines = cmd.executeToString().split("\n"); //$NON-NLS-1$
return lines;
}
}
HgDebugInstallClient.java 0000664 0000000 0000000 00000004545 11737135005 0034760 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import com.vectrace.MercurialEclipse.exception.HgException;
public class HgDebugInstallClient extends AbstractClient {
/**
* Key is the charset name, value is "true" if hg supports this charset encoding
*/
public static final Map ENCODINGS = Collections
.synchronizedMap(new HashMap());
public static String debugInstall() throws HgException {
AbstractShellCommand command = getDebugInstallCommand();
return new String(command.executeToBytes(Integer.MAX_VALUE)).trim();
}
private static AbstractShellCommand getDebugInstallCommand() {
return new RootlessHgCommand("debuginstall", "Checking Mercurial installation") {
{
isInitialCommand = startSignal.getCount() > 0;
}
};
}
/**
* @param defaultCharset non null
* @return true if the given changeset is supported by the hg installation
*/
public static boolean hgSupportsEncoding(String defaultCharset) {
Boolean b;
synchronized(ENCODINGS){
b = ENCODINGS.get(defaultCharset);
}
if (b == null) {
AbstractShellCommand cmd = getDebugInstallCommand();
cmd.addOptions("--encoding", defaultCharset); //$NON-NLS-1$
try {
cmd.executeToString();
} catch (HgException e) {
// there might have been an exception but it is not necessarily
// related to the encoding. so only return false if the following
// string is in the message
if (e.getMessage().contains("unknown encoding:")) { //$NON-NLS-1$
synchronized(ENCODINGS){
ENCODINGS.put(defaultCharset, Boolean.FALSE);
}
return false;
}
}
synchronized(ENCODINGS){
ENCODINGS.put(defaultCharset, Boolean.TRUE);
}
return true;
}
return b.booleanValue();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgGrepClient.java 0000664 0000000 0000000 00000005331 11737135005 0033351 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.search.MercurialTextSearchMatchAccess;
import com.vectrace.MercurialEclipse.utils.StringUtils;
/**
* @author Bastian
*
*/
public class HgGrepClient extends AbstractClient {
/**
* Greps given Hg repo with params -lnu -all for given pattern
*
* @param root
* @param pattern
* @param all
* @param res
* @return
* @throws HgException
*/
public static List grep(HgRoot root, String pattern, List files, boolean all, final IProgressMonitor monitor)
throws HgException {
final AbstractShellCommand cmd = new HgCommand("grep", "Searching repository", root, true);
cmd.addOptions("-nuf");
if (all) {
cmd.addOptions("--all");
}
if (StringUtils.isEmpty(pattern)) {
return new ArrayList();
}
cmd.addOptions(pattern);
cmd.addFilesWithoutFolders(files);
String result = null;
if (monitor != null) {
Timer t = new Timer("HG GREP watcher");
try {
t.schedule(new TimerTask() {
@Override
public void run() {
if (monitor.isCanceled()) {
cmd.terminate();
cancel();
}
}
}, 100, 100);
result = cmd.executeToString(false);
} finally {
t.cancel();
}
} else {
result = cmd.executeToString(false);
}
return getSearchResults(root, result, all);
}
/**
* @param root
* @param result
* @return
*/
private static List getSearchResults(HgRoot root,
String result, boolean all) {
String[] lines = result.split("\n");
List list = new ArrayList();
for (String line : lines) {
try {
list.add(new MercurialTextSearchMatchAccess(root, line, all));
} catch (HgException e) {
// skip parsing errors, add only successful matches
}
}
return list;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgIdentClient.java 0000664 0000000 0000000 00000006415 11737135005 0033523 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
public class HgIdentClient extends AbstractClient {
public static final String VERSION_ZERO = "0000000000000000000000000000000000000000";
/**
* @param b
* byte array containing integer data
* @param idx
* start index to read integer from
* @return integer value, corresponding to the 4 bytes from the given array at given position
*/
private static int getNextInt(byte[] b, int idx) {
int result = 0;
for(int i = 0; i < 4 && i + idx < b.length; i++) {
result = (result << 8) + (b[i + idx] & 0xff);
}
return result;
}
static String getCurrentChangesetId(InputStream inputStream) throws HgException {
StringBuilder id = new StringBuilder(20);
byte[] first20bytes = new byte[20];
int read;
try {
read = inputStream.read(first20bytes);
} catch (IOException e) {
throw new HgException(e.getMessage(), e);
}
for (int i = 0; i < read; i += 4) {
int next = getNextInt(first20bytes, i);
String s = Integer.toHexString(next);
int size = s.length();
while(size < 8) {
id.append('0');
size++;
}
id.append(s);
}
return id.toString();
}
/**
* Returns the current node-id as a String
*
* @param repository
* the root of the repository to identify
* @return Returns the node-id for the current changeset
* @throws HgException
*/
public static String getCurrentChangesetId(HgRoot repository) throws HgException {
File file = new File(repository, ".hg" + File.separator + "dirstate");
if(!file.exists()){
// new repository with no files
return VERSION_ZERO;
}
FileInputStream reader = null;
try {
reader = new FileInputStream(file);
} catch (FileNotFoundException e) {
// sometimes hg is writing the file at same time we trying to read from it
// this happens especially if we run many add/remove operations
synchronized (HgIdentClient.class) {
try {
HgIdentClient.class.wait(300);
} catch (InterruptedException e1) {
MercurialEclipsePlugin.logError(e1);
}
}
try {
reader = new FileInputStream(file);
} catch (FileNotFoundException e1) {
MercurialEclipsePlugin.logError(e1);
}
if(reader == null) {
throw new HgException("Dirstate failed for the path: " + file, e);
}
}
try {
return getCurrentChangesetId(reader);
} finally {
try {
reader.close();
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgIgnoreClient.java0000664 0000000 0000000 00000007522 11737135005 0033703 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgIgnoreClient extends AbstractClient {
public static void addExtension(IFile file) throws HgException {
HgRoot hgRoot = getHgRoot(file);
addPattern(hgRoot, "regexp", escape("." + file.getFileExtension()) + "$"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
public static void addFile(IFile file) throws HgException {
HgRoot hgRoot = getHgRoot(file);
String regexp = "^" + getRelativePath(hgRoot, file) + "$"; //$NON-NLS-1$ //$NON-NLS-2$
addPattern(hgRoot, "regexp", regexp); //$NON-NLS-1$
}
private static String getRelativePath(HgRoot hgRoot, IResource resource) {
IPath path = ResourceUtils.getPath(resource);
String relative = hgRoot.toRelative(path.toFile());
relative = relative.replace('\\', '/');
return escape(relative);
}
public static void addFolder(IFolder folder) throws HgException {
HgRoot hgRoot = getHgRoot(folder);
String regexp = "^" + getRelativePath(hgRoot, folder) + "$"; //$NON-NLS-1$ //$NON-NLS-2$
addPattern(hgRoot, "regexp", regexp); //$NON-NLS-1$
}
public static void addRegexp(IProject project, String regexp) throws HgException {
HgRoot hgRoot = getHgRoot(project);
addPattern(hgRoot, "regexp", regexp); //$NON-NLS-1$
}
public static void addGlob(IProject project, String glob) throws HgException {
HgRoot hgRoot = getHgRoot(project);
addPattern(hgRoot, "glob", glob); //$NON-NLS-1$
}
private static String escape(String string) {
StringBuilder result = new StringBuilder();
int len = string.length();
for(int i=0; i filter) throws HgException {
HgRoot hgRoot = getHgRoot(resource);
if (cs == null) {
// local resource
if (resource instanceof IFile) {
return new HgFile(hgRoot, (IFile)resource);
}
if (resource instanceof IContainer) {
return new HgFolder(hgRoot, (IContainer)resource, filter);
}
return null;
}
String revision = cs.getChangeset();
HgCommand command = new HgCommand("locate", "Retrieving repository contents", hgRoot, true);
if (cs.getDirection() == Direction.INCOMING && cs.getBundleFile() != null) {
try {
command.setBundleOverlay(cs.getBundleFile());
} catch (IOException e) {
throw new HgException("Unable to determine canonical path for " + cs.getBundleFile(), e);
}
}
if (revision != null && revision.length() != 0) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
IPath relpath = ResourceUtils.getPath(resource).makeRelativeTo(hgRoot.getIPath());
command.addOptions(getHgResourceSearchPattern(resource));
String[] lines = null;
try {
lines = command.executeToString().split("\n"); //$NON-NLS-1$
} catch (HgException e) {
// it is normal that the resource does not exist.
}
if (resource instanceof IStorage) {
if (lines == null || lines.length == 0) {
return new NullHgFile(hgRoot, cs, relpath);
}
for (String line : lines) {
return new HgFile(hgRoot, cs, new Path(line));
}
}
return new HgFolder(hgRoot, cs, relpath, lines, filter);
}
public static IHgResource getHgResources(IHgResource hgResource, String revision, SortedSet filter) {
HgRoot hgRoot = hgResource.getHgRoot();
AbstractShellCommand command = new HgCommand("locate", "Retrieving repository contents", hgRoot, true);
if (revision != null && revision.length() != 0) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
if (hgResource instanceof IHgFile) {
command.addOptions("glob:" + hgResource.getHgRootRelativePath());
} else {
command.addOptions("glob:" + hgResource.getHgRootRelativePath() + System.getProperty("file.separator") + "**");
}
String[] lines = null;
try {
lines = command.executeToString().split("\n"); //$NON-NLS-1$
} catch (HgException e) {
// it is normal that the resource does not exist.
MercurialEclipsePlugin.logWarning(e.getMessage(), e);
}
if (hgResource instanceof IStorage) {
if (lines == null || lines.length == 0) {
return new NullHgFile(hgRoot, revision, new Path(hgResource.getHgRootRelativePath()));
}
for (String line : lines) {
return new HgFile(hgRoot, revision, new Path(line));
}
}
return new HgFolder(hgRoot, revision, hgResource.getIPath(), lines, filter);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgLogClient.java 0000664 0000000 0000000 00000036524 11737135005 0033205 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others. All rights
* reserved. This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0 which accompanies this
* distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: Bastian Doetsch - implementation
* Andrei Loskutov - bugfixes
* Zsolt Koppany (Intland)
* Ilya Ivanov (Intland)
******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.history.MercurialHistory;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.HgRootContainer;
import com.vectrace.MercurialEclipse.model.ChangeSet.Builder;
import com.vectrace.MercurialEclipse.model.ChangeSet.Direction;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
import com.vectrace.MercurialEclipse.team.cache.MercurialRootCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
import com.vectrace.MercurialEclipse.utils.StringUtils;
public class HgLogClient extends AbstractParseChangesetClient {
private static final Map> EMPTY_MAP =
Collections.unmodifiableMap(new HashMap>());
// "{rev}:{node} {date|isodate} {author|person}#{tags}**#{branches}**#{desc|firstline}\n"
private static final Pattern GET_REVISIONS_PATTERN = Pattern
.compile("^([-0-9]+):([a-f0-9]+) ([^ ]+ [^ ]+ [^ ]+) ([^#]*)#(.*)\\*\\*#(.*)\\*\\*#(.*)$"); //$NON-NLS-1$
public static final String NOLIMIT = "999999999999";
public static ChangeSet[] getHeads(HgRoot hgRoot) throws HgException {
HgCommand command = new HgCommand("heads", "Listing heads", hgRoot, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
return getRevisions(command);
}
public static ChangeSet getTip(HgRoot hgRoot) throws HgException {
HgCommand command = new HgCommand("log", "Finding tip revision", hgRoot, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addOptions("-r", HgRevision.TIP.getChangeset());
ChangeSet[] sets = getRevisions(command);
if(sets.length != 1){
throw new HgException("Unable to get changeset for 'tip' version");
}
return sets[0];
}
/**
* @param command
* a command with optionally its Files set
*/
private static ChangeSet[] getRevisions(HgCommand command)
throws HgException {
command.addOptions("--template", //$NON-NLS-1$
"{rev}:{node} {date|isodate} {author|person}#{tags}**#{branches}**#{desc|firstline}\n"); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
String[] lines = null;
try {
lines = command.executeToString().split("\n"); //$NON-NLS-1$
} catch (HgException e) {
if (!e.getMessage()
.contains(
"abort: can only follow copies/renames for explicit file names")) { //$NON-NLS-1$
throw new HgException(e);
}
return null;
}
List changeSets = new ArrayList();
HgRoot hgRoot = command.getHgRoot();
for (String line : lines) {
if(StringUtils.isEmpty(line)){
continue;
}
Matcher m = GET_REVISIONS_PATTERN.matcher(line);
if (m.matches()) {
Builder builder = new ChangeSet.Builder(
Integer.parseInt(m.group(1)), // revisions
m.group(2), // changeset
m.group(6), // branch
m.group(3), // date
m.group(4), // user
hgRoot).description(m.group(7));
builder.tags(m.group(5));
ChangeSet changeSet = builder.build();
changeSets.add(changeSet);
} else {
throw new HgException(Messages.getString("HgLogClient.parseException") + line + "'"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
return changeSets.toArray(new ChangeSet[changeSets.size()]);
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getCompleteProjectLog(
IResource res, boolean withFiles) throws HgException {
return getProjectLog(res, -1, Integer.MAX_VALUE, withFiles);
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getCompleteRootLog(
HgRoot hgRoot, boolean withFiles) throws HgException {
return getRootLog(hgRoot, -1, Integer.MAX_VALUE, withFiles);
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getProjectLogBatch(
IResource res, int batchSize, int startRev, boolean withFiles)
throws HgException {
return getProjectLog(res, batchSize, startRev, withFiles);
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getRecentProjectLog(
IResource res, int limitNumber, boolean withFiles) throws HgException {
return getProjectLogBatch(res, limitNumber, -1, withFiles);
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getProjectLog(IResource res,
int limitNumber, int startRev, boolean withFiles)
throws HgException {
HgCommand command = new HgCommand("log", "Retrieving history", //$NON-NLS-1$
res, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addStyleFile(withFiles ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_DEFAULT);
boolean isFile = res.getType() == IResource.FILE;
addRange(command, startRev, limitNumber, isFile);
if (isFile) {
command.addOptions("-f"); //$NON-NLS-1$
}
if (res.getType() != IResource.PROJECT) {
IPath path = ResourceUtils.getPath(res);
if(path.isEmpty()) {
return EMPTY_MAP;
}
command.addOptions(path.toOSString());
} else {
HgRoot hgRoot = command.getHgRoot();
File fileHandle = ResourceUtils.getFileHandle(res);
if(!hgRoot.equals(fileHandle)){
// for multiple projects under same hg root we should return only current project history
command.addOptions(fileHandle.getAbsolutePath());
}
}
String result = command.executeToString();
if (result.length() == 0) {
return EMPTY_MAP;
}
Map> revisions = createLocalRevisions(
res, result, Direction.LOCAL, null, null, null);
return revisions;
}
/**
* @return map where the key is an absolute file path, never null
*/
public static Map> getRootLog(HgRoot hgRoot,
int limitNumber, int startRev, boolean withFiles)
throws HgException {
HgCommand command = new HgCommand("log", "Retrieving history", hgRoot, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addStyleFile(withFiles ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_DEFAULT);
addRange(command, startRev, limitNumber, false);
String result = command.executeToString();
if (result.length() == 0) {
return EMPTY_MAP;
}
Path path = new Path(hgRoot.getAbsolutePath());
Map> revisions = createLocalRevisions(path, result, Direction.LOCAL, null, null, null, hgRoot);
return revisions;
}
/**
* @return never null
*/
public static Map> getPathLog(boolean isFile, File path,
HgRoot hgRoot, int limitNumber, int startRev, boolean withFiles)
throws HgException {
if(hgRoot == null) {
return EMPTY_MAP;
}
HgCommand command = new HgCommand("log", "Retrieving history", hgRoot, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addStyleFile(withFiles ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_DEFAULT);
addRange(command, startRev, limitNumber, isFile);
if (isFile) {
command.addOptions("-f"); //$NON-NLS-1$
}
command.addOptions(hgRoot.toRelative(path));
String result = command.executeToString();
if (result.length() == 0) {
return EMPTY_MAP;
}
Map> revisions = createLocalRevisions(
new Path(path.getAbsolutePath()),
result, Direction.LOCAL, null, null, null, hgRoot);
return revisions;
}
private static void addRange(AbstractShellCommand command, int startRev, int limitNumber, boolean isFile) {
if (startRev >= 0 && startRev != Integer.MAX_VALUE) {
// always advise to follow until 0 revision: the reason is that log limit
// might be bigger then the difference of two consequent revisions on a specific resource
command.addOptions("-r"); //$NON-NLS-1$
command.addOptions(startRev + ":" + 0); //$NON-NLS-1$
}
if(isFile && startRev == Integer.MAX_VALUE) {
// always start with the tip to get the latest version of a file too
// seems that hg log misses some versions if the file working copy is not at the tip
command.addOptions("-r"); //$NON-NLS-1$
command.addOptions("tip:0"); //$NON-NLS-1$
}
setLimit(command, limitNumber);
}
public static void setLimit(AbstractShellCommand command, int limitNumber) {
command.addOptions("--limit", (limitNumber > 0) ? limitNumber + "" : NOLIMIT); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* This method modifies given revision: it may change the revision's parent file
*
* @param rev non null
* @param history non null
* @param monitor non null
* @return may return null
*/
public static ChangeSet getLogWithBranchInfo(MercurialRevision rev,
MercurialHistory history, IProgressMonitor monitor) throws HgException {
ChangeSet changeSet = rev.getChangeSet();
IResource resource = rev.getResource();
int limitNumber = 1;
Map> map;
if(resource instanceof HgRootContainer) {
map = getRootLog(((HgRootContainer) resource).getHgRoot(), limitNumber, changeSet
.getChangesetIndex(), true);
} else {
map = getProjectLog(resource, limitNumber, changeSet.getChangesetIndex(), true);
}
IPath location = ResourceUtils.getPath(resource);
if(location.isEmpty()) {
return null;
}
if(!map.isEmpty()) {
return Collections.min(map.get(location));
}
File possibleParent = rev.getParent();
MercurialRevision next = rev;
if(possibleParent == null && !monitor.isCanceled()){
HgRoot hgRoot = changeSet.getHgRoot();
File file = location.toFile();
// try first to guess the parent (and avoid the while loop below), see issue #10302
possibleParent = HgStatusClient.guessPossibleSourcePath(hgRoot, file, rev.getRevision());
if(possibleParent != null && !possibleParent.equals(location.toFile())){
// got different parent, may be it's the right one?
// validate if the possible parent IS the parent for this version
map = getPathLog(resource.getType() == IResource.FILE,
possibleParent, hgRoot, limitNumber, rev.getRevision(), true);
}
// go up one revision step by step, looking for the fist time "branch" occurence
// this may take a long time...
while(map.isEmpty() && (next = history.getNext(next)) != null && !monitor.isCanceled()){
if(next.getParent() == null) {
int revision = next.getRevision();
possibleParent = HgStatusClient.getPossibleSourcePath(hgRoot, file, revision);
} else {
possibleParent = next.getParent();
}
if(possibleParent != null){
// validate if the possible parent IS the parent for this version
map = getPathLog(resource.getType() == IResource.FILE,
possibleParent, hgRoot, limitNumber, rev.getRevision(), true);
if(!map.isEmpty()) {
// bingo, log is not null
break;
}
// see issue 10302: file seems to be copied/renamed multiple times
// restart the search from the beginning with the newly obtained path
// if it is different to the original one
if(possibleParent.equals(location.toFile())){
// give up
possibleParent = null;
break;
}
// restart
next = rev;
file = possibleParent;
}
}
if(monitor.isCanceled()){
return null;
}
// remember parent for all visited versions
if(possibleParent != null) {
while(next != rev && (next = history.getPrev(next)) != rev){
if(next == null) {
break;
}
next.setParent(possibleParent);
}
}
}
if(possibleParent != null){
rev.setParent(possibleParent);
if(map.isEmpty() && !monitor.isCanceled()) {
map = getPathLog(resource.getType() == IResource.FILE,
possibleParent, MercurialTeamProvider.getHgRoot(resource),
limitNumber, rev.getRevision(), true);
}
if(!map.isEmpty()) {
return Collections.min(map.get(new Path(possibleParent.getAbsolutePath())));
}
}
return null;
}
public static ChangeSet getChangeset(IResource res, String nodeId,
boolean withFiles) throws HgException {
Assert.isNotNull(nodeId);
HgRoot root = MercurialRootCache.getInstance().getHgRoot(res);
HgCommand command = new HgCommand("log", "Retrieving history", //$NON-NLS-1$
root, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addStyleFile(withFiles ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_DEFAULT);
command.addOptions("--rev", nodeId); //$NON-NLS-1$
String result = command.executeToString();
Map> revisions = createLocalRevisions(
res, result, Direction.LOCAL, null, null, null);
IPath location = ResourceUtils.getPath(res);
if(location.isEmpty()) {
return null;
}
Set set = revisions.get(location);
if (set != null) {
return Collections.min(set);
}
return null;
}
/**
* Tries to retrieve (possible not existing) changeset for the given id.
* @param hgRoot non null
* @param nodeId non null
* @return might return null if the changeset is not known/existing in the repo
*/
public static ChangeSet getChangeset(HgRoot hgRoot, String nodeId) throws HgException {
return getChangeset(hgRoot, nodeId, false);
}
public static ChangeSet getChangeset(HgRoot hgRoot, String nodeId, boolean withFiles) throws HgException {
Assert.isNotNull(nodeId);
HgCommand command = new HgCommand("log", "Retrieving history", hgRoot, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
command.addStyleFile(withFiles ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_DEFAULT);
command.addOptions("--rev", nodeId); //$NON-NLS-1$
String result = command.executeToString();
Path path = new Path(hgRoot.getAbsolutePath());
Map> revisions = createLocalRevisions(path, result, Direction.LOCAL, null, null, null, hgRoot);
Set set = revisions.get(path);
if (set != null && !set.isEmpty()) {
return Collections.min(set);
}
return null;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgMergeClient.java 0000664 0000000 0000000 00000003121 11737135005 0033506 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
public class HgMergeClient extends AbstractClient {
public static String merge(HgRoot hgRoot, String revision, boolean forced)
throws HgException {
HgCommand command = new HgCommand("merge", "Merging", hgRoot, false);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.IMERGE_TIMEOUT);
addMergeToolPreference(command);
if (revision != null) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
if (forced) {
command.addOptions("-f"); //$NON-NLS-1$
}
return command.executeToString();
}
public static boolean isConflict(HgException e) {
// if conflicts aren't resolved and no merge tool is started, hg
// exits with 1
return e.getStatus().getCode() == 1;
}
}
HgOutgoingClient.java 0000664 0000000 0000000 00000005612 11737135005 0034172 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bugfixes
* Philip Graf - proxy support
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.ChangeSet.Direction;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RemoteData;
import com.vectrace.MercurialEclipse.team.cache.RemoteKey;
public class HgOutgoingClient extends AbstractParseChangesetClient {
/**
* @return never return null
*/
public static RemoteData getOutgoing(RemoteKey key) throws HgException {
HgCommand command = getCommand(key);
boolean computeFullStatus = MercurialEclipsePlugin.getDefault().getPreferenceStore().getBoolean(MercurialPreferenceConstants.SYNC_COMPUTE_FULL_REMOTE_FILE_STATUS);
addInsecurePreference(command);
command.addStyleFile(computeFullStatus ? AbstractParseChangesetClient.STYLE_WITH_FILES
: AbstractParseChangesetClient.STYLE_WITH_FILES_FAST);
if (key.isAllowUnrelated()) {
command.addOptions("-f");
}
addRepoToHgCommand(key.getRepo(), command);
String result = getResult(command);
if (result == null) {
return new RemoteData(key, Direction.OUTGOING);
}
RemoteData revisions = createRemoteRevisions(key, result, Direction.OUTGOING, null);
return revisions;
}
private static String getResult(AbstractShellCommand command) throws HgException {
try {
String result = command.executeToString();
if (result.endsWith("no changes found")) { //$NON-NLS-1$
return null;
}
return result;
} catch (HgException hg) {
if (hg.getStatus().getCode() == 1) {
return null;
}
throw hg;
}
}
private static HgCommand getCommand(RemoteKey key) {
HgRoot hgRoot = key.getRoot();
HgCommand command = new HgCommand("outgoing", "Calculating outgoing changesets", hgRoot, false); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
// see issue 10495, 11093: there can be many branch heads: "--rev branch" cannot be used
if (key.getBranch() != null) {
command.addOptions("--branch", key.getBranch());
}
return command;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgParentClient.java0000664 0000000 0000000 00000014162 11737135005 0033707 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2006-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
public class HgParentClient extends AbstractClient {
private static final Pattern ANCESTOR_PATTERN = Pattern
.compile("^(-?[0-9]+):([0-9a-f]+)$"); //$NON-NLS-1$
private static final Pattern LINE_SEPERATOR_PATTERN = Pattern.compile("\n");
public static int[] getParents(HgRoot hgRoot) throws HgException {
AbstractShellCommand command = new HgCommand("parents", //$NON-NLS-1$
"Finding parent revisions", hgRoot, false);
command.addOptions("--template", "{rev}\n"); //$NON-NLS-1$ //$NON-NLS-2$
String[] lines = getLines(command.executeToString());
int[] parents = new int[lines.length];
for (int i = 0; i < lines.length; i++) {
parents[i] = Integer.parseInt(lines[i]);
}
return parents;
}
public static String[] getParentNodeIds(HgRoot hgRoot)
throws HgException {
AbstractShellCommand command = new HgCommand("parents", "Finding parent revisions", hgRoot,
false);
command.addOptions("--template", "{node}\n"); //$NON-NLS-1$ //$NON-NLS-2$
return parseParentsCommand(command);
}
public static String[] getParentNodeIds(IResource file)
throws HgException {
AbstractShellCommand command = new HgCommand("parents", //$NON-NLS-1$
"Finding parent revisions", file, false);
if(file instanceof IFile) {
command.addFiles(file);
}
command.addOptions("--template", "{node}\n"); //$NON-NLS-1$ //$NON-NLS-2$
return parseParentsCommand(command);
}
public static String[] getParentNodeIds(ChangeSet cs, String template) throws HgException {
AbstractShellCommand command = new HgCommand("parents", //$NON-NLS-1$
"Finding parent revisions", cs.getHgRoot(), false);
command.addOptions("--template", template + "\n", "--rev", cs //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
.getChangeset());
return parseParentsCommand(command);
}
public static String[] getParentNodeIds(IResource resource, ChangeSet cs) throws HgException {
AbstractShellCommand command = new HgCommand("parents", //$NON-NLS-1$
"Finding parent revisions", resource, false);
command.addOptions("--template", "{node}\n", "--rev", cs //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
.getChangeset());
return parseParentsCommand(command);
}
private static String[] parseParentsCommand(AbstractShellCommand parentsCommand) throws HgException {
String[] lines = getLines(parentsCommand.executeToString());
String[] parents = new String[lines.length];
for (int i = 0; i < lines.length; i++) {
parents[i] = lines[i].trim();
}
return parents;
}
/**
* @param hgRoot The root that these nodes are in
* @param node1 The first changeset id
* @param node2 The second changeset id
* @return An array of length 2 with the revision index at index 0 and the global node id at
* index 1. The revision index is -1 for unrelated.
* @throws HgException
*/
public static String[] findCommonAncestor(HgRoot hgRoot, String node1, String node2)
throws HgException {
AbstractShellCommand command = new HgCommand("debugancestor", //$NON-NLS-1$
"Finding common ancestor", hgRoot, false);
command.addOptions(node1, node2);
String result = command.executeToString().trim();
Matcher m = ANCESTOR_PATTERN.matcher(result);
if (m.matches()) {
String local = m.group(1);
String global = m.group(2);
String[] revision = {local, global};
return revision;
}
throw new HgException("Parse exception: '" + result + "'");
}
/**
* This methods finds the common ancestor of two changesets, supporting
* overlays for using incoming changesets. Only one changeset may be
* incoming.
*
* @param hgRoot
* hg root
* @param cs1
* first changeset
* @param cs2
* second changeset
* @return An array of length 2 with the revision index at index 0 and the global node id at
* index 1. The revision index is -1 for unrelated.
* @throws HgException
*/
public static String[] findCommonAncestor(HgRoot hgRoot, ChangeSet cs1, ChangeSet cs2)
throws HgException {
String result;
try {
HgCommand command = new HgCommand("debugancestor", "Finding common ancestor", hgRoot,
false);
if (cs1.getBundleFile() != null || cs2.getBundleFile() != null) {
if (cs1.getBundleFile() != null) {
command.setBundleOverlay(cs1.getBundleFile());
} else {
command.setBundleOverlay(cs2.getBundleFile());
}
}
command.addOptions(cs1.getChangeset(), cs2.getChangeset());
result = command.executeToString().trim();
Matcher m = ANCESTOR_PATTERN.matcher(result);
if (m.matches()) {
String local = m.group(1);
String global = m.group(2);
String[] revision = {local, global};
return revision;
}
throw new HgException("Parse exception: '" + result + "'");
} catch (NumberFormatException e) {
throw new HgException(e.getLocalizedMessage(), e);
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
/**
* Splits an output of a command into lines. Lines are separated by a newline character (\n).
*
* @param output
* The output of a command.
* @return The lines of the output.
*/
private static String[] getLines(String output) {
if (output == null || output.length() == 0) {
return new String[0];
}
return LINE_SEPERATOR_PATTERN.split(output);
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgPatchClient.java 0000664 0000000 0000000 00000013663 11737135005 0033522 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Steeven Lee - import/export stuff
* Bastian Doetsch - additions
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.history.MercurialRevision;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
public class HgPatchClient extends AbstractClient {
public static final String PATCH_EXTENSION = ".diff";
/**
* Import a patch. Throws an exception if there is a conflict
*
* @see #isPatchImportConflict(HgException)
*
* @param hgRoot non null
* @param patchLocation non null
* @param options non null
*/
public static String importPatch(HgRoot hgRoot, File patchLocation,
ArrayList options) throws HgException {
AbstractShellCommand command = new HgCommand("import", "Importing patch", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.addFile(patchLocation);
command.addOptions(options.toArray(new String[options.size()]));
return command.executeToString();
}
/**
* Determine if the given exception indicates a conflict occurred
*
* @param e
* The exception to check
* @return True if the exception indicates a conflict occurred
*/
public static boolean isPatchImportConflict(HgException e) {
return e.getMessage().contains("patch failed to apply.");
}
/**
* @param hgRoot non null hg root
* @param resources non null set of files to export as diff to the latest state. If the set
* is empty, a complete diff of the hg root is exported
* @param patchFile non null target file for the diff
* @param options non null list of options, may be empty
* @throws HgException
* @return True on success
*/
public static boolean exportPatch(HgRoot hgRoot, List resources,
File patchFile, List options) throws HgException {
AbstractShellCommand command = makeExportUncommittedCommand(hgRoot, options);
command.addFiles(resources);
return command.executeToFile(patchFile, false);
}
/**
* export diff file to clipboard
*
* @param resources
* @throws HgException
*/
public static String exportPatch(HgRoot root, List resources,
List options) throws HgException {
AbstractShellCommand command = makeExportUncommittedCommand(root, options);
command.addFiles(resources);
return command.executeToString();
}
private static AbstractShellCommand makeExportUncommittedCommand(HgRoot root, List options) {
AbstractShellCommand command = new HgCommand( "diff", "Exporting patch of uncommitted changes", root, true); //$NON-NLS-1$
command.addOptions(options.toArray(new String[options.size()]));
return command;
}
/**
* Export a changeset to a string
*
* @param root
* The repository root
* @param cs
* The changeset
* @param options
* Options. May be null
* @return The string as a patch
* @throws HgException
*/
public static String exportPatch(HgRoot root, ChangeSet cs, List options)
throws HgException {
return makeExportPatchCommand(root, cs, options).executeToString();
}
/**
* Export a changeset to a file
*
* @param root
* The repository root
* @param cs
* The changeset
* @param patchFile
* The file to output to
* @param options
* Options. May be null
* @return True on success
* @throws HgException
*/
public static boolean exportPatch(HgRoot root, ChangeSet cs, File patchFile,
List options) throws HgException {
return makeExportPatchCommand(root, cs, options).executeToFile(patchFile, false);
}
private static AbstractShellCommand makeExportPatchCommand(HgRoot root, ChangeSet cs,
List options) {
AbstractShellCommand command = new HgCommand("export", "Exporting changeset "
+ cs.getChangeset(), root, true);
if (options != null) {
command.addOptions(options.toArray(new String[options.size()]));
}
command.addOptions("--git");
command.addOptions("-r", cs.getChangeset());
return command;
}
/**
* Get a diff for a single changeSet or a range for revisions.
*
* Use the extended diff format (--git) that shows renames and file attributes.
*
* @param hgRoot The root. Must not be null.
* @param entry Revision of the changeset or first revision of changeset-range (if secondEntry != null). Must not be null.
* @param secondEntry second revision of changeset range. If null entry a diff will be created for parameter entry a a single Changeset.
* @return Diff as a string in extended diff format (--git).
* @throws HgException
*/
public static String getDiff(HgRoot hgRoot, MercurialRevision entry, MercurialRevision secondEntry) throws HgException {
HgCommand diffCommand = new HgCommand("diff", //$NON-NLS-1$
"Calculating diff between revisions", hgRoot, true);
if( secondEntry == null ){
diffCommand.addOptions("-c", "" + entry.getChangeSet().getRevision().getChangeset());
} else {
diffCommand.addOptions("-r", ""+entry.getChangeSet().getRevision().getChangeset());
diffCommand.addOptions("-r", ""+secondEntry.getChangeSet().getRevision().getChangeset());
}
diffCommand.addOptions("--git");
return diffCommand.executeToString();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgPathsClient.java 0000664 0000000 0000000 00000002725 11737135005 0033537 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 Bastian Doetsch and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Zsolt Koppany (Intland) - bug fixes
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.FileNotFoundException;
import java.util.Map;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.Branch;
import com.vectrace.MercurialEclipse.model.HgRoot;
public class HgPathsClient extends AbstractClient {
public static final String DEFAULT = Branch.DEFAULT;
public static final String DEFAULT_PULL = "default-pull"; //$NON-NLS-1$
public static final String DEFAULT_PUSH = "default-push"; //$NON-NLS-1$
/**
* @param hgRoot non null
* @return map with "logical name" : "url" pairs. May be empty.
* @throws HgException
*/
public static Map getPaths(HgRoot hgRoot) throws HgException {
try {
return hgRoot.getPaths();
} catch (FileNotFoundException e) {
throw new HgException("Unable to read paths for repository: " + hgRoot, e);
}
}
}
HgPushPullClient.java 0000664 0000000 0000000 00000015163 11737135005 0034155 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Bastian Doetsch - added authentication to push
* Andrei Loskutov - bug fixes
* Ilya Ivanov (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.regex.Pattern;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.menu.UpdateJob;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
public class HgPushPullClient extends AbstractClient {
/**
* matches ("number" "heads") message
*/
private static final Pattern HEADS_PATTERN = Pattern.compile("\\(\\+\\d+\\sheads\\)");
public static String push(HgRoot hgRoot, IHgRepositoryLocation repo,
boolean force, ChangeSet changeset, int timeout) throws HgException {
return push(hgRoot, repo, force, changeset, timeout, null);
}
public static String push(HgRoot hgRoot, IHgRepositoryLocation repo,
boolean force, ChangeSet changeset, int timeout, String branch) throws HgException {
AbstractShellCommand command = new HgCommand("push", //$NON-NLS-1$
makeDescription("Pushing", changeset, branch), hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PUSH_TIMEOUT);
addInsecurePreference(command);
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
applyChangeset(command, changeset);
boolean newBranch = MercurialEclipsePlugin.getDefault().getPreferenceStore()
.getBoolean(MercurialPreferenceConstants.PREF_PUSH_NEW_BRANCH);
if (newBranch) {
command.addOptions("--new-branch");
}
if (branch != null) {
command.addOptions("--branch", branch);
}
addRepoToHgCommand(repo, command);
return new String(command.executeToBytes(timeout));
}
public static String pull(HgRoot hgRoot, ChangeSet changeset,
IHgRepositoryLocation repo, boolean update, boolean rebase,
boolean force, boolean timeout, boolean merge) throws HgException {
return pull(hgRoot, changeset, repo, update, rebase, force, timeout, merge, null);
}
public static String pull(HgRoot hgRoot, ChangeSet changeset,
IHgRepositoryLocation repo, boolean update, boolean rebase,
boolean force, boolean timeout, boolean merge, String branch) throws HgException {
boolean separateUpdate = false;
HgCommand command = new HgCommand("pull", //$NON-NLS-1$
makeDescription("Pulling", changeset, branch), hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
addInsecurePreference(command);
// --update and --branch together will switch to latest of the branch rather than usual
// branch crossing logic. See http://www.javaforge.com/issue/19520
// TODO: pull from bundle so --branch isn't necessary
if (update && branch != null && changeset == null) {
update = false;
separateUpdate = true;
}
if (update) {
command.addOptions("--update"); //$NON-NLS-1$
addMergeToolPreference(command);
} else if (rebase) {
command.addOptions("--config", "extensions.hgext.rebase="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("--rebase"); //$NON-NLS-1$
addMergeToolPreference(command);
}
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
applyChangeset(command, changeset);
if (branch != null) {
command.addOptions("--branch", branch);
}
addRepoToHgCommand(repo, command);
String result = null;
try {
if (timeout) {
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
result = new String(command.executeToBytes());
} else {
result = new String(command.executeToBytes(Integer.MAX_VALUE));
}
if (separateUpdate) {
try {
result += HgUpdateClient.updateWithoutRefresh(hgRoot, null, false);
} catch (HgException e) {
if (HgUpdateClient.isCrossesBranchError(e) || HgUpdateClient.isWorkspaceUpdateConflict(e)) {
result += e.getMessage();
} else {
// ??
throw e;
}
}
}
} finally {
// TODO: detect workspace conflicts on update and notify user
if ((update || separateUpdate) && result != null && !merge && !rebase) {
// different messages from hg depending on if branch was set or not
// TODO: clean up this detection
if (result.contains("not updating, since new heads added")
|| result.contains("not updating: crosses branches")
|| (branch != null && HEADS_PATTERN.matcher(result).find())) {
// inform user about new heads and ask if he wants to merge or rebase
UpdateJob.handleMultipleHeads(hgRoot, false);
}
}
// doesn't matter how far we were: we have to trigger update of caches in case
// the pull was *partly* successful (e.g. pull was ok, but update not)
refreshProjects((update || separateUpdate), hgRoot);
}
return result;
}
private static String makeDescription(String op, ChangeSet changeset, String branch) {
if (changeset == null) {
return op + " all changes" + ((branch == null) ? "" : " in " + branch);
}
return op + " changeset " + changeset.getChangeset();
}
protected static void applyChangeset(AbstractShellCommand command, ChangeSet changeset) {
if (changeset != null) {
String cs = changeset.getChangeset();
if (cs != null && (cs = cs.trim()).length() > 0) {
command.addOptions("-r", cs); //$NON-NLS-1$
}
}
}
private static void refreshProjects(boolean update, final HgRoot hgRoot) {
// The reason to use "all" instead of only "local + incoming", is that we can pull
// from another repo as the sync clients for given project may use
// in this case, we also need to update "outgoing" changesets
final int flags = RefreshRootJob.ALL;
if(update) {
new RefreshWorkspaceStatusJob(hgRoot, flags).schedule();
} else {
new RefreshRootJob(hgRoot, flags).schedule();
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgRemoveClient.java0000664 0000000 0000000 00000011612 11737135005 0033710 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Bastian Doetsch - removeResources()
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.HgFeatures;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.MercurialRootCache;
import com.vectrace.MercurialEclipse.team.cache.MercurialStatusCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgRemoveClient extends AbstractClient {
public static void removeResource(IResource resource,
IProgressMonitor monitor) throws HgException {
if (monitor != null) {
monitor.subTask(Messages.getString("HgRemoveClient.removeResource.1") + resource.getName() //$NON-NLS-1$
+ Messages.getString("HgRemoveClient.removeResource.2")); //$NON-NLS-1$
}
HgRoot root = MercurialRootCache.getInstance().getHgRoot(resource);
HgCommand command = new HgCommand("remove", "Removing resource", root, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(command.getHgRoot()));
command.addOptions("--force"); //$NON-NLS-1$
command.addFiles(resource);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.REMOVE_TIMEOUT);
command.executeToBytes();
MercurialStatusCache.getInstance().refreshStatus(resource, monitor);
}
public static void removeResources(List resources) throws HgException {
Map> resourcesByRoot = ResourceUtils.groupByRoot(resources);
for (Map.Entry> mapEntry : resourcesByRoot.entrySet()) {
HgRoot hgRoot = mapEntry.getKey();
// if there are too many resources, do several calls
// From 1.8 hg can do it in one call
if (!HgFeatures.LISTFILE.isEnabled()) {
int size = mapEntry.getValue().size();
@SuppressWarnings("deprecation")
int delta = AbstractShellCommand.MAX_PARAMS - 1;
for (int i = 0; i < size; i += delta) {
AbstractShellCommand command = new HgCommand(
"remove", "Removing resource", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.REMOVE_TIMEOUT);
command.addFiles(mapEntry.getValue().subList(i, Math.min(i + delta, size)));
command.executeToBytes();
}
} else {
AbstractShellCommand command = new HgCommand("remove", "Removing resource", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.REMOVE_TIMEOUT);
command.addFiles(mapEntry.getValue());
command.executeToBytes();
}
}
}
public static void removeResourcesLater(Map> resourcesByRoot) throws HgException {
for (Map.Entry> mapEntry : resourcesByRoot.entrySet()) {
HgRoot hgRoot = mapEntry.getKey();
// if there are too many resources, do several calls
// From 1.8 hg can do it in one call
int size = mapEntry.getValue().size();
if (!HgFeatures.LISTFILE.isEnabled()) {
@SuppressWarnings("deprecation")
int delta = AbstractShellCommand.MAX_PARAMS - 1;
for (int i = 0; i < size; i += delta) {
final int j = Math.min(i + delta, size);
AbstractShellCommand command = new HgCommand("remove", //$NON-NLS-1$
"Removing " + (j - i) + " resources", hgRoot, true);
command.addOptions("-Af");
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.REMOVE_TIMEOUT);
command.addFiles(mapEntry.getValue().subList(i, j));
command.executeToBytes();
}
} else {
AbstractShellCommand command = new HgCommand("remove", //$NON-NLS-1$
"Removing " + size + " resources", hgRoot, true);
command.addOptions("-Af");
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.REMOVE_TIMEOUT);
command.addFiles(mapEntry.getValue());
command.executeToBytes();
}
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgRenameClient.java0000664 0000000 0000000 00000004174 11737135005 0033667 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgRenameClient extends AbstractClient {
public static void renameResource(IPath source, IPath dest, HgRoot hgRoot,
IProgressMonitor monitor) throws HgException {
if(!hgRoot.getIPath().isPrefixOf(source)) {
throw new HgException("Cannot move: source ('" + source +
"') is not inside the repository: '" + hgRoot + "'");
}
if(!hgRoot.getIPath().isPrefixOf(dest)) {
throw new HgException("Cannot move: destination ('" + dest +
"') is not inside the repository: '" + hgRoot + "'");
}
if (monitor != null) {
monitor.subTask(Messages.getString("HgRenameClient.moving.1")
+ source.lastSegment()
+ Messages.getString("HgRenameClient.moving.2") //$NON-NLS-1$
+ dest.lastSegment());
}
HgCommand command = new HgCommand("rename", "Renaming resource", hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.addOptions("--force"); //$NON-NLS-1$
command.addFile(source.toFile());
command.addFile(dest.toFile());
command.executeToBytes();
// see issue 14135: not versioned (new or derived) files may left after move
// => move them manually (also allows "undo" in Eclipse to work properly)
ResourceUtils.move(source.toFile(), dest.toFile());
}
}
HgResolveClient.java 0000664 0000000 0000000 00000016663 11737135005 0034026 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.FlaggedAdaptable;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.MercurialStatusCache;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgResolveClient extends AbstractClient {
/**
* List merge state of files after merge
*/
public static List list(IResource res) throws HgException {
AbstractShellCommand command = new HgCommand("resolve", //$NON-NLS-1$
"Calculating conflict status for resource", res, false);
command
.setUsePreferenceTimeout(MercurialPreferenceConstants.IMERGE_TIMEOUT);
command.addOptions("-l"); //$NON-NLS-1$
String[] lines = command.executeToString().split("\n"); //$NON-NLS-1$
List result = new ArrayList();
if (lines.length != 1 || !"".equals(lines[0])) { //$NON-NLS-1$
HgRoot hgRoot = getHgRoot(res);
IProject project = res.getProject();
for (String line : lines) {
// Status line is always hg root relative. For those projects
// which has different project root hg root relative path must
// be converted to project relative
IResource iFile = ResourceUtils.convertRepoRelPath(hgRoot, project, line.substring(2));
if(iFile != null){
FlaggedAdaptable fa = new FlaggedAdaptable(iFile, line.charAt(0));
result.add(fa);
}
}
}
return result;
}
/**
* List merge state of files after merge
*/
public static List list(HgRoot hgRoot) throws HgException {
AbstractShellCommand command = new HgCommand("resolve", "Listing conflict status", hgRoot, false);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.IMERGE_TIMEOUT);
command.addOptions("-l"); //$NON-NLS-1$
String[] lines = command.executeToString().split("\n"); //$NON-NLS-1$
List result = new ArrayList();
if (lines.length != 1 || !"".equals(lines[0])) { //$NON-NLS-1$
for (String line : lines) {
// Status line is always hg root relative. For those projects
// which has different project root (always deeper than hg root)
// hg root relative path must be converted
String repoRelPath = line.substring(2);
IResource iFile = ResourceUtils.getFileHandle(hgRoot.toAbsolute(new Path(repoRelPath)));
if(iFile != null){
FlaggedAdaptable fa = new FlaggedAdaptable(iFile, line.charAt(0));
result.add(fa);
}
}
}
return result;
}
/**
* Mark a resource as resolved ("R")
*/
public static String markResolved(IFile ifile) throws HgException {
File file = ResourceUtils.getFileHandle(ifile);
HgCommand command = new HgCommand("resolve", //$NON-NLS-1$
"Marking resource as resolved", ifile, false);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(command
.getHgRoot()));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.IMERGE_TIMEOUT);
try {
command.addOptions("-m", file.getCanonicalPath()); //$NON-NLS-1$
String result = command.executeToString();
// cleanup .orig files left after merge
File origFile = new File(file.getAbsolutePath() + ".orig");
if(origFile.isFile()){
IResource fileToDelete = ResourceUtils.convert(origFile);
boolean deleted = origFile.delete();
if(!deleted){
MercurialEclipsePlugin.logInfo("Failed to cleanup " + origFile + " file after merge", null);
} else {
try {
fileToDelete.refreshLocal(IResource.DEPTH_ZERO, null);
} catch (CoreException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
refreshStatus(ifile);
return result;
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
/**
* Mark a resource as unresolved ("U")
*/
public static String markUnresolved(IFile ifile) throws HgException {
IPath path = ResourceUtils.getPath(ifile);
if(path.isEmpty()) {
throw new HgException("Failed to unresolve: location is unknown: " + ifile);
}
File file = path.toFile();
HgCommand command = new HgCommand("resolve", //$NON-NLS-1$
"Marking resource as unresolved", ifile, false);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(command
.getHgRoot()));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.IMERGE_TIMEOUT);
try {
command.addOptions("-u", file.getCanonicalPath()); //$NON-NLS-1$
String result = command.executeToString();
refreshStatus(ifile);
return result;
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
private static void refreshStatus(IResource res) throws HgException {
MercurialStatusCache.getInstance().refreshStatus(res, null);
ResourceUtils.touch(res);
}
/**
* Executes resolve command to find change sets necessary for merging
*
* WARNING: This method potentially reverts changes!
*
* Future: We should write some python to interface with the Mercurial API directly to get this
* info so we don't have to do operations with side effects or rely on --debug output.
*
* @param file
* The file to consider
* @return An array of length 3 of changeset ids: result[0] - 'my' result[1] - 'other' result[2]
* - 'base'
* @throws HgException
*/
public static String[] restartMergeAndGetChangeSetsForCompare(IFile file) throws HgException {
String[] results = new String[3];
HgCommand command = new HgCommand("resolve", "Invoking resolve to find parent information", file, false);
command.addOptions("--config", "ui.merge=internal:mustfail", "--debug");
command.addFiles(file);
String stringResult = "";
try {
command.executeToString();
} catch (HgException e) {
// exception is expected here
stringResult = e.getMessage();
}
String filename = file.getName();
String patternString = "my .*" + filename + "@?([0-9a-fA-F]*)\\+?[\\s]"
+ "other .*" + filename + "@?([0-9a-fA-F]*)\\+?[\\s]"
+ "ancestor .*" + filename + "@?([0-9a-fA-F]*)\\+?[\\s]";
Matcher matcher = Pattern.compile(patternString).matcher(stringResult);
if (matcher.find() && matcher.groupCount() == 3) {
results[0] = matcher.group(1); // my
results[1] = matcher.group(2); // other
results[2] = matcher.group(3); // ancestor
}
return results;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgRevertClient.java0000664 0000000 0000000 00000011313 11737135005 0033720 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 Andrei Loskutov and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import com.vectrace.MercurialEclipse.HgFeatures;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.FileStatus;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.team.Messages;
/**
* @author Andrei
*/
public class HgRevertClient extends AbstractClient {
/**
* @param monitor non null
* @param hgRoot the root of all given resources
* @param resources resources to revert
* @param cs might be null
* @return a copy of file paths affected by this command, if any. Never returns null,
* but may return empty list. The elements of the set are absolute file paths.
* @throws HgException
*/
public static Set performRevert(IProgressMonitor monitor, HgRoot hgRoot,
List resources, ChangeSet cs) throws HgException {
Set fileSet = new HashSet();
monitor.subTask(Messages.getString("ActionRevert.reverting") + " " + hgRoot.getName() + "..."); //$NON-NLS-1$ //$NON-NLS-2$
// if there are too many resources, do several calls
int size = resources.size();
MercurialUtilities.setOfferAutoCommitMerge(true);
if(size == 0) {
return fileSet;
}
IResource firstFile = resources.get(0);
if(size == 1 && cs != null && (cs.isMoved(firstFile) || cs.isRemoved(firstFile))) {
HgRevision parentRevision = cs.getParentRevision(0, true);
HgCommand command = createRevertCommand(hgRoot, "Reverting " + firstFile.getName());
command.addOptions("--rev", parentRevision.getChangeset());
command.addFiles(firstFile);
if(cs.isMoved(firstFile)) {
FileStatus status = cs.getStatus(firstFile);
if(status != null) {
IPath path = status.getAbsoluteCopySourcePath();
command.addFile(path.toFile());
}
}
command.executeToString();
fileSet.addAll(command.getAffectedFiles());
} else {
// if there are too many resources, do several calls
// From 1.8 hg can do it in one call
if(!HgFeatures.LISTFILE.isEnabled()) {
@SuppressWarnings("deprecation")
int delta = AbstractShellCommand.MAX_PARAMS - 1;
for (int i = 0; i < size && !monitor.isCanceled(); i += delta) {
// the last argument will be replaced with a path
HgCommand command = createRevertCommand(hgRoot, "Reverting resource " + i + " of " + size);
if (cs != null) {
command.addOptions("--rev", cs.getChangeset());
}
command.addFiles(resources.subList(i, Math.min(i + delta, size)));
command.executeToString();
fileSet.addAll(command.getAffectedFiles());
}
} else {
// the last argument will be replaced with a path
HgCommand command = createRevertCommand(hgRoot, "Reverting " + size + " resources");
if (cs != null) {
command.addOptions("--rev", cs.getChangeset());
}
command.addFiles(resources);
command.executeToString();
fileSet.addAll(command.getAffectedFiles());
}
}
monitor.worked(1);
return fileSet;
}
public static void performRevertAll(IProgressMonitor monitor, HgRoot hgRoot) throws HgException {
monitor.subTask(Messages.getString("ActionRevert.reverting") + " " + hgRoot.getName() + "..."); //$NON-NLS-1$ //$NON-NLS-2$
HgCommand command = createRevertCommand(hgRoot, "Reverting all resources");
command.addOptions("--all");
command.executeToString();
MercurialUtilities.setOfferAutoCommitMerge(true);
}
private static HgCommand createRevertCommand(HgRoot hgRoot, String message) {
HgCommand command = new HgCommand("revert", message, hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.COMMIT_TIMEOUT);
command.addOptions("--no-backup");
return command;
}
}
HgRollbackClient.java 0000664 0000000 0000000 00000002437 11737135005 0034132 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2007-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import org.eclipse.core.runtime.CoreException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
public class HgRollbackClient extends AbstractClient {
public static String rollback(final HgRoot hgRoot) throws CoreException {
HgCommand command = new HgCommand("rollback", "Rolling back last transaction", hgRoot, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
String result = command.executeToString();
new RefreshWorkspaceStatusJob(hgRoot, RefreshRootJob.ALL).schedule();
return result;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgRootClient.java 0000664 0000000 0000000 00000005245 11737135005 0033403 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* Calls hg root
*
* @author bastian
*
*/
public class HgRootClient extends AbstractClient {
/**
* @param file
* @return hg root as canonical path (see {@link File#getCanonicalPath()})
* @throws HgException
*/
public static HgRoot getHgRoot(File file) throws HgException {
// get the canonical path of the first existing directory
File dir = ResourceUtils.getFirstExistingDirectory(file);
HgRoot hgRoot;
try {
hgRoot = new HgRoot(dir);
} catch(IOException e) {
throw new HgException(Messages.getString("HgRootClient.error.cannotGetCanonicalPath")+file.getName()); //$NON-NLS-1$
}
// search up the parents recursive if we see .hg directory there
File root = findHgDir(hgRoot);
if (root == null) {
throw new HgException(file.getName() + Messages.getString("HgRootClient.error.noRoot")); //$NON-NLS-1$
}
// .hg parent dir found
try {
hgRoot = new HgRoot(root);
} catch (IOException e) {
throw new HgException(Messages.getString("HgRootClient.error.cannotGetCanonicalPath")+file.getName()); //$NON-NLS-1$
}
return hgRoot;
}
/**
* Searches the .hg directory up in all parents of the given file
* @param startDir a directory
* @return directory named ".hg" (in any case), or null if the given file does not
* have parents wich contains .hg directory
*/
private static File findHgDir(File startDir) {
FileFilter hg = new FileFilter() {
public boolean accept(File path) {
return path.getName().equalsIgnoreCase(".hg") && path.isDirectory(); //$NON-NLS-1$
}
};
File root = startDir;
File[] rootContent = root.listFiles(hg);
while (rootContent != null && rootContent.length == 0) {
root = root.getParentFile();
if (root == null) {
return null;
}
rootContent = root.listFiles(hg);
}
if(rootContent != null) {
return root;
}
return null;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgServeClient.java 0000664 0000000 0000000 00000011721 11737135005 0033540 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.OutputStream;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgServeClient extends AbstractClient {
/**
* Rule which forbids running server on same port
*/
private static final class ServeRule implements ISchedulingRule {
final int port;
private ServeRule(int port) {
super();
this.port = port;
}
public boolean isConflicting(ISchedulingRule rule) {
return contains(rule);
}
public boolean contains(ISchedulingRule rule) {
if(this == rule){
return true;
}
if(!(rule instanceof ServeRule)){
return false;
}
return this.port == ((ServeRule) rule).port;
}
}
static class HgServeJob extends Job {
private final HgRoot hgRoot;
private final boolean ipv6;
private final String name;
private final String prefix;
private final int port;
private final String webdirConf;
private final boolean stdio;
private final IProgressMonitor progress;
public HgServeJob(HgRoot hgRoot, int port, String prefix,
String name, String webdirConf, boolean ipv6, boolean stdio) {
super(Messages.getString("HgServeClient.serveJob.name") //$NON-NLS-1$
+ hgRoot.getName() + "..."); //$NON-NLS-1$
this.hgRoot = hgRoot;
this.port = port;
this.prefix = prefix;
this.name = name;
this.webdirConf = webdirConf;
this.ipv6 = ipv6;
this.stdio = stdio;
progress = getJobManager().createProgressGroup();
progress.beginTask("Local Mercurial Server on port " + port, IProgressMonitor.UNKNOWN);
setProgressGroup(progress, IProgressMonitor.UNKNOWN);
setPriority(LONG);
setUser(false);
setSystem(false);
setRule(new ServeRule(port));
}
@Override
protected IStatus run(IProgressMonitor monitor) {
final AbstractShellCommand command = getCommand(progress, hgRoot, port, prefix,
name, webdirConf, stdio, ipv6);
try {
command.executeToBytes(Integer.MAX_VALUE, false);
} catch (HgException e) {
MercurialEclipsePlugin.logError(e);
} finally {
command.terminate();
progress.done();
monitor.done();
}
return Status.OK_STATUS;
}
@Override
public boolean belongsTo(Object family) {
return HgServeClient.class == family;
}
}
public static boolean serve(HgRoot hgRoot, int port, String prefixPath,
String name, String webdirConf, boolean stdio, boolean ipv6) {
Job[] jobs = Job.getJobManager().find(HgServeClient.class);
for (Job job : jobs) {
ServeRule rule = (ServeRule) job.getRule();
if(rule != null && rule.port == port && job.getState() == Job.RUNNING){
return false;
}
}
new HgServeJob(hgRoot, port, prefixPath, name, webdirConf, ipv6, stdio)
.schedule();
return true;
}
private static AbstractShellCommand getCommand(final IProgressMonitor progress, HgRoot hgRoot,
final int port, String prefixPath, String name, String webdirConf, boolean stdio,
boolean ipv6) {
final AbstractShellCommand command = new HgCommand("serve", "Serving repository", hgRoot, true){
@Override
protected ProzessWrapper createProcessWrapper(OutputStream output, String jobName,
ProcessBuilder builder) {
ProzessWrapper wrapper = super.createProcessWrapper(output, jobName, builder);
wrapper.setProgressGroup(progress, IProgressMonitor.UNKNOWN);
wrapper.setPriority(Job.LONG);
wrapper.setUser(false);
wrapper.setSystem(true);
return wrapper;
}
};
command.setExecutionRule(new AbstractShellCommand.DefaultExecutionRule());
if (port != 8000) {
command.addOptions("--port", String.valueOf(port)); //$NON-NLS-1$
}
if (prefixPath != null && prefixPath.length() > 0) {
command.addOptions("--prefix", prefixPath); //$NON-NLS-1$
}
if (name != null && name.length() > 0) {
command.addOptions("--name", name); //$NON-NLS-1$
}
if (webdirConf != null && webdirConf.length() > 0) {
command.addOptions("--webdir-conf", webdirConf); //$NON-NLS-1$
}
if (stdio) {
command.addOptions("--stdio"); //$NON-NLS-1$
}
if (ipv6) {
command.addOptions("--ipv6"); //$NON-NLS-1$
}
// start daemon
return command;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgStatusClient.java0000664 0000000 0000000 00000033342 11737135005 0033742 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Jerome Negre - initial
* Bastian Doetsch - changes
* Brian Wallis - getMergeStatus
* Andrei Loskutov - bug fixes
* Zsolt Koppany (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.Branch;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.MercurialStatusCache;
public class HgStatusClient extends AbstractClient {
// expected output for merge:
// b63617c1e3460bd87eb51d2b8841b37fff1834d6+00838f86e1024072e715d31f477262d5162acd09+ default
// match second part (the one we merge with)
// output for "usual" state:
// b63617c1e3460bd87eb51d2b8841b37fff1834d6+ default
// OR b63617c1e3460bd87eb51d2b8841b37fff1834d6 hallo branch
// + after the id is the "dirty" flag - if some files are not committed yet
//
// As well in Mercurial 1.6.0 during some rebases the following output:
// filtering src/nexj/core/admin/platform/websphere/WebSphereInstaller.java through
// filtering src/nexj/core/meta/j2ee/ibmconfig/cells/defaultCell/applications/defaultApp/deployments/defaultApp/deployment.xml through
// filtering src/nexj/core/meta/sys/system.chtypes through
// 02bfc05967b86ba65a0cb990178638e4c491c865+d35923c18f8f564c6205e722119d88c6daa3f56d+ default
// These leading lines are ignored.
private static final Pattern ID_MERGE_AND_BRANCH_IGNORE_PATTERN = Pattern.compile("^filtering\\s.+\\sthrough\\s*$");
// group 1 group 2 group 3
// (first parent, optional dirty flag)(merge parent, optional dirty flag) space (branch name)
private static final Pattern ID_MERGE_AND_BRANCH_PATTERN = Pattern.compile("^([0-9a-z]+\\+?)([0-9a-z]+)?\\+?\\s+(.+)$");
public static String getStatusWithoutIgnored(HgRoot root, IResource res) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating resource status", root, true); //$NON-NLS-1$
// modified, added, removed, deleted, unknown, ignored, clean
command.addOptions("-marduc"); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
if (res.getType() == IResource.FILE) {
command.addFiles(res);
}
return command.executeToString();
}
public static String[] getStatus(HgRoot root, String revision1, String revision2, String filter, String inPattern, String exPattern) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating resource status", root, true); //$NON-NLS-1$
// modified, added, removed, deleted, unknown
command.addOptions(filter);
if (revision1 != null && revision1 != "") {
command.addOptions("--rev", revision1); //$NON-NLS-1$
}
if (revision2 != null && revision2 != "") {
command.addOptions("--rev", revision2); //$NON-NLS-1$
}
if (inPattern != null && inPattern != "") {
command.addOptions("--include", inPattern); //$NON-NLS-1$
}
if (exPattern != null && exPattern != "") {
command.addOptions("--exclude", exPattern); //$NON-NLS-1$
}
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
return command.executeToString().split("\n"); //$NON-NLS-1$
}
public static TreeSet removeStatusIndicator(String[] status) {
TreeSet set = new TreeSet();
for (String line : status) {
if (line.length() > 2) {
set.add(line.substring(2));
}
}
return set;
}
public static String getStatusWithoutIgnored(HgRoot root) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating resource status", root, true); //$NON-NLS-1$
// modified, added, removed, deleted, unknown, ignored, clean
command.addOptions("-marduc"); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
return command.executeToString();
}
/**
* @param hgRoot non null
* @return non null, but probably empty array with root relative file paths with all
* files under the given root, which are untracked by hg
*/
public static String[] getUntrackedFiles(HgRoot hgRoot) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating untracked files", hgRoot, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
command.addOptions("-u", "-n"); //$NON-NLS-1$ //$NON-NLS-2$
return command.executeToString().split("\n"); //$NON-NLS-1$
}
public static void assertClean(HgRoot root) throws HgException {
if (isDirty(root)) {
throw new HgException("Unexpected condition: " + root.getName() + " is dirty");
}
}
public static boolean isDirty(HgRoot root) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating dirty state", root, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
command.addOptions("-mard"); // modified, added, removed, deleted //$NON-NLS-1$
return command.executeToBytes().length != 0;
}
/**
* @param root non null
* @return current changeset id, merge id and branch name for the working directory
* @throws HgException
*/
public static String[] getIdMergeAndBranch(HgRoot root) throws HgException {
AbstractShellCommand command = new HgCommand("id", "Identifying status", root, true); //$NON-NLS-1$
// Full global IDs + branch name
command.addOptions("-ib", "--debug"); //$NON-NLS-1$ //$NON-NLS-2$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
String versionIds = null;
BufferedReader br = new BufferedReader(new StringReader(command.executeToString().trim()));
try {
while ((versionIds = br.readLine()) != null) {
if (!ID_MERGE_AND_BRANCH_IGNORE_PATTERN.matcher(versionIds).matches()) {
break;
}
}
} catch (IOException e) {
MercurialEclipsePlugin.logError(e);
} finally {
try {
br.close();
} catch (IOException ex) {
}
}
Matcher m = ID_MERGE_AND_BRANCH_PATTERN.matcher((versionIds == null) ? "" : versionIds);
String mergeId = null;
String branch = Branch.DEFAULT;
// current working directory id
String id = "";
if (m.matches() && m.groupCount() > 2) {
id = m.group(1);
mergeId = m.group(2);
branch = m.group(3);
}
if (id.endsWith("+")) {
id = id.substring(0, id.length() - 1);
}
return new String[] { id, mergeId, branch };
}
public static String getStatusWithoutIgnored(HgRoot root, List files) throws HgException {
AbstractShellCommand command = new HgCommand("status", //$NON-NLS-1$
"Calculating status for " + files.size() + " resources", root, true);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
// modified, added, removed, deleted, unknown, ignored, clean
command.addOptions("-marduc"); //$NON-NLS-1$
command.addFiles(files);
return command.executeToString();
}
/**
* @return root relative paths of changed files, never null
*/
public static String[] getDirtyFiles(HgRoot root) throws HgException {
AbstractShellCommand command = new HgCommand("status", "Calculating dirty resources", root, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
command.addOptions("-mard"); //$NON-NLS-1$
String result = command.executeToString();
if (result == null || result.length() == 0) {
return new String[0];
}
// now we will have status AND path info
String[] status = result.split("\n");
for (int i = 0; i < status.length; i++) {
// remove status info from status AND path line
status[i] = status[i].substring(2);
}
return status;
}
public static Set getDirtyFilePaths(HgRoot root) throws HgException {
String[] dirtyFiles = getDirtyFiles(root);
IPath rootPath = new Path(root.getAbsolutePath());
Set resources = new HashSet();
for (String rootRelativePath : dirtyFiles) {
// determine absolute path
IPath path = rootPath.append(rootRelativePath);
resources.add(path);
}
return resources;
}
/**
* Returns possible ancestor of the given file, if given file is a result of
* a copy or rename operation.
*
* Note: this is a very inefficient algorithm, which may need a lot of time to
* complete.
*
* @param file
* successor path (as full absolute file path)
* @param root
* hg root
* @param firstKnownRevision the version at which the information about possible
* parent file should be retrieved
*
* @return full absolute file path which was the source of the given file one changeset
* before given version, or null if the given file was not copied or renamed
* at given version.
* @throws HgException
*/
public static File getPossibleSourcePath(HgRoot root, File file, int firstKnownRevision) throws HgException{
return getPossibleSourcePath(root, file, firstKnownRevision - 1, "" + firstKnownRevision);
}
/**
* Guesses a possible ancestor of the given file, if given file is a result of
* a copy or rename operation.
*
* Note: this is a fast but inaccurate algorithm, which may not return expected
* information
*
* @param file
* successor path (as full absolute file path)
* @param root
* hg root
* @param firstKnownRevision the version at which the information about possible
* parent file should be retrieved
* @return full absolute file path which was the source of the given file one changeset
* before given version, or null if the given file was not copied or renamed
* at given version.
* @throws HgException
*/
public static File guessPossibleSourcePath(HgRoot root, File file, int firstKnownRevision) throws HgException {
// See issue #10302: we trying to cheat: "hg status -arC --rev firstKnownRevision:tip file" will return
// A file
// source_file
// in case the given file was known between "firstKnownRevision" and "tip"
// TODO not sure if "tip" works always as expected, but now it's my best guess for the upper limit
return getPossibleSourcePath(root, file, firstKnownRevision, HgRevision.TIP.getChangeset());
}
private static File getPossibleSourcePath(HgRoot root, File file, int firstRev, String secondRev) throws HgException{
AbstractShellCommand command = new HgCommand("status", "Finding resource status", root, true); //$NON-NLS-1$
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
command.addOptions("-arC"); //$NON-NLS-1$
command.addOptions("--rev"); //$NON-NLS-1$
command.addOptions(firstRev + ":" + secondRev); //$NON-NLS-1$
command.addFile(file);
String result = command.executeToString();
if (result == null || result.length() == 0) {
return null;
}
String relativePath = root.toRelative(file);
String[] statusAndFileNames = result.split("\n"); //$NON-NLS-1$
String prefixAdded = MercurialStatusCache.CHAR_ADDED + " ";
String prefixRemoved = MercurialStatusCache.CHAR_REMOVED + " ";
for (int i = 0; i < statusAndFileNames.length; i++) {
// looks like: "A folder\foo" or "R folder\foo" or "folder\foo"
String pathWithStatus = statusAndFileNames[i];
if(pathWithStatus.startsWith(prefixAdded) || pathWithStatus.startsWith(prefixRemoved)){
if(i + 1 < statusAndFileNames.length && pathWithStatus.endsWith(relativePath)){
// XXX should not just trim whitespace in the path, if it contains whitespaces, it will not work
// on the other side it's just idiotic to have filenames with leading or trailing spaces
String nextLine = statusAndFileNames[i + 1].trim();
if(!nextLine.startsWith(prefixAdded) && !nextLine.startsWith(prefixRemoved)) {
return new File(root, nextLine);
}
}
}
}
return null;
}
/**
* Execute 'hg status --rev cs --rev csparent', with bundle overlay if applicable
*
* @param cs
* The changeset to use
* @return Status output
* @throws HgException
*/
public static String getStatusForChangeset(ChangeSet cs) throws HgException {
HgCommand command = new HgCommand(
"status", //$NON-NLS-1$
"Calcuting resources changes in changeset " + cs.getChangeset(), cs.getHgRoot(),
true);
if (cs.getBundleFile() != null) {
try {
command.setBundleOverlay(cs.getBundleFile());
} catch (IOException e) {
throw new HgException("Couldn't set bundle overlay", e);
}
}
// modified, added, removed, deleted
command.addOptions("-mard"); //$NON-NLS-1$
command.addOptions("--rev", cs.getParentRevision(0).getChangeset());
command.addOptions("--rev", cs.getRevision().getChangeset());
command.setUsePreferenceTimeout(MercurialPreferenceConstants.STATUS_TIMEOUT);
return command.executeToString();
}
}
HgSubreposClient.java 0000664 0000000 0000000 00000007642 11737135005 0034206 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* lordofthepigs - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.utils.IniFile;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* @author lordofthepigs
*
*/
public class HgSubreposClient extends AbstractClient {
private static final String HGSUB = ".hgsub";
private static final String HGDIR = ".hg";
/**
* Returns the list of the subrepositories of the specified Hg repository that are cloned inside the working copy.
*/
public static Set findSubrepositories(HgRoot hgRoot){
File hgsub = new File(hgRoot, HGSUB);
if(!hgsub.isFile()){
return new HashSet();
}
Map subrepos;
try {
IniFile iniFile = new IniFile(hgsub.getAbsolutePath());
subrepos = iniFile.getSection(null);
} catch (FileNotFoundException e) {
// this shouldn't happen because we checked for existence of the file before, but who knows,
// bad timing happens...
MercurialEclipsePlugin.logError(e);
return new HashSet();
}
if(subrepos == null || subrepos.isEmpty()){
return new HashSet();
}
Set result = new HashSet();
for(String subReposRootPath : subrepos.keySet()){
File subReposRootDir = new File(hgRoot, subReposRootPath);
if(!subReposRootDir.isDirectory()){
// for some reason the subrepos was not cloned or disappeared, just ignore it
continue;
}
File subRepoHg = new File(subReposRootDir, HGDIR);
if(subRepoHg.isDirectory()){
// we are reasonably sure that an HgRoot really exists in subReposRootDir
try{
result.add(new HgRoot(subReposRootDir));
} catch(IOException ioe){
MercurialEclipsePlugin.logError(ioe);
}
}
}
return result;
}
public static Set findSubrepositoriesRecursively(HgRoot root){
Set found = new HashSet();
doFindSubrepositoriesRecursively(root, found, Path.EMPTY);
return found;
}
public static Set findSubrepositoriesRecursivelyWithin(HgRoot root, IResource container){
if(container.getType() == IResource.FILE){
// a file cannot contain a subrepo
return new HashSet();
}
Set found = new HashSet();
doFindSubrepositoriesRecursively(root, found, ResourceUtils.getPath(container));
return found;
}
/**
* recursively finds all the subrepositories under the specified HgRoot and stores all the
* discovered subrepos in the specified set. An IPath can optionally be specified, in which
* case, all the returned subrepos will be children of that IPath.
*
* @param containerPath
* non null. Use {@link Path#EMPTY} if the containerPath should be not used
*/
private static void doFindSubrepositoriesRecursively(HgRoot root, Set found, IPath containerPath){
Set subs = findSubrepositories(root);
for(HgRoot sub : subs){
if(containerPath.isEmpty() || containerPath.isPrefixOf(sub.getIPath())) {
found.add(sub);
doFindSubrepositoriesRecursively(sub, found, containerPath);
}
}
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgTagClient.java 0000664 0000000 0000000 00000007622 11737135005 0033174 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation of remove
* Andrei Loskutov - bug fixes
* Zsolt Koppany (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.vectrace.MercurialEclipse.compare.TagComparator;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Tag;
public class HgTagClient extends AbstractClient {
private static final Pattern GET_TAGS_PATTERN = Pattern.compile("^(.*) ([-0-9]+):([a-f0-9]+)( local)?$"); //$NON-NLS-1$
/**
* Fetches all tags for given root. The tags do NOT have full changeset info
* attached.
* @param hgRoot non null
* @return never null, might be empty array
* @throws HgException
*/
public static Tag[] getTags(HgRoot hgRoot) throws HgException {
AbstractShellCommand command = new HgCommand("tags", "Retrieving tags", hgRoot, false); //$NON-NLS-1$
command.addOptions("-v"); //$NON-NLS-1$
String[] lines = command.executeToString().split("\n"); //$NON-NLS-1$
Collection tags = getTags(hgRoot, lines);
Tag[] sortedTags = tags.toArray(new Tag[] {});
return sortedTags;
}
/**
* @param hgRoot non null
* @param withChangesets true to fetch corresponding changesets too
* @return never null, might be empty array
* @throws HgException
*/
public static Tag[] getTags(HgRoot hgRoot, boolean withChangesets) throws HgException {
Tag[] tags = getTags(hgRoot);
if(withChangesets) {
for (Tag tag : tags) {
// triggers changeset loading, if the local changeset cache
// doesn't contain the tag version
tag.getChangeSet();
}
}
return tags;
}
protected static Collection getTags(HgRoot hgRoot, String[] lines) throws HgException {
List tags = new ArrayList();
for (String line : lines) {
Matcher m = GET_TAGS_PATTERN.matcher(line);
if (m.matches()) {
String tagName = m.group(1).trim();
Tag tag = new Tag(hgRoot, tagName, Integer.parseInt(m.group(2)), m.group(3), m.group(4) != null);
tags.add(tag);
} else {
throw new HgException(Messages.getString("HgTagClient.parseException") + line + "'"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
Collections.sort(tags, new TagComparator());
return tags;
}
/**
* @param user
* if null, uses the default user
* @throws HgException
*/
public static void addTag(HgRoot hgRoot, String name, String rev, String user, boolean local, boolean force) throws HgException {
HgCommand command = new HgCommand(
"tag", "Tagging revision " + ((rev == null) ? "" : rev + " ") + "as " + name, hgRoot, false); //$NON-NLS-1$
if (local) {
command.addOptions("-l");
}
if (force) {
command.addOptions("-f");
}
if (rev != null) {
command.addOptions("-r", rev);
}
command.addUserName(user);
command.addOptions(name);
command.executeToBytes();
command.rememberUserName();
}
public static String removeTag(HgRoot hgRoot, Tag tag, String user) throws HgException {
HgCommand command = new HgCommand("tag", "Removing tag " + tag, hgRoot, false); //$NON-NLS-1$
command.addUserName(user);
command.addOptions("--remove");
command.addOptions(tag.getName());
String result = command.executeToString();
command.rememberUserName();
return result;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/HgUpdateClient.java0000664 0000000 0000000 00000006631 11737135005 0033702 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.ui.PlatformUI;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
public class HgUpdateClient extends AbstractClient {
public static void cleanUpdate(final HgRoot hgRoot, String revision) throws HgException
{
update(hgRoot, revision, true);
}
/**
* Perform an update and refresh the workspace. Handles unresolved conflicts and shows the user a message
*/
public static void update(final HgRoot hgRoot, String revision, boolean clean)
throws HgException {
try {
updateWithoutRefresh(hgRoot, revision, clean);
} catch (HgException e) {
if (isWorkspaceUpdateConflict(e)) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
MessageDialog
.openInformation(null, "Unresolved conflicts",
"You have unresolved conflicts after update. Use Synchronize View to edit conflicts");
}
});
} else {
throw e;
}
} finally {
new RefreshWorkspaceStatusJob(hgRoot, RefreshRootJob.LOCAL).schedule();
}
}
/**
* Perform an update.
*
* @param hgRoot
* The root to use
* @param revision
* The revision, may be null
* @param clean
* Whether a clean update should be done
* @return The result of the invocation
*/
public static String updateWithoutRefresh(HgRoot hgRoot, String revision, boolean clean) throws HgException {
HgCommand command = new HgCommand("update", makeDescription(revision, clean), hgRoot, false); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.UPDATE_TIMEOUT);
if (revision != null && revision.trim().length() > 0) {
command.addOptions("-r", revision); //$NON-NLS-1$
}
if (clean) {
command.addOptions("-C"); //$NON-NLS-1$
}
addMergeToolPreference(command);
return command.executeToString();
}
private static String makeDescription(String revision, boolean clean) {
revision = (revision == null || revision.trim().length() == 0) ? null : revision.trim();
if (revision != null) {
return ((clean) ? "Clean update" : "Updating") + " to " + revision;
}
return (clean) ? "Clean update" : "Updating working directory";
}
public static boolean isWorkspaceUpdateConflict(HgException e) {
return e.getMessage().contains("use 'hg resolve' to retry unresolved file merges");
}
public static boolean isCrossesBranchError(HgException e) {
return e.getMessage().contains("abort: crosses branches") && e.getStatus().getCode() == -1;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/IConfiguration.java0000664 0000000 0000000 00000001623 11737135005 0033756 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
/**
* @author Stefan
*
*/
public interface IConfiguration {
/**
* @return
*/
String getExecutable();
/**
* @param commandId
* @return
*/
int getTimeOut(String commandId);
/**
* @param preferenceConstant
* @param defaultIfNotSet
* @return
*/
String getPreference(String preferenceConstant, String defaultIfNotSet);
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/IConsole.java 0000664 0000000 0000000 00000001537 11737135005 0032555 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
/**
* @author Stefan
*
*/
public interface IConsole {
void commandInvoked(String command);
void commandCompleted(int exitCode, long timeInMillis, String message, Throwable error);
void printError(String message, Throwable root);
void printMessage(String message, Throwable root);
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/IErrorHandler.java 0000664 0000000 0000000 00000001427 11737135005 0033540 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
/**
* @author Stefan
*
*/
public interface IErrorHandler {
/**
* @param e
*/
void logError(Throwable e);
/**
* @param message
* @param e
* @return
*/
void logWarning(String message, Throwable e);
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/Messages.java 0000664 0000000 0000000 00000002131 11737135005 0032600 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* @author bastian
*
*/
public final class Messages {
private static final String BUNDLE_NAME = "com.vectrace.MercurialEclipse.commands.messages"; //$NON-NLS-1$
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
private Messages() {
}
public static String getString(String key) {
try {
return RESOURCE_BUNDLE.getString(key);
} catch (MissingResourceException e) {
return '!' + key + '!';
}
}
}
RootlessHgCommand.java 0000664 0000000 0000000 00000002670 11737135005 0034352 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* John Peberdy implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands;
import java.io.File;
import java.util.List;
import org.eclipse.core.runtime.Assert;
/**
* A command to invoke hg definitely outside of an hg root.
*/
public class RootlessHgCommand extends AbstractShellCommand {
public RootlessHgCommand(String command, String uiName) {
this(command, uiName, null);
}
public RootlessHgCommand(String command, String uiName, File workingDir) {
super(uiName, null, workingDir, false);
Assert.isNotNull(command);
this.command = command;
}
// operations
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#customizeCommands(java.util.List)
*/
@Override
protected void customizeCommands(List cmd) {
cmd.add(1, "-y");
}
/**
* @see com.vectrace.MercurialEclipse.commands.AbstractShellCommand#getExecutable()
*/
@Override
protected String getExecutable() {
return HgClients.getExecutable();
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/ 0000775 0000000 0000000 00000000000 11737135005 0032370 5 ustar 00root root 0000000 0000000 HgAtticClient.java 0000664 0000000 0000000 00000003667 11737135005 0035652 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2009 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgAtticClient extends AbstractClient {
public static String shelve(HgRoot hgRoot, String commitMessage,
boolean git, String user, String name) throws HgException {
HgCommand cmd = new HgCommand("attic-shelve", "Invoking attic-shelve", hgRoot, false);
if (commitMessage != null && commitMessage.length() > 0) {
cmd.addOptions("-m", commitMessage); // $NON-NLS-1$
}
if (git) {
cmd.addOptions("--git"); // $NON-NLS-1$
}
cmd.addUserName(user);
cmd.addOptions("--currentdate", name); // $NON-NLS-1$
String result = cmd.executeToString();
cmd.rememberUserName();
return result;
}
public static String unshelve(HgRoot hgRoot, boolean guessRenamedFiles,
boolean delete, String name) throws HgException {
AbstractShellCommand cmd = new HgCommand("attic-unshelve", "Invoking attic-unshelve", hgRoot, false);
if (guessRenamedFiles) {
cmd.addOptions("--similarity"); // $NON-NLS-1$
}
if (delete) {
cmd.addOptions("--delete"); // $NON-NLS-1$
}
cmd.addOptions(name);
return cmd.executeToString();
}
}
HgBookmarkClient.java 0000664 0000000 0000000 00000005540 11737135005 0036343 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2008 Bastian Doetsch and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.util.ArrayList;
import java.util.List;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.Bookmark;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*/
public class HgBookmarkClient extends AbstractClient {
/**
* @return a List of bookmarks
*/
public static List getBookmarks(HgRoot hgRoot) throws HgException {
AbstractShellCommand cmd = new HgCommand("bookmarks", "Listing bookmarks", hgRoot, true);
cmd.addOptions("--config", "extensions.hgext.bookmarks="); //$NON-NLS-1$ //$NON-NLS-2$
String result = cmd.executeToString();
return convert(result);
}
private static ArrayList convert(String result) {
ArrayList bookmarks = new ArrayList();
if (!result.startsWith("no bookmarks set")) { //$NON-NLS-1$
String[] split = result.split("\n"); //$NON-NLS-1$
for (String string : split) {
bookmarks.add(new Bookmark(string));
}
}
return bookmarks;
}
public static String create(HgRoot hgRoot, String name, String targetChangeset)
throws HgException {
AbstractShellCommand cmd = new HgCommand("bookmarks", "Adding bookmark", hgRoot, true);
cmd.addOptions("--config", "extensions.hgext.bookmarks="); //$NON-NLS-1$ //$NON-NLS-2$
cmd.addOptions("--rev", targetChangeset, name); //$NON-NLS-1$
return cmd.executeToString();
}
public static String rename(HgRoot hgRoot, String name, String newName)
throws HgException {
AbstractShellCommand cmd = new HgCommand("bookmarks", "Renaming bookmark", hgRoot, true);
cmd.addOptions("--config", "extensions.hgext.bookmarks="); //$NON-NLS-1$ //$NON-NLS-2$
cmd.addOptions("--rename", name, newName); //$NON-NLS-1$
return cmd.executeToString();
}
public static String delete(HgRoot hgRoot, String name)
throws HgException {
AbstractShellCommand cmd = new HgCommand("bookmarks", "Deleting bookmark", hgRoot, true);
cmd.addOptions("--config", "extensions.hgext.bookmarks="); //$NON-NLS-1$ //$NON-NLS-2$
cmd.addOptions("--delete", name); //$NON-NLS-1$
return cmd.executeToString();
}
}
HgGLogClient.java 0000664 0000000 0000000 00000007700 11737135005 0035426 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.HgLogClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.GChangeSet;
import com.vectrace.MercurialEclipse.model.GChangeSet.RowCount;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
public class HgGLogClient extends HgCommand {
private final List sets = new ArrayList();
public HgGLogClient(IResource resource, int batchSize, int startRev) throws HgException {
super("glog", "Retrieving revision graph for resource", resource, false);
File fileHandle = ResourceUtils.getFileHandle(resource);
if(fileHandle.getPath().length() == 0) {
// unknown or virtual resource
return;
}
if (resource.getType() == IResource.FILE) {
addOptions(fileHandle.getAbsolutePath());
} else {
if (resource.getType() != IResource.PROJECT){
// glog doesn't follow directories
return;
}
if(!hgRoot.equals(fileHandle)){
// multiple projects under same hg root handled by glog as directories
return;
}
}
configureOptions(batchSize, startRev);
load(executeToString());
}
private void configureOptions(int batchSize, int startRev) {
addOptions("--config", "extensions.graphlog="); //$NON-NLS-1$ //$NON-NLS-2$
addOptions("--template", "*{rev}\\n"); // Removes everything //$NON-NLS-1$ //$NON-NLS-2$
if(batchSize > 0) {
addOptions("--limit", String.valueOf(batchSize)); //$NON-NLS-1$
} else {
// set very high limit for log/glog when no limit is wanted to override limits set in user's .hgrc
addOptions("--limit", HgLogClient.NOLIMIT); //$NON-NLS-1$
}
if (startRev >= 0 && startRev != Integer.MAX_VALUE) {
// always advise to follow until 0 revision: the reason is that log limit
// might be bigger then the difference of two consequent revisions on a specific resource
addOptions("-r");
addOptions(startRev + ":" + 0);
}
setUsePreferenceTimeout(MercurialPreferenceConstants.LOG_TIMEOUT);
}
public HgGLogClient(HgRoot hgRoot, int batchSize, int startRev) throws HgException {
super("glog", "Retrieving revision graph", hgRoot, false);
configureOptions(batchSize, startRev);
load(executeToString());
}
private void load(String s) {
String[] split = s.split("\n"); //$NON-NLS-1$
// real changeset count as glog inserts a line between two changesets
int length = split.length / 2;
int lengthp1 = length;
RowCount rowCount = new RowCount();
GChangeSet last = null;
// Mercurial 1.9 glog issue workaround
// TODO: redesign parsing algorithm and revision graph presentation
int j=0;
for (int i = 0; i < lengthp1; i++) {
// adjust index for spacing
int changeset = i * 2;
String afterS = i != length ? split[changeset + 1] : "";
if(split[changeset].indexOf('*') == -1) {
continue;
}
// add current changeset and next line
GChangeSet newOne = new GChangeSet(rowCount, j++, split[changeset], afterS);
newOne.clean(last);
last = newOne;
sets.add(last);
}
}
public List getChangeSets() {
return sets;
}
}
HgRebaseClient.java 0000664 0000000 0000000 00000014650 11737135005 0036001 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2008 Bastian Doetsch and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.io.File;
import java.util.regex.Pattern;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
/**
* @author bastian
*
*/
public class HgRebaseClient extends AbstractClient {
private static final Pattern REBASING_CONFLICT = Pattern.compile("^abort:.*unresolved conflicts", Pattern.MULTILINE);
/**
* Calls hg rebase.
*
* Doesn't support supplying custom commit messages for collapse and continued collapse.
*
* @param hgRoot
* a hg root that is to be rebased.
* @param sourceRev
* --source option, -1 if not set
* @param baseRev
* --base option, -1 if not set
* @param destRev
* --dest option, -1 if not set
* @param collapse
* true, if --collapse is to be used
* @param cont
* true, if --continue is to be used
* @param abort
* true, if --abort is to be used
* @param keepBranches
* @param useExternalMergeTool
* @param user
* The user to use for collapse and continued collapse. May be null
* @return the output of the command
* @throws HgException
*/
public static String rebase(HgRoot hgRoot, int sourceRev, int baseRev, int destRev,
boolean collapse, boolean cont, boolean abort, boolean keepBranches, boolean keep,
boolean useExternalMergeTool, String user) throws HgException {
AbstractShellCommand c = new HgCommand("rebase", "Rebasing", hgRoot, false);//$NON-NLS-1$
c.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
c.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
if (!useExternalMergeTool) {
// we use (non-existent) simplemerge, so no tool is started. We
// need this option, though, as we still want the Mercurial merge to
// take place.
c.addOptions("--config", "ui.merge=simplemerge"); //$NON-NLS-1$ //$NON-NLS-2$
// Do not invoke external editor for commit message
// Future: Allow user to specify this
c.addOptions("--config", "ui.editor=echo"); //$NON-NLS-1$ //$NON-NLS-2$
// Future: Delete this block and use addMergeToolPreference(command);
}
c.addOptions("--config", "extensions.hgext.rebase="); //$NON-NLS-1$ //$NON-NLS-2$
// User is only applicable for collapse and continued collapse invocations
if (user != null) {
c.addOptions("--config", "ui.username=" + user); //$NON-NLS-1$ //$NON-NLS-2$
}
if (!cont && !abort) {
if (sourceRev >= 0 && baseRev <= 0) {
c.addOptions("--source", "" + sourceRev); //$NON-NLS-1$ //$NON-NLS-2$
}
if (sourceRev < 0 && baseRev >= 0) {
c.addOptions("--base", "" + baseRev); //$NON-NLS-1$ //$NON-NLS-2$
}
if (destRev >= 0) {
c.addOptions("--dest", "" + destRev); //$NON-NLS-1$ //$NON-NLS-2$
}
if (collapse) {
c.addOptions("--collapse"); //$NON-NLS-1$
}
}
if (cont && !abort) {
c.addOptions("--continue"); //$NON-NLS-1$
}
if (abort && !cont) {
c.addOptions("--abort"); //$NON-NLS-1$
}
if (keepBranches) {
c.addOptions("--keepbranches"); //$NON-NLS-1$
}
if (keep) {
c.addOptions("--keep"); //$NON-NLS-1$
}
MercurialUtilities.setOfferAutoCommitMerge(true);
return c.executeToString();
}
/**
* Invoke hg rebase --abort. Note: Refreshes the workspace.
*
* @param hgRoot
* The hg root to use
* @return The result message
* @throws HgException
* On error
*/
public static String abortRebase(HgRoot hgRoot) throws HgException {
try {
return rebase(hgRoot, -1, -1, -1, false, false, true, false, false, false, null);
} finally {
new RefreshWorkspaceStatusJob(hgRoot, RefreshRootJob.ALL).schedule();
}
}
/**
* Check to see if we are in the middle of a rebase.
* Assume the presence of the /.hg/rebasestate file means that we are
*
* @param hgRoot
* @return true if we are currently rebasing
*/
public static boolean isRebasing(HgRoot hgRoot) {
return new File(hgRoot, ".hg" + File.separator + "rebasestate").exists();
}
/**
* Determine if the given exception indicates a rebase conflict occurred.
*
* Warning: Will this work on non-English locales?
*
* Warning: Will hg output change?
*
* @param e
* The exception to check
* @return True if the exception indicates a conflict occurred
*/
public static boolean isRebaseConflict(HgException e) {
String message = e.getMessage();
// Conflicts are expected:
// 1.6.x:
// /bin/sh: simplemerge: command not found
// merging file1.txt
// merging file1.txt
// merging file1.txt failed!
// abort: fix unresolved conflicts with hg resolve then run hg rebase --continue.
// Command line: /home/john/runtime-New_configuration/hgtest2/hg -y
// rebase --config ui.merge=simplemerge --config ui.editor=echo --config
// extensions.hgext.rebase= --config ui.username=john --base 8 --dest 5, error
// code: 255
// 1.8.3 and 1.8.4
// merging file1-4.txt
// /bin/sh: simplemerge: command not found
// merging file1-4.txt failed!
// abort: unresolved conflicts (see hg resolve, then hg rebase --continue).
// Command line: /home/john/runtime-New_configuration/hgtest:hg -y rebase --config
// ui.merge=simplemerge --config ui.editor=echo --config extensions.hgext.rebase= --source
// 3442 --dest 3441, error code: 255
return (message != null && REBASING_CONFLICT.matcher(message).find());
}
}
HgSignClient.java 0000664 0000000 0000000 00000010267 11737135005 0035500 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.ResourcesPlugin;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.GpgCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.team.MercurialUtilities;
/**
* Client for hg sign
*
* @author Bastian Doetsch
*
*/
public final class HgSignClient {
private HgSignClient() {
// hide constructor of utility class.
}
/**
* Calls hg sign. add a signature for the current or given revision If no
* revision is given, the parent of the working directory is used, or tip if
* no revision is checked out.
*
* @param hgRoot
* the current hg root
* @param cs
* ChangeSet, may be null
* @param key
* the keyId to use
* @param message
* commit message
* @param user
* user name for commit
* @param local
* flag, if signing is only local
* @param force
* flag to even sign if sigfile is changed
* @param noCommit
* flag, if commit shall happen (invalidates params message and
* user)
* @param passphrase
* the passphrase or null
* @author Bastian Doetsch
*/
public static String sign(HgRoot hgRoot, ChangeSet cs, String key,
String message, String user, boolean local, boolean force,
boolean noCommit, String passphrase) throws HgException {
HgCommand command = new HgCommand("sign", "Signing revision", hgRoot, true); //$NON-NLS-1$
File file = new File("me.gpg.tmp"); //$NON-NLS-1$
String cmd = "gpg.cmd=" + //$NON-NLS-1$
MercurialUtilities.getGpgExecutable(true) + " --batch --no-tty --armor"; //$NON-NLS-1$
if (passphrase != null && passphrase.length() > 0) {
FileWriter fw = null;
try {
fw = new FileWriter(file);
fw.write(passphrase.concat("\n")); //$NON-NLS-1$
fw.flush();
cmd = cmd + " --passphrase-file " + //$NON-NLS-1$
file.getCanonicalPath();
} catch (IOException e) {
throw new HgException(e.getMessage());
} finally {
if (fw != null) {
try {
fw.close();
} catch (Exception e) {
MercurialEclipsePlugin.logError(e);
}
}
}
}
command.addOptions("-k", key, "--config", "extensions.gpg=", "--config", cmd); //$NON-NLS-1$ //$NON-NLS-2$
if (local) {
command.addOptions("-l"); //$NON-NLS-1$
}
if (force) {
command.addOptions("-f"); //$NON-NLS-1$
}
if (noCommit) {
command.addOptions("--no-commit"); //$NON-NLS-1$
} else {
command.addOptions("-m", message); //$NON-NLS-1$
command.addUserName(user);
}
command.addOptions(cs.getChangeset());
String result;
try {
result = command.executeToString();
command.rememberUserName();
return result;
} finally {
if (!file.delete()) {
throw new HgException(file.getName()+" could not be deleted.");
}
}
}
public static String getPrivateKeyList(HgRoot hgRoot) throws HgException {
List getKeysCmd = new ArrayList();
getKeysCmd.add(MercurialUtilities.getGpgExecutable(true));
getKeysCmd.add("--list-secret-keys"); //$NON-NLS-1$
GpgCommand command = new GpgCommand(hgRoot, "Retrieving GPG key list", getKeysCmd, ResourcesPlugin
.getWorkspace().getRoot().getLocation().toFile());
return new String(command.executeToBytes());
}
}
HgSigsClient.java 0000664 0000000 0000000 00000006276 11737135005 0035512 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Signature;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
/**
* @author bastian
*/
public class HgSigsClient extends AbstractClient {
private static HgException notAvailable;
/**
* Gets signed changesets
*
* @param hgRoot
* @return the identifiers of signed changesets (rev:node)
* @throws HgException
*/
public static List getSigs(HgRoot hgRoot) throws CoreException {
try {
List nodes = new ArrayList();
File sigFile = new File(hgRoot, ".hgsigs"); //$NON-NLS-1$
if (sigFile.exists()) {
LineNumberReader reader = null;
try {
reader = new LineNumberReader(new FileReader(sigFile));
String line = reader.readLine();
while (line != null) {
String nodeId = line.substring(0, line.indexOf(" 0 ")); //$NON-NLS-1$
Signature sig = new Signature(null, nodeId, hgRoot);
nodes.add(sig);
line = reader.readLine();
}
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
} finally {
if (reader != null) {
reader.close();
}
}
}
return nodes;
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
/**
* @return may return null, if "sigcheck" command is not available
* @throws HgException if command failed
*/
public static String checkSig(HgRoot hgRoot, String nodeId) throws HgException {
if(notAvailable != null){
return null;
}
try {
AbstractShellCommand c = new HgCommand("sigcheck", //$NON-NLS-1$
"Checking signature", hgRoot, false);
c.addOptions("--config", "extensions.gpg=");
c.setUsePreferenceTimeout(MercurialPreferenceConstants.DEFAULT_TIMEOUT);
c.addOptions(nodeId);
return c.executeToString();
} catch (HgException e) {
String message = e.getMessage();
if(message != null && message.contains("unknown") && message.contains("'sigcheck'")){
MercurialEclipsePlugin.logError(e);
notAvailable = e;
return null;
}
throw e;
}
}
}
HgStripClient.java 0000664 0000000 0000000 00000005071 11737135005 0035676 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
/**
* Calls hg strip
*
* @author bastian
*/
public final class HgStripClient {
private HgStripClient() {
// hide constructor of utility class.
}
public static String stripCurrent(final HgRoot hgRoot, boolean keep, boolean backup, boolean force)
throws HgException {
return strip(hgRoot, keep, backup, force, ".");
}
/**
* strip a revision and all later revs on the same branch
*/
public static String strip(final HgRoot hgRoot, boolean keep, boolean backup, boolean force, ChangeSet changeset)
throws HgException {
return strip(hgRoot, keep, backup, force, changeset.getChangeset());
}
private static String strip(final HgRoot hgRoot, boolean keep, boolean backup, boolean force, String changeset)
throws HgException {
HgCommand command = new HgCommand("strip", "Stripping revision " + changeset, hgRoot, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.COMMIT_TIMEOUT);
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (keep) {
command.addOptions("--keep"); //$NON-NLS-1$
}
if (!backup) {
command.addOptions("--no-backup"); //$NON-NLS-1$
}
if (force) {
command.addOptions("-f"); //$NON-NLS-1$
}
command.addOptions(changeset);
String result = command.executeToString();
new RefreshWorkspaceStatusJob(hgRoot, RefreshRootJob.ALL).schedule();
return result;
}
}
HgSvnClient.java 0000664 0000000 0000000 00000006551 11737135005 0035347 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2005-2008 Bastian Doetsch and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.io.File;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.RootlessHgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
/**
* @author bastian
*
*/
public class HgSvnClient extends AbstractClient {
public static String pull(HgRoot hgRoot) throws HgException {
HgCommand cmd = new HgCommand("svn", "Invoking svn pull", hgRoot, false);
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
cmd.addOptions("pull"); //$NON-NLS-1$
String result = cmd.executeToString();
// The reason to use "all" instead of only "local + incoming", is that we can pull
// from another repo as the sync clients for given project may use
// in this case, we also need to update "outgoing" changesets
new RefreshRootJob(hgRoot, RefreshRootJob.ALL).schedule();
return result;
}
public static String push(HgRoot currentWorkingDirectory) throws HgException {
AbstractShellCommand cmd = new HgCommand("svn", //$NON-NLS-1$
"Invoking svn push", currentWorkingDirectory, false);
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.PUSH_TIMEOUT);
cmd.addOptions("push"); //$NON-NLS-1$
return cmd.executeToString();
}
public static String rebase(HgRoot hgRoot)
throws HgException {
HgCommand cmd = new HgCommand("svn", "Invoking svn rebase", hgRoot, false);
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.PUSH_TIMEOUT);
cmd.addOptions("--config", "extensions.hgext.rebase="); //$NON-NLS-1$ //$NON-NLS-2$
cmd.addOptions("rebase"); //$NON-NLS-1$
String result = cmd.executeToString();
new RefreshRootJob(hgRoot, RefreshRootJob.ALL).schedule();
return result;
}
public static void clone(File currentWorkingDirectory,
IHgRepositoryLocation repo, boolean timeout, String cloneName)
throws HgException {
AbstractShellCommand cmd = new RootlessHgCommand("svnclone", //$NON-NLS-1$
"Invoking svnclone", ResourceUtils.getFirstExistingDirectory(currentWorkingDirectory));
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.CLONE_TIMEOUT);
addRepoToHgCommand(repo, cmd);
if (cloneName != null) {
cmd.addOptions(cloneName);
}
if (timeout) {
cmd.setUsePreferenceTimeout(MercurialPreferenceConstants.CLONE_TIMEOUT);
cmd.executeToBytes();
} else {
cmd.executeToBytes(Integer.MAX_VALUE);
}
}
}
HgTransplantClient.java 0000664 0000000 0000000 00000007550 11737135005 0036727 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions;
import java.net.URI;
import java.util.SortedSet;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
public final class HgTransplantClient {
public static class TransplantOptions {
public boolean all;
public boolean branch;
public boolean continueLastTransplant;
public boolean filterChangesets;
public boolean merge;
public boolean prune;
public String branchName;
public String filter;
public String mergeNodeId;
public String pruneNodeId;
/** changesets sorted in the ascending revision order */
public SortedSet nodes;
/**
* @return Human readable description
*/
public String getDescription() {
if (continueLastTransplant) {
return "Continuing transplant";
} else if (all) {
return "Transplanting all revisions from source";
} else if (nodes == null) {
return "Transplanting";
} else if (nodes.size() > 1) {
return "Transplanting " + nodes.size() + " revisions";
}
return "Transplanting revision " + nodes.first().getChangeset();
}
}
private HgTransplantClient() {
// hide constructor of utility class.
}
/**
* Cherrypicks given ChangeSets from repository or branch.
*/
public static String transplant(HgRoot hgRoot,
IHgRepositoryLocation repo, TransplantOptions options) throws HgException {
AbstractShellCommand command = new HgCommand("transplant", options.getDescription(), hgRoot, false); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(hgRoot));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
command.addOptions("--config", "extensions.hgext.transplant="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("--log"); //$NON-NLS-1$
if (options.continueLastTransplant) {
command.addOptions("--continue"); //$NON-NLS-1$
} else {
if (options.branch) {
command.addOptions("--branch"); //$NON-NLS-1$
command.addOptions(options.branchName);
if (options.all) {
command.addOptions("--all"); //$NON-NLS-1$
} else {
// the exact revision will be specified below via changeset id
}
} else {
command.addOptions("--source"); //$NON-NLS-1$
URI uri = repo.getUri();
if (uri != null) {
command.addOptions(uri.toASCIIString());
} else {
command.addOptions(repo.getLocation());
}
}
if (options.prune) {
command.addOptions("--prune"); //$NON-NLS-1$
command.addOptions(options.pruneNodeId);
}
if (options.merge) {
command.addOptions("--merge"); //$NON-NLS-1$
command.addOptions(options.mergeNodeId);
}
if (!options.all && options.nodes != null && options.nodes.size() > 0) {
for (ChangeSet node : options.nodes) {
command.addOptions(node.getChangeset());
}
}
if (options.filterChangesets) {
command.addOptions("--filter", options.filter); //$NON-NLS-1$
}
}
return new String(command.executeToBytes());
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/forest/ 0000775 0000000 0000000 00000000000 11737135005 0033672 5 ustar 00root root 0000000 0000000 HgFcloneClient.java 0000664 0000000 0000000 00000004414 11737135005 0037305 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/forest /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.forest;
import java.io.File;
import java.net.URI;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.RootlessHgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
/**
* @author bastian
*
*/
public class HgFcloneClient extends AbstractClient {
public static void fclone(File parentDirectory, IHgRepositoryLocation repo,
boolean noUpdate, boolean pull, boolean uncompressed,
boolean timeout, String rev, String cloneName)
throws HgException {
AbstractShellCommand command = new RootlessHgCommand("fclone", "Invoking fclone", parentDirectory); //$NON-NLS-1$
// command.addOptions("--config", "extensions.hgext.forest="); //$NON-NLS-1$ //$NON-NLS-2$
if (noUpdate) {
command.addOptions("--noupdate"); //$NON-NLS-1$
}
if (pull) {
command.addOptions("--pull"); //$NON-NLS-1$
}
if (uncompressed) {
command.addOptions("--uncompressed"); //$NON-NLS-1$
}
if (rev != null && rev.length() > 0) {
command.addOptions("--rev", rev); //$NON-NLS-1$
}
URI uri = repo.getUri();
if (uri != null) {
command.addOptions(uri.toASCIIString());
} else {
command.addOptions(repo.getLocation());
}
if (cloneName != null) {
command.addOptions(cloneName);
}
if (timeout) {
command
.setUsePreferenceTimeout(MercurialPreferenceConstants.CLONE_TIMEOUT);
command.executeToBytes();
} else {
command.executeToBytes(Integer.MAX_VALUE);
}
}
}
HgFpushPullClient.java 0000664 0000000 0000000 00000007723 11737135005 0040027 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/forest /*******************************************************************************
* Copyright (c) 2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch - implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.forest;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgPushPullClient;
import com.vectrace.MercurialEclipse.commands.RootlessHgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.IHgRepositoryLocation;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
public class HgFpushPullClient extends HgPushPullClient {
public static String fpush(File forestRoot, IHgRepositoryLocation repo,
ChangeSet changeset, int timeout, File snapFile) throws CoreException {
AbstractShellCommand command = new RootlessHgCommand("fpush", "Invoking fpush", forestRoot);
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PUSH_TIMEOUT);
if (snapFile != null) {
try {
command.addOptions("--snapfile", snapFile.getCanonicalPath());
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
HgPushPullClient.applyChangeset(command, changeset);
URI uri = repo.getUri();
if (uri != null) {
command.addOptions(uri.toASCIIString());
} else {
command.addOptions(repo.getLocation());
}
return new String(command.executeToBytes(timeout));
}
public static String fpull(File forestRoot, IHgRepositoryLocation repo,
boolean update, boolean timeout, ChangeSet changeset,
boolean walkHg, File snapFile, boolean partial) throws HgException {
URI uri = repo.getUri();
String pullSource;
if (uri != null) {
pullSource = uri.toASCIIString();
} else {
pullSource = repo.getLocation();
}
AbstractShellCommand command = new RootlessHgCommand("fpull", "Invoking fpull", forestRoot);
if (update) {
command.addOptions("--update");
}
applyChangeset(command, changeset);
if (snapFile != null) {
try {
command.addOptions("--snapfile", snapFile.getCanonicalPath());
} catch (IOException e) {
throw new HgException(e.getLocalizedMessage(), e);
}
}
if (walkHg) {
command.addOptions("--walkhg", "true");
}
if (partial) {
command.addOptions("--partial");
}
command.addOptions(pullSource);
String result;
if (timeout) {
command.setUsePreferenceTimeout(MercurialPreferenceConstants.PULL_TIMEOUT);
result = new String(command.executeToBytes());
} else {
result = new String(command.executeToBytes(Integer.MAX_VALUE));
}
Set roots = MercurialEclipsePlugin.getRepoManager().getAllRepoLocationRoots(repo);
// The reason to use "all" instead of only "local + incoming", is that we can pull
// from another repo as the sync clients for given project may use
// in this case, we also need to update "outgoing" changesets
final int flags = RefreshRootJob.ALL;
for (final HgRoot hgRoot : roots) {
if (update) {
new RefreshWorkspaceStatusJob(hgRoot, flags).schedule();
} else {
new RefreshRootJob(hgRoot, flags).schedule();
}
}
return result;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq/ 0000775 0000000 0000000 00000000000 11737135005 0033005 5 ustar 00root root 0000000 0000000 HgQAppliedClient.java 0000664 0000000 0000000 00000004141 11737135005 0036706 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Patch;
/**
* @author bastian
*
*/
public class HgQAppliedClient extends AbstractClient {
public static List getAppliedPatches(HgRoot root) throws HgException {
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qapplied", "Invoking qapplied", root, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("-v"); //$NON-NLS-1$
command.addOptions("-s"); //$NON-NLS-1$
return HgQSeriesClient.parse(command.executeToString());
}
public static List getUnappliedPatches(HgRoot root) throws HgException{
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qunapplied", "Invoking qunapplied", root, true); //$NON-NLS-1$
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("-v"); //$NON-NLS-1$
command.addOptions("-s"); //$NON-NLS-1$
return HgQSeriesClient.parse(command.executeToString());
}
}
HgQDeleteClient.java 0000664 0000000 0000000 00000004657 11737135005 0036546 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Patch;
/**
* @author bastian
*
*/
public class HgQDeleteClient extends AbstractClient {
public static String delete(HgRoot root, boolean keep, String patch) throws HgException {
List patches = new ArrayList(1);
patches.add(patch);
return doDelete(root, keep, null, patches);
}
public static String delete(HgRoot root, boolean keep,
ChangeSet changeset, List patches) throws HgException {
Assert.isNotNull(patches);
List patcheNames = new ArrayList(patches.size());
for (Patch patch : patches) {
patcheNames.add(patch.getName());
}
return doDelete(root, keep, changeset, patcheNames);
}
private static String doDelete(HgRoot root, boolean keep,
ChangeSet changeset, List patches) throws HgException {
Assert.isNotNull(patches);
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qdelete", //$NON-NLS-1$
"Invoking qdelete", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (keep) {
command.addOptions("--keep"); //$NON-NLS-1$
}
if (changeset != null) {
command.addOptions("--rev", changeset.getChangeset()); //$NON-NLS-1$
} else {
for (String patch : patches) {
command.addOptions(patch);
}
}
return command.executeToString();
}
}
HgQFinishClient.java 0000664 0000000 0000000 00000003746 11737135005 0036562 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Patch;
/**
* @author bastian
*
*/
public class HgQFinishClient extends AbstractClient {
private static AbstractShellCommand makeCommand(HgRoot root) {
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qfinish", //$NON-NLS-1$
"Invoking qfinish", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
return command;
}
@SuppressWarnings("null")
public static String finish(HgRoot root, List revs) throws HgException {
Assert.isTrue(revs != null && revs.size() > 0);
AbstractShellCommand command = makeCommand(root);
for (Patch p : revs) {
command.addOptions(p.getName());
}
return command.executeToString();
}
/**
* Calls qfinish -a
*/
public static String finishAllApplied(HgRoot root) throws HgException {
AbstractShellCommand command = makeCommand(root);
command.addOptions("--applied");
return command.executeToString();
}
}
HgQFoldClient.java 0000664 0000000 0000000 00000005265 11737135005 0036224 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.HgCommitClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Patch;
/**
* @author bastian
*
*/
public class HgQFoldClient extends AbstractClient {
public static String fold(HgRoot root, boolean keep, String message,
String patchName) throws HgException {
List patchNames = new ArrayList(1);
patchNames.add(patchName);
return doFold(root, keep, message, patchNames);
}
public static String fold(HgRoot root, boolean keep, String message,
List patches) throws HgException {
Assert.isNotNull(patches);
List patchNames = new ArrayList(patches.size());
for (Patch patch : patches) {
patchNames.add(patch.getName());
}
return doFold(root, keep, message, patchNames);
}
private static String doFold(HgRoot root, boolean keep, String message,
List patches) throws HgException {
Assert.isNotNull(patches);
Assert.isNotNull(root);
HgCommand command = new HgCommand("qfold", //$NON-NLS-1$
"Invoking qfold", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
File messageFile = null;
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (keep) {
command.addOptions("--keep"); //$NON-NLS-1$
}
if (message != null && message.length() > 0) {
messageFile = HgCommitClient.addMessage(command, message);
}
for (String patch : patches) {
command.addOptions(patch);
}
try {
return command.executeToString();
} finally {
HgCommitClient.deleteMessage(messageFile);
}
}
public static boolean isPatchConflict(HgException e) {
return e.getMessage().contains("patch failed, unable to continue");
}
}
HgQHeaderClient.java 0000664 0000000 0000000 00000003156 11737135005 0036525 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Philip Graf implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* Client for {@code qheader}.
*
* @author Philip Graf
*/
public class HgQHeaderClient extends AbstractClient {
/**
* Returns the header of the topmost patch. This method calls {@code hg qheader} without a
* specified patch and returns the result.
*
* @param resource
* @return The header of the topmost patch. Never returns {@code null}.
* @throws HgException
* Thrown when the Hg command cannot be executed.
*/
public static String getHeader(HgRoot root) throws HgException {
AbstractShellCommand command = new HgCommand("qheader", "Invoking qheader", root, false); //$NON-NLS-1$
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
return command.executeToString().trim();
}
}
HgQImportClient.java 0000664 0000000 0000000 00000005452 11737135005 0036610 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian Doetsch implementation
* Philip Graf Fix for importing from a patch file
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.preferences.MercurialPreferenceConstants;
/**
* @author bastian
*
*/
public class HgQImportClient extends AbstractClient {
/**
* Import a changeset with a specific name
*/
public static String qimport(HgRoot root, boolean force, ChangeSet changeset, String name)
throws HgException {
return qimport(root, force, false, new ChangeSet[] { changeset }, null, name);
}
public static String qimport(HgRoot root, boolean force, boolean existing,
ChangeSet[] changesets, IPath patchFile) throws HgException {
return qimport(root, force, existing, changesets, patchFile, null);
}
private static String qimport(HgRoot root, boolean force, boolean existing, ChangeSet[] changesets,
IPath patchFile, String name) throws HgException {
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qimport", //$NON-NLS-1$
"Invoking qimport", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.setUsePreferenceTimeout(MercurialPreferenceConstants.CLONE_TIMEOUT);
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
if (name != null) {
command.addOptions("--name", name); //$NON-NLS-1$
}
command.addOptions("--git"); //$NON-NLS-1$
if (changesets != null && changesets.length>0) {
command.addOptions("--rev", changesets[changesets.length-1].getChangeset()+ ":" +changesets[0].getChangeset()); //$NON-NLS-1$ //$NON-NLS-2$
} else {
Assert.isNotNull(patchFile);
if (existing) {
command.addOptions("--existing"); //$NON-NLS-1$
}
command.addOptions(patchFile.toOSString());
}
return command.executeToString();
}
}
HgQInitClient.java 0000664 0000000 0000000 00000002516 11737135005 0036237 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
/**
* @author bastian
*
*/
public class HgQInitClient extends AbstractClient {
public static String init(IResource resource, boolean repository) throws HgException {
AbstractShellCommand command = new HgCommand("qinit", "Invoking qinit", resource, true); //$NON-NLS-1$
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (repository) {
command.addOptions("--create-repo"); //$NON-NLS-1$
}
return command.executeToString();
}
}
HgQNewClient.java 0000664 0000000 0000000 00000005472 11737135005 0036071 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.io.File;
import java.util.List;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.HgCommitClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgQNewClient extends AbstractClient {
public static String createNewPatch(HgRoot root, String commitMessage, String user, String date, String patchName) throws HgException {
return createNewPatch(root, commitMessage, null, user, date, patchName, true);
}
public static String createNewPatch(HgRoot root, String commitMessage,
List resources, String user, String date, String patchName)
throws HgException {
return createNewPatch(root, commitMessage, resources, user, date, patchName, false);
}
private static String createNewPatch(HgRoot root, String commitMessage,
List resources, String user, String date, String patchName, boolean all)
throws HgException {
HgCommand command = new HgCommand("qnew", //$NON-NLS-1$
"Invoking qnew", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
File messageFile = null;
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (commitMessage != null && commitMessage.length() > 0) {
messageFile = HgCommitClient.addMessage(command, commitMessage);
}
command.addOptions("--git"); //$NON-NLS-1$
if (user != null && user.length() > 0) {
command.addOptions("--user", user); //$NON-NLS-1$
} else {
command.addOptions("--currentuser"); //$NON-NLS-1$
}
if (date != null && date.length() > 0) {
command.addOptions("--date", date); //$NON-NLS-1$
} else {
command.addOptions("--currentdate"); //$NON-NLS-1$
}
if (!all) {
if (resources.isEmpty()) {
command.addOptions("--exclude", "*");
} else {
command.addFiles(resources);
}
}
command.addOptions(patchName);
try {
return command.executeToString();
} finally {
HgCommitClient.deleteMessage(messageFile);
}
}
}
HgQPopClient.java 0000664 0000000 0000000 00000004120 11737135005 0036063 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import org.eclipse.core.runtime.Assert;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*/
public class HgQPopClient extends AbstractClient {
public static String popAll(HgRoot root, boolean force)
throws HgException {
Assert.isNotNull(root);
AbstractShellCommand command = new HgCommand("qpop", //$NON-NLS-1$
"Invoking qpop", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("-a"); //$NON-NLS-1$
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
return command.executeToString();
}
public static String pop(HgRoot root, boolean force, String patchName)
throws HgException {
AbstractShellCommand command = new HgCommand("qpop", //$NON-NLS-1$
"Invoking qpop", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
if (!"".equals(patchName)) { //$NON-NLS-1$
command.addOptions(patchName);
}
return command.executeToString();
}
}
HgQPushClient.java 0000664 0000000 0000000 00000005072 11737135005 0036253 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.HgPatchClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgQPushClient extends AbstractClient {
public static String pushAll(HgRoot root, boolean force)
throws HgException {
AbstractShellCommand command = new HgCommand("qpush", //$NON-NLS-1$
"Invoking qpush", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("-a"); //$NON-NLS-1$
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
return command.executeToString();
}
public static String push(HgRoot root, boolean force, String patchName)
throws HgException {
AbstractShellCommand command = new HgCommand("qpush", //$NON-NLS-1$
"Invoking qpush", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (force) {
command.addOptions("--force"); //$NON-NLS-1$
}
if (!"".equals(patchName)) { //$NON-NLS-1$
command.addOptions(patchName);
}
return command.executeToString();
}
public static boolean isPatchApplyConflict(HgException e) {
// Mercurial 2.0:
// applying 3489.diff
// patching file src/file1.text
// Hunk #1 FAILED at 8
// 1 out of 1 hunks FAILED -- saving rejects to file src/file1.text.rej
// patch failed, unable to continue (try -v)
// patch failed, rejects left in working dir
// errors during apply, please fix and refresh 3489.diff.
return e.getMessage().contains("patch failed, rejects left in working dir")
|| HgPatchClient.isPatchImportConflict(e);
}
}
HgQRefreshClient.java 0000664 0000000 0000000 00000006163 11737135005 0036734 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.io.File;
import java.util.List;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.commands.HgCommitClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
/**
* @author bastian
*
*/
public class HgQRefreshClient extends AbstractClient {
public static String refresh(HgRoot root, boolean shortFlag, List files,
String message, boolean currentDate) throws HgException {
HgCommand command = new HgCommand("qrefresh", //$NON-NLS-1$
"Invoking qrefresh", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (shortFlag) {
command.addOptions("-s"); //$NON-NLS-1$
}
File messageFile = null;
if (message != null && message.length() > 0) {
messageFile = HgCommitClient.addMessage(command, message);
}
if (currentDate) {
command.addOptions("--currentdate");
}
command.addFiles(files);
try
{
return command.executeToString();
}
finally
{
HgCommitClient.deleteMessage(messageFile);
}
}
public static String refresh(HgRoot root, String commitMessage,
List resources, String user, String date)
throws HgException {
HgCommand command = new HgCommand("qrefresh", //$NON-NLS-1$
"Invoking qrefresh", root, true);
command.setExecutionRule(new AbstractShellCommand.ExclusiveExecutionRule(root));
File messageFile = null;
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
if (commitMessage != null && commitMessage.length() > 0) {
messageFile = HgCommitClient.addMessage(command, commitMessage);
}
command.addOptions("--git"); //$NON-NLS-1$
if (user != null && user.length() > 0) {
command.addOptions("--user", user); //$NON-NLS-1$
} else {
command.addOptions("--currentuser"); //$NON-NLS-1$
}
if (date != null && date.length() > 0) {
command.addOptions("--date", date); //$NON-NLS-1$
} else {
command.addOptions("--currentdate"); //$NON-NLS-1$
}
// TODO: this will refresh dirty files in the patch regardless of whether they're selected
command.addOptions("-s");
command.addFiles(resources);
try
{
return command.executeToString();
}
finally
{
HgCommitClient.deleteMessage(messageFile);
}
}
}
HgQSeriesClient.java 0000664 0000000 0000000 00000005234 11737135005 0036566 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/extensions/mq /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* bastian implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.commands.extensions.mq;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IResource;
import com.vectrace.MercurialEclipse.commands.AbstractClient;
import com.vectrace.MercurialEclipse.commands.AbstractShellCommand;
import com.vectrace.MercurialEclipse.commands.HgCommand;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.model.Patch;
/**
* @author bastian
*
*/
public class HgQSeriesClient extends AbstractClient {
public static List getPatchesInSeries(HgRoot root)
throws HgException {
AbstractShellCommand command = new HgCommand("qseries", //$NON-NLS-1$
"Invoking qseries", root, true);
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("-v"); //$NON-NLS-1$
command.addOptions("--summary"); //$NON-NLS-1$
return parse(command.executeToString());
}
protected static List parse(String executeToString) {
List list = new ArrayList();
if (executeToString != null && executeToString.indexOf("\n") >= 0) { //$NON-NLS-1$
String[] patches = executeToString.split("\n"); //$NON-NLS-1$
int i = 1;
for (String string : patches) {
String[] components = string.split(":", 2); //$NON-NLS-1$
String[] patchData = components[0].trim().split(" ", 3); //$NON-NLS-1$
Patch p = new Patch();
p.setIndex(i++);
p.setApplied("A".equals(patchData[1])); //$NON-NLS-1$
p.setName(patchData[2].trim());
if (components.length>1) {
String summary = components[1].trim();
p.setSummary(summary);
}
list.add(p);
}
}
return list;
}
public static List getPatchesNotInSeries(IResource resource)
throws HgException {
AbstractShellCommand command = new HgCommand("qseries", //$NON-NLS-1$
"Invoking qseries", resource, true);
command.addOptions("--config", "extensions.hgext.mq="); //$NON-NLS-1$ //$NON-NLS-2$
command.addOptions("--summary", "--missing"); //$NON-NLS-1$ //$NON-NLS-2$
return parse(command.executeToString());
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/commands/messages.properties0000664 0000000 0000000 00000001762 11737135005 0034124 0 ustar 00root root 0000000 0000000 HgAddClient.addingResourcesFrom=Adding resources from
HgClients.error.notInitializedWithConfig=HgClient has not been initialized with a configuration
HgClients.error.notInitializedWithConsole=HgClients has not been initialized with a console
HgCommitClient.commitJob.committing=Committing resources from
HgIgnoreClient.failedToAddEntry=Failed to add an entry to .hgignore
HgIgnoreClient.failedToAddHgIgnore=Failed to add an entry to .hgignore
HgIgnoreClient.failedToCloseHgIgnore=Failed to close file .hgignore
HgLogClient.parseException=Parse exception: '
HgRemoveClient.removeResource.1=Removing
HgRemoveClient.removeResource.2=\ from repository
HgRenameClient.moving.1=Moving
HgRenameClient.moving.2=\ to
HgRootClient.error.cannotGetCanonicalPath=Cannot get cannonical path for file
HgRootClient.error.noRoot=\ does not have a hg root
HgServeClient.serveJob.name=Controller thread for serving repository
HgServeClient.serverThread.name=Server thread for:
HgTagClient.parseException=Parse exception: '
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/compare/ 0000775 0000000 0000000 00000000000 11737135005 0030016 5 ustar 00root root 0000000 0000000 HgCompareEditorInput.java 0000664 0000000 0000000 00000015246 11737135005 0034646 0 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/compare /*******************************************************************************
* Copyright (c) 2006-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.compare;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.compare.CompareConfiguration;
import org.eclipse.compare.CompareEditorInput;
import org.eclipse.compare.CompareNavigator;
import org.eclipse.compare.ICompareNavigator;
import org.eclipse.compare.INavigatable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.SyncInfoCompareInput;
import com.vectrace.MercurialEclipse.model.FileFromChangeSet;
import com.vectrace.MercurialEclipse.synchronize.cs.ChangesetGroup;
public class HgCompareEditorInput extends CompareEditorInput {
private static final HgDifferencer DIFFERENCER = new HgDifferencer();
private final RevisionNode left;
private final RevisionNode ancestor;
private final RevisionNode right;
private final ISynchronizePageConfiguration syncConfig;
/**
* Does either a 2-way or 3-way compare, depending on if one is an ancestor
* of the other. If they are divergent, then it finds the common ancestor
* and does 3-way compare.
* @param syncConfig
*/
public HgCompareEditorInput(CompareConfiguration configuration,
RevisionNode left, RevisionNode right, RevisionNode ancestor, ISynchronizePageConfiguration syncConfig) {
this(configuration, left, right, ancestor, true, syncConfig);
setTitle("Compare " + left.getName());
}
private HgCompareEditorInput(CompareConfiguration configuration,
RevisionNode left, RevisionNode right, RevisionNode ancestor, boolean bLeftEditable,
ISynchronizePageConfiguration syncConfig) {
super(configuration);
this.syncConfig = syncConfig;
this.left = left;
this.ancestor = ancestor;
this.right = right;
configuration.setLeftLabel(getLabel(left));
configuration.setLeftEditable(bLeftEditable);
configuration.setRightLabel(getLabel(right));
configuration.setRightEditable(false);
configuration.setAncestorLabel(getLabel(ancestor));
}
private static String getLabel(RevisionNode node) {
if (node != null) {
return node.getLabel();
}
return "";
}
@Override
protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException,
InterruptedException {
byte[] content = null;
RevisionNode parent = ancestor;
if(parent != null){
content = parent.getContent();
}
if(content == null || content.length == 0){
// See issue 11149: sometimes we fail to determine the ancestor version, but we
// see it too late as the editor is opened with an "empty" parent node.
// In such case ENTIRE file is considered as a huge merge conflict.
// So as quick and dirty workaround we avoid using 3-way merge if parent content is unknown
parent = null;
}
return DIFFERENCER.findDifferences(parent != null, monitor, null, parent, left, right);
}
@Override
public String getOKButtonLabel() {
if (getCompareConfiguration().isLeftEditable() || getCompareConfiguration().isRightEditable()) {
return "Save Changes";
}
return super.getOKButtonLabel();
}
/**
* Overriden to allow navigation through multiple changes in the sync view via shortcuts
* "Ctrl + ." (Navigate->Next) or "Ctrl + ," (Navigate->Previous).
* @see SyncInfoCompareInput
*/
@Override
public synchronized ICompareNavigator getNavigator() {
CompareNavigator navigator = (CompareNavigator) super.getNavigator();
if (syncConfig != null) {
CompareNavigator nav = (CompareNavigator) syncConfig.getProperty(
SynchronizePageConfiguration.P_NAVIGATOR);
return new SyncNavigatorWrapper(navigator, nav);
}
return navigator;
}
private class SyncNavigatorWrapper extends CompareNavigator {
private final CompareNavigator textDfiffDelegate;
private final CompareNavigator syncViewDelegate;
public SyncNavigatorWrapper(CompareNavigator textDfiffDelegate,
CompareNavigator syncViewDelegate) {
this.textDfiffDelegate = textDfiffDelegate;
this.syncViewDelegate = syncViewDelegate;
}
@Override
public boolean selectChange(boolean next) {
boolean endReached = textDfiffDelegate.selectChange(next);
if(endReached && syncViewDelegate != null && isSelectedInSynchronizeView()){
// forward navigation to the sync view
return syncViewDelegate.selectChange(next);
}
return endReached;
}
@Override
// This method won't be used by our implementation
protected INavigatable[] getNavigatables() {
return new INavigatable[0];
}
@Override
public boolean hasChange(boolean next) {
return (textDfiffDelegate.hasChange(next) || syncViewDelegate.hasChange(next));
}
}
private boolean isSelectedInSynchronizeView() {
if (syncConfig == null) {
return false;
}
ISelection s = syncConfig.getSite().getSelectionProvider().getSelection();
if (!(s instanceof IStructuredSelection)) {
return false;
}
IStructuredSelection ss = (IStructuredSelection) s;
Object element = ss.getFirstElement();
if (element instanceof FileFromChangeSet
|| element instanceof ChangesetGroup) {
return true;
}
return false;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((ancestor == null) ? 0 : ancestor.hashCode());
result = prime * result + ((left == null) ? 0 : left.hashCode());
result = prime * result + ((right == null) ? 0 : right.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof HgCompareEditorInput)) {
return false;
}
HgCompareEditorInput other = (HgCompareEditorInput) obj;
if (ancestor == null) {
if (other.ancestor != null) {
return false;
}
} else if (!ancestor.equals(other.ancestor)) {
return false;
}
if (left == null) {
if (other.left != null) {
return false;
}
} else if (!left.equals(other.left)) {
return false;
}
if (right == null) {
if (other.right != null) {
return false;
}
} else if (!right.equals(other.right)) {
return false;
}
return true;
}
} eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/compare/HgDifferencer.java 0000664 0000000 0000000 00000005675 11737135005 0033371 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2010 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* ge.zhong implementation
*******************************************************************************/
package com.vectrace.MercurialEclipse.compare;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.DiffNode;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.compare.structuremergeviewer.IDiffContainer;
/**
* Compare sparse trees for performance
*/
public class HgDifferencer extends Differencer {
@Override
protected Object visit(Object data, int result, Object ancestor, Object left, Object right) {
DiffNode node = null;
Object[] ancestorChildren = getChildren(ancestor);
Object[] rightChildren = getChildren(right);
Object[] leftChildren = getChildren(left);
if ((left == null && rightChildren != null && rightChildren.length > 0)
|| (right == null && leftChildren != null && leftChildren.length > 0)) {
node = new DiffNode((IDiffContainer) data, Differencer.CHANGE,
(ITypedElement) ancestor, (ITypedElement) left, (ITypedElement) right);
Set allSet = new HashSet(20);
Map ancestorSet = null;
Map rightSet = null;
Map leftSet = null;
if (ancestorChildren != null) {
ancestorSet = new HashMap(10);
for (int i = 0; i < ancestorChildren.length; i++) {
Object ancestorChild = ancestorChildren[i];
ancestorSet.put(ancestorChild, ancestorChild);
allSet.add(ancestorChild);
}
}
if (rightChildren != null) {
rightSet = new HashMap(10);
for (int i = 0; i < rightChildren.length; i++) {
Object rightChild = rightChildren[i];
rightSet.put(rightChild, rightChild);
allSet.add(rightChild);
}
}
if (leftChildren != null) {
leftSet = new HashMap(10);
for (int i = 0; i < leftChildren.length; i++) {
Object leftChild = leftChildren[i];
leftSet.put(leftChild, leftChild);
allSet.add(leftChild);
}
}
Iterator e = allSet.iterator();
while (e.hasNext()) {
Object keyChild = e.next();
Object ancestorChild = ancestorSet != null ? ancestorSet.get(keyChild) : null;
Object leftChild = leftSet != null ? leftSet.get(keyChild) : null;
Object rightChild = rightSet != null ? rightSet.get(keyChild) : null;
visit(node, result, ancestorChild, leftChild, rightChild);
}
} else {
node = new DiffNode((IDiffContainer) data, result, (ITypedElement) ancestor,
(ITypedElement) left, (ITypedElement) right);
}
return node;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/compare/RevisionNode.java 0000664 0000000 0000000 00000013604 11737135005 0033271 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2006-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andrei Loskutov - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.compare;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.compare.CompareUI;
import org.eclipse.compare.IEditableContent;
import org.eclipse.compare.IEditableContentExtension;
import org.eclipse.compare.IEncodedStreamContentAccessor;
import org.eclipse.compare.IModificationDate;
import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.IStructureComparator;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Shell;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.model.HgResource;
import com.vectrace.MercurialEclipse.model.IHgFolder;
import com.vectrace.MercurialEclipse.model.IHgResource;
public class RevisionNode implements IEncodedStreamContentAccessor, IStructureComparator, ITypedElement,
IEditableContent, IModificationDate, IEditableContentExtension {
private final IHgResource resource;
private List children;
public RevisionNode(IHgResource resource) {
this.resource = resource;
}
public IHgResource getHgResource() {
return resource;
}
/**
* @see org.eclipse.compare.ITypedElement#getName()
*/
public String getName() {
if (resource != null) {
return resource.getName();
}
return null;
}
public String getLabel()
{
String name = resource.getName();
if (resource.getChangeSet() != null) {
name = name + " [" + resource.getChangeSet().toString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
}
return name;
}
public InputStream getContents() throws CoreException {
if (resource instanceof IStorage) {
return ((IStorage) resource).getContents();
}
return null;
}
public byte[] getContent() {
if (resource instanceof HgResource) {
return ((HgResource) resource).getContent();
}
return null;
}
@Override
public boolean equals(Object other) {
if (other instanceof RevisionNode) {
return this.resource.equals(((RevisionNode) other).getHgResource());
}
return false;
}
@Override
public int hashCode() {
return resource.hashCode();
}
public boolean isWorkingCopy() {
return resource.getResource() != null;
}
/**
* @see org.eclipse.compare.IEditableContentExtension#isReadOnly()
*/
public boolean isReadOnly() {
return resource.isReadOnly();
}
/**
* @see org.eclipse.compare.IEditableContentExtension#validateEdit(org.eclipse.swt.widgets.Shell)
*/
public IStatus validateEdit(Shell shell) {
IResource res = resource.getResource();
if (res instanceof IFile) {
// See org.eclipse.compare.ResourceNode.validateEdit(Shell)
if (isReadOnly()) {
return ResourcesPlugin.getWorkspace().validateEdit(new IFile[] { (IFile)res}, shell);
}
return Status.OK_STATUS;
}
// Not in workspace
return Status.CANCEL_STATUS;
}
/**
* @see org.eclipse.compare.IEditableContent#isEditable()
*/
public boolean isEditable() {
return !isReadOnly();
}
/**
* @see org.eclipse.compare.IEditableContent#replace(org.eclipse.compare.ITypedElement, org.eclipse.compare.ITypedElement)
*/
public ITypedElement replace(ITypedElement dest, ITypedElement src) {
// TODO Auto-generated method stub
return null;
}
/**
* @see org.eclipse.compare.ITypedElement#getImage()
*/
public Image getImage() {
return CompareUI.getImage(getType());
}
/**
* @see org.eclipse.compare.ITypedElement#getType()
*/
public String getType() {
if (resource instanceof IHgFolder) {
return ITypedElement.FOLDER_TYPE;
}
if (resource != null) {
String s= resource.getFileExtension();
if (s != null) {
return s;
}
}
return ITypedElement.UNKNOWN_TYPE;
}
/**
* @see org.eclipse.compare.structuremergeviewer.IStructureComparator#getChildren()
*/
public Object[] getChildren() {
if (children == null) {
children = new ArrayList();
if (resource instanceof IHgFolder) {
IHgResource[] members = ((IHgFolder) resource).members();
for (int i = 0; i < members.length; i++) {
IStructureComparator child = new RevisionNode(members[i]);
children.add(child);
}
}
}
return children.toArray();
}
/**
* @see org.eclipse.compare.IEncodedStreamContentAccessor#getCharset()
*/
public String getCharset() throws CoreException {
return resource.getHgRoot().getEncoding();
}
/**
* @see org.eclipse.compare.IModificationDate#getModificationDate()
*/
public long getModificationDate() {
IResource res = resource.getResource();
if (res != null) {
return res.getLocalTimeStamp();
}
// Future: get timestamp from commit time?
return 0;
}
/**
* @see org.eclipse.compare.IEditableContent#setContent(byte[])
*/
public void setContent(byte[] newContent) {
if (resource.getResource() instanceof IFile) {
InputStream is = new ByteArrayInputStream(newContent);
try {
// update cache
((HgResource) resource).setContent(newContent);
// update local file
((IFile) resource.getResource()).setContents(is, true, true, null);
} catch (CoreException e) {
MercurialEclipsePlugin.logError(e);
}
}
}
} eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/compare/TagComparator.java 0000664 0000000 0000000 00000002442 11737135005 0033426 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*******************************************************************************/
package com.vectrace.MercurialEclipse.compare;
import java.util.Comparator;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.model.Tag;
/**
* Thsi class can be used to compare Tags by names.
*
* @author Zsolt Koppany
* @version $Id$
*/
public class TagComparator implements Comparator {
private static final String TIP = HgRevision.TIP.getChangeset();
public int compare(Tag tag1, Tag tag2) {
/* "tip" must be always the first in the collection */
if (tag1 == null || tag1.getName() == null || TIP.equals(tag1.getName())) {
return -1;
}
if (TIP.equals(tag2.getName())) {
return 1;
}
// sort by name
int cmp = tag1.getName().compareToIgnoreCase(tag2.getName());
if (cmp == 0) {
// Check it case sensitive
cmp = tag1.getName().compareTo(tag2.getName());
}
return cmp;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/dialogs/ 0000775 0000000 0000000 00000000000 11737135005 0030012 5 ustar 00root root 0000000 0000000 eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/dialogs/BookmarkDialog.java 0000664 0000000 0000000 00000021065 11737135005 0033546 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2005-2008 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Bastian implementation
* Andrei Loskutov - bug fixes
* Zsolt Koppany (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.dialogs;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Text;
import com.vectrace.MercurialEclipse.HgRevision;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.extensions.HgBookmarkClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.ui.BookmarkTable;
import com.vectrace.MercurialEclipse.ui.ChangesetTable;
import com.vectrace.MercurialEclipse.ui.SWTWidgetHelper;
/**
* @author bastian
*/
public class BookmarkDialog extends TrayDialog {
private final HgRoot hgRoot;
private ChangesetTable csTable;
private Text bmNameTextBox;
private Button renameCheckBox;
private BookmarkTable bookmarkTable;
private Text newBmNameTextBox;
private Button deleteCheckBox;
private boolean modifyTab;
private Label renameLabel;
public BookmarkDialog(Shell parentShell, HgRoot hgRoot) {
super(parentShell);
setShellStyle(getShellStyle() | SWT.RESIZE);
this.hgRoot = hgRoot;
}
@Override
protected void configureShell(Shell newShell) {
super.configureShell(newShell);
newShell.setText(Messages.getString("BookmarkDialog.shell.text")); //$NON-NLS-1$
}
@Override
protected IDialogSettings getDialogBoundsSettings() {
IDialogSettings dialogSettings = MercurialEclipsePlugin.getDefault().getDialogSettings();
String sectionName = getClass().getSimpleName();
IDialogSettings section = dialogSettings.getSection(sectionName);
if (section == null) {
dialogSettings.addNewSection(sectionName);
}
return section;
}
@Override
protected Control createDialogArea(Composite parent) {
Composite composite = SWTWidgetHelper.createComposite(parent, 1);
composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
TabFolder tabFolder = new TabFolder(composite, SWT.FILL);
tabFolder.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
createCreateTabItem(tabFolder);
createModifyTabItem(tabFolder);
return composite;
}
protected TabItem createCreateTabItem(TabFolder folder) {
// setup control
TabItem item = new TabItem(folder, folder.getStyle());
item.setText(Messages.getString("BookmarkDialog.createTab.name")); //$NON-NLS-1$
Composite c = SWTWidgetHelper.createComposite(folder, 2);
GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
c.setLayoutData(layoutData);
item.setControl(c);
Listener tabSl = new Listener() {
public void handleEvent(Event event) {
if (event.type == SWT.Show) {
modifyTab = false;
}
}
};
item.addListener(SWT.Show, tabSl);
// create widgets
Group tipGroup = SWTWidgetHelper.createGroup(c, Messages.getString("BookmarkDialog.createGroup.label")); //$NON-NLS-1$
SWTWidgetHelper.createLabel(tipGroup, Messages.getString("BookmarkDialog.bookmarkName")); //$NON-NLS-1$
this.bmNameTextBox = SWTWidgetHelper.createTextField(tipGroup);
Group revGroup = SWTWidgetHelper.createGroup(c, Messages.getString("BookmarkDialog.selectRevision")); //$NON-NLS-1$
revGroup.setLayoutData(layoutData);
this.csTable = new ChangesetTable(revGroup, hgRoot);
csTable.setLayoutData(layoutData);
this.csTable.setEnabled(true);
SelectionListener sl = new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
modifyTab = false;
}
};
csTable.addSelectionListener(sl);
return item;
}
protected TabItem createModifyTabItem(TabFolder folder) {
// setup control
TabItem item = new TabItem(folder, folder.getStyle());
item.setText(Messages.getString("BookmarkDialog.modifyTab.name")); //$NON-NLS-1$
Composite c = SWTWidgetHelper.createComposite(folder, 2);
GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
c.setLayoutData(layoutData);
item.setControl(c);
Listener tabSl = new Listener() {
public void handleEvent(Event event) {
if (event.type == SWT.Show) {
modifyTab = true;
}
}
};
item.addListener(SWT.Show, tabSl);
// create widgets
Group selGroup = SWTWidgetHelper.createGroup(c, Messages.getString("BookmarkDialog.selectBookmark")); //$NON-NLS-1$
selGroup.setLayoutData(layoutData);
bookmarkTable = new BookmarkTable(selGroup);
bookmarkTable.setLayoutData(layoutData);
bookmarkTable.updateTable(hgRoot);
SelectionListener sl = new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
modifyTab = true;
}
};
this.bookmarkTable.addSelectionListener(sl);
Group renameGroup = SWTWidgetHelper.createGroup(c, Messages.getString("BookmarkDialog.renameGroup.label")); //$NON-NLS-1$
this.setDeleteCheckBox(SWTWidgetHelper.createCheckBox(renameGroup, Messages.getString("BookmarkDialog.option.delete"))); //$NON-NLS-1$
SelectionListener delSl = new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
boolean selection = deleteCheckBox.getSelection();
if (selection) {
renameCheckBox.setSelection(false);
renameLabel.setEnabled(false);
bmNameTextBox.setEnabled(false);
modifyTab = true;
}
}
};
this.deleteCheckBox.addSelectionListener(delSl);
this.renameCheckBox = SWTWidgetHelper.createCheckBox(renameGroup, Messages.getString("BookmarkDialog.option.rename")); //$NON-NLS-1$
renameLabel = SWTWidgetHelper.createLabel(renameGroup, Messages.getString("BookmarkDialog.newName")); //$NON-NLS-1$
this.newBmNameTextBox = SWTWidgetHelper.createTextField(renameGroup);
this.newBmNameTextBox.setEnabled(false);
renameLabel.setEnabled(false);
SelectionListener renSl = new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
boolean selection = renameCheckBox.getSelection();
if (selection) {
deleteCheckBox.setSelection(false);
modifyTab = true;
}
renameLabel.setEnabled(selection);
newBmNameTextBox.setEnabled(selection);
}
};
renameCheckBox.addSelectionListener(renSl);
return item;
}
@Override
protected void okPressed() {
try {
if (!modifyTab) {
// create new bookmark
String targetRev = HgRevision.TIP.getChangeset();
if (csTable.getSelection() != null) {
targetRev = csTable.getSelection().getChangeset();
}
HgBookmarkClient.create(hgRoot, bmNameTextBox.getText(), targetRev);
} else {
if (renameCheckBox.getSelection()) {
HgBookmarkClient.rename(hgRoot, bookmarkTable.getSelection().getName(), newBmNameTextBox.getText());
} else if (deleteCheckBox.getSelection()) {
HgBookmarkClient.delete(hgRoot, bookmarkTable.getSelection().getName());
}
}
} catch (HgException e) {
MercurialEclipsePlugin.logError(e);
MercurialEclipsePlugin.showError(e);
}
super.okPressed();
}
public ChangesetTable getCsTable() {
return csTable;
}
public Text getBmNameTextBox() {
return bmNameTextBox;
}
public Button getRenameCheckBox() {
return renameCheckBox;
}
public BookmarkTable getBookmarkTable() {
return bookmarkTable;
}
public void setDeleteCheckBox(Button deleteCheckBox) {
this.deleteCheckBox = deleteCheckBox;
}
public Button getDeleteCheckBox() {
return deleteCheckBox;
}
}
eclipse-mercurialeclipse-1.9.4/plugin/src/com/vectrace/MercurialEclipse/dialogs/CommitDialog.java 0000664 0000000 0000000 00000100103 11737135005 0033220 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright (c) 2006-2009 VecTrace (Zingo Andersen) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Eclipse.org - see CommitWizardCommitPage
* Software Balm Consulting Inc (Peter Hunnisett ) - implementation
* Bastian Doetsch - Added spellchecking and some other stuff
* StefanC - many updates
* Zingo Andersen - some updates
* Andrei Loskutov - bug fixes
* Adam Berkes (Intland) - bug fixes
*******************************************************************************/
package com.vectrace.MercurialEclipse.dialogs;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TitleAreaDialog;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.source.AnnotationModel;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.ProgressMonitorPart;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Sash;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.editors.text.TextSourceViewerConfiguration;
import org.eclipse.ui.texteditor.AnnotationPreference;
import org.eclipse.ui.texteditor.DefaultMarkerAnnotationAccess;
import org.eclipse.ui.texteditor.SourceViewerDecorationSupport;
import org.eclipse.ui.texteditor.spelling.SpellingAnnotation;
import com.vectrace.MercurialEclipse.MercurialEclipsePlugin;
import com.vectrace.MercurialEclipse.commands.HgAddClient;
import com.vectrace.MercurialEclipse.commands.HgCommitClient;
import com.vectrace.MercurialEclipse.commands.HgLogClient;
import com.vectrace.MercurialEclipse.commands.HgPatchClient;
import com.vectrace.MercurialEclipse.commands.HgRemoveClient;
import com.vectrace.MercurialEclipse.commands.HgStatusClient;
import com.vectrace.MercurialEclipse.commands.extensions.HgStripClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQAppliedClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQDeleteClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQFinishClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQFoldClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQImportClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQNewClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQPopClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQPushClient;
import com.vectrace.MercurialEclipse.commands.extensions.mq.HgQRefreshClient;
import com.vectrace.MercurialEclipse.exception.HgException;
import com.vectrace.MercurialEclipse.menu.SwitchHandler;
import com.vectrace.MercurialEclipse.model.ChangeSet;
import com.vectrace.MercurialEclipse.model.HgRoot;
import com.vectrace.MercurialEclipse.mylyn.MylynFacadeFactory;
import com.vectrace.MercurialEclipse.storage.HgCommitMessageManager;
import com.vectrace.MercurialEclipse.team.ActionRevert;
import com.vectrace.MercurialEclipse.team.MercurialTeamProvider;
import com.vectrace.MercurialEclipse.team.cache.LocalChangesetCache;
import com.vectrace.MercurialEclipse.team.cache.RefreshRootJob;
import com.vectrace.MercurialEclipse.team.cache.RefreshWorkspaceStatusJob;
import com.vectrace.MercurialEclipse.ui.ChangesetInfoTray;
import com.vectrace.MercurialEclipse.ui.CommitFilesChooser;
import com.vectrace.MercurialEclipse.ui.SWTWidgetHelper;
import com.vectrace.MercurialEclipse.utils.ResourceUtils;
import com.vectrace.MercurialEclipse.utils.StringUtils;
/**
* A commit dialog box allowing choosing of what files to commit and a commit message for those
* files. Untracked files may also be chosen.
*/
public class CommitDialog extends TitleAreaDialog {
public static final String FILE_MODIFIED = Messages.getString("CommitDialog.modified"); //$NON-NLS-1$
public static final String FILE_ADDED = Messages.getString("CommitDialog.added"); //$NON-NLS-1$
public static final String FILE_REMOVED = Messages.getString("CommitDialog.removed"); //$NON-NLS-1$
public static final String FILE_UNTRACKED = Messages.getString("CommitDialog.untracked"); //$NON-NLS-1$
public static final String FILE_DELETED = Messages.getString("CommitDialog.deletedInWorkspace"); //$NON-NLS-1$
public static final String FILE_CLEAN = Messages.getString("CommitDialog.clean"); //$NON-NLS-1$
private static final String DEFAULT_COMMIT_MESSAGE = Messages
.getString("CommitDialog.defaultCommitMessage"); //$NON-NLS-1$
private ISourceViewer commitTextBox;
protected CommitFilesChooser commitFilesList;
private List resourcesToAdd;
private List