org.codehaus.mevenide.netbeans.SubprojectProviderImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of nb-project Show documentation
Implementation of a Netbeans project backed by Maven2 POM files.
The newest version!
/* ==========================================================================
 * Copyright 2005 Mevenide Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 * =========================================================================
 */
package org.codehaus.mevenide.netbeans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.apache.maven.artifact.Artifact;
import org.codehaus.mevenide.netbeans.api.ProjectURLWatcher;
import org.codehaus.mevenide.netbeans.queries.MavenFileOwnerQueryImpl;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.spi.project.SubprojectProvider;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.WeakListeners;

/**
 * finds subprojects (projects this one depends on) that are locally available
 * and can be build as one unit. Uses maven multiproject infrastructure. (maven.multiproject.includes)
 * @author  Milos Kleint ([email protected])
 */
public class SubprojectProviderImpl implements SubprojectProvider {

    private NbMavenProject project;
    private List listeners;
    private ChangeListener listener2;

    /** Creates a new instance of SubprojectProviderImpl */
    public SubprojectProviderImpl(NbMavenProject proj) {
        project = proj;
        listeners = new ArrayList();
        ProjectURLWatcher.addPropertyChangeListener(proj, new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {
                if (NbMavenProject.PROP_PROJECT.equals(evt.getPropertyName())) {
                    fireChange();
                }
            }
        });
        listener2 = new ChangeListener() {

            public void stateChanged(ChangeEvent event) {
                fireChange();
            }
        };
        MavenFileOwnerQueryImpl.getInstance().addChangeListener(
                WeakListeners.change(listener2,
                MavenFileOwnerQueryImpl.getInstance()));
    }

    public Set getSubprojects() {
        Set projects = new HashSet();
        File basedir = FileUtil.toFile(project.getProjectDirectory());
        addProjectModules(basedir, projects, project.getOriginalMavenProject().getModules());
        addOpenedCandidates(projects);
        projects.remove(project);
        return projects;
    }

    private void addOpenedCandidates(Set resultset) {
        Set opened = MavenFileOwnerQueryImpl.getInstance().getOpenedProjects();
        List compileArtifacts = project.getOriginalMavenProject().getCompileArtifacts();
        List artPaths = new ArrayList();
        for (Artifact ar : compileArtifacts) {
            artPaths.add(project.getArtifactRelativeRepositoryPath(ar));
        }
        for (NbMavenProject prj : opened) {
            String prjpath = prj.getArtifactRelativeRepositoryPath();
            if (artPaths.contains(prjpath)) {
                resultset.add(prj);
            }
        }
    }

    private boolean isProcessed(Set resultset, FileObject projectDir) {

        for (Project p : resultset) {
            if (p.getProjectDirectory().equals(projectDir)) {
                return true;
            }
        }

        return false;
    }

    private void addProjectModules(File basedir, Set resultset, List modules) {
        if (modules == null || modules.size() == 0) {
            return;
        }
        Iterator it = modules.iterator();
        while (it.hasNext()) {
            String path = (String) it.next();
            File sub = new File(basedir, path);
            File projectFile = FileUtil.normalizeFile(sub);
            if (projectFile.exists()) {
                FileObject projectDir = FileUtil.toFileObject(projectFile);
                if (projectDir != null && !isProcessed(resultset, projectDir)) {
                    Project proj = processOneSubproject(projectDir);
                    NbMavenProject mv = proj != null ? proj.getLookup().lookup(NbMavenProject.class) : null;
                    if (mv != null) {
                        // ignore the pom type projects when resolving subprojects..
                        // maybe make an user settable option??
                        if (!ProjectURLWatcher.TYPE_POM.equalsIgnoreCase(mv.getProjectWatcher().getPackagingType())) {
                            resultset.add(proj);
                        }
                        addProjectModules(FileUtil.toFile(mv.getProjectDirectory()),
                                resultset, mv.getOriginalMavenProject().getModules());
                    }
                } else {
                    // HUH?
                    ErrorManager.getDefault().log("fileobject not found=" + sub); //NOI18N
                }

            } else {
                ErrorManager.getDefault().log("project file not found=" + sub); //NOI18N
            }



        }
    }

    private Project processOneSubproject(FileObject projectDir) {


        try {
            return ProjectManager.getDefault().findProject(projectDir);
        } catch (IOException exc) {
            ErrorManager.getDefault().notify(exc);
        }

        return null;
    }

    public synchronized void addChangeListener(ChangeListener changeListener) {
        listeners.add(changeListener);
    }

    public synchronized void removeChangeListener(ChangeListener changeListener) {
        listeners.remove(changeListener);
    }

    private void fireChange() {
        List lists = new ArrayList();
        synchronized (this) {
            lists.addAll(listeners);
        }
        for (ChangeListener listener : lists) {
            listener.stateChanged(new ChangeEvent(this));
        }
    }
}