moduleadapter.java

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

package org.python.pydev.refactoring.ast.adapters;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.TextUtilities;
import org.python.pydev.core.ICodeCompletionASTManager;
import org.python.pydev.core.ICompletionState;
import org.python.pydev.core.IPythonNature;
import org.python.pydev.core.ISourceModule;
import org.python.pydev.core.IToken;
import org.python.pydev.core.structure.CompletionRecursionException;
import org.python.pydev.editor.codecompletion.revisited.CompletionState;
import org.python.pydev.editor.codecompletion.revisited.modules.CompiledToken;
import org.python.pydev.editor.codecompletion.revisited.modules.SourceToken;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.ast.ClassDef;
import org.python.pydev.parser.jython.ast.FunctionDef;
import org.python.pydev.parser.jython.ast.Module;
import org.python.pydev.parser.jython.ast.Str;
import org.python.pydev.plugin.PydevPlugin;
import org.python.pydev.refactoring.ast.adapters.offsetstrategy.BeginOffset;
import org.python.pydev.refactoring.ast.adapters.offsetstrategy.EndOffset;
import org.python.pydev.refactoring.ast.adapters.offsetstrategy.IOffsetStrategy;
import org.python.pydev.refactoring.ast.adapters.offsetstrategy.InitOffset;
import org.python.pydev.refactoring.ast.visitors.VisitorFactory;
import org.python.pydev.refactoring.ast.visitors.info.ImportVisitor;
import org.python.pydev.refactoring.core.FQIdentifier;
import org.python.pydev.refactoring.core.PythonModuleManager;

public class ModuleAdapter extends AbstractScopeNode<Module> {

	private List<FQIdentifier> aliasToFQIdentifier;

	private IDocument doc;

	private File file;

	private SortedMap<String, String> importedModules;

	private PythonModuleManager moduleManager;

	private IOffsetStrategy offsetStrategy;

	private ISourceModule sourceModule;

	private IPythonNature nature;
    
    public String getEndLineDelimiter(){
        return TextUtilities.getDefaultLineDelimiter(doc);
    }


	public ModuleAdapter(PythonModuleManager pm, File file, IDocument doc, Module node, IPythonNature nature) {
		super(null, null, node, TextUtilities.getDefaultLineDelimiter(doc));
//		Assert.isNotNull(pm); TODO: MAKE THIS ASSERTION TRUE
		this.moduleManager = pm;
		this.file = file;
		this.doc = doc;
		this.aliasToFQIdentifier = null;
		this.importedModules = null;
		this.nature = nature;
	}

	public ModuleAdapter(PythonModuleManager pm, ISourceModule module, IPythonNature nature) {
        super();
//		Assert.isNotNull(pm); TODO: MAKE THIS ASSERTION TRUE
        this.file = module.getFile();
        this.doc = PythonModuleManager.getDocFromFile(this.file);
        init(null, null, (Module) (module).getAst(), TextUtilities.getDefaultLineDelimiter(this.doc));
		this.sourceModule = module;
		this.moduleManager = pm;
		this.aliasToFQIdentifier = null;
		this.importedModules = null;
		this.nature = nature;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof ModuleAdapter) {
			String otherPath = ((ModuleAdapter) obj).getFile().getAbsolutePath();
			return this.file.getAbsolutePath().compareToIgnoreCase(otherPath) == 0;
		}
		return super.equals(obj);
	}

	public List<FQIdentifier> getAliasToIdentifier() {
		if (aliasToFQIdentifier == null)
			initAliasList();

		return aliasToFQIdentifier;
	}

	public List<IClassDefAdapter> getClassHierarchy(IClassDefAdapter scopeClass) {
		List<IClassDefAdapter> bases = new ArrayList<IClassDefAdapter>();

		resolveClassHierarchy(bases, scopeClass, new HashSet<String>());
		Collections.reverse(bases);
		bases.add(new ObjectAdapter(this, this, getEndLineDelimiter()));

		return bases;
	}

	public String getBaseContextName(IClassDefAdapter contextClass, String originalName) {
		originalName = resolveRealToAlias(originalName);
		for (String baseName : contextClass.getBaseClassNames()) {
			if (baseName.endsWith(originalName)) {
				return baseName;
			}
		}

		return originalName;
	}

	private String resolveRealToAlias(String originalName) {
		for (FQIdentifier identifier : getAliasToIdentifier()) {
			if (identifier.getRealName().compareTo(originalName) == 0) {
				originalName = identifier.getAlias();
			}
		}
		return originalName;
	}

	private File getFile() {
		return this.file;
	}

	public List<String> getGlobarVarNames() {
		List<String> globalNames = new ArrayList<String>();
		if(this.sourceModule != null && nature != null){
			try {
				ICodeCompletionASTManager astManager = nature.getAstManager();
				if(astManager != null){
					IToken[] tokens = astManager.getCompletionsForModule(this.sourceModule, new CompletionState(-1, -1, "", nature, ""));
					for (IToken token : tokens) {
						globalNames.add(token.getRepresentation());
					}
				}
			} catch (CompletionRecursionException e) {
				PydevPlugin.log(e);
			}
		}else{
			for (SimpleAdapter adapter : getAssignedVariables()) {
				globalNames.add(adapter.getName());
			}
		}
		return globalNames;
	}

	@Override
	public ModuleAdapter getModule() {
		return this;
	}

	@Override
	public AbstractScopeNode<?> getParent() {
		return this;
	}

	public int getOffset(IASTNodeAdapter adapter, int strategy) {
		int offset = 0;

		setStrategy(adapter, strategy);
		try {
			offset = offsetStrategy.getOffset();
		} catch (BadLocationException e) {
			// fallback :)
			String src = doc.get();
			int nameIndex = src.indexOf(adapter.getName());
			return src.indexOf(":", nameIndex) + 2;
		}
		return offset;
	}

	public SortedMap<String, String> getRegularImportedModules() {
		if (importedModules == null)
			initAliasList();

		return importedModules;
	}

	public IClassDefAdapter getScopeClass(ITextSelection selection) {
        IASTNodeAdapter bestClassScope = null;
		Iterator<IClassDefAdapter> iter = getClasses().iterator();
		while (iter.hasNext()) {
            IASTNodeAdapter classScope = (IASTNodeAdapter) iter.next();
			if (isSelectionInAdapter(selection, classScope)){
				bestClassScope = classScope;
            }

			if (classScope.getNodeFirstLine() > selection.getEndLine()){
				break;
            }

		}

		return (IClassDefAdapter) bestClassScope;
	}

	private void initAliasList() {
		ImportVisitor visitor = VisitorFactory.createVisitor(ImportVisitor.class, getASTNode());
		this.importedModules = visitor.getImportedModules();
		this.aliasToFQIdentifier = visitor.getAliasToFQIdentifier();
	}

	public boolean isGlobal(String name) {
		return getGlobarVarNames().contains(name);
	}

	private boolean isSelectionInAdapter(ITextSelection selection, IASTNodeAdapter adapter) {

		int startOffSet = selection.getOffset();
		int endOffSet = selection.getOffset() + selection.getLength();

		try {
			int lastLine = adapter.getNodeLastLine() - 1;
			int adapterStartOffset = doc.getLineOffset(adapter.getNodeFirstLine() - 1) + adapter.getNodeIndent() - 1;

			int adapterEndOffset = doc.getLineOffset(lastLine) + doc.getLineLength(lastLine);

			return (adapterStartOffset <= startOffSet && adapterEndOffset >= endOffSet);
		} catch (BadLocationException e) {

		}
		return false;
	}

	private boolean isAdapterInSelection(ITextSelection selection, IASTNodeAdapter adapter) {

		int startOffSet = selection.getOffset();
		int endOffSet = selection.getOffset() + selection.getLength();

		try {
			int adapterStartOffset = getStartOffset(adapter);

			return (adapterStartOffset >= startOffSet && adapterStartOffset < endOffSet);
		} catch (BadLocationException e) {

		}
		return false;
	}

	public int getEndOffset(IASTNodeAdapter adapter, int adapterStartOffset) throws BadLocationException {
		int lastLine = adapter.getNodeLastLine() - 1;

		int adapterEndOffset = 0;
		if (adapter.getASTNode() instanceof Str) {
			adapterEndOffset += adapterStartOffset + adapter.getName().length();
		} else {
			adapterEndOffset = doc.getLineOffset(lastLine) + doc.getLineLength(lastLine);
		}
		return adapterEndOffset;
	}

	public int getStartOffset(SimpleNode node) throws BadLocationException {
		return getStartOffset(new SimpleAdapter(this, this, node, getEndLineDelimiter()));
	}

	public int getStartOffset(IASTNodeAdapter adapter) throws BadLocationException {
		return doc.getLineOffset(adapter.getNodeFirstLine() - 1) + adapter.getNodeIndent() - 1;
	}

	public boolean isNodeInSelection(ITextSelection selection, SimpleNode node) {
		return isAdapterInSelection(selection, new SimpleAdapter(this, this, node, getEndLineDelimiter()));
	}

	private IClassDefAdapter resolveClassHierarchy(List<IClassDefAdapter> bases, IClassDefAdapter adap, Set<String> memo) {
		if (adap.hasBaseClass() && adap.getModule() != null) {
			
			List<IClassDefAdapter> baseClasses = adap.getModule().getBaseClasses(adap);
			for (IClassDefAdapter elem : baseClasses) {
				if (elem != null && !memo.contains(elem.getName())) {
					memo.add(elem.getName());
					bases.add(resolveClassHierarchy(bases, elem, memo));
				}
			}
		}

		return adap;
	}

	public List<IClassDefAdapter> getBaseClasses(IClassDefAdapter clazz) {

		List<String> baseNames = clazz.getBaseClassNames();
		List<IClassDefAdapter> bases = new ArrayList<IClassDefAdapter>();
		Set<String> importedBaseNames = new HashSet<String>();
		List<IClassDefAdapter> moduleClasses = getClasses();
		for (IClassDefAdapter adapter : moduleClasses) {
			for (String baseName : baseNames) {

				if (baseName.compareTo(adapter.getName()) == 0) {
					bases.add(adapter);
				} else {
					importedBaseNames.add(baseName);
				}
			}
		}

		bases.addAll(resolveImportedClass(importedBaseNames));