[Pydev-cvs] org.python.pydev/src_completions/org/python/pydev/editor/codecompletion/revisited/javai

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/pydev/org.python.pydev/src_completions/org/python/pydev/editor/codecompletion/revisited/javaintegration
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24293/src_completions/org/python/pydev/editor/codecompletion/revisited/javaintegration

Modified Files:
	JavaProjectModulesManager.java AbstractJavaClassModule.java 
	JythonModulesManagerUtils.java 
Added Files:
	JavaZipModule.java JavaModuleInProject.java 
Removed Files:
	JavaZipClassModule.java JavaClassModuleInProject.java 
Log Message:
Code-completion working with the java packages (and not only for java classes).

--- JavaZipClassModule.java DELETED ---

Index: JavaProjectModulesManager.java
===================================================================
RCS file: /cvsroot/pydev/org.python.pydev/src_completions/org/python/pydev/editor/codecompletion/revisited/javaintegration/JavaProjectModulesManager.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** JavaProjectModulesManager.java	6 Jan 2008 17:31:13 -0000	1.4
--- JavaProjectModulesManager.java	9 Jan 2008 01:01:20 -0000	1.5
***************
*** 15,18 ****
--- 15,19 ----
  import org.eclipse.core.resources.IResource;
  import org.eclipse.core.runtime.IProgressMonitor;
+ import org.eclipse.core.runtime.Path;
  import org.eclipse.jdt.core.IClasspathEntry;
  import org.eclipse.jdt.core.IJavaElement;
***************
*** 20,24 ****
  import org.eclipse.jdt.core.IPackageFragment;
  import org.eclipse.jdt.core.IPackageFragmentRoot;
- import org.eclipse.jdt.core.IType;
  import org.eclipse.jdt.core.JavaCore;
  import org.eclipse.jdt.core.JavaModelException;
--- 21,24 ----
***************
*** 324,338 ****
          }
          try {
!             IType type = this.javaProject.findType(name);
              if(DEBUG_GET_MODULE){
!                 System.out.println("Found: "+type);
              }

!             if(type != null){

                  //now, there's a catch here, we'll find any class in the project classpath, even if it's in the 
                  //global classpath (e.g.: rt.jar), and this shouldn't be treated in this project modules manager
                  //(that's treated in the Jython system manager)
!                 IJavaElement ancestor = type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                  if(ancestor instanceof IPackageFragmentRoot){
                      IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) ancestor;
--- 324,338 ----
          }
          try {
!             IJavaElement javaElement = this.javaProject.findElement(new Path(name.replace('.', '/')));
              if(DEBUG_GET_MODULE){
!                 System.out.println("Found: "+javaElement);
              }

!             if(javaElement != null){

                  //now, there's a catch here, we'll find any class in the project classpath, even if it's in the 
                  //global classpath (e.g.: rt.jar), and this shouldn't be treated in this project modules manager
                  //(that's treated in the Jython system manager)
!                 IJavaElement ancestor = javaElement.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                  if(ancestor instanceof IPackageFragmentRoot){
                      IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) ancestor;
***************
*** 342,346 ****
                      }
                  }
!                 return new JavaClassModuleInProject(name, this.javaProject);
              }
          } catch (JavaModelException e) {
--- 342,346 ----
                      }
                  }
!                 return new JavaModuleInProject(name, this.javaProject);
              }
          } catch (JavaModelException e) {

--- JavaClassModuleInProject.java DELETED ---

--- NEW FILE: JavaModuleInProject.java ---
package org.python.pydev.editor.codecompletion.revisited.javaintegration;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.core.CompletionProposal;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.ui.text.java.CompletionProposalCollector;
import org.python.pydev.core.IToken;
import org.python.pydev.core.Tuple;
import org.python.pydev.core.docutils.StringUtils;

/**
 * This class defines a module that represents a given java class or package within a java project 
 * (that's referenced from a jython project).
 *
 * @author Fabio
 */
public class JavaModuleInProject extends AbstractJavaClassModule {

    private static final boolean DEBUG_CLASS_MODULE_IN_PROJECT = false;

    private static final int UNKNOWN = -1; 
    private static final int IS_PACKAGE = 0; 
    private static final int IS_CLASS = 1; 

    private IJavaProject javaProject;

    private int moduleType = UNKNOWN;

    /**
     * @param name that's the name of the module for jython
     * @param javaProject that's the project where it exists.
     */
    protected JavaModuleInProject(String name, IJavaProject javaProject) {
        super(name);
        this.javaProject = javaProject;

        if(DEBUG_CLASS_MODULE_IN_PROJECT){
            System.out.println("Created JavaClassModuleInProject: "+name);
        }

        this.tokens = createTokens(name);
        if(DEBUG_CLASS_MODULE_IN_PROJECT){
            System.out.println("JavaClassModuleInProject tokens:");
            for(IToken t:this.tokens){
                System.out.println(t.getRepresentation());
            }
        }

    }

    /**
     * @return whether it's a package or a class.
     */
    public boolean isPackage() {
        if(this.moduleType == UNKNOWN){
            throw new RuntimeException("Still can't determine whether it's a package or not.");
        }
        return this.moduleType == IS_PACKAGE;
    }

    /**
     * TODO: It doesn't have any file available?
     */
    @Override
    public File getFile() {
        return null;
    }

    /**
     * @see AbstractJavaClassModule#getJavaCompletionProposals(String, String)
     */
    @Override
    protected List<Tuple<IJavaElement, CompletionProposal>> getJavaCompletionProposals(String completeClassDesc, String filterCompletionName)
            throws Exception {
        String contents;
        if(filterCompletionName != null){
            //pre-filter it a bit if we already know the completion name
            contents = "new %s().%s";
            contents = StringUtils.format(contents, completeClassDesc, completeClassDesc, filterCompletionName);

        }else{
            contents = "new %s().";
            contents = StringUtils.format(contents, completeClassDesc, completeClassDesc);
        }

        return getJavaCompletionProposals(contents, contents.length(), filterCompletionName);
    }

    /**
     * @see AbstractJavaClassModule#getJavaCompletionProposals(String, int, String)
     * 
     * @note: the completionOffset is ignored (we find the type and go for the completions on that type).
     */
    @Override
    protected List<Tuple<IJavaElement, CompletionProposal>> getJavaCompletionProposals(String contents, int completionOffset,
            String filterCompletionName) throws Exception {
        try {
            IType type = this.javaProject.findType(name);

            final List<Tuple<IJavaElement, CompletionProposal>> ret = new ArrayList<Tuple<IJavaElement, CompletionProposal>>();

            //we only get actual completions on a class (otherwise, what we have is a package -- which is treated
            //as if it was an empty __init__.py file -- without any tokens).
            if(type != null){
                ICompilationUnit unit = type.getCompilationUnit();
                CompletionProposalCollector collector = createCollector(filterCompletionName, ret, unit);
                type.codeComplete(StringUtils.format(contents, name).toCharArray(), -1, 0, new char[0][0], new char[0][0], new int[0], false, collector);
            }

            if(this.moduleType == UNKNOWN){
                //if we found the type, it's a class (otherwise it's a package).
                this.moduleType = type==null?IS_PACKAGE:IS_CLASS;
            }

            return ret;
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }   

    }

}

--- NEW FILE: JavaZipModule.java ---
package org.python.pydev.editor.codecompletion.revisited.javaintegration;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.CompletionProposal;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.ui.text.java.CompletionProposalCollector;
import org.python.pydev.core.Tuple;
import org.python.pydev.core.docutils.StringUtils;
import org.python.pydev.editor.codecompletion.revisited.modules.EmptyModuleForZip;

/**
 * This is the module wrapper around java files or java packages.
 * 
 * Don't know how to make the completions for java correctly... check: 
 * http://www.eclipse.org/newsportal/article.php?id=68521&group=eclipse.platform#68521
 * 
 * @author Fabio
 */
public class JavaZipModule extends AbstractJavaClassModule {

    public static final boolean DEBUG_JARS = false;

    private File file;

    /**
     * If true, this represents a .class file in a zip, otherwise, it's a module representation.
     */
    private boolean isFileInZip;

    @Override
    public File getFile() {
        return file;
    }

    /**
     * If it's not a file in a zip, it's a folder (in which case it's a package).
     */
    public boolean isPackage() {
        return !this.isFileInZip;
    }

    private static HashMap<String, IClasspathEntry[]> classpathEntries = new HashMap<String, IClasspathEntry[]>();

    /**
     * @return the classpath entries that should be used to make the code-completion for this class.
     */
    protected synchronized IClasspathEntry[] getClasspathEntries() {
        return getClasspathEntries(this.file.getAbsolutePath());
    }

    /**
     * @return the classpath entries used in this class
     */
    private static synchronized IClasspathEntry[] getClasspathEntries(String path) {
        IClasspathEntry[] entry = classpathEntries.get(path);
        if(entry == null){
            entry = new IClasspathEntry[] { JavaCore.newLibraryEntry(Path.fromOSString(path), null, null, true) };
            classpathEntries.put(path, entry);
        }
        return entry;
    }

    /**
     * Creates a java class module from a .class in a jar.
     */
    public JavaZipModule(EmptyModuleForZip emptyModuleForZip) {
        super(emptyModuleForZip.getName());
        this.file = emptyModuleForZip.f;
        this.isFileInZip = emptyModuleForZip.isFile;

        if(DEBUG_JARS){
            System.out.println("Created JavaZipClassModule: "+name);
        }
        if(isFileInZip){
            //we only have tokens for a class 
            this.tokens = createTokens(name);
        }else{
            //otherwise, it's a folder (which is treated as a module without any tokens -- as an empty __init__.py file)
            this.tokens = EMPTY_ITOKEN;
        }

    }

    /**
     * Gets tuples with the java element and the corresponding completion proposal for that element.
     * 
     * @param completeClassDesc the name of the class from where we should get the tokens. E.g. java.lang.Class, javax.swing.JFrame
     * @param filterCompletionName if specified, only return matches from elements that have the name passed (otherwise it should be null)
     * @return a list of tuples corresponding to the element and the proposal for the gotten elements
     * @throws JavaModelException
     */
    protected List<Tuple<IJavaElement, CompletionProposal>> getJavaCompletionProposals(String completeClassDesc, final String filterCompletionName) throws JavaModelException {
        String contents;
        if(filterCompletionName != null){
            //pre-filter it a bit if we already know the completion name
            contents = "class CompletionClass {void main(){new %s().%s}}";
            contents = StringUtils.format(contents, completeClassDesc, filterCompletionName);

        }else{
            contents = "class CompletionClass {void main(){new %s().}}";
            contents = StringUtils.format(contents, completeClassDesc);
        }

        return getJavaCompletionProposals(contents, contents.length() - 2, filterCompletionName);
    }

    /**
     * Gets tuples with the java element and the corresponding completion proposal for that element.
     * 
     * @param contents the contents that should be set for doing the code-completion
     * @param completionOffset the offset where the code completion should be requested
     * @param filterCompletionName if specified, only return matches from elements that have the name passed (otherwise it should be null)
     * @return a list of tuples corresponding to the element and the proposal for the gotten elements
     * @throws JavaModelException
     */
    protected List<Tuple<IJavaElement, CompletionProposal>> getJavaCompletionProposals(String contents, int completionOffset, 
            final String filterCompletionName) throws JavaModelException {

        final List<Tuple<IJavaElement, CompletionProposal>> ret = new ArrayList<Tuple<IJavaElement, CompletionProposal>>();

        IClasspathEntry entries[] = getClasspathEntries();
        ICompilationUnit unit = new WorkingCopyOwner(){}.newWorkingCopy(name, entries, new NullProgressMonitor());
        unit.getBuffer().setContents(contents);
        CompletionProposalCollector collector = createCollector(filterCompletionName, ret, unit);

        unit.codeComplete(completionOffset, collector); //fill the completions while searching it
        return ret;
    }

}

Index: JythonModulesManagerUtils.java
===================================================================
RCS file: /cvsroot/pydev/org.python.pydev/src_completions/org/python/pydev/editor/codecompletion/revisited/javaintegration/JythonModulesManagerUtils.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** JythonModulesManagerUtils.java	6 Jan 2008 12:25:42 -0000	1.3
--- JythonModulesManagerUtils.java	9 Jan 2008 01:01:20 -0000	1.4
***************
*** 17,21 ****
      public static AbstractModule createModuleFromJar(EmptyModuleForZip emptyModuleForZip) throws JDTNotAvailableException{
          try{
!             return new JavaZipClassModule(emptyModuleForZip);
          }catch(Exception e){
              tryRethrowAsJDTNotAvailableException(e);
--- 17,21 ----
      public static AbstractModule createModuleFromJar(EmptyModuleForZip emptyModuleForZip) throws JDTNotAvailableException{
          try{
!             return new JavaZipModule(emptyModuleForZip);
          }catch(Exception e){
              tryRethrowAsJDTNotAvailableException(e);

Index: AbstractJavaClassModule.java
===================================================================
RCS file: /cvsroot/pydev/org.python.pydev/src_completions/org/python/pydev/editor/codecompletion/revisited/javaintegration/AbstractJavaClassModule.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** AbstractJavaClassModule.java	6 Jan 2008 12:25:42 -0000	1.1
--- AbstractJavaClassModule.java	9 Jan 2008 01:01:20 -0000	1.2
***************
*** 394,397 ****
--- 394,405 ----
          return collector;
      }
+     
+     /**
+      * For java, as we don't have __init__.py, the package folder name is always the actual name of the module
+      */
+     @Override
+     public String getPackageFolderName() {
+         return this.name;
+     }

  }