Attachment #54925 for bug #165581

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 63-68 Link Here

(-)src/org/eclipse/mylar/tasks/core/AbstractRepositoryConnector.java (+4 lines)
63		63
64	public abstract String getTaskWebUrl(String repositoryUrl, String taskId);	64	public abstract String getTaskWebUrl(String repositoryUrl, String taskId);
65		65
		66	public String[] getTaskIdsFromComment(TaskRepository repository, String comment) {
		67	return null;
		68	}
		69
66	public abstract boolean canCreateTaskFromKey(TaskRepository repository);	70	public abstract boolean canCreateTaskFromKey(TaskRepository repository);
67		71
68	public abstract boolean canCreateNewTask(TaskRepository repository);	72	public abstract boolean canCreateNewTask(TaskRepository repository);





import junit.framework.TestCase;

import org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction;

/**
 * @author Mik Kersten


	public void test07LegacyMatching() {
		String label = "Progress on: 123: foo \nhttps://bugs.eclipse.org";
		String id = OpenCorrespondingTaskAction.getTaskIdFromLegacy07Label(label);
		assertEquals("123", id);
	}
	
	public void testUrlMatching() {
		String label = "bla bla\nhttp://foo.bar-123 bla bla";
		String id = OpenCorrespondingTaskAction.getUrlFromComment(label);
		assertEquals("http://foo.bar-123", id);
	}
	

Lines 13-19 Link Here

(-)src/org/eclipse/mylar/internal/jira/core/JiraRepositoryConnector.java (+30 lines)
13		13
14	import java.net.UnknownHostException;	14	import java.net.UnknownHostException;
15	import java.util.ArrayList;	15	import java.util.ArrayList;
		16	import java.util.HashSet;
16	import java.util.List;	17	import java.util.List;
		18	import java.util.regex.Matcher;
		19	import java.util.regex.Pattern;
17		20
18	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
Lines 37-42 Link Here
37	import org.tigris.jira.core.model.Issue;	40	import org.tigris.jira.core.model.Issue;
38	import org.tigris.jira.core.model.IssueType;	41	import org.tigris.jira.core.model.IssueType;
39	import org.tigris.jira.core.model.Priority;	42	import org.tigris.jira.core.model.Priority;
		43	import org.tigris.jira.core.model.Project;
40	import org.tigris.jira.core.model.Version;	44	import org.tigris.jira.core.model.Version;
41	import org.tigris.jira.core.service.JiraServer;	45	import org.tigris.jira.core.service.JiraServer;
42		46
Lines 213-218 Link Here
213	public String getTaskWebUrl(String repositoryUrl, String taskId) {	217	public String getTaskWebUrl(String repositoryUrl, String taskId) {
214	return repositoryUrl + DELIM_URL + taskId;	218	return repositoryUrl + DELIM_URL + taskId;
215	}	219	}
		220
		221	@Override
		222	public String[] getTaskIdsFromComment(TaskRepository repository, String comment) {
		223	JiraServer server = JiraServerFacade.getDefault().getJiraServer(repository);
		224	if (server != null) {
		225	// (?:(MNGECLIPSE-\d+?)\|(SPR-\d+?))\D
		226	StringBuffer sb = new StringBuffer("(");
		227	String sep = "";
		228	for (Project project : server.getProjects()) {
		229	sb.append(sep).append("(?:"+project.getKey()+"\\-\\d+?)");
		230	sep = "\|";
		231	}
		232	sb.append(")\\D");
		233
		234	Pattern p = Pattern.compile(sb.toString(), Pattern.CASE_INSENSITIVE \| Pattern.DOTALL \| Pattern.MULTILINE);
		235	Matcher m = p.matcher(comment);
		236	HashSet<String> ids = new HashSet<String>();
		237	while(m.find()) {
		238	ids.add(m.group(1));
		239	}
		240	return ids.toArray(new String[ids.size()]);
		241	}
		242
		243	return super.getTaskIdsFromComment(repository, comment);
		244	}
		245
216		246
217	public static void updateTaskDetails(String repositoryUrl, JiraTask task, Issue issue, boolean notifyOfChange) {	247	public static void updateTaskDetails(String repositoryUrl, JiraTask task, Issue issue, boolean notifyOfChange) {
218	if (issue.getKey() != null) {	248	if (issue.getKey() != null) {




 org.eclipse.jdt.core,
 org.eclipse.ui.forms,
 org.eclipse.core.resources,
 org.eclipse.compare,
 org.eclipse.search,
 org.eclipse.jface.text,
 org.eclipse.team.core,
 org.eclipse.team.ui,
 org.eclipse.mylar.context.core,
 org.eclipse.mylar.context.ui,
 org.eclipse.mylar.tasks.ui,

 org.eclipse.mylar.bugzilla.ui,
 org.eclipse.mylar.tasks.core,
 org.eclipse.mylar.monitor,
 org.eclipse.mylar.java
 org.eclipse.mylar.team
Eclipse-AutoStart: true
Bundle-Vendor: Eclipse.org
Export-Package: org.eclipse.mylar.internal.sandbox,




///*******************************************************************************
// * Copyright (c) 2004 - 2006 Mylar committers 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
// *******************************************************************************/
//
//package org.eclipse.mylar.internal.sandbox.team;
//
//import org.eclipse.core.resources.IResource;
//import org.eclipse.core.runtime.IAdapterFactory;
//import org.eclipse.core.runtime.IAdapterManager;
//import org.eclipse.mylar.internal.team.ILinkedTaskInfo;
//import org.eclipse.mylar.internal.team.LinkedTaskInfo;
//import org.eclipse.mylar.tasks.core.TaskRepository;
//import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
//import org.eclipse.team.core.TeamException;
//import org.eclipse.team.internal.core.subscribers.ChangeSet;
//import org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode;
//import org.eclipse.team.internal.ui.synchronize.SyncInfoModelElement;
//import org.eclipse.team.internal.ui.synchronize.SynchronizeModelElement;
//import org.tigris.subversion.subclipse.core.ISVNRemoteResource;
//import org.tigris.subversion.subclipse.core.sync.SVNStatusSyncInfo;
//
///**
// * Wrapper class used to isolate Subclibse dependencies 
// * 
// * @author Eugene Kuleshov
// */
//public class SubclipseLinkedTaskInfoWrapper {
//
//	public static void init(IAdapterManager adapterManager, IAdapterFactory factory) {
//		// XXX put back
//		Class logEntryClass = org.tigris.subversion.subclipse.core.history.LogEntry.class;
//		adapterManager.registerAdapters(FACTORY, logEntryClass);
//	}
//
//	private static ILinkedTaskInfo adaptSubclipseChangeset(ChangeSetDiffNode diff, ChangeSet set) {
//        SynchronizeModelElement diffContainer = (SynchronizeModelElement) diff.getChildren()[0];
//
//        IResource res = diffContainer.getResource();
//
//        SyncInfoModelElement melement = (SyncInfoModelElement) diffContainer.getChildren()[0];
//
//        // Specific to Subclipse
//        SVNStatusSyncInfo info = (SVNStatusSyncInfo) melement.getSyncInfo();
//
//        ISVNRemoteResource remoteResource = (ISVNRemoteResource) info.getRemote();
//        SVNRevision rev = remoteResource.getLastChangedRevision();
//
//		String comment;
//		try {
//			ISVNLogMessage[] messages = remoteResource.getLogMessages(rev, rev, SVNRevision.START, false, false, 1);
//			comment = messages[0].getMessage();
//		} catch (TeamException ex) {
//			comment = diff.getSet().getComment();
//		}
//		return adaptFromComment(diff, res, comment);
//	}
//
//	private static ILinkedTaskInfo adaptSubclipseLogEntry(Object object) {
//		org.tigris.subversion.subclipse.core.history.LogEntry logEntry = 
//			(org.tigris.subversion.subclipse.core.history.LogEntry) object;
//
//		String comment = logEntry.getComment();
//		IResource res = logEntry.getResource().getResource();
//		
//		return adaptFromComment(object, res, comment);
//	}
//
//	private static ILinkedTaskInfo adaptFromComment(Object object, IResource res, String comment) {
//		ProjectProperties props = null;
//		try {
//			props = ProjectProperties.getProjectProperties(res);
//		} catch (TeamException ex) {
//			// ignore?
//		}
//		
//		String[] urls = null;
//		String repositoryUrl = null;
//		if(props!=null) {
//			repositoryUrl = getRepositoryUrl(props.getUrl());
//			urls = props.getLinkList(comment).getUrls();
//		}
//		if (urls == null || urls.length == 0) {
//			// we can do better job then this method
//			urls = ProjectProperties.getUrls(comment).getUrls();
//		}
//		if (urls != null && urls.length > 0) {
//			return new LinkedTaskInfo(repositoryUrl, null, urls[0]);
//		}
//		return null;
//	}
//
//	private static String getRepositoryUrl(String url) {
//		for (TaskRepository repository : TasksUiPlugin.getRepositoryManager().getAllRepositories()) {
//			if(url.startsWith(repository.getUrl())) {
//				return repository.getUrl();
//			}
//		}
//		return null;
//	}
//	
//}





package org.eclipse.mylar.internal.team.ui.actions;

import org.eclipse.compare.structuremergeviewer.IDiffElement;
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.IAdaptable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylar.internal.tasks.ui.TaskListImages;
import org.eclipse.mylar.internal.tasks.ui.TasksUiUtil;
import org.eclipse.mylar.internal.team.ILinkedTaskInfo;
import org.eclipse.mylar.internal.team.LinkedTaskInfo;
import org.eclipse.mylar.internal.team.template.CommitTemplateManager;
import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.core.TaskRepositoryManager;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.team.MylarTeamPlugin;
import org.eclipse.team.core.history.IFileRevision;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry;
import org.eclipse.team.internal.ccvs.core.mapping.CVSCheckedInChangeSet;
import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
import org.eclipse.team.internal.core.subscribers.DiffChangeSet;
import org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode;
import org.eclipse.team.internal.ui.synchronize.SynchronizeModelElement;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.ObjectPluginAction;

/**
 * Action used to open linked task
 * 
 * @author Mik Kersten
 * @author Eugene Kuleshov
 */
public class OpenCorrespondingTaskAction extends Action implements IViewActionDelegate {

	private static final String LABEL = "Open Corresponding Task";

	private ISelection selection;

	private static final String PREFIX_HTTP = "http://";

	private static final String PREFIX_HTTPS = "https://";

	private ISelection selection;

	public OpenCorrespondingTaskAction() {
		setText(LABEL);
		setToolTipText(LABEL);


	private void run(StructuredSelection selection) {
		Object element = selection.getFirstElement();
		boolean opened = false;

		ILinkedTaskInfo info = null;
		if (element instanceof ILinkedTaskInfo) {
			info = (ILinkedTaskInfo) element;
		} else if (element instanceof IAdaptable) {
			info = (ILinkedTaskInfo) ((IAdaptable) element).getAdapter(ILinkedTaskInfo.class);
		}
		if (info == null) {
			info = (ILinkedTaskInfo) Platform.getAdapterManager().getAdapter(element, ILinkedTaskInfo.class);
			ITask task = ((ContextChangeSet) element).getTask();
			if (task != null) {
				TasksUiUtil.openEditor(task, false);
				opened = true;
			}
		}

		if (info != null) {
			info = reconsile(info);
			if (info.getTask() != null) {
				// XXX which one to use?
				// TaskUiUtil.openEditor(info.getTask(), false);
				TasksUiUtil.refreshAndOpenTaskListElement(info.getTask());
				return;
			}
			if (info.getRepositoryUrl() != null && info.getTaskId() != null) {
				TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(info.getRepositoryUrl());
				if (repository != null) {
					if (TasksUiUtil.openRepositoryTask(repository, info.getTaskId())) {
						return;
					if (repository != null) {
						AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getRepositoryUi(repository.getKind());
						if (connectorUi != null && id != null) {
							opened = TasksUiUtil.openRepositoryTask(repository, id);
						}
					}
				}
			}
			if (info.getTaskFullUrl() != null) {
				TasksUiUtil.openUrl(info.getTaskFullUrl());
				return;
			}
		}

		// TODO show Open Remote Task dialog?
		MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
				"Unable to open correspond task", "Unable to open correspond task");
	}
					String repositoryUrl = null;
					if (fullUrl != null) {
						AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
								.getConnectorForRepositoryTaskUrl(fullUrl);
						if (connector != null) {
							repositoryUrl = connector.getRepositoryUrlFromTaskUrl(fullUrl);
						}
					} else {
						ITask task = TasksUiPlugin.getTaskListManager().getTaskList().getActiveTask();
						if (task instanceof AbstractRepositoryTask) {
							repositoryUrl = ((AbstractRepositoryTask) task).getRepositoryUrl();
						} else if (TasksUiPlugin.getRepositoryManager().getAllRepositories().size() == 1) {
							repositoryUrl = TasksUiPlugin.getRepositoryManager().getAllRepositories().get(0).getUrl();
						}
					}

	public void selectionChanged(IAction action, ISelection selection) {
		this.selection = selection;
	}

	/**
	 * Reconcile <code>ILinkedTaskInfo</code> data.
	 * 
	 * This is used in order to keep LinkedTaskInfo lightweight with minimal
	 * dependencies.
	 */
	private ILinkedTaskInfo reconsile(ILinkedTaskInfo info) {
		ITask task = info.getTask();
		if (task != null) {
			return info;
		}

		String repositoryUrl = info.getRepositoryUrl();
		String taskId = info.getTaskId();
		String taskFullUrl = info.getTaskFullUrl();
		String comment = info.getComment();

		TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();

		TaskRepository repository = null;
		if(repositoryUrl!=null) {
			repository = repositoryManager.getRepository(repositoryUrl);
		}

		AbstractRepositoryConnector connector = null;
		if(taskFullUrl!=null) {
			connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
		}		
		if (connector == null && repository!=null) {
			connector = repositoryManager.getRepositoryConnector(repository.getKind());
		}

		if (repositoryUrl == null && connector != null) {
			repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
		}

		if (taskId == null && connector != null) {
			taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
		}
		if (taskId == null && repository != null && comment != null) {
			String[] ids = connector.getTaskIdsFromComment(repository, comment);
			if (ids != null && ids.length > 0) {
				taskId = ids[0];
			}
		}
		if (taskId == null && comment!=null) {
			CommitTemplateManager commitTemplateManager = MylarTeamPlugin.getDefault().getCommitTemplateManager();
			taskId = commitTemplateManager.getTaskIdFromCommentOrLabel(comment);
			if (taskId == null) {
				taskId = getTaskIdFromLegacy07Label(comment);
			}
		}
	}

		if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
			taskFullUrl = connector.getTaskWebUrl(repositoryUrl, taskId);
			return ((CVSCheckedInChangeSet) element).getComment();
		} else if (element instanceof ChangeSetDiffNode) {
			return ((ChangeSetDiffNode) element).getName();
		} else if (element instanceof LogEntry) {
			return ((LogEntry) element).getComment();
		} else if (element instanceof IFileRevision) {
			return ((IFileRevision) element).getComment();
		}
		return null;
	}

		if (task == null) {
			if (taskId != null && repositoryUrl != null) {
				// XXX fix this hack (jira ids don't work here)
				if(!taskId.contains(AbstractRepositoryTask.HANDLE_DELIM)) {
					String handle = AbstractRepositoryTask.getHandle(repositoryUrl, taskId);
					task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(handle);
			}
		} else if (element instanceof SynchronizeModelElement) {
			SynchronizeModelElement modelElement = (SynchronizeModelElement)element;
			IResource resource = modelElement.getResource();
			if (resource != null) {
				return resource.getProject();
			} else {
				IDiffElement[] elements = modelElement.getChildren();
				if (elements.length > 0) {
					// TODO: only checks first diff
					if (elements[0] instanceof SynchronizeModelElement) {
						return ((SynchronizeModelElement)elements[0]).getResource().getProject();
					}
				}
			}
			if (task == null && taskFullUrl != null) {
				// search by fullUrl
				for (ITask currTask : TasksUiPlugin.getTaskListManager().getTaskList().getAllTasks()) {
					if (currTask instanceof AbstractRepositoryTask) {
						String currUrl = ((AbstractRepositoryTask) currTask).getUrl();
						if (taskFullUrl.equals(currUrl)) {
							return new LinkedTaskInfo(currTask);
						}
					}
				}
			}
		} else {
			
		}
		if (task != null) {
			return new LinkedTaskInfo(task);
		}

		return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment);
	}

	public static String getUrlFromComment(String comment) {

		}
		return null;
	}
	

//	private Object findParent(ISynchronizeModelElement element) {
//		if (element instanceof ChangeSetDiffNode) {
//			return element;
//		} else if (element.getParent() instanceof ISynchronizeModelElement) {
//			return findParent((ISynchronizeModelElement) element.getParent());
//		}
//		return null;
//	}
	

	public void selectionChanged(IAction action, ISelection selection) {
		this.selection = selection;
	}

}





package org.eclipse.mylar.internal.team;

import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.ITask;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.core.TaskRepositoryManager;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;

/**
 * Default implementation of {@link ILinkedTaskInfo}

 */
public class LinkedTaskInfo implements ILinkedTaskInfo {

	private ITask task;
	
	private String repositoryUrl;
	
	private String taskId;

	private String taskFullUrl;

	private String comment;
	
	private ITask task;

	public LinkedTaskInfo(ITask task) {
		this.task = task;
				AbstractRepositoryTask.getRepositoryUrl(task.getHandleIdentifier()), //
				AbstractRepositoryTask.getTaskId(task.getHandleIdentifier()), //
				task.getUrl());
	}

	public LinkedTaskInfo(String taskFullUrl) {
		this.taskFullUrl = taskFullUrl;
	}

	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl) {
		init(null, repositoryUrl, taskId, taskFullUrl);
	}

	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl, String comment) {
		// TODO should this even be here?

		TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();
		AbstractRepositoryConnector connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
		if (connector == null && repositoryUrl != null) {
			TaskRepository repository = repositoryManager.getRepository(repositoryUrl);
			if (repository != null) {
				connector = repositoryManager.getRepositoryConnector(repository.getKind());
			}
		}

		if (repositoryUrl == null && connector != null) {
			repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
		}

		if (taskId == null && connector != null) {
			taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
		}

		if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
			taskFullUrl = connector.getTaskWebUrl(repositoryUrl, taskId);
		}
		
		if (task == null) {
			if (taskId != null && repositoryUrl != null) {
				String handle = AbstractRepositoryTask.getHandle(repositoryUrl, taskId);
				task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(handle);
			}
			if (task == null && taskFullUrl != null) {
				// search by fullUrl
				for (ITask currTask : TasksUiPlugin.getTaskListManager().getTaskList().getAllTasks()) {
					if (currTask instanceof AbstractRepositoryTask) {
						String currUrl = ((AbstractRepositoryTask) currTask).getUrl();
						if (taskFullUrl.equals(currUrl)) {
							task = currTask;
							break;
						}
					}
				}
			}
		}

		if (taskFullUrl == null && task != null) {
			taskFullUrl = task.getUrl();
		}

		this.task = task;
		this.repositoryUrl = repositoryUrl;
		this.taskId = taskId;
		this.taskFullUrl = taskFullUrl;
		this.comment = comment;
	}

	public String getRepositoryUrl() {

		return taskId;
	}

	public String getComment() {
		return comment;
	}

}






package org.eclipse.mylar.internal.team;

import org.eclipse.compare.structuremergeviewer.DiffNode;
import org.eclipse.compare.structuremergeviewer.IDiffElement;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.Platform;
import org.eclipse.mylar.internal.team.template.CommitTemplateManager;
import org.eclipse.mylar.tasks.core.TaskRepository;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
import org.eclipse.mylar.team.MylarTeamPlugin;
import org.eclipse.team.core.history.IFileRevision;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.internal.ccvs.core.CVSException;
import org.eclipse.team.internal.ccvs.core.ICVSResource;
import org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
import org.eclipse.team.internal.core.subscribers.ChangeSet;

import org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode;
import org.eclipse.team.internal.ui.synchronize.SynchronizeModelElement;


/**
 * Adapter factory used to create adapters for <code>LinkedTaskInfo</code>
 * 
 * @author Eugene Kuleshov
 */


	private static IAdapterFactory FACTORY = new LinkedTaskInfoAdapterFactory();

	private static final String PREFIX_HTTP = "http://";

    private static final String PREFIX_HTTPS = "https://";

//    private static boolean haveSubclipse;
    
	public static void registerAdapters() {
		IAdapterManager adapterManager = Platform.getAdapterManager();



		// Team public
		adapterManager.registerAdapters(FACTORY, IFileRevision.class);
		adapterManager.registerAdapters(FACTORY, DiffNode.class);

		// Team internal
		adapterManager.registerAdapters(FACTORY, DiffChangeSet.class); // CVSCheckedInChangeSet
		adapterManager.registerAdapters(FACTORY, ChangeSetDiffNode.class);
		adapterManager.registerAdapters(FACTORY, SynchronizeModelElement.class);

		// Team CVS internal; is it used? Maybe CVS History view in Eclipse 3.1?
		adapterManager.registerAdapters(FACTORY, LogEntry.class);
		
		// Subclipse		
//		try {
//			SubclipseWrapper.init(adapterManager, FACTORY);
//			haveSubclipse = true;
//		} catch (Throwable ex) {
//			// ignore
//		}  
	}

	public static void unregisterAdapters() {
		Platform.getAdapterManager().unregisterAdapters(FACTORY);
	}

	
	private LinkedTaskInfoAdapterFactory() {
	}

	@SuppressWarnings("unchecked")
	public Object getAdapter(Object object, Class adapterType) {
		if (!ILinkedTaskInfo.class.equals(adapterType)) {
			return null;
		}

		if (object instanceof ChangeSetDiffNode) {
			return adaptChangeSetDiffNode(object);
		}

		if(object instanceof DiffNode) {
			return getAdapter(((DiffNode) object).getParent(), adapterType);
		}
		
//		if(haveSubclipse &&
//				"org.tigris.subversion.subclipse.core.history.LogEntry".equals(object.getClass().getName())) {
//			ILinkedTaskInfo info = SubclipseWrapper.adaptSubclipseLogEntry(object);
//			if(info!=null) {
//				return info;
//			}
//		}
		
		// TODO add other adapted types

		return adaptFromComment(object);

	}

	private ILinkedTaskInfo adaptChangeSetDiffNode(Object object) {
		ChangeSetDiffNode diffNode = (ChangeSetDiffNode) object;
		ChangeSet set = diffNode.getSet();

		Object adapter = null;
		if (set instanceof IAdaptable) {
			adapter = ((IAdaptable) set).getAdapter(ILinkedTaskInfo.class);
		}
		if (adapter == null) {
			adapter = Platform.getAdapterManager().getAdapter(set, ILinkedTaskInfo.class);
		}
		if (adapter != null) {
			return (ILinkedTaskInfo) adapter;
		}

		return adaptFromComment(object);
	}

	private ILinkedTaskInfo adaptFromComment(Object object) {
		String comment = getCommentForElement(object);
		if (comment == null) {
			return null;
		}
		
		IResource resource = getResourceForElement(object);
		if (resource != null) {
			TaskRepository repository = TasksUiPlugin.getDefault().getRepositoryForResource(resource, false);
			if (repository != null) {
				return new LinkedTaskInfo(repository.getUrl(), null, null, comment);
			}
		}

		return new LinkedTaskInfo(null, null, null, comment);
	}

	private static String getCommentForElement(Object element) {
		if (element instanceof DiffChangeSet) {
			return ((DiffChangeSet) element).getComment();
		} else if (element instanceof ChangeSetDiffNode) {
			return ((ChangeSetDiffNode) element).getName();
		} else if (element instanceof IFileRevision) {
			return ((IFileRevision) element).getComment();
		} else if (element instanceof LogEntry) {
			return ((LogEntry) element).getComment();
		}
		return null;
		String fullTaskUrl = getUrlFromComment(comment);
        if(fullTaskUrl!=null) {
        	return new LinkedTaskInfo(fullTaskUrl);
        }
        
        return null;
	}
	
    private String getCommentFromElement(Object element) {
        if (element instanceof DiffChangeSet) {
            return ((DiffChangeSet) element).getComment();
        } else if (element instanceof ChangeSetDiffNode) {
            return ((ChangeSetDiffNode) element).getName();
        } else if (element instanceof IFileRevision) {
        	return ((IFileRevision) element).getComment();
        } else if (element instanceof org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry) {
            return ((org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry) element).getComment();
        } else if (element instanceof org.tigris.subversion.subclipse.core.history.LogEntry) {
            return ((org.tigris.subversion.subclipse.core.history.LogEntry) element).getComment();
        }
        return null;
    }
	
	
	//

	private static IResource getResourceForElement(Object element) {
		if (element instanceof DiffChangeSet) {
			IResource[] resources = ((DiffChangeSet) element).getResources();
			if (resources.length > 0) {
				// TODO: only checks first resource
				return resources[0];
			}
		} 
		if (element instanceof SynchronizeModelElement) {
			SynchronizeModelElement modelElement = (SynchronizeModelElement) element;
			IResource resource = modelElement.getResource();
			if (resource != null) {
				return resource;
			} else {
				IDiffElement[] elements = modelElement.getChildren();
				if (elements.length > 0) {
					// TODO: only checks first diff
					if (elements[0] instanceof SynchronizeModelElement) {
						return ((SynchronizeModelElement) elements[0]).getResource();
					}
				}
			}
		} 
		if (element instanceof IAdaptable) {
			IAdaptable adaptable = (IAdaptable) element;
        int firstDelimIndex = comment.indexOf(PREFIX_START_1);
        if (firstDelimIndex == -1) {
            firstDelimIndex = comment.indexOf(PREFIX_START_2);
            usedPrefix = PREFIX_START_2;
        }
        if (firstDelimIndex != -1) {
            int idStart = firstDelimIndex + usedPrefix.length();
            int idEnd = comment.indexOf(PREFIX_DELIM, firstDelimIndex + usedPrefix.length());// comment.indexOf(PREFIX_DELIM);
            if (idEnd != -1 && idStart < idEnd) {
                String id = comment.substring(idStart, idEnd);
                if (id != null) {
                    return id.trim();
                }
            } else {
                return comment.substring(0, firstDelimIndex);
            }
        }
        return null;
    }
	
    private static IProject findCorrespondingProject(Object element) {
        if (element instanceof DiffChangeSet) {
            IResource[] resources = ((DiffChangeSet) element).getResources();
            if (resources.length > 0) {
                // TODO: only checks first resource
                return resources[0].getProject();
            }
        } else if (element instanceof SynchronizeModelElement) {
            SynchronizeModelElement modelElement = (SynchronizeModelElement)element;
            IResource resource = modelElement.getResource();
            if (resource != null) {
                return resource.getProject();
            } else {
                IDiffElement[] elements = modelElement.getChildren();
                if (elements.length > 0) {
                    // TODO: only checks first diff
                    if (elements[0] instanceof SynchronizeModelElement) {
                        return ((SynchronizeModelElement)elements[0]).getResource().getProject();
                    }
                }
            }
        } else if (element instanceof IAdaptable) {
        	IAdaptable adaptable = (IAdaptable) element;
			IResourceVariant resourceVariant = (IResourceVariant) adaptable.getAdapter(IResourceVariant.class);
			if (resourceVariant != null && resourceVariant instanceof RemoteResource) {
				RemoteResource remoteResource = (RemoteResource) resourceVariant;
				// TODO is there a better way then iterating trough all projects?
				String path = remoteResource.getRepositoryRelativePath();
				for (IProject project : ResourcesPlugin.getWorkspace().getRoot().getProjects()) {
					if (project.isAccessible()) {
						ICVSResource cvsResource = CVSWorkspaceRoot.getCVSFolderFor(project);
						try {
							if (cvsResource != null && path.startsWith(cvsResource.getRepositoryRelativePath())) {
								return project;
							}
						} catch (CVSException ex) {
							// ignore
						}
					}
				}
			}
		}

		// TODO any other resource types?

		return null;
	}
	
    }  
}


Lines 210-215 Link Here

(-)src/org/eclipse/mylar/internal/team/ContextChangeSet.java (+2 lines)
210	return new ChangeSetResourceMapping(this);	210	return new ChangeSetResourceMapping(this);
211	} else if (adapter == ITask.class) {	211	} else if (adapter == ITask.class) {
212	return task;	212	return task;
		213	} else if (adapter == ILinkedTaskInfo.class) {
		214	return new LinkedTaskInfo(getTask());
213	} else {	215	} else {
214	return null;	216	return null;
215	}	217	}

Lines 30-33 Link Here

(-)src/org/eclipse/mylar/internal/team/ILinkedTaskInfo.java (+2 lines)
30		30
31	ITask getTask();	31	ITask getTask();
32		32
		33	String getComment();
		34
33	}	35	}

Lines 10-17 Link Here

(-)META-INF/MANIFEST.MF (-3 lines)
10	org.eclipse.team.cvs.ui,	10	org.eclipse.team.cvs.ui,
11	org.eclipse.team.cvs.core,	11	org.eclipse.team.cvs.core,
12	org.eclipse.team.ui,	12	org.eclipse.team.ui,
13	org.tigris.subversion.subclipse.core;resolution:=optional,
14	org.tigris.subversion.subclipse.ui;resolution:=optional,
15	org.eclipse.jface,	13	org.eclipse.jface,
16	org.eclipse.core.resources,	14	org.eclipse.core.resources,
17	org.eclipse.core.runtime,	15	org.eclipse.core.runtime,
Lines 27-33 Link Here
27	Eclipse-LazyStart: true	25	Eclipse-LazyStart: true
28	Export-Package: org.eclipse.mylar.internal.team,	26	Export-Package: org.eclipse.mylar.internal.team,
29	org.eclipse.mylar.internal.team.ccvs,	27	org.eclipse.mylar.internal.team.ccvs,
30	org.eclipse.mylar.internal.team.subclipse,
31	org.eclipse.mylar.internal.team.template,	28	org.eclipse.mylar.internal.team.template,
32	org.eclipse.mylar.internal.team.ui,	29	org.eclipse.mylar.internal.team.ui,
33	org.eclipse.mylar.internal.team.ui.actions,	30	org.eclipse.mylar.internal.team.ui.actions,




   <extension
         point="org.eclipse.mylar.team.providers">
      <repository class="org.eclipse.mylar.internal.team.ccvs.CvsRepositoryProvider"/>
      <repository class="org.eclipse.mylar.internal.team.subclipse.SubclipseTeamRepositoryProvider"/>
   </extension>
    
   <extension

    </extension>
    
     <extension point="org.eclipse.ui.popupMenus"> 

     	<objectContribution
				id="org.eclipse.mylar.ui.team.synchronize.open.report"
				objectClass="org.eclipse.mylar.internal.team.ILinkedTaskInfo"
				adaptable="true">
			<action
				class="org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction"
				enablesFor="1" 
				icon="icons/elcl16/task-repository.gif"
				id="org.eclipse.mylar.ui.team.synchronize.contribution.open.report"
				label="Open Corresponding Task"
				menubarPath="mylar"
				tooltip="Open Corresponding Task">
			</action> 
		</objectContribution>

        <!--
		<objectContribution
            objectClass="org.eclipse.team.ui.synchronize.ISynchronizeModelElement"
            id="org.eclipse.mylar.ui.team.synchronize.open.report">

	           tooltip="Open Corresponding Task"> 
	  		</action> 
	    </objectContribution>
	    -->
	   	
	   	<!-- is this from Eclipse 3.1 History view?
	   	<objectContribution
            objectClass="org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry"
            id="org.eclipse.mylar.ui.team.history.open.report">

	           tooltip="Open Corresponding Task"> 
	  		</action> 
	    </objectContribution>
	   	-->
		
		<!--
		<objectContribution
            objectClass="org.eclipse.team.core.history.IFileRevision"
            id="org.eclipse.mylar.ui.team.synchronize.open.report">

	           tooltip="Open Corresponding Task"> 
	  		</action> 
	    </objectContribution>
	    -->
		
		<!-- Subclipse History view -->
		<objectContribution
            objectClass="org.tigris.subversion.subclipse.core.history.LogEntry"
            id="org.eclipse.mylar.ui.team.synchronize.open.report">
         <action
	           class="org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction"
	           enablesFor="1" 
	           icon="icons/elcl16/task-repository.gif"
	           id="org.eclipse.mylar.ui.team.synchronize.contribution.open.report"
	           label="Open Corresponding Task"
	           menubarPath="mylar"
	           tooltip="Open Corresponding Task">
	  		</action> 
	    </objectContribution>
	    
	    <!--
		<objectContribution
            objectClass="org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode"




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *     Gunnar Wagenknecht - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.team.subclipse;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.IAction;
import org.eclipse.mylar.team.AbstractTeamRepositoryProvider;
import org.eclipse.team.internal.core.subscribers.ActiveChangeSetManager;
import org.osgi.framework.Bundle;

/**
 * Subclipse integration for Mylar.
 */
public class SubclipseTeamRepositoryProvider extends AbstractTeamRepositoryProvider {

	@SuppressWarnings("unchecked")
	@Override
	public ActiveChangeSetManager getActiveChangeSetManager() {
		// collectors.add((CVSActiveChangeSetCollector)CVSUIPlugin.getPlugin().getChangeSetManager());
		Bundle svnBundle = Platform.getBundle("org.tigris.subversion.subclipse.core");
		if (svnBundle != null) {
			Method getChangeSetManagerMethod;
			try {
				Class providerPlugin = svnBundle.loadClass("org.tigris.subversion.subclipse.core.SVNProviderPlugin"); // Class.forName("org.tigris.subversion.subclipse.core.SVNProviderPlugin");
				Method getPluginMethod = providerPlugin.getMethod("getPlugin", new Class[0]);
				Object pluginInstance = getPluginMethod.invoke(null, new Object[0]);
				getChangeSetManagerMethod = providerPlugin.getDeclaredMethod("getChangeSetManager", new Class[0]);
				Object manager = getChangeSetManagerMethod.invoke(pluginInstance, new Object[0]);
				if (manager instanceof ActiveChangeSetManager) {
					return (ActiveChangeSetManager) manager;
				}
			} catch (Throwable t) {
				// intore missing tigris collector
			}
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean hasOutgoingChanges(IResource[] resources) {
		if (Platform.getBundle("org.tigris.subversion.subclipse.core") == null)
			return false;

		try {
			Class commitActionClass = Class.forName("org.tigris.subversion.subclipse.ui.actions.CommitAction");
			Constructor commitActionConstructor = commitActionClass.getConstructor(new Class[] { String.class });
			Object commitAction = commitActionConstructor.newInstance(new Object[] { "" });
			Method setSelectedResourcesMethod = commitActionClass.getMethod("setSelectedResources",
					new Class[] { IResource[].class });
			setSelectedResourcesMethod.invoke(commitAction, new Object[] { resources });

			Method hasOutgoingChangesMethod = commitActionClass.getMethod("hasOutgoingChanges", new Class[0]);
			Boolean hasOutgoingChanges = (Boolean) hasOutgoingChangesMethod.invoke(commitAction, new Object[0]);

			return hasOutgoingChanges.booleanValue();
		} catch (Throwable t) {
			// Noting we can do
		}

		return false;
	}

	@SuppressWarnings("unchecked")
	@Override
	public void commit(IResource[] resources) {
		if (Platform.getBundle("org.tigris.subversion.subclipse.core") == null)
			return;

		try {
			Class commitActionClass = Class.forName("org.tigris.subversion.subclipse.ui.actions.CommitAction");
			Constructor commitActionConstructor = commitActionClass.getConstructor(new Class[] { String.class });
			Object commitAction = commitActionConstructor.newInstance(new Object[] { "" });
			Method setSelectedResourcesMethod = commitActionClass.getMethod("setSelectedResources",
					new Class[] { IResource[].class });
			setSelectedResourcesMethod.invoke(commitAction, new Object[] { resources });

			Method executeMethod = commitActionClass.getMethod("execute", new Class[] { IAction.class });
			executeMethod.invoke(commitAction, new Object[] { null });
		} catch (Throwable t) {
			// nothing we can do
		}
	}
}

Return to bug 165581

Lines 13-19 Link Here

(-)src/org/eclipse/mylar/ide/tests/OpenCorrespondingTaskActionTest.java (-3 / +3 lines)
13		13
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
16	import org.eclipse.mylar.internal.team.LinkedTaskInfoAdapterFactory;	16	import org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction;
17		17
18	/**	18	/**
19	* @author Mik Kersten	19	* @author Mik Kersten
Lines 34-46 Link Here
34		34
35	public void test07LegacyMatching() {	35	public void test07LegacyMatching() {
36	String label = "Progress on: 123: foo \nhttps://bugs.eclipse.org";	36	String label = "Progress on: 123: foo \nhttps://bugs.eclipse.org";
37	String id = LinkedTaskInfoAdapterFactory.getTaskIdFromLegacy07Label(label);	37	String id = OpenCorrespondingTaskAction.getTaskIdFromLegacy07Label(label);
38	assertEquals("123", id);	38	assertEquals("123", id);
39	}	39	}
40		40
41	public void testUrlMatching() {	41	public void testUrlMatching() {
42	String label = "bla bla\nhttp://foo.bar-123 bla bla";	42	String label = "bla bla\nhttp://foo.bar-123 bla bla";
43	String id = LinkedTaskInfoAdapterFactory.getUrlFromComment(label);	43	String id = OpenCorrespondingTaskAction.getUrlFromComment(label);
44	assertEquals("http://foo.bar-123", id);	44	assertEquals("http://foo.bar-123", id);
45	}	45	}
46		46

Lines 11-21 Link Here

(-)META-INF/MANIFEST.MF (-5 / +1 lines)
11	org.eclipse.jdt.core,	11	org.eclipse.jdt.core,
12	org.eclipse.ui.forms,	12	org.eclipse.ui.forms,
13	org.eclipse.core.resources,	13	org.eclipse.core.resources,
14	org.eclipse.compare,
15	org.eclipse.search,	14	org.eclipse.search,
16	org.eclipse.jface.text,	15	org.eclipse.jface.text,
17	org.eclipse.team.core,
18	org.eclipse.team.ui,
19	org.eclipse.mylar.context.core,	16	org.eclipse.mylar.context.core,
20	org.eclipse.mylar.context.ui,	17	org.eclipse.mylar.context.ui,
21	org.eclipse.mylar.tasks.ui,	18	org.eclipse.mylar.tasks.ui,
Lines 23-30 Link Here
23	org.eclipse.mylar.bugzilla.ui,	20	org.eclipse.mylar.bugzilla.ui,
24	org.eclipse.mylar.tasks.core,	21	org.eclipse.mylar.tasks.core,
25	org.eclipse.mylar.monitor,	22	org.eclipse.mylar.monitor,
26	org.eclipse.mylar.java,	23	org.eclipse.mylar.java
27	org.eclipse.mylar.team
28	Eclipse-AutoStart: true	24	Eclipse-AutoStart: true
29	Bundle-Vendor: Eclipse.org	25	Bundle-Vendor: Eclipse.org
30	Export-Package: org.eclipse.mylar.internal.sandbox,	26	Export-Package: org.eclipse.mylar.internal.sandbox,

Removed Link Here

(-)src/org/eclipse/mylar/internal/sandbox/team/SubclipseLinkedTaskInfoWrapper.java (-105 lines)
1	///*******************************************************************************
2	// * Copyright (c) 2004 - 2006 Mylar committers and others.
3	// * All rights reserved. This program and the accompanying materials
4	// * are made available under the terms of the Eclipse Public License v1.0
5	// * which accompanies this distribution, and is available at
6	// * http://www.eclipse.org/legal/epl-v10.html
7	// *******************************************************************************/
8	//
9	//package org.eclipse.mylar.internal.sandbox.team;
10	//
11	//import org.eclipse.core.resources.IResource;
12	//import org.eclipse.core.runtime.IAdapterFactory;
13	//import org.eclipse.core.runtime.IAdapterManager;
14	//import org.eclipse.mylar.internal.team.ILinkedTaskInfo;
15	//import org.eclipse.mylar.internal.team.LinkedTaskInfo;
16	//import org.eclipse.mylar.tasks.core.TaskRepository;
17	//import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
18	//import org.eclipse.team.core.TeamException;
19	//import org.eclipse.team.internal.core.subscribers.ChangeSet;
20	//import org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode;
21	//import org.eclipse.team.internal.ui.synchronize.SyncInfoModelElement;
22	//import org.eclipse.team.internal.ui.synchronize.SynchronizeModelElement;
23	//import org.tigris.subversion.subclipse.core.ISVNRemoteResource;
24	//import org.tigris.subversion.subclipse.core.sync.SVNStatusSyncInfo;
25	//
26	///**
27	// * Wrapper class used to isolate Subclibse dependencies
28	// *
29	// * @author Eugene Kuleshov
30	// */
31	//public class SubclipseLinkedTaskInfoWrapper {
32	//
33	// public static void init(IAdapterManager adapterManager, IAdapterFactory factory) {
34	// // XXX put back
35	// Class logEntryClass = org.tigris.subversion.subclipse.core.history.LogEntry.class;
36	// adapterManager.registerAdapters(FACTORY, logEntryClass);
37	// }
38	//
39	// private static ILinkedTaskInfo adaptSubclipseChangeset(ChangeSetDiffNode diff, ChangeSet set) {
40	// SynchronizeModelElement diffContainer = (SynchronizeModelElement) diff.getChildren()[0];
41	//
42	// IResource res = diffContainer.getResource();
43	//
44	// SyncInfoModelElement melement = (SyncInfoModelElement) diffContainer.getChildren()[0];
45	//
46	// // Specific to Subclipse
47	// SVNStatusSyncInfo info = (SVNStatusSyncInfo) melement.getSyncInfo();
48	//
49	// ISVNRemoteResource remoteResource = (ISVNRemoteResource) info.getRemote();
50	// SVNRevision rev = remoteResource.getLastChangedRevision();
51	//
52	// String comment;
53	// try {
54	// ISVNLogMessage[] messages = remoteResource.getLogMessages(rev, rev, SVNRevision.START, false, false, 1);
55	// comment = messages[0].getMessage();
56	// } catch (TeamException ex) {
57	// comment = diff.getSet().getComment();
58	// }
59	// return adaptFromComment(diff, res, comment);
60	// }
61	//
62	// private static ILinkedTaskInfo adaptSubclipseLogEntry(Object object) {
63	// org.tigris.subversion.subclipse.core.history.LogEntry logEntry =
64	// (org.tigris.subversion.subclipse.core.history.LogEntry) object;
65	//
66	// String comment = logEntry.getComment();
67	// IResource res = logEntry.getResource().getResource();
68	//
69	// return adaptFromComment(object, res, comment);
70	// }
71	//
72	// private static ILinkedTaskInfo adaptFromComment(Object object, IResource res, String comment) {
73	// ProjectProperties props = null;
74	// try {
75	// props = ProjectProperties.getProjectProperties(res);
76	// } catch (TeamException ex) {
77	// // ignore?
78	// }
79	//
80	// String[] urls = null;
81	// String repositoryUrl = null;
82	// if(props!=null) {
83	// repositoryUrl = getRepositoryUrl(props.getUrl());
84	// urls = props.getLinkList(comment).getUrls();
85	// }
86	// if (urls == null \|\| urls.length == 0) {
87	// // we can do better job then this method
88	// urls = ProjectProperties.getUrls(comment).getUrls();
89	// }
90	// if (urls != null && urls.length > 0) {
91	// return new LinkedTaskInfo(repositoryUrl, null, urls[0]);
92	// }
93	// return null;
94	// }
95	//
96	// private static String getRepositoryUrl(String url) {
97	// for (TaskRepository repository : TasksUiPlugin.getRepositoryManager().getAllRepositories()) {
98	// if(url.startsWith(repository.getUrl())) {
99	// return repository.getUrl();
100	// }
101	// }
102	// return null;
103	// }
104	//
105	//}

Lines 11-62 Link Here

(-)src/org/eclipse/mylar/internal/team/ui/actions/OpenCorrespondingTaskAction.java (-132 / +120 lines)
11		11
12	package org.eclipse.mylar.internal.team.ui.actions;	12	package org.eclipse.mylar.internal.team.ui.actions;
13		13
14	import org.eclipse.compare.structuremergeviewer.IDiffElement;
15	import org.eclipse.core.resources.IProject;
16	import org.eclipse.core.resources.IResource;
17	import org.eclipse.core.resources.IWorkspaceRoot;
18	import org.eclipse.core.resources.ResourcesPlugin;
19	import org.eclipse.core.runtime.IAdaptable;	14	import org.eclipse.core.runtime.IAdaptable;
20	import org.eclipse.core.runtime.Path;	15	import org.eclipse.core.runtime.Platform;
21	import org.eclipse.jface.action.Action;	16	import org.eclipse.jface.action.Action;
22	import org.eclipse.jface.action.IAction;	17	import org.eclipse.jface.action.IAction;
		18	import org.eclipse.jface.dialogs.MessageDialog;
23	import org.eclipse.jface.viewers.ISelection;	19	import org.eclipse.jface.viewers.ISelection;
24	import org.eclipse.jface.viewers.StructuredSelection;	20	import org.eclipse.jface.viewers.StructuredSelection;
25	import org.eclipse.mylar.internal.tasks.ui.TaskListImages;	21	import org.eclipse.mylar.internal.tasks.ui.TaskListImages;
26	import org.eclipse.mylar.internal.tasks.ui.TasksUiUtil;	22	import org.eclipse.mylar.internal.tasks.ui.TasksUiUtil;
27	import org.eclipse.mylar.internal.team.ContextChangeSet;	23	import org.eclipse.mylar.internal.team.ILinkedTaskInfo;
		24	import org.eclipse.mylar.internal.team.LinkedTaskInfo;
		25	import org.eclipse.mylar.internal.team.template.CommitTemplateManager;
28	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;	26	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
29	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;	27	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
30	import org.eclipse.mylar.tasks.core.ITask;	28	import org.eclipse.mylar.tasks.core.ITask;
31	import org.eclipse.mylar.tasks.core.TaskRepository;	29	import org.eclipse.mylar.tasks.core.TaskRepository;
32	import org.eclipse.mylar.tasks.ui.AbstractRepositoryConnectorUi;	30	import org.eclipse.mylar.tasks.core.TaskRepositoryManager;
33	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	31	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
34	import org.eclipse.mylar.team.MylarTeamPlugin;	32	import org.eclipse.mylar.team.MylarTeamPlugin;
35	import org.eclipse.team.core.history.IFileRevision;
36	import org.eclipse.team.core.variants.IResourceVariant;
37	import org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry;
38	import org.eclipse.team.internal.ccvs.core.mapping.CVSCheckedInChangeSet;
39	import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
40	import org.eclipse.team.internal.core.subscribers.DiffChangeSet;
41	import org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode;
42	import org.eclipse.team.internal.ui.synchronize.SynchronizeModelElement;
43	import org.eclipse.ui.IViewActionDelegate;	33	import org.eclipse.ui.IViewActionDelegate;
44	import org.eclipse.ui.IViewPart;	34	import org.eclipse.ui.IViewPart;
		35	import org.eclipse.ui.PlatformUI;
45	import org.eclipse.ui.internal.ObjectPluginAction;	36	import org.eclipse.ui.internal.ObjectPluginAction;
46		37
47	/**	38	/**
		39	* Action used to open linked task
		40	*
48	* @author Mik Kersten	41	* @author Mik Kersten
		42	* @author Eugene Kuleshov
49	*/	43	*/
50	public class OpenCorrespondingTaskAction extends Action implements IViewActionDelegate {	44	public class OpenCorrespondingTaskAction extends Action implements IViewActionDelegate {
51		45
52	private static final String LABEL = "Open Corresponding Task";	46	private static final String LABEL = "Open Corresponding Task";
53		47
54	private ISelection selection;
55
56	private static final String PREFIX_HTTP = "http://";	48	private static final String PREFIX_HTTP = "http://";
57		49
58	private static final String PREFIX_HTTPS = "https://";	50	private static final String PREFIX_HTTPS = "https://";
59		51
		52	private ISelection selection;
		53
60	public OpenCorrespondingTaskAction() {	54	public OpenCorrespondingTaskAction() {
61	setText(LABEL);	55	setText(LABEL);
62	setToolTipText(LABEL);	56	setToolTipText(LABEL);
Lines 86-206 Link Here
86		80
87	private void run(StructuredSelection selection) {	81	private void run(StructuredSelection selection) {
88	Object element = selection.getFirstElement();	82	Object element = selection.getFirstElement();
89	boolean opened = false;
90		83
91	if (element instanceof ChangeSetDiffNode) {	84	ILinkedTaskInfo info = null;
92	ChangeSetDiffNode diffNode = (ChangeSetDiffNode) element;	85	if (element instanceof ILinkedTaskInfo) {
93	if (diffNode.getSet() instanceof ContextChangeSet) {	86	info = (ILinkedTaskInfo) element;
94	ITask task = ((ContextChangeSet) diffNode.getSet()).getTask();	87	} else if (element instanceof IAdaptable) {
95	TasksUiUtil.openEditor(task, false);	88	info = (ILinkedTaskInfo) ((IAdaptable) element).getAdapter(ILinkedTaskInfo.class);
96	opened = true;	89	}
97	}	90	if (info == null) {
98	} else if (element instanceof ContextChangeSet) {	91	info = (ILinkedTaskInfo) Platform.getAdapterManager().getAdapter(element, ILinkedTaskInfo.class);
99	ITask task = ((ContextChangeSet) element).getTask();
100	if (task != null) {
101	TasksUiUtil.openEditor(task, false);
102	opened = true;
103	}
104	}	92	}
105		93
106	if (!opened) {	94	if (info != null) {
107	IProject project = findCorrespondingProject(element);	95	info = reconsile(info);
108	String comment = getCommentFromSelection(element);	96	if (info.getTask() != null) {
109		97	// XXX which one to use?
110	if (comment != null) {	98	// TaskUiUtil.openEditor(info.getTask(), false);
111	String id = MylarTeamPlugin.getDefault().getCommitTemplateManager()	99	TasksUiUtil.refreshAndOpenTaskListElement(info.getTask());
112	.getTaskIdFromCommentOrLabel(comment);	100	return;
113	if (id == null) {	101	}
114	id = getTaskIdFromLegacy07Label(comment);	102	if (info.getRepositoryUrl() != null && info.getTaskId() != null) {
115	}	103	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(info.getRepositoryUrl());
116		104	if (repository != null) {
117	if (project != null) {	105	if (TasksUiUtil.openRepositoryTask(repository, info.getTaskId())) {
118	TaskRepository repository = TasksUiPlugin.getDefault().getRepositoryForResource(project, false);	106	return;
119	if (repository != null) {
120	AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getRepositoryUi(repository.getKind());
121	if (connectorUi != null && id != null) {
122	opened = TasksUiUtil.openRepositoryTask(repository, id);
123	}
124	}	107	}
125	}	108	}
		109	}
		110	if (info.getTaskFullUrl() != null) {
		111	TasksUiUtil.openUrl(info.getTaskFullUrl());
		112	return;
		113	}
		114	}
126		115
127	// try opening via URL if present	116	// TODO show Open Remote Task dialog?
128	if (!opened) {	117	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
129	String fullUrl = getUrlFromComment(comment);	118	"Unable to open correspond task", "Unable to open correspond task");
130		119	}
131	String repositoryUrl = null;
132	if (fullUrl != null) {
133	AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
134	.getConnectorForRepositoryTaskUrl(fullUrl);
135	if (connector != null) {
136	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(fullUrl);
137	}
138	} else {
139	ITask task = TasksUiPlugin.getTaskListManager().getTaskList().getActiveTask();
140	if (task instanceof AbstractRepositoryTask) {
141	repositoryUrl = ((AbstractRepositoryTask) task).getRepositoryUrl();
142	} else if (TasksUiPlugin.getRepositoryManager().getAllRepositories().size() == 1) {
143	repositoryUrl = TasksUiPlugin.getRepositoryManager().getAllRepositories().get(0).getUrl();
144	}
145	}
146		120
147	opened = TasksUiUtil.openRepositoryTask(repositoryUrl, id, fullUrl);	121	public void selectionChanged(IAction action, ISelection selection) {
148	if (!opened) {	122	this.selection = selection;
149	TasksUiUtil.openUrl(fullUrl);	123	}
150	}	124
151	}	125	/**
		126	* Reconcile <code>ILinkedTaskInfo</code> data.
		127	*
		128	* This is used in order to keep LinkedTaskInfo lightweight with minimal
		129	* dependencies.
		130	*/
		131	private ILinkedTaskInfo reconsile(ILinkedTaskInfo info) {
		132	ITask task = info.getTask();
		133	if (task != null) {
		134	return info;
		135	}
		136
		137	String repositoryUrl = info.getRepositoryUrl();
		138	String taskId = info.getTaskId();
		139	String taskFullUrl = info.getTaskFullUrl();
		140	String comment = info.getComment();
		141
		142	TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();
		143
		144	TaskRepository repository = null;
		145	if(repositoryUrl!=null) {
		146	repository = repositoryManager.getRepository(repositoryUrl);
		147	}
		148
		149	AbstractRepositoryConnector connector = null;
		150	if(taskFullUrl!=null) {
		151	connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
		152	}
		153	if (connector == null && repository!=null) {
		154	connector = repositoryManager.getRepositoryConnector(repository.getKind());
		155	}
		156
		157	if (repositoryUrl == null && connector != null) {
		158	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
		159	}
		160
		161	if (taskId == null && connector != null) {
		162	taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
		163	}
		164	if (taskId == null && repository != null && comment != null) {
		165	String[] ids = connector.getTaskIdsFromComment(repository, comment);
		166	if (ids != null && ids.length > 0) {
		167	taskId = ids[0];
		168	}
		169	}
		170	if (taskId == null && comment!=null) {
		171	CommitTemplateManager commitTemplateManager = MylarTeamPlugin.getDefault().getCommitTemplateManager();
		172	taskId = commitTemplateManager.getTaskIdFromCommentOrLabel(comment);
		173	if (taskId == null) {
		174	taskId = getTaskIdFromLegacy07Label(comment);
152	}	175	}
153	}	176	}
154	}
155		177
156	private String getCommentFromSelection(Object element) {	178	if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
157	if (element instanceof DiffChangeSet) {	179	taskFullUrl = connector.getTaskWebUrl(repositoryUrl, taskId);
158	return ((CVSCheckedInChangeSet) element).getComment();
159	} else if (element instanceof ChangeSetDiffNode) {
160	return ((ChangeSetDiffNode) element).getName();
161	} else if (element instanceof LogEntry) {
162	return ((LogEntry) element).getComment();
163	} else if (element instanceof IFileRevision) {
164	return ((IFileRevision) element).getComment();
165	}	180	}
166	return null;
167	}
168		181
169	private IProject findCorrespondingProject(Object element) {	182	if (task == null) {
170	if (element instanceof DiffChangeSet) {	183	if (taskId != null && repositoryUrl != null) {
171	IResource[] resources = ((DiffChangeSet) element).getResources();	184	// XXX fix this hack (jira ids don't work here)
172	if (resources.length > 0) {	185	if(!taskId.contains(AbstractRepositoryTask.HANDLE_DELIM)) {
173	// TODO: only checks first resource	186	String handle = AbstractRepositoryTask.getHandle(repositoryUrl, taskId);
174	return resources[0].getProject();	187	task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(handle);
175	}
176	} else if (element instanceof SynchronizeModelElement) {
177	SynchronizeModelElement modelElement = (SynchronizeModelElement)element;
178	IResource resource = modelElement.getResource();
179	if (resource != null) {
180	return resource.getProject();
181	} else {
182	IDiffElement[] elements = modelElement.getChildren();
183	if (elements.length > 0) {
184	// TODO: only checks first diff
185	if (elements[0] instanceof SynchronizeModelElement) {
186	return ((SynchronizeModelElement)elements[0]).getResource().getProject();
187	}
188	}	188	}
189	}	189	}
190	} else if (element instanceof IAdaptable) {	190	if (task == null && taskFullUrl != null) {
191	// TODO: there must be a better way to get at the local resource	191	// search by fullUrl
192	IResourceVariant resourceVariant = (IResourceVariant) ((IAdaptable) element)	192	for (ITask currTask : TasksUiPlugin.getTaskListManager().getTaskList().getAllTasks()) {
193	.getAdapter(IResourceVariant.class);	193	if (currTask instanceof AbstractRepositoryTask) {
194	if (resourceVariant != null && resourceVariant instanceof RemoteResource) {	194	String currUrl = ((AbstractRepositoryTask) currTask).getUrl();
195	RemoteResource remoteResource = (RemoteResource) resourceVariant;	195	if (taskFullUrl.equals(currUrl)) {
196	String path = remoteResource.getRepositoryRelativePath();	196	return new LinkedTaskInfo(currTask);
197	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();	197	}
198	return root.getProject(new Path(path).removeFirstSegments(1).uptoSegment(1).toString());	198	}
		199	}
199	}	200	}
200	} else {
201
202	}	201	}
203	return null;	202	if (task != null) {
		203	return new LinkedTaskInfo(task);
		204	}
		205
		206	return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment);
204	}	207	}
205		208
206	public static String getUrlFromComment(String comment) {	209	public static String getUrlFromComment(String comment) {
Lines 247-266 Link Here
247	}	250	}
248	return null;	251	return null;
249	}	252	}
250
251
252	// private Object findParent(ISynchronizeModelElement element) {
253	// if (element instanceof ChangeSetDiffNode) {
254	// return element;
255	// } else if (element.getParent() instanceof ISynchronizeModelElement) {
256	// return findParent((ISynchronizeModelElement) element.getParent());
257	// }
258	// return null;
259	// }
260
261
262	public void selectionChanged(IAction action, ISelection selection) {
263	this.selection = selection;
264	}
265		253
266	}	254	}

Lines 11-22 Link Here

(-)src/org/eclipse/mylar/internal/team/LinkedTaskInfo.java (-65 / +15 lines)
11		11
12	package org.eclipse.mylar.internal.team;	12	package org.eclipse.mylar.internal.team;
13		13
14	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
15	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
16	import org.eclipse.mylar.tasks.core.ITask;	14	import org.eclipse.mylar.tasks.core.ITask;
17	import org.eclipse.mylar.tasks.core.TaskRepository;
18	import org.eclipse.mylar.tasks.core.TaskRepositoryManager;
19	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
20		15
21	/**	16	/**
22	* Default implementation of {@link ILinkedTaskInfo}	17	* Default implementation of {@link ILinkedTaskInfo}
Lines 25-104 Link Here
25	*/	20	*/
26	public class LinkedTaskInfo implements ILinkedTaskInfo {	21	public class LinkedTaskInfo implements ILinkedTaskInfo {
27		22
		23	private ITask task;
		24
		25	private String repositoryUrl;
		26
28	private String taskId;	27	private String taskId;
29		28
30	private String taskFullUrl;	29	private String taskFullUrl;
31		30
32	private String repositoryUrl;	31	private String comment;
33		32
34	private ITask task;
35		33
36	public LinkedTaskInfo(ITask task) {	34	public LinkedTaskInfo(ITask task) {
37	init(task, //	35	this.task = task;
38	AbstractRepositoryTask.getRepositoryUrl(task.getHandleIdentifier()), //
39	AbstractRepositoryTask.getTaskId(task.getHandleIdentifier()), //
40	task.getUrl());
41	}	36	}
42		37
43	public LinkedTaskInfo(String taskFullUrl) {	38	public LinkedTaskInfo(String taskFullUrl) {
44	init(null, null, null, taskFullUrl);	39	this.taskFullUrl = taskFullUrl;
45	}
46
47	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl) {
48	init(null, repositoryUrl, taskId, taskFullUrl);
49	}	40	}
50		41
51	private void init(ITask task, String repositoryUrl, String taskId, String taskFullUrl) {	42	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl, String comment) {
52	// TODO should this even be here?
53
54	TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();
55	AbstractRepositoryConnector connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
56	if (connector == null && repositoryUrl != null) {
57	TaskRepository repository = repositoryManager.getRepository(repositoryUrl);
58	if (repository != null) {
59	connector = repositoryManager.getRepositoryConnector(repository.getKind());
60	}
61	}
62
63	if (repositoryUrl == null && connector != null) {
64	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
65	}
66
67	if (taskId == null && connector != null) {
68	taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
69	}
70
71	if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
72	taskFullUrl = connector.getTaskWebUrl(repositoryUrl, taskId);
73	}
74
75	if (task == null) {
76	if (taskId != null && repositoryUrl != null) {
77	String handle = AbstractRepositoryTask.getHandle(repositoryUrl, taskId);
78	task = TasksUiPlugin.getTaskListManager().getTaskList().getTask(handle);
79	}
80	if (task == null && taskFullUrl != null) {
81	// search by fullUrl
82	for (ITask currTask : TasksUiPlugin.getTaskListManager().getTaskList().getAllTasks()) {
83	if (currTask instanceof AbstractRepositoryTask) {
84	String currUrl = ((AbstractRepositoryTask) currTask).getUrl();
85	if (taskFullUrl.equals(currUrl)) {
86	task = currTask;
87	break;
88	}
89	}
90	}
91	}
92	}
93
94	if (taskFullUrl == null && task != null) {
95	taskFullUrl = task.getUrl();
96	}
97
98	this.task = task;
99	this.repositoryUrl = repositoryUrl;	43	this.repositoryUrl = repositoryUrl;
100	this.taskId = taskId;	44	this.taskId = taskId;
101	this.taskFullUrl = taskFullUrl;	45	this.taskFullUrl = taskFullUrl;
		46	this.comment = comment;
102	}	47	}
103		48
104	public String getRepositoryUrl() {	49	public String getRepositoryUrl() {
Lines 117-120 Link Here
117	return taskId;	62	return taskId;
118	}	63	}
119		64
		65	public String getComment() {
		66	return comment;
		67	}
		68
120	}	69	}
		70

Lines 8-14 Link Here

(-)plugin.xml (-16 / +24 lines)
8	<extension	8	<extension
9	point="org.eclipse.mylar.team.providers">	9	point="org.eclipse.mylar.team.providers">
10	<repository class="org.eclipse.mylar.internal.team.ccvs.CvsRepositoryProvider"/>	10	<repository class="org.eclipse.mylar.internal.team.ccvs.CvsRepositoryProvider"/>
11	<repository class="org.eclipse.mylar.internal.team.subclipse.SubclipseTeamRepositoryProvider"/>
12	</extension>	11	</extension>
13		12
14	<extension	13	<extension
Lines 29-34 Link Here
29	</extension>	28	</extension>
30		29
31	<extension point="org.eclipse.ui.popupMenus">	30	<extension point="org.eclipse.ui.popupMenus">
		31
		32	<objectContribution
		33	id="org.eclipse.mylar.ui.team.synchronize.open.report"
		34	objectClass="org.eclipse.mylar.internal.team.ILinkedTaskInfo"
		35	adaptable="true">
		36	<action
		37	class="org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction"
		38	enablesFor="1"
		39	icon="icons/elcl16/task-repository.gif"
		40	id="org.eclipse.mylar.ui.team.synchronize.contribution.open.report"
		41	label="Open Corresponding Task"
		42	menubarPath="mylar"
		43	tooltip="Open Corresponding Task">
		44	</action>
		45	</objectContribution>
		46
		47	<!--
32	<objectContribution	48	<objectContribution
33	objectClass="org.eclipse.team.ui.synchronize.ISynchronizeModelElement"	49	objectClass="org.eclipse.team.ui.synchronize.ISynchronizeModelElement"
34	id="org.eclipse.mylar.ui.team.synchronize.open.report">	50	id="org.eclipse.mylar.ui.team.synchronize.open.report">
Lines 42-47 Link Here
42	tooltip="Open Corresponding Task">	58	tooltip="Open Corresponding Task">
43	</action>	59	</action>
44	</objectContribution>	60	</objectContribution>
		61	-->
		62
		63	<!-- is this from Eclipse 3.1 History view?
45	<objectContribution	64	<objectContribution
46	objectClass="org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry"	65	objectClass="org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry"
47	id="org.eclipse.mylar.ui.team.history.open.report">	66	id="org.eclipse.mylar.ui.team.history.open.report">
Lines 55-60 Link Here
55	tooltip="Open Corresponding Task">	74	tooltip="Open Corresponding Task">
56	</action>	75	</action>
57	</objectContribution>	76	</objectContribution>
		77	-->
		78
		79	<!--
58	<objectContribution	80	<objectContribution
59	objectClass="org.eclipse.team.core.history.IFileRevision"	81	objectClass="org.eclipse.team.core.history.IFileRevision"
60	id="org.eclipse.mylar.ui.team.synchronize.open.report">	82	id="org.eclipse.mylar.ui.team.synchronize.open.report">
Lines 68-89 Link Here
68	tooltip="Open Corresponding Task">	90	tooltip="Open Corresponding Task">
69	</action>	91	</action>
70	</objectContribution>	92	</objectContribution>
		93	-->
71		94
72	<!-- Subclipse History view -->
73	<objectContribution
74	objectClass="org.tigris.subversion.subclipse.core.history.LogEntry"
75	id="org.eclipse.mylar.ui.team.synchronize.open.report">
76	<action
77	class="org.eclipse.mylar.internal.team.ui.actions.OpenCorrespondingTaskAction"
78	enablesFor="1"
79	icon="icons/elcl16/task-repository.gif"
80	id="org.eclipse.mylar.ui.team.synchronize.contribution.open.report"
81	label="Open Corresponding Task"
82	menubarPath="mylar"
83	tooltip="Open Corresponding Task">
84	</action>
85	</objectContribution>
86
87	<!--	95	<!--
88	<objectContribution	96	<objectContribution
89	objectClass="org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode"	97	objectClass="org.eclipse.team.internal.ui.synchronize.ChangeSetDiffNode"

Removed Link Here

(-)src/org/eclipse/mylar/internal/team/subclipse/SubclipseTeamRepositoryProvider.java (-97 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	* Gunnar Wagenknecht - initial API and implementation
11	*******************************************************************************/
12	package org.eclipse.mylar.internal.team.subclipse;
13
14	import java.lang.reflect.Constructor;
15	import java.lang.reflect.Method;
16
17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.jface.action.IAction;
20	import org.eclipse.mylar.team.AbstractTeamRepositoryProvider;
21	import org.eclipse.team.internal.core.subscribers.ActiveChangeSetManager;
22	import org.osgi.framework.Bundle;
23
24	/**
25	* Subclipse integration for Mylar.
26	*/
27	public class SubclipseTeamRepositoryProvider extends AbstractTeamRepositoryProvider {
28
29	@SuppressWarnings("unchecked")
30	@Override
31	public ActiveChangeSetManager getActiveChangeSetManager() {
32	// collectors.add((CVSActiveChangeSetCollector)CVSUIPlugin.getPlugin().getChangeSetManager());
33	Bundle svnBundle = Platform.getBundle("org.tigris.subversion.subclipse.core");
34	if (svnBundle != null) {
35	Method getChangeSetManagerMethod;
36	try {
37	Class providerPlugin = svnBundle.loadClass("org.tigris.subversion.subclipse.core.SVNProviderPlugin"); // Class.forName("org.tigris.subversion.subclipse.core.SVNProviderPlugin");
38	Method getPluginMethod = providerPlugin.getMethod("getPlugin", new Class[0]);
39	Object pluginInstance = getPluginMethod.invoke(null, new Object[0]);
40	getChangeSetManagerMethod = providerPlugin.getDeclaredMethod("getChangeSetManager", new Class[0]);
41	Object manager = getChangeSetManagerMethod.invoke(pluginInstance, new Object[0]);
42	if (manager instanceof ActiveChangeSetManager) {
43	return (ActiveChangeSetManager) manager;
44	}
45	} catch (Throwable t) {
46	// intore missing tigris collector
47	}
48	}
49	return null;
50	}
51
52	@SuppressWarnings("unchecked")
53	@Override
54	public boolean hasOutgoingChanges(IResource[] resources) {
55	if (Platform.getBundle("org.tigris.subversion.subclipse.core") == null)
56	return false;
57
58	try {
59	Class commitActionClass = Class.forName("org.tigris.subversion.subclipse.ui.actions.CommitAction");
60	Constructor commitActionConstructor = commitActionClass.getConstructor(new Class[] { String.class });
61	Object commitAction = commitActionConstructor.newInstance(new Object[] { "" });
62	Method setSelectedResourcesMethod = commitActionClass.getMethod("setSelectedResources",
63	new Class[] { IResource[].class });
64	setSelectedResourcesMethod.invoke(commitAction, new Object[] { resources });
65
66	Method hasOutgoingChangesMethod = commitActionClass.getMethod("hasOutgoingChanges", new Class[0]);
67	Boolean hasOutgoingChanges = (Boolean) hasOutgoingChangesMethod.invoke(commitAction, new Object[0]);
68
69	return hasOutgoingChanges.booleanValue();
70	} catch (Throwable t) {
71	// Noting we can do
72	}
73
74	return false;
75	}
76
77	@SuppressWarnings("unchecked")
78	@Override
79	public void commit(IResource[] resources) {
80	if (Platform.getBundle("org.tigris.subversion.subclipse.core") == null)
81	return;
82
83	try {
84	Class commitActionClass = Class.forName("org.tigris.subversion.subclipse.ui.actions.CommitAction");
85	Constructor commitActionConstructor = commitActionClass.getConstructor(new Class[] { String.class });
86	Object commitAction = commitActionConstructor.newInstance(new Object[] { "" });
87	Method setSelectedResourcesMethod = commitActionClass.getMethod("setSelectedResources",
88	new Class[] { IResource[].class });
89	setSelectedResourcesMethod.invoke(commitAction, new Object[] { resources });
90
91	Method executeMethod = commitActionClass.getMethod("execute", new Class[] { IAction.class });
92	executeMethod.invoke(commitAction, new Object[] { null });
93	} catch (Throwable t) {
94	// nothing we can do
95	}
96	}
97	}