/*******************************************************************************
* Copyright (c) 2010 Sonatype, Inc.
* 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.m2e.editor.dialogs;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.ARTIFACT_ID;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.DEPENDENCIES;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.DEPENDENCY;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.DEPENDENCY_MANAGEMENT;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.GROUP_ID;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.VERSION;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.findChild;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.findChilds;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.getChild;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.getTextValue;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.performOnDOMDocument;
import static org.eclipse.m2e.core.ui.internal.editing.PomEdits.removeChild;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.eclipse.core.resources.IFile;
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.viewers.IColorProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.apache.maven.model.Dependency;
import org.apache.maven.project.MavenProject;
import org.eclipse.m2e.core.MavenPlugin;
import org.eclipse.m2e.core.project.IMavenProjectFacade;
import org.eclipse.m2e.core.ui.internal.components.PomHierarchyComposite;
import org.eclipse.m2e.core.ui.internal.dialogs.AbstractMavenDialog;
import org.eclipse.m2e.core.ui.internal.editing.PomEdits.CompoundOperation;
import org.eclipse.m2e.core.ui.internal.editing.PomEdits.Operation;
import org.eclipse.m2e.core.ui.internal.editing.PomEdits.OperationTuple;
import org.eclipse.m2e.core.ui.internal.editing.PomHelper;
import org.eclipse.m2e.core.ui.internal.util.ParentHierarchyEntry;
import org.eclipse.m2e.editor.MavenEditorPlugin;
import org.eclipse.m2e.editor.composites.DependencyLabelProvider;
import org.eclipse.m2e.editor.composites.ListEditorContentProvider;
import org.eclipse.m2e.editor.pom.ValueProvider;
/**
* This dialog is used to present the user with a list of dialogs that they can move to being managed under
* "dependencyManagement". It allows them to pick the destination POM where the dependencies will be managed.
*
* @author rgould
*/
public class ManageDependenciesDialog extends AbstractMavenDialog {
private static final Logger LOG = LoggerFactory.getLogger(ManageDependenciesDialog.class);
private static final String DIALOG_SETTINGS = ManageDependenciesDialog.class.getName();
private TableViewer dependenciesViewer;
private final List<ParentHierarchyEntry> projectHierarchy;
private PomHierarchyComposite pomHierarchy;
private IStatus status;
private List<Object> originalSelection;
private ValueProvider<List<Dependency>> modelVProvider;
/**
* Hierarchy is a LinkedList representing the hierarchy relationship between POM represented by model and its parents.
* The head of the list should be the child, while the tail should be the root parent, with the others in between.
*/
public ManageDependenciesDialog(Shell parent, ValueProvider<List<Dependency>> modelVProvider,
List<ParentHierarchyEntry> hierarchy) {
this(parent, modelVProvider, hierarchy, null);
}
public ManageDependenciesDialog(Shell parent, ValueProvider<List<Dependency>> modelVProvider,
List<ParentHierarchyEntry> hierarchy, List<Object> selection) {
super(parent, DIALOG_SETTINGS);
setShellStyle(getShellStyle() | SWT.RESIZE);
setTitle(Messages.ManageDependenciesDialog_dialogTitle);
this.projectHierarchy = hierarchy;
this.originalSelection = selection;
this.modelVProvider = modelVProvider;
}
/* (non-Javadoc)
* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
*/
protected Control createDialogArea(Composite parent) {
readSettings();
Composite composite = (Composite) super.createDialogArea(parent);
Label infoLabel = new Label(composite, SWT.WRAP);
infoLabel.setText(Messages.ManageDependenciesDialog_dialogInfo);
Label horizontalBar = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
SashForm sashForm = new SashForm(composite, SWT.SMOOTH | SWT.HORIZONTAL);
Composite dependenciesComposite = new Composite(sashForm, SWT.NONE);
Label selectDependenciesLabel = new Label(dependenciesComposite, SWT.NONE);
selectDependenciesLabel.setText(Messages.ManageDependenciesDialog_selectDependenciesLabel);
final Table dependenciesTable = new Table(dependenciesComposite, SWT.FLAT | SWT.MULTI | SWT.BORDER);
final TableColumn column = new TableColumn(dependenciesTable, SWT.NONE);
dependenciesTable.addControlListener(new ControlAdapter() {
@Override
public void controlResized(ControlEvent e) {
column.setWidth(dependenciesTable.getClientArea().width);
}
});
Composite pomComposite = new Composite(sashForm, SWT.NONE);
Label selectPomLabel = new Label(pomComposite, SWT.NONE);
selectPomLabel.setText(Messages.ManageDependenciesDialog_selectPOMLabel);
pomHierarchy = new PomHierarchyComposite(pomComposite, SWT.BORDER);
pomHierarchy.setHierarchy(getProjectHierarchy());
// pomsViewer = new TreeViewer(pomComposite, SWT.BORDER);
/*
* Configure layouts
*/
GridLayout layout = new GridLayout(1, false);
composite.setLayout(layout);
GridData gridData = new GridData(SWT.FILL, SWT.NONE, true, false);
gridData.widthHint = 300;
infoLabel.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.NONE, true, false);
horizontalBar.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
sashForm.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
dependenciesComposite.setLayoutData(gridData);
layout = new GridLayout(1, false);
dependenciesComposite.setLayout(layout);
gridData = new GridData(SWT.FILL, SWT.NONE, true, false);
selectDependenciesLabel.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
dependenciesTable.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
pomComposite.setLayoutData(gridData);
layout = new GridLayout(1, false);
pomComposite.setLayout(layout);
gridData = new GridData(SWT.FILL, SWT.NONE, true, false);
selectPomLabel.setLayoutData(gridData);
gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
pomHierarchy.setLayoutData(gridData);
//pomsViewer.getTree().setLayoutData(gridData);
/*
* Set up list/tree viewers
*/
dependenciesViewer = new TableViewer(dependenciesTable);
dependenciesViewer.setLabelProvider(new DependencyLabelProvider());
dependenciesViewer.setContentProvider(new ListEditorContentProvider<Dependency>());
//MNGECLIPSE-2675 only show the dependencies not already managed (decide just by absence of the version element
List<Dependency> deps = modelVProvider.getValue();
List<Dependency> nonManaged = new ArrayList<Dependency>();
if(deps != null) {
for(Dependency d : deps) {
if(d.getVersion() != null) {
nonManaged.add(d);
}
}
}
dependenciesViewer.setInput(nonManaged);
dependenciesViewer.addSelectionChangedListener(new DependenciesViewerSelectionListener());
pomHierarchy.addSelectionChangedListener(new PomViewerSelectionChangedListener());
if(getProjectHierarchy().size() > 0) {
pomHierarchy.setSelection(new StructuredSelection(pomHierarchy.getProject()));
}
if(originalSelection != null && originalSelection.size() > 0) {
dependenciesViewer.setSelection(new StructuredSelection(originalSelection));
}
return composite;
}
@Override
protected void computeResult() {
final ParentHierarchyEntry currentPOM = getCurrentPOM();
final ParentHierarchyEntry targetPOM = getTargetPOM();
final IFile current = currentPOM.getResource();
final IFile target = targetPOM.getResource();
if(target == null || current == null) {
return;
}
final boolean same = targetPOM.equals(currentPOM);
final LinkedList<Dependency> modelDeps = getDependenciesList();
/*
* 1) Remove version values from the dependencies from the current POM
* 2) Add dependencies to dependencyManagement of targetPOM
*/
//First we remove the version from the original dependency
Job perform = new Job("Updating POM file(s)") {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
if(same) {
performOnDOMDocument(new OperationTuple(current, new CompoundOperation(createManageOperation(modelDeps),
createRemoveVersionOperation(modelDeps))));
} else {
performOnDOMDocument(new OperationTuple(target, createManageOperation(modelDeps)), new OperationTuple(
current, createRemoveVersionOperation(modelDeps)));
}
} catch(Exception e) {
LOG.error("Error updating managed dependencies", e);
return new Status(IStatus.ERROR, MavenEditorPlugin.PLUGIN_ID, "Error updating managed dependencies", e);
}
return Status.OK_STATUS;
}
};
perform.setUser(false);
perform.setSystem(true);
perform.schedule();
}
public static Operation createRemoveVersionOperation(final List<Dependency> modelDeps) {
return new Operation() {
public void process(Document document) {
List<Element> deps = findChilds(findChild(document.getDocumentElement(), DEPENDENCIES), DEPENDENCY);
for(Element dep : deps) {
String grid = getTextValue(findChild(dep, GROUP_ID));
String artid = getTextValue(findChild(dep, ARTIFACT_ID));
for(Dependency modelDep : modelDeps) {
if(modelDep.getGroupId() != null && modelDep.getGroupId().equals(grid) && modelDep.getArtifactId() != null
&& modelDep.getArtifactId().equals(artid)) {
removeChild(dep, findChild(dep, VERSION));
}
}
}
}
};
}
public static Operation createManageOperation(final List<Dependency> modelDeps) {
return new Operation() {
public void process(Document document) {
List<Dependency> modelDependencies = new ArrayList<Dependency>(modelDeps);
Element managedDepsElement = getChild(document.getDocumentElement(), DEPENDENCY_MANAGEMENT, DEPENDENCIES);
List<Element> existing = findChilds(managedDepsElement, DEPENDENCY);
for(Element dep : existing) {
String artifactId = getTextValue(findChild(dep, ARTIFACT_ID));
String groupId = getTextValue(findChild(dep, GROUP_ID));
//cloned list, shall not modify shared resource (used by the remove operation)
Iterator<Dependency> mdIter = modelDependencies.iterator();
while(mdIter.hasNext()) {
//TODO: here we iterate to find existing managed dependencies and decide not to overwrite them.
// but this could eventually break the current project when the versions are diametrally different
// we should have shown this information to the user in the UI in the first place (for him to decide what to do)
Dependency md = mdIter.next();
if(artifactId.equals(md.getArtifactId()) && groupId.equals(md.getGroupId())) {
mdIter.remove();
break;
}
}
}
//TODO is the version is defined by property expression, we should make sure the property is defined in the current project
for(Dependency modelDependency : modelDependencies) {
PomHelper.createDependency(managedDepsElement, modelDependency.getGroupId(), modelDependency.getArtifactId(),
modelDependency.getVersion());
}
}
};
}
protected LinkedList<Dependency> getDependenciesList() {
IStructuredSelection selection = (IStructuredSelection) dependenciesViewer.getSelection();
LinkedList<Dependency> dependencies = new LinkedList<Dependency>();
for(Object obj : selection.toArray()) {
dependencies.add((Dependency) obj);
}
return dependencies;
}
protected List<ParentHierarchyEntry> getProjectHierarchy() {
return this.projectHierarchy;
}
protected ParentHierarchyEntry getTargetPOM() {
IStructuredSelection selection = (IStructuredSelection) pomHierarchy.getSelection();
return (ParentHierarchyEntry) selection.getFirstElement();
}
protected ParentHierarchyEntry getCurrentPOM() {
return pomHierarchy.getProject();
}
/**
* Compare the list of selected dependencies against the selected targetPOM. If one of the dependencies is already
* under dependencyManagement, but has a different version than the selected dependency, warn the user about this.
* returns true if the user has been warned (but this method updates the status itself)
*
* @param model
* @param dependencies
*/
protected boolean checkDependencies(org.apache.maven.model.Model model, LinkedList<Dependency> dependencies) {
if(this.status != null && this.status.getCode() == IStatus.ERROR) {
//Don't warn the user if there is already an error
return false;
}
if(model == null || model.getDependencyManagement() == null
|| model.getDependencyManagement().getDependencies() == null
|| model.getDependencyManagement().getDependencies().isEmpty()) {
return false;
}
for(Dependency selectedDep : dependencies) {
for(org.apache.maven.model.Dependency targetDep : model.getDependencyManagement().getDependencies()) {
if(selectedDep.getGroupId().equals(targetDep.getGroupId())
&& selectedDep.getArtifactId().equals(targetDep.getArtifactId())
&& !selectedDep.getVersion().equals(targetDep.getVersion())) {
String modelID = model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion(); //$NON-NLS-1$ //$NON-NLS-2$
if(targetDep.getLocation("") != null && targetDep.getLocation("").getSource() != null) { //$NON-NLS-1$ //$NON-NLS-2$
modelID = targetDep.getLocation("").getSource().getModelId(); //$NON-NLS-1$
}
Object[] arguments = {selectedDep.getArtifactId() + "-" + selectedDep.getVersion(), //$NON-NLS-1$
targetDep.getVersion(), modelID};
String message = NLS.bind(Messages.ManageDependenciesDialog_dependencyExistsWarning, arguments);
updateStatus(new Status(IStatus.WARNING, MavenEditorPlugin.PLUGIN_ID, message));
return true;
}
}
}
return false;
}
protected void checkStatus(ParentHierarchyEntry targetProject, LinkedList<Dependency> selectedDependencies) {
if(targetProject == null || selectedDependencies.isEmpty()) {
updateStatus(new Status(IStatus.ERROR, MavenEditorPlugin.PLUGIN_ID,
Messages.ManageDependenciesDialog_emptySelectionError));
return;
}
boolean error = false;
if(targetProject.getFacade() == null) {
error = true;
updateStatus(new Status(IStatus.ERROR, MavenEditorPlugin.PLUGIN_ID,
Messages.ManageDependenciesDialog_projectNotPresentError));
} else {
error = checkDependencies(targetProject.getProject().getModel(), getDependenciesList());
}
if(!error) {
clearStatus();
}
}
protected void clearStatus() {
updateStatus(new Status(IStatus.OK, MavenEditorPlugin.PLUGIN_ID, "")); //$NON-NLS-1$
}
protected class DependenciesViewerSelectionListener implements ISelectionChangedListener {
public void selectionChanged(SelectionChangedEvent event) {
checkStatus(getTargetPOM(), getDependenciesList());
}
}
protected class PomViewerSelectionChangedListener implements ISelectionChangedListener {
public void selectionChanged(SelectionChangedEvent event) {
checkStatus(getTargetPOM(), getDependenciesList());
}
}
@Override
protected void updateStatus(IStatus status) {
this.status = status;
super.updateStatus(status);
}
public static class DepLabelProvider extends LabelProvider implements IColorProvider {
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
*/
@Override
public String getText(Object element) {
MavenProject project = null;
if(element instanceof MavenProject) {
project = (MavenProject) element;
} else if(element instanceof Object[]) {
project = (MavenProject) ((Object[]) element)[0];
} else {
return ""; //$NON-NLS-1$
}
StringBuffer buffer = new StringBuffer();
buffer.append(project.getGroupId() + " : " + project.getArtifactId() + " : " + project.getVersion()); //$NON-NLS-1$ //$NON-NLS-2$
return buffer.toString();
}
public Color getForeground(Object element) {
if(element instanceof MavenProject) {
MavenProject project = (MavenProject) element;
IMavenProjectFacade search = MavenPlugin.getMavenProjectRegistry().getMavenProject(project.getGroupId(),
project.getArtifactId(), project.getVersion());
if(search == null) {
//This project is not in the workspace so we can't really modify it.
return Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY);
}
}
return null;
}
public Color getBackground(Object element) {
return null;
}
}
public class ContentProvider implements ITreeContentProvider {
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
public void dispose() {
}
public boolean hasChildren(Object element) {
Object[] children = getChildren(element);
return children.length != 0;
}
public Object getParent(Object element) {
if(element instanceof MavenProject) {
MavenProject project = (MavenProject) element;
return project.getParent();
}
return null;
}
/*
* Return root element
* (non-Javadoc)
* @see org.eclipse.jface.viewers.ITreeContentProvider#getElements(java.lang.Object)
*/
public Object[] getElements(Object inputElement) {
if(inputElement instanceof LinkedList) {
LinkedList<MavenProject> projects = (LinkedList<MavenProject>) inputElement;
if(projects.isEmpty()) {
return new Object[0];
}
return new Object[] {projects.getLast()};
}
return new Object[0];
}
public Object[] getChildren(Object parentElement) {
if(parentElement instanceof MavenProject) {
/*
* Walk the hierarchy list until we find the parentElement and
* return the previous element, which is the child.
*/
MavenProject parent = (MavenProject) parentElement;
if(getProjectHierarchy().size() == 1) {
//No parent exists, only one element in the tree
return new Object[0];
}
if(getProjectHierarchy().get(0).equals(parent)) {
//We are the final child
return new Object[0];
}
ListIterator<ParentHierarchyEntry> iter = getProjectHierarchy().listIterator();
while(iter.hasNext()) {
ParentHierarchyEntry next = iter.next();
if(next.equals(parent)) {
iter.previous();
ParentHierarchyEntry previous = iter.previous();
return new Object[] {previous};
}
}
}
return new Object[0];
}
}
}