/**
* This function creates a module and resolves the module name (use this function if only the file
* is available).
*
* @throws MisconfigurationException
*/
public static IModule createModuleFromDoc(File file, IDocument doc, IPythonNature pythonNature)
throws MisconfigurationException {
IModulesManager projModulesManager = pythonNature.getAstManager().getModulesManager();
String moduleName = null;
if (file != null) {
moduleName = projModulesManager.resolveModule(FileUtils.getFileAbsolutePath(file));
}
if (moduleName == null) {
moduleName = MODULE_NAME_WHEN_FILE_IS_UNDEFINED;
}
IModule module = createModuleFromDoc(moduleName, file, doc, pythonNature, false);
return module;
}
public static ModuleAdapter createModuleAdapter(
PythonModuleManager pythonModuleManager, File file, IDocument doc, IPythonNature nature)
throws Throwable {
if (file != null && file.exists()) {
if (pythonModuleManager != null) {
IModulesManager modulesManager = pythonModuleManager.getIModuleManager();
if (modulesManager != null) {
String modName = modulesManager.resolveModule(REF.getFileAbsolutePath(file));
if (modName != null) {
IModule module = modulesManager.getModule(modName, nature, true);
if (module instanceof ISourceModule) {
SourceModule iSourceModule = (SourceModule) module;
if (iSourceModule.parseError != null) {
throw iSourceModule.parseError;
}
return new ModuleAdapter(pythonModuleManager, ((ISourceModule) module), nature, doc);
}
}
}
}
}
return new ModuleAdapter(pythonModuleManager, file, doc, getRootNode(doc), nature);
}
/** @param version IPythonNature.PYTHON_VERSION_XXX */
protected ModuleAdapter createModuleAdapterFromDataSource(String version) throws Throwable {
codeCompletionTestsBase.restorePythonPath(
REF.getFileAbsolutePath(data.file.getParentFile()), true);
PythonModuleManager pythonModuleManager =
new PythonModuleManager(CodeCompletionTestsBase.nature);
if (version != null) {
// As the files will be found in the system, we need to set the system modules manager info.
IModulesManager modulesManager = pythonModuleManager.getIModuleManager();
SystemModulesManager systemModulesManager =
(SystemModulesManager) modulesManager.getSystemModulesManager();
systemModulesManager.setInfo(new InterpreterInfo(version, "", new ArrayList<String>()));
CodeCompletionTestsBase.nature.setVersion(version, null);
}
ModuleAdapter module =
VisitorFactory.createModuleAdapter(
pythonModuleManager,
data.file,
new Document(data.source),
CodeCompletionTestsBase.nature,
CodeCompletionTestsBase.nature);
return module;
}
/** @param module - module from where to get completions. */
@SuppressWarnings("unchecked")
private CompiledModule(String name, int tokenTypes, IModulesManager manager) {
super(name);
isPythonBuiltin = ("__builtin__".equals(name) || "builtins".equals(name));
if (COMPILED_MODULES_ENABLED) {
try {
setTokens(name, manager);
} catch (Exception e) {
// ok, something went wrong... let's give it another shot...
synchronized (this) {
try {
wait(10);
} catch (InterruptedException e1) {
// empty block
} // just wait a little before a retry...
}
try {
AbstractShell shell =
AbstractShell.getServerShell(manager.getNature(), AbstractShell.COMPLETION_SHELL);
synchronized (shell) {
shell.clearSocket();
}
setTokens(name, manager);
} catch (Exception e2) {
tokens = new HashMap<String, IToken>();
Log.log(e2);
}
}
} else {
// not used if not enabled.
tokens = new HashMap<String, IToken>();
}
List<IModulesObserver> participants =
ExtensionHelper.getParticipants(ExtensionHelper.PYDEV_MODULES_OBSERVER);
if (participants != null) {
for (IModulesObserver observer : participants) {
observer.notifyCompiledModuleCreated(this, manager);
}
}
}
/**
* Restores the info for a module manager
*
* @param monitor a monitor to keep track of the progress
* @param m the module manager
* @param nature the associated nature (may be null if there is no associated nature -- as is the
* case when restoring system info).
* @return the info generated from the module manager
*/
public static AbstractAdditionalTokensInfo restoreInfoForModuleManager(
IProgressMonitor monitor,
IModulesManager m,
String additionalFeedback,
AbstractAdditionalTokensInfo info,
IPythonNature nature,
int grammarVersion) {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
// TODO: Check if keeping a zip file open makes things faster...
// Timer timer = new Timer();
ModulesKey[] allModules = m.getOnlyDirectModules();
int i = 0;
FastStringBuffer msgBuffer = new FastStringBuffer();
for (ModulesKey key : allModules) {
if (monitor.isCanceled()) {
return null;
}
i++;
if (PythonPathHelper.canAddAstInfoFor(
key)) { // otherwise it should be treated as a compiled module (no ast generation)
if (i % 17 == 0) {
msgBuffer.clear();
msgBuffer.append("Creating ");
msgBuffer.append(additionalFeedback);
msgBuffer.append(" additional info (");
msgBuffer.append(i);
msgBuffer.append(" of ");
msgBuffer.append(allModules.length);
msgBuffer.append(") for ");
msgBuffer.append(key.file.getName());
monitor.setTaskName(msgBuffer.toString());
monitor.worked(1);
}
try {
if (info.addAstInfo(key, false) == null) {
String str = "Unable to generate ast -- using %s.\nError:%s";
ErrorDescription errorDesc = null;
throw new RuntimeException(
com.aptana.shared_core.string.StringUtils.format(
str,
PyParser.getGrammarVersionStr(grammarVersion),
(errorDesc != null && errorDesc.message != null)
? errorDesc.message
: "unable to determine"));
}
} catch (Throwable e) {
Log.log(IStatus.ERROR, "Problem parsing the file :" + key.file + ".", e);
}
}
}
// timer.printDiff("Time to restore additional info");
return info;
}
private void setTokens(String name, IModulesManager manager)
throws IOException, Exception, CoreException {
if (TRACE_COMPILED_MODULES) {
Log.log(IStatus.INFO, ("Compiled modules: getting info for:" + name), null);
}
final IPythonNature nature = manager.getNature();
AbstractShell shell = AbstractShell.getServerShell(nature, AbstractShell.COMPLETION_SHELL);
synchronized (shell) {
Tuple<String, List<String[]>> completions =
shell.getImportCompletions(
name,
manager.getCompletePythonPath(
nature.getProjectInterpreter(),
nature.getRelatedInterpreterManager())); // default
if (TRACE_COMPILED_MODULES) {
Log.log(
IStatus.INFO,
("Compiled modules: "
+ name
+ " file: "
+ completions.o1
+ " found: "
+ completions.o2.size()
+ " completions."),
null);
}
String fPath = completions.o1;
if (fPath != null) {
if (!fPath.equals("None")) {
this.file = new File(fPath);
}
String f = fPath;
if (f.toLowerCase().endsWith(".pyc")) {
f = f.substring(0, f.length() - 1); // remove the c from pyc
File f2 = new File(f);
if (f2.exists()) {
this.file = f2;
}
}
}
ArrayList<IToken> array = new ArrayList<IToken>();
for (String[] element : completions.o2) {
// let's make this less error-prone.
try {
String o1 = element[0]; // this one is really, really needed
String o2 = "";
String o3 = "";
if (element.length > 0) {
o2 = element[1];
}
if (element.length > 0) {
o3 = element[2];
}
IToken t;
if (element.length > 0) {
t = new CompiledToken(o1, o2, o3, name, Integer.parseInt(element[3]));
} else {
t = new CompiledToken(o1, o2, o3, name, IToken.TYPE_BUILTIN);
}
array.add(t);
} catch (Exception e) {
String received = "";
for (int i = 0; i < element.length; i++) {
received += element[i];
received += " ";
}
Log.log(
IStatus.ERROR,
("Error getting completions for compiled module "
+ name
+ " received = '"
+ received
+ "'"),
e);
}
}
// as we will use it for code completion on sources that map to modules, the __file__ should
// also
// be added...
if (array.size() > 0 && (name.equals("__builtin__") || name.equals("builtins"))) {
array.add(new CompiledToken("__file__", "", "", name, IToken.TYPE_BUILTIN));
array.add(new CompiledToken("__name__", "", "", name, IToken.TYPE_BUILTIN));
array.add(new CompiledToken("__builtins__", "", "", name, IToken.TYPE_BUILTIN));
array.add(new CompiledToken("__dict__", "", "", name, IToken.TYPE_BUILTIN));
}
addTokens(array);
}
}
