projectmodulesmanager.java

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

                }
                return module;
            }
        }
        
        for (ModulesManager m : managersInvolved) {
            if (m instanceof ProjectModulesManager) {
                ProjectModulesManager pM = (ProjectModulesManager) m;
                module = pM.getModuleInDirectManager(name, nature, dontSearchInit);

            }else if (m instanceof SystemModulesManager) {
                SystemModulesManager systemModulesManager = (SystemModulesManager) m;
                module = systemModulesManager.getModuleWithoutBuiltins(name, nature, dontSearchInit); 
                
            }else{
                throw new RuntimeException("Unexpected: "+m);
            }
            
            if(module != null){
                if(DEBUG_MODULES){
                    System.out.println("Trying to get:"+name+" - "+" returned:"+module+" - "+m.getClass());
                }
                return module;
            }
        }
        if(DEBUG_MODULES){
            System.out.println("Trying to get:"+name+" - "+" returned:null - "+this.getClass());
        }
        return null;
    }
    
    public IModule getModuleInDirectManager(String name, IPythonNature nature, boolean dontSearchInit) {
        return super.getModule(name, nature, dontSearchInit);
    }

    protected String getResolveModuleErr(IResource member) {
		return "Unable to find the path "+member+" in the project were it\n" +
        "is added as a source folder for pydev (project: "+project.getName()+")";
	}

    /** 
     * @see org.python.pydev.core.IProjectModulesManager#resolveModule(java.lang.String)
     */
    public String resolveModule(String full) {
        return resolveModule(full, true);
    }
    
    /** 
     * @see org.python.pydev.core.IProjectModulesManager#resolveModule(java.lang.String, boolean)
     */
    public String resolveModule(String full, boolean checkSystemManager) {
        ModulesManager[] managersInvolved = this.getManagersInvolved(checkSystemManager);
        for (ModulesManager m : managersInvolved) {
            
            String mod;
            if (m instanceof ProjectModulesManager) {
                ProjectModulesManager pM = (ProjectModulesManager) m;
                mod = pM.resolveModuleInDirectManager(full);
            
            }else{
                mod = m.resolveModule(full);
            }

            if(mod != null){
                return mod;
            }
        }
        return null;
    }

    public String resolveModuleInDirectManager(String full) {
        return super.resolveModule(full);
    }
    
    public String resolveModuleInDirectManager(IResource member, IProject container) {
        File inOs = member.getRawLocation().toFile();
        return resolveModuleInDirectManager(REF.getFileAbsolutePath(inOs));
    }

    
    /** 
     * @see org.python.pydev.core.IProjectModulesManager#changePythonPath(java.lang.String, org.eclipse.core.resources.IProject, org.eclipse.core.runtime.IProgressMonitor)
     */
    public void changePythonPath(String pythonpath, IProject project, IProgressMonitor monitor, String defaultSelectedInterpreter) {
        super.changePythonPath(pythonpath, project, monitor, defaultSelectedInterpreter);
    }

    /** 
     * @see org.python.pydev.core.IProjectModulesManager#getSize()
     */
    public int getSize() {
        int size = 0;
        ModulesManager[] managersInvolved = this.getManagersInvolved(true);
        for (int i = 0; i < managersInvolved.length; i++) {
            size += managersInvolved[i].modulesKeys.size();
        }
        return size;
    }

    public String[] getBuiltins() {
    	return getBuiltins(null);
    }

    /** 
     * @see org.python.pydev.core.IProjectModulesManager#getBuiltins()
     */
    public String[] getBuiltins(String defaultSelectedInterpreter) {
        String[] builtins = null;
        ISystemModulesManager systemModulesManager = getSystemModulesManager(defaultSelectedInterpreter);
        if(systemModulesManager != null){
            builtins = systemModulesManager.getBuiltins();
        }
        return builtins;
    }


    /**
     * @param checkSystemManager whether the system manager should be added
     * @param referenced true if we should get the referenced projects 
     *                   false if we should get the referencing projects
     * @return the Managers that this project references or the ones that reference this project (depends on 'referenced') 
     * 
     * Change in 1.3.3: adds itself to the list of returned managers
     */
    private synchronized ModulesManager[] getManagers(boolean checkSystemManager, boolean referenced) {
    	if(this.completionCache != null){
    		ModulesManager[] ret = this.completionCache.getManagers(referenced);
    		if(ret != null){
    			return ret;
    		}
    	}
        ArrayList<ModulesManager> list = new ArrayList<ModulesManager>();
        SystemModulesManager systemModulesManager = getSystemModulesManager(null);
        if(systemModulesManager == null){
        	//may happen in initialization
        	PydevPlugin.log("System modules manager still not available (still initializing).");
        	return new ModulesManager[]{};
        }
        
        if(project != null){
        	HashSet<IProject> projs = new HashSet<IProject>();
        	getProjectsRecursively(project, referenced, projs);
            addModuleManagers(list, projs);
        }
        //add itself
        list.add(this);
        
        //the system is the last one we add.
        if(checkSystemManager && systemModulesManager != null){
            list.add(systemModulesManager);
        }
        ModulesManager[] ret = (ModulesManager[]) list.toArray(new ModulesManager[list.size()]);
        if(this.completionCache != null){
        	this.completionCache.setManagers(ret, referenced);
        }
        return ret;
    }


	private void getProjectsRecursively(IProject project, boolean referenced, HashSet<IProject> memo) {
		IProject[] projects = null;
		try {
			if(referenced){
				projects = project.getReferencedProjects();
			}else{
			    projects = project.getReferencingProjects();
			}
		} catch (CoreException e) {
			//ignore (it's closed)
		}
		
		
		HashSet<IProject> newFound = new HashSet<IProject>();
		
		if(projects != null){
			for (IProject p : projects) {
				if(!memo.contains(p)){
					memo.add(p);
					newFound.add(p);
				}
			}
		}
		
		for (IProject p : newFound) {
			getProjectsRecursively(p, referenced, memo);
		}
	}
    

    /**
     * @param list the list that will be filled with the managers
     * @param projects the projects that should have the managers added
     */
    private void addModuleManagers(ArrayList<ModulesManager> list, Collection<IProject> projects) {
    	for(IProject project:projects){
	        PythonNature nature = PythonNature.getPythonNature(project);
	        if(nature!=null){
	            ICodeCompletionASTManager otherProjectAstManager = nature.getAstManager();
	            if(otherProjectAstManager != null){
	                IModulesManager projectModulesManager = otherProjectAstManager.getModulesManager();
	                if(projectModulesManager != null){
	                    list.add((ModulesManager) projectModulesManager);
	                }
	            }
            }
        }
    }

    
    /**
     * @return Returns the managers that this project references(does not include itself).
     */
    public ModulesManager[] getManagersInvolved(boolean checkSystemManager) {
        return getManagers(checkSystemManager, true);
    }

    /**
     * @return Returns the managers that reference this project (does not include itself).
     */
    public ModulesManager[] getRefencingManagersInvolved(boolean checkSystemManager) {
        return getManagers(checkSystemManager, false);
    }


    
    /** 
     * @see org.python.pydev.core.IProjectModulesManager#getCompletePythonPath()
     */
    public List<String> getCompletePythonPath(String interpreter){
        List<String> l = new ArrayList<String>();
        ModulesManager[] managersInvolved = getManagersInvolved(true);
        for (ModulesManager m:managersInvolved) {
            if(m instanceof SystemModulesManager){
                SystemModulesManager systemModulesManager = (SystemModulesManager) m;
                l.addAll(systemModulesManager.getCompletePythonPath(interpreter, nature));
                
            }else{
                l.addAll(m.pythonPathHelper.getPythonpath());
            }
        }
        return l;
    }




}