[Pydev-cvs] org.python.pydev/src/org/python/pydev/plugin/nature IPythonPathNature.java,NONE,1.1 PythonPathNature.java,NONE,1.1 PythonNature.java,NONE,1.1

[Fabio Z. <fa...@us...>]

Update of /cvsroot/pydev/org.python.pydev/src/org/python/pydev/plugin/nature
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7006/src/org/python/pydev/plugin/nature

Added Files:
	IPythonPathNature.java PythonPathNature.java PythonNature.java 
Log Message:
almost there...

--- NEW FILE: IPythonPathNature.java ---
/*
 * License: Common Public License v1.0
 * Created on Jun 2, 2005
 * 
 * @author Fabio Zadrozny
 */
package org.python.pydev.plugin.nature;

import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;

/**
 * @author Fabio Zadrozny
 */
public interface IPythonPathNature {

    /**
     * Sets the project this python path nature is associated with
     * @param project
     */
    public void setProject(IProject project);

    /**
     * @return the pythonpath (source and externals) for the project as a list of strings
     */
    public List getCompleteProjectPythonPath();

    /**
     * @return the pythonpath (source and externals) as a string (paths separated by | )
     * @throws CoreException
     */
    public String getOnlyProjectPythonPathStr() throws CoreException;

    /**
     * Sets the project source path (paths are relative to the project location and are separated by | ) 
     * 
     * @param newSourcePath
     * @throws CoreException
     */
    public void setProjectSourcePath(String newSourcePath) throws CoreException;

    /**
     * Sets the project external source paths (those are full-paths for mapping to a file in the filesystem, separated by | ).
     * 
     * @param newExternalSourcePath
     * @throws CoreException
     */
    public void setProjectExternalSourcePath(String newExternalSourcePath) throws CoreException;

    /**
     * @return only the project source paths (paths are relative to the project location and are separated by | )
     * @throws CoreException
     */
    public String getProjectSourcePath() throws CoreException;

    /**
     * @return only the project external source paths (those are full-paths for mapping to a file in the filesystem, separated by | ).
     * @throws CoreException
     */
    public String getProjectExternalSourcePath() throws CoreException;

}

--- NEW FILE: PythonNature.java ---
/*
 * License: Common Public License v1.0
 * Created on Mar 11, 2004
 * 
 * @author Fabio Zadrozny
 * @author atotic
 */
package org.python.pydev.plugin.nature;

import java.io.File;

import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IProjectNature;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.python.pydev.builder.PyDevBuilderPrefPage;
import org.python.pydev.editor.codecompletion.revisited.ASTManager;
import org.python.pydev.editor.codecompletion.revisited.IASTManager;
import org.python.pydev.plugin.PydevPlugin;
import org.python.pydev.ui.IInterpreterManager;
import org.python.pydev.ui.PyProjectPythonDetails;
import org.python.pydev.ui.pythonpathconf.InterpreterInfo;
import org.python.pydev.utils.JobProgressComunicator;
import org.python.pydev.utils.REF;

/**
 * PythonNature is currently used as a marker class.
 * 
 * When python nature is present, project gets extra properties. Project gets assigned python nature when: - a python file is edited - a
 * python project wizard is created
 * 
 *  
 */
public class PythonNature implements IProjectNature {

    /**
     * This is the nature ID
     */
    public static final String PYTHON_NATURE_ID = "org.python.pydev.pythonNature";

    /**
     * This is the nature name
     */
    public static final String PYTHON_NATURE_NAME = "pythonNature";

    /**
     * Builder id for pydev (code completion todo and others)
     */
    public static final String BUILDER_ID = "org.python.pydev.PyDevBuilder";

    /**
     * Project associated with this nature.
     */
    private IProject project;

    /**
     * This is the completions cache for the nature represented by this object (it is associated with a project).
     */
    private IASTManager astManager;

    /**
     * We have to know if it has already been initialized.
     */
    private boolean initialized;

    /**
     * Manages pythonpath things
     */
    private IPythonPathNature pythonPathNature = new PythonPathNature();

    /**
     * This method is called only when the project has the nature added..
     * 
     * @see org.eclipse.core.resources.IProjectNature#configure()
     */
    public void configure() throws CoreException {
    }

    /**
     * @see org.eclipse.core.resources.IProjectNature#deconfigure()
     */
    public void deconfigure() throws CoreException {
    }

    /**
     * Returns the project
     * 
     * @see org.eclipse.core.resources.IProjectNature#getProject()
     */
    public IProject getProject() {
        return project;
    }

    /**
     * Sets this nature's project - called from the eclipse platform.
     * 
     * @see org.eclipse.core.resources.IProjectNature#setProject(org.eclipse.core.resources.IProject)
     */
    public void setProject(IProject project) {
        this.project = project;
        this.pythonPathNature.setProject(project);
    }

    /**
     * Utility routine to add PythonNature to the project
     */
    public static synchronized void addNature(IProject project, IProgressMonitor monitor) throws CoreException {
        if (project == null) {
            return;
        }

        IProjectDescription desc = project.getDescription();

        //only add the nature if it still hasn't been added.
        if (project.hasNature(PYTHON_NATURE_ID) == false) {

            String[] natures = desc.getNatureIds();
            String[] newNatures = new String[natures.length + 1];
            System.arraycopy(natures, 0, newNatures, 0, natures.length);
            newNatures[natures.length] = PYTHON_NATURE_ID;
            desc.setNatureIds(newNatures);
            project.setDescription(desc, monitor);
        }

        //add the builder. It is used for pylint, pychecker, code completion, etc.
        ICommand[] commands = desc.getBuildSpec();

        //now, add the builder if it still hasn't been added.
        if (hasBuilder(commands) == false && PyDevBuilderPrefPage.usePydevBuilders()) {

            ICommand command = desc.newCommand();
            command.setBuilderName(BUILDER_ID);
            ICommand[] newCommands = new ICommand[commands.length + 1];

            System.arraycopy(commands, 0, newCommands, 1, commands.length);
            newCommands[0] = command;
            desc.setBuildSpec(newCommands);
            project.setDescription(desc, monitor);
        }

        IProjectNature n = project.getNature(PYTHON_NATURE_ID);
        if (n instanceof PythonNature) {
            PythonNature nature = (PythonNature) n;
            //call initialize always - let it do the control.
            nature.init();
        }

    }

    /**
     * Utility to know if the pydev builder is in one of the commands passed.
     * 
     * @param commands
     */
    private static boolean hasBuilder(ICommand[] commands) {
        for (int i = 0; i < commands.length; i++) {
            if (commands[i].getBuilderName().equals(BUILDER_ID)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Initializes the python nature if it still has not been for this session.
     * 
     * Actions includes restoring the dump from the code completion cache
     */
    private void init() {
        if (initialized == false) {
            initialized = true;

            astManager = null;
            
            Job myJob = new Job("Pydev code completion") {

                protected IStatus run(IProgressMonitor monitor) {

                    astManager = (IASTManager) REF.readFromFile(getAstOutputFile());
                    //errors can happen when restoring it
                    if(astManager != null){
	                    restoreAditionalManagers();
	                    
                    }else{
                        try {
                            String pythonPathStr = pythonPathNature.getOnlyProjectPythonPathStr();
                            rebuildPath(pythonPathStr);
                        } catch (CoreException e) {
                            
                            PydevPlugin.log(e);
                        }
                        
                    }
                    return Status.OK_STATUS;
                }
            };
            myJob.schedule();

        }
    }


    /**
     * Returns the directory that should store completions.
     * 
     * @param p
     * @return
     */
    private static File getCompletionsCacheDir(IProject p) {
        IPath location = p.getWorkingLocation(PydevPlugin.getPluginID());
        IPath path = location;
    
        File file = new File(path.toOSString());
        return file;
    }
    
    private File getCompletionsCacheDir() {
        return getCompletionsCacheDir(getProject());
    }

    /**
     * @param dir: parent directory where file should be.
     * @return the file where the python path helper should be saved.
     */
    private File getAstOutputFile() {
        return new File(getCompletionsCacheDir(), "asthelper.completions");
    }

    /**
     * This method is called whenever the pythonpath for the project with this nature is changed. 
     */
    public void rebuildPath(final String paths) {
        Job myJob = new Job("Pydev code completion: rebuilding modules") {

            protected IStatus run(IProgressMonitor monitor) {
                if(astManager == null){
                    astManager = new ASTManager();
                }

                astManager.changePythonPath(paths, project, new JobProgressComunicator(monitor, "Rebuilding modules", 500, this));
                restoreAditionalManagers();
                saveAstManager(false);

                return Status.OK_STATUS;
            }
        };
        myJob.schedule();
        
    }

    /**
     * This must be called so that 
     */
    private void restoreAditionalManagers() {
        if(astManager != null){
	        IInterpreterManager iMan = PydevPlugin.getInterpreterManager();
	        InterpreterInfo info = iMan.getDefaultInterpreterInfo(new NullProgressMonitor());
	        astManager.setSystemModuleManager(info.modulesManager, getProject());
        }
    }
    
    /**
     * @return Returns the completionsCache.
     */
    public IASTManager getAstManager() {
        return astManager;
    }
    
    public void setAstManager(IASTManager astManager){
        this.astManager = astManager;
    }

    public IPythonPathNature getPythonPathNature() {
        return pythonPathNature;
    }
    
    public static IPythonPathNature getPythonPathNature(IProject project) {
        PythonNature pythonNature = getPythonNature(project);
        return pythonNature.pythonPathNature;
    }
    /**
     * @param project
     * @return
     */
    public static PythonNature getPythonNature(IProject project) {
        if(project != null){
            try {
                if(project.hasNature(PYTHON_NATURE_ID)){
	                IProjectNature n = project.getNature(PYTHON_NATURE_ID);
	                if(n instanceof PythonNature){
	                    return (PythonNature) n;
	                }
                }
            } catch (CoreException e) {
                PydevPlugin.log(e);
            }
        }
        return null;
    }

    /**
     * @return
     */
    public String getVersion() {
        return PyProjectPythonDetails.getPythonVersion();
    }

    /**
     * 
     */
    public void saveAstManager(boolean saveNow) {
        //TODO: put into a save list...
        REF.writeToFile(astManager, getAstOutputFile());
    }
}
--- NEW FILE: PythonPathNature.java ---
/*
 * License: Common Public License v1.0
 * Created on Jun 2, 2005
 * 
 * @author Fabio Zadrozny
 */
package org.python.pydev.plugin.nature;

import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.QualifiedName;
import org.python.pydev.editor.codecompletion.revisited.ProjectModulesManager;
import org.python.pydev.plugin.PydevPlugin;
import org.python.pydev.utils.REF;

/**
 * @author Fabio Zadrozny
 */
public class PythonPathNature implements IPythonPathNature {

    /**
     * This is the property that has the python path - associated with the project.
     */
    private static final QualifiedName PROJECT_SOURCE_PATH = new QualifiedName(PydevPlugin.getPluginID(), "PROJECT_SOURCE_PATH");
    private static final QualifiedName PROJECT_EXTERNAL_SOURCE_PATH = new QualifiedName(PydevPlugin.getPluginID(), "PROJECT_EXTERNAL_SOURCE_PATH");
    private IProject project;


    public void setProject(IProject project){
        this.project = project;
    }
    

    public List getCompleteProjectPythonPath() {
        if(project == null){
            return null;
        }
        
        PythonNature nature = PythonNature.getPythonNature(project);
        ProjectModulesManager projectModulesManager = nature.getAstManager().getProjectModulesManager();
        return projectModulesManager.getCompletePythonPath();
    }

    /**
     * @param project
     * @return
     * @throws CoreException
     */
    public String getOnlyProjectPythonPathStr() throws CoreException {
        String source = project.getPersistentProperty(PROJECT_SOURCE_PATH);
        String external = project.getPersistentProperty(PROJECT_EXTERNAL_SOURCE_PATH);
        
        if(source == null){
            source = "";
        }
        //we have to work on this one to resolve to full files, as what is stored is the position
        //relative to the project location
        String[] strings = source.split("\\|");
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < strings.length; i++) {
            if(strings[i].trim().length()>0){
                IPath p = new Path(strings[i]);
                p = PydevPlugin.getLocation(p, project);
                buf.append(REF.getFileAbsolutePath(p.toFile()));
                buf.append("|");
            }
        }
        
        
        if(external == null){
            external = "";
        }
        return buf.toString()+"|"+external;
    }

    

    public void setProjectSourcePath(String newSourcePath) throws CoreException {
        project.setPersistentProperty(PythonPathNature.PROJECT_SOURCE_PATH, newSourcePath);
    }

    public void setProjectExternalSourcePath(String newExternalSourcePath) throws CoreException {
        project.setPersistentProperty(PythonPathNature.PROJECT_EXTERNAL_SOURCE_PATH, newExternalSourcePath);
    }

    public String getProjectSourcePath() throws CoreException {
        return project.getPersistentProperty(PythonPathNature.PROJECT_SOURCE_PATH);
    }

    public String getProjectExternalSourcePath() throws CoreException {
        return project.getPersistentProperty(PythonPathNature.PROJECT_EXTERNAL_SOURCE_PATH);
    }

}