/**
* This method will wait some time until the given nature is properly configured with the ast
* manager.
*/
protected void waitForNatureToBeRecreated(PythonNature nature) {
// Let's give it some time to run the jobs that restore the nature
long finishAt = System.currentTimeMillis() + 5000; // 5 secs is the max time
Display display = Display.getCurrent();
if (display == null) {
display = Display.getDefault();
}
Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
if (finishAt < System.currentTimeMillis()) {
break;
}
if (nature != null) {
if (nature.getAstManager() != null) {
break;
}
}
}
assertTrue(nature != null);
assertTrue(nature.getAstManager() != null);
}
private String checkValidSourceFolder(String text) throws CoreException {
validatedSourceFolder = null;
if (text == null || text.trim().length() == 0) {
return "The source folder must be filled.";
}
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IResource resource = root.findMember(new Path(text));
if (resource == null) {
return "The source folder was not found in the workspace.";
}
if (!(resource instanceof IContainer)) {
return "The source folder was found in the workspace but is not a container.";
}
IProject project = resource.getProject();
if (project == null) {
return "Unable to find the project related to the source folder.";
}
IPythonPathNature nature = PythonNature.getPythonPathNature(project);
if (nature == null) {
return "The pydev nature is not configured on the project: " + project.getName();
}
String full = resource.getFullPath().toString();
String[] srcPaths = PythonNature.getStrAsStrItems(nature.getProjectSourcePath(true));
for (String str : srcPaths) {
if (str.equals(full)) {
validatedSourceFolder = (IContainer) resource;
return null;
}
}
return "The selected source folder is not recognized as a valid source folder.";
}
/**
* @param f
* @return
* @throws CoreException
*/
public String getSrcFolderFromFolder(IFolder f) throws CoreException {
IPythonPathNature nature = PythonNature.getPythonPathNature(f.getProject());
if (nature != null) {
String[] srcPaths = PythonNature.getStrAsStrItems(nature.getProjectSourcePath(true));
String relFolder = f.getFullPath().toString() + "/";
for (String src : srcPaths) {
if (relFolder.startsWith(src + "/")) {
return src;
}
}
}
return null;
}
/** @return the natures that were created. */
public static List<PythonNature> getInitializedPythonNatures() {
ArrayList<PythonNature> ret = new ArrayList<PythonNature>();
synchronized (createdNatures) {
for (Iterator<WeakReference<PythonNature>> it = createdNatures.iterator(); it.hasNext(); ) {
PythonNature pythonNature = it.next().get();
if (pythonNature == null) {
it.remove();
} else if (pythonNature.getProject() != null) {
ret.add(pythonNature);
}
}
}
return ret;
}
public static List<IPythonNature> getPythonNaturesRelatedTo(int relatedTo) {
ArrayList<IPythonNature> ret = new ArrayList<IPythonNature>();
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject[] projects = root.getProjects();
for (IProject project : projects) {
PythonNature nature = getPythonNature(project);
try {
if (nature != null) {
if (nature.getInterpreterType() == relatedTo) {
ret.add(nature);
}
}
} catch (CoreException e) {
throw new RuntimeException(e);
}
}
return ret;
}
/**
* @return an array with the vm arguments in the given configuration.
* @throws CoreException
*/
private String[] getVMArguments(ILaunchConfiguration configuration) throws CoreException {
String args = configuration.getAttribute(Constants.ATTR_VM_ARGUMENTS, (String) null);
if (args != null && args.trim().length() > 0) {
String expanded =
getStringSubstitution(PythonNature.getPythonNature(project))
.performStringSubstitution(args);
return parseStringIntoList(expanded);
}
return null;
}
protected void discoverDefaultVersion(final String projectType, final String projectInterpreter) {
defaultVersion =
DJANGO_14; // It should be discovered below, but if not found for some reason, this will be
// the default.
SystemPythonNature nature;
try {
final int interpreterType = PythonNature.getInterpreterTypeFromVersion(projectType);
IInterpreterManager interpreterManagerFromType =
PydevPlugin.getInterpreterManagerFromType(interpreterType);
IInterpreterInfo interpreterInfo;
if (IPythonNature.DEFAULT_INTERPRETER.equals(projectInterpreter)) {
interpreterInfo = interpreterManagerFromType.getDefaultInterpreterInfo(false);
} else {
interpreterInfo = interpreterManagerFromType.getInterpreterInfo(projectInterpreter, null);
}
nature = new SystemPythonNature(interpreterManagerFromType, interpreterInfo);
AbstractRunner runner = UniversalRunner.getRunner(nature);
Tuple<String, String> output =
runner.runCodeAndGetOutput(
GET_DJANGO_VERSION, new String[] {}, null, new NullProgressMonitor());
String err = output.o2.trim();
String out = output.o1.trim();
if (err.length() > 0) {
Log.log("Error attempting to determine Django version: " + err);
} else {
// System.out.println("Gotten version: "+out);
if (out.startsWith("0.")) {
setDefaultVersion(DjangoSettingsPage.DJANGO_11_OR_EARLIER);
} else if (out.startsWith("1.")) {
out = out.substring(2);
if (out.startsWith("0") || out.startsWith("1")) {
setDefaultVersion(DjangoSettingsPage.DJANGO_11_OR_EARLIER);
} else if (out.startsWith("2") || out.startsWith("3")) {
setDefaultVersion(DjangoSettingsPage.DJANGO_12_OR_13);
} else {
// Later version
setDefaultVersion(DjangoSettingsPage.DJANGO_14);
}
}
}
} catch (Exception e) {
Log.log("Unable to determine Django version.", e);
}
}
public static IPythonNature addNature(IEditorInput element) {
if (element instanceof FileEditorInput) {
IFile file = (IFile) ((FileEditorInput) element).getAdapter(IFile.class);
if (file != null) {
try {
return PythonNature.addNature(file.getProject(), null, null, null, null, null, null);
} catch (CoreException e) {
Log.log(e);
}
}
}
return null;
}
/**
* Can be used to extract the pythonpath used from a given configuration.
*
* @param conf the configuration from where we want to get the pythonpath
* @return a string with the pythonpath used (with | as a separator)
* @throws CoreException
* @throws InvalidRunException
* @throws MisconfigurationException
*/
public static String getPythonpathFromConfiguration(
ILaunchConfiguration conf, IInterpreterManager manager)
throws CoreException, InvalidRunException, MisconfigurationException {
IProject p = getProjectFromConfiguration(conf);
PythonNature pythonNature = PythonNature.getPythonNature(p);
if (pythonNature == null) {
throw new CoreException(
PydevDebugPlugin.makeStatus(
IStatus.ERROR, "Project should have a python nature: " + p.getName(), null));
}
IInterpreterInfo l = getInterpreterLocation(conf, pythonNature, manager);
return SimpleRunner.makePythonPathEnvString(pythonNature, l, manager);
}
/**
* Create a project with the structure:
*
* <p>/pydev_unit_test_project junit.jar <-- set in pythonpath /src <-- set in pythonpath /pack1
* __init__.py /pack2 __init__.py mod1.py
*
* <p>/java_unit_test_project /src <-- set in classpath JavaDefault.java (default package)
* /javamod1/JavaClass.java /javamod2/JavaClass.java
*
* <p>Note: the initialization of the structure will happen only once and will be re-used in all
* the tests after it.
*/
@Override
protected void setUp() throws Exception {
closeWelcomeView();
String mod1Contents = "import java.lang.Class\njava.lang.Class";
if (editor == null) {
InterpreterInfo.configurePathsCallback =
new ICallback<Boolean, Tuple<List<String>, List<String>>>() {
public Boolean call(Tuple<List<String>, List<String>> arg) {
return Boolean.TRUE;
}
};
PydevPlugin.setJythonInterpreterManager(
new JythonInterpreterManager(PydevPlugin.getDefault().getPluginPreferences()));
PydevPlugin.setPythonInterpreterManager(
new PythonInterpreterManager(PydevPlugin.getDefault().getPluginPreferences()));
ProjectModulesManager.IN_TESTS = true;
NullProgressMonitor monitor = new NullProgressMonitor();
createJythonInterpreterManager(monitor);
createPythonInterpreterManager(monitor);
IProject project = createProject(monitor, "pydev_unit_test_project");
IJavaProject javaProject =
configureAsJavaProject(createProject(monitor, "java_unit_test_project"), monitor);
setProjectReference(monitor, project, javaProject);
createJunitJar(monitor, project);
createGrinderJar(monitor, project);
IFolder sourceFolder = createSourceFolder(monitor, project);
initFile = createPackageStructure(sourceFolder, "pack1.pack2", monitor);
mod1 = initFile.getParent().getFile(new Path("mod1.py"));
// OK, structure created, now, let's open mod1.py with a PyEdit so that the tests can begin...
// create the contents and open the editor
mod1.create(new ByteArrayInputStream(mod1Contents.getBytes()), true, monitor);
PythonNature nature = PythonNature.getPythonNature(project);
waitForNatureToBeRecreated(nature);
editor = (PyEdit) PyOpenEditor.doOpenEditor(mod1);
} else {
setFileContents(mod1Contents); // just make sure that the contents of mod1 are correct.
}
}
/** Utility routine to remove a PythonNature from a project. */
public static synchronized void removeNature(IProject project, IProgressMonitor monitor)
throws CoreException {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
PythonNature nature = PythonNature.getPythonNature(project);
if (nature == null) {
return;
}
try {
// we have to set the nature store to stop listening changes to .pydevproject
nature.pythonNatureStore.setProject(null);
} catch (Exception e) {
Log.log(e);
}
try {
// we have to remove the project from the pythonpath nature too...
nature.pythonPathNature.setProject(null, null);
} catch (Exception e) {
Log.log(e);
}
// notify listeners that the pythonpath nature is now empty for this project
try {
PythonNatureListenersManager.notifyPythonPathRebuilt(project, null);
} catch (Exception e) {
Log.log(e);
}
try {
// actually remove the pydev configurations
IResource member = project.findMember(".pydevproject");
if (member != null) {
member.delete(true, null);
}
} catch (CoreException e) {
Log.log(e);
}
// and finally... remove the nature
IProjectDescription description = project.getDescription();
List<String> natures = new ArrayList<String>(Arrays.asList(description.getNatureIds()));
natures.remove(PYTHON_NATURE_ID);
description.setNatureIds(natures.toArray(new String[natures.size()]));
project.setDescription(description, monitor);
}
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
if (element instanceof IAdaptable) {
IAdaptable adaptable = (IAdaptable) element;
Object adapted = adaptable.getAdapter(IProject.class);
if (adapted instanceof IProject) {
IProject project = (IProject) adapted;
if (!project.isOpen()) {
return true; // As we don't know about the nature of closed projects, don't filter it out.
}
return PythonNature.getPythonNature(project) != null;
}
}
return true;
}
/**
* Creates a source folder and configures the project to use it and the junit.jar
*
* @param addNature if false, no nature will be initially added to the project (if true, the
* nature will be added)
*/
protected IFolder createSourceFolder(
IProgressMonitor monitor, IProject project, boolean addNature) throws CoreException {
IFolder sourceFolder = project.getFolder(new Path("src"));
if (!sourceFolder.exists()) {
sourceFolder.create(true, true, monitor);
}
if (addNature) {
PythonNature.addNature(
project,
monitor,
PythonNature.JYTHON_VERSION_2_1,
"/pydev_unit_test_project/src|/pydev_unit_test_project/junit.jar|/pydev_unit_test_project/grinder.jar",
null,
null,
null);
}
return sourceFolder;
}
/** @return The nature to be used for this breakpoint or null if it cannot be determined. */
private IPythonNature getPythonNature() {
IMarker marker = getMarker();
IPythonNature nature = PythonNature.getPythonNature(marker.getResource());
if (nature == null) {
try {
String externalPath = (String) marker.getAttribute(PyBreakpoint.PY_BREAK_EXTERNAL_PATH_ID);
if (externalPath != null) {
Tuple<IPythonNature, String> infoForFile =
PydevPlugin.getInfoForFile(new File(externalPath));
if (infoForFile != null) {
nature = infoForFile.o1;
}
}
} catch (CoreException e) {
throw new RuntimeException(e);
}
}
return nature;
}
/** Actually remove the python nature from the project. */
public void run(IAction action) {
if (selectedProject == null) {
return;
}
if (!MessageDialog.openConfirm(
null,
"Confirm Remove Pydev Nature",
org.python.pydev.shared_core.string.StringUtils.format(
"Are you sure that you want to remove the Pydev nature from %s?",
selectedProject.getName()))) {
return;
}
try {
PythonNature.removeNature(selectedProject, null);
} catch (Throwable e) {
Log.log(e);
}
}
/**
* Gets it using all the natures that match a given interpreter manager.
*
* @throws MisconfigurationException
*/
private static void getFromManagerAndRelatedNatures(
String selectedText, IInterpreterManager useManager) {
AbstractAdditionalTokensInfo additionalSystemInfo;
try {
additionalSystemInfo =
AdditionalSystemInterpreterInfo.getAdditionalSystemInfo(
useManager, useManager.getDefaultInterpreterInfo().getExecutableOrJar());
} catch (MisconfigurationException e) {
MessageDialog.openError(
getShell(),
"Error",
"Additional info is not available (default interpreter not configured).");
handle(e);
return;
}
List<AbstractAdditionalTokensInfo> additionalInfo =
new ArrayList<AbstractAdditionalTokensInfo>();
additionalInfo.add(additionalSystemInfo);
List<IPythonNature> natures =
PythonNature.getPythonNaturesRelatedTo(useManager.getInterpreterType());
for (IPythonNature nature : natures) {
AbstractAdditionalDependencyInfo info;
try {
info = AdditionalProjectInterpreterInfo.getAdditionalInfoForProject(nature);
if (info != null) {
additionalInfo.add(info);
}
} catch (MisconfigurationException e) {
// just go on to the next nature if one is not properly configured.
handle(e);
}
}
doSelect(natures, additionalInfo, selectedText);
}
/*
* (non-Javadoc)
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)
*/
public void initializeFrom(ILaunchConfiguration configuration) {
try {
String id = configuration.getType().getIdentifier();
IInterpreterManager manager = null;
if (Constants.ID_JYTHON_LAUNCH_CONFIGURATION_TYPE.equals(id)
|| Constants.ID_JYTHON_UNITTEST_LAUNCH_CONFIGURATION_TYPE.equals(id)) {
manager = PydevPlugin.getJythonInterpreterManager();
} else if (Constants.ID_IRONPYTHON_LAUNCH_CONFIGURATION_TYPE.equals(id)
|| Constants.ID_IRONPYTHON_UNITTEST_LAUNCH_CONFIGURATION_TYPE.equals(id)) {
manager = PydevPlugin.getIronpythonInterpreterManager();
} else if (Constants.ID_PYTHON_REGULAR_LAUNCH_CONFIGURATION_TYPE.equals(id)
|| Constants.ID_PYTHON_COVERAGE_LAUNCH_CONFIGURATION_TYPE.equals(id)
|| Constants.ID_PYTHON_UNITTEST_LAUNCH_CONFIGURATION_TYPE.equals(id)) {
manager = PydevPlugin.getPythonInterpreterManager();
} else {
// Get from the project
try {
// could throw core exception if project does not exist.
IProject project = PythonRunnerConfig.getProjectFromConfiguration(configuration);
PythonNature nature = PythonNature.getPythonNature(project);
if (nature != null) {
manager = PydevPlugin.getInterpreterManager(nature);
}
} catch (Exception e) {
Log.log(e);
}
if (manager == null) {
Log.log("Could not recognize: '" + id + "' using default python interpreter manager.");
manager = PydevPlugin.getPythonInterpreterManager();
}
}
String pythonPath = PythonRunnerConfig.getPythonpathFromConfiguration(configuration, manager);
fPythonPathList.removeAll();
java.util.List<String> paths = SimpleRunner.splitPythonpath(pythonPath);
for (String p : paths) {
fPythonPathList.add(p);
}
setErrorMessage(null);
} catch (Exception e) {
// Exceptions here may have several reasons
// - The interpreter is incorrectly configured
// - The arguments use an unresolved variable.
// In each case, the exception contains a meaningful message, that is displayed
Log.log(e);
String message = e.getMessage();
if (message == null) {
message = "null (see error log for the traceback).";
}
String errorMsg =
org.python.pydev.shared_core.string.StringUtils.replaceNewLines(message, " ");
fPythonPathList.removeAll();
fPythonPathList.add(errorMsg);
setErrorMessage(errorMsg);
}
}
/**
* Utility routine to add PythonNature to the project
*
* @param projectPythonpath: @see {@link IPythonPathNature#setProjectSourcePath(String)}
*/
public static synchronized IPythonNature addNature(
IProject project,
IProgressMonitor monitor,
String version,
String projectPythonpath,
String externalProjectPythonpath,
String projectInterpreter,
Map<String, String> variableSubstitution)
throws CoreException {
if (project == null || !project.isOpen()) {
return null;
}
if (monitor == null) {
monitor = new NullProgressMonitor();
}
if (projectInterpreter == null) {
projectInterpreter = IPythonNature.DEFAULT_INTERPRETER;
}
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);
} else {
// Return if it already has the nature configured.
IProjectNature n = getPythonNature(project);
if (n instanceof IPythonNature) {
return (IPythonNature) n;
}
}
// 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 = getPythonNature(project);
if (n instanceof PythonNature) {
PythonNature nature = (PythonNature) n;
// call initialize always - let it do the control.
nature.init(
version,
projectPythonpath,
externalProjectPythonpath,
monitor,
projectInterpreter,
variableSubstitution);
return nature;
}
return null;
}
/**
* Create a command line for launching.
*
* @param actualRun if true it'll make the variable substitution and start the listen connector in
* the case of a debug session.
* @return command line ready to be exec'd
* @throws CoreException
* @throws JDTNotAvailableException
*/
public String[] getCommandLine(boolean actualRun) throws CoreException, JDTNotAvailableException {
List<String> cmdArgs = new ArrayList<String>();
if (isJython()) {
// "java.exe" -classpath "C:\bin\jython21\jython.jar" org.python.util.jython script %ARGS%
String javaLoc = JavaVmLocationFinder.findDefaultJavaExecutable().getAbsolutePath();
if (!InterpreterInfo.isJythonExecutable(interpreter.toOSString())) {
throw new RuntimeException(
"The jython jar must be specified as the interpreter to run. Found: " + interpreter);
}
cmdArgs.add(javaLoc);
// some nice things on the classpath config: http://mindprod.com/jgloss/classpath.html
cmdArgs.add("-classpath");
String cpath;
// TODO: add some option in the project so that the user can choose to use the
// classpath specified in the java project instead of the pythonpath itself
// if (project.getNature(Constants.JAVA_NATURE) != null){
// cpath = getClasspath(JavaCore.create(project));
// } else {
cpath = interpreter + SimpleRunner.getPythonPathSeparator() + pythonpathUsed;
// }
cmdArgs.add(cpath);
cmdArgs.add(
"-Dpython.path="
+ pythonpathUsed); // will be added to the env variables in the run (check if this
// works on all platforms...)
addVmArgs(cmdArgs);
if (isDebug) {
// This was removed because it cannot be used. See:
// http://bugs.jython.org/issue1438
// cmdArgs.add("-Dpython.security.respectJavaAccessibility=false");
cmdArgs.add("org.python.util.jython");
addDebugArgs(cmdArgs, "jython", actualRun);
} else {
cmdArgs.add("org.python.util.jython");
}
} else {
// python or iron python
cmdArgs.add(interpreter.toOSString());
// Next option is for unbuffered stdout, otherwise Eclipse will not see any output until done
cmdArgs.add("-u");
addVmArgs(cmdArgs);
if (isDebug && isIronpython()) {
addIronPythonDebugVmArgs(cmdArgs);
}
addDebugArgs(cmdArgs, "python", actualRun);
}
// Check if we should do code-coverage...
boolean coverageRun = PyCoveragePreferences.getAllRunsDoCoverage();
if (coverageRun && isDebug) {
if (actualRun) {
RunInUiThread.async(
new Runnable() {
public void run() {
PyDialogHelpers.openWarning(
"Conflicting options: coverage with debug.",
"Making a debug run with coverage enabled will not yield the expected results.\n\n"
+ "They'll conflict because both use the python tracing facility (i.e.: sys.settrace()).\n"
+ "\n"
+ "To debug a coverage run, do a regular run and use the remote debugger "
+ "(but note that the coverage will stop when it's enabled).\n"
+ "\n"
+ "Note: the run will be continued anyways.");
}
});
}
}
if (isUnittest()) {
cmdArgs.add(getRunFilesScript());
} else {
if (coverageRun) {
// Separate support (unittest has the coverage support builtin).
cmdArgs.add(getCoverageScript());
cmdArgs.add(PyCoverage.getCoverageFileLocation().getAbsolutePath());
cmdArgs.add("run");
cmdArgs.add("--source");
cmdArgs.add(PyCodeCoverageView.getChosenDir().getLocation().toOSString());
}
}
for (IPath p : resource) {
cmdArgs.add(p.toOSString());
}
if (!isUnittest()) {
// The program arguments are not used when running a unittest (excluded from the tab group in
// favor
// of a way to overriding the default unittest arguments).
String runArguments[] = null;
if (actualRun && arguments != null) {
String expanded =
getStringSubstitution(PythonNature.getPythonNature(project))
.performStringSubstitution(arguments);
runArguments = parseStringIntoList(expanded);
}
for (int i = 0; runArguments != null && i < runArguments.length; i++) {
cmdArgs.add(runArguments[i]);
}
} else {
// Last thing (first the files and last the special parameters the user passed -- i.e.: nose
// parameters)
addUnittestArgs(cmdArgs, actualRun, coverageRun);
}
String[] retVal = new String[cmdArgs.size()];
cmdArgs.toArray(retVal);
if (actualRun) {
CreatedCommandLineParams createdCommandLineParams =
new CreatedCommandLineParams(retVal, coverageRun);
// Provide a way for clients to alter the command line.
List<Object> participants =
ExtensionHelper.getParticipants(ExtensionHelper.PYDEV_COMMAND_LINE_PARTICIPANT);
for (Object object : participants) {
try {
IPyCommandLineParticipant c = (IPyCommandLineParticipant) object;
createdCommandLineParams = c.updateCommandLine(createdCommandLineParams);
} catch (Exception e) {
Log.log(e);
}
}
retVal = createdCommandLineParams.cmdLine;
PythonRunnerCallbacks.onCreatedCommandLine.call(createdCommandLineParams);
}
return retVal;
}
/**
* Sets defaults.
*
* @throws InvalidRunException
* @throws MisconfigurationException
*/
@SuppressWarnings("unchecked")
public PythonRunnerConfig(
ILaunchConfiguration conf, String mode, String run, boolean makeArgumentsVariableSubstitution)
throws CoreException, InvalidRunException, MisconfigurationException {
// 1st thing, see if this is a valid run.
project = getProjectFromConfiguration(conf);
if (project == null) { // Ok, we could not find it out
throw Log.log("Could not get project for configuration: " + conf);
}
// We need the project to find out the default interpreter from the InterpreterManager.
IPythonNature pythonNature = PythonNature.getPythonNature(project);
if (pythonNature == null) {
CoreException e = Log.log("No python nature for project: " + project.getName());
throw e;
}
// now, go on configuring other things
this.configuration = conf;
this.run = run;
isDebug = mode.equals(ILaunchManager.DEBUG_MODE);
isInteractive = mode.equals("interactive");
resource = getLocation(conf, pythonNature);
arguments = getArguments(conf, makeArgumentsVariableSubstitution);
IPath workingPath = getWorkingDirectory(conf, pythonNature);
workingDirectory = workingPath == null ? null : workingPath.toFile();
acceptTimeout = PydevPrefs.getPreferences().getInt(PydevEditorPrefs.CONNECT_TIMEOUT);
interpreterLocation =
getInterpreterLocation(conf, pythonNature, this.getRelatedInterpreterManager());
interpreter = getInterpreter(interpreterLocation, conf, pythonNature);
// make the environment
ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
envp = launchManager.getEnvironment(conf);
IInterpreterManager manager;
if (isJython()) {
manager = PydevPlugin.getJythonInterpreterManager();
} else if (isIronpython()) {
manager = PydevPlugin.getIronpythonInterpreterManager();
} else {
manager = PydevPlugin.getPythonInterpreterManager();
}
boolean win32 = PlatformUtils.isWindowsPlatform();
if (envp == null) {
// ok, the user has done nothing to the environment, just get all the default environment
// which has the pythonpath in it
envp = SimpleRunner.getEnvironment(pythonNature, interpreterLocation, manager);
} else {
// ok, the user has done something to configure it, so, just add the pythonpath to the
// current env (if he still didn't do so)
Map envMap = conf.getAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, (Map) null);
String pythonpath =
SimpleRunner.makePythonPathEnvString(pythonNature, interpreterLocation, manager);
updateVar(pythonNature, manager, win32, envMap, "PYTHONPATH", pythonpath);
if (isJython()) {
// Also update the classpath env variable.
updateVar(pythonNature, manager, win32, envMap, "CLASSPATH", pythonpath);
// And the jythonpath env variable
updateVar(pythonNature, manager, win32, envMap, "JYTHONPATH", pythonpath);
} else if (isIronpython()) {
// Also update the ironpythonpath env variable.
updateVar(pythonNature, manager, win32, envMap, "IRONPYTHONPATH", pythonpath);
}
// And we also must get the environment variables specified in the interpreter manager.
envp = interpreterLocation.updateEnv(envp, envMap.keySet());
}
boolean hasDjangoNature = project.hasNature(PythonNature.DJANGO_NATURE_ID);
String settingsModule = null;
Map<String, String> variableSubstitution = null;
final String djangoSettingsKey = "DJANGO_SETTINGS_MODULE";
String djangoSettingsEnvEntry = null;
try {
variableSubstitution = pythonNature.getPythonPathNature().getVariableSubstitution();
settingsModule = variableSubstitution.get(djangoSettingsKey);
if (settingsModule != null) {
if (settingsModule.trim().length() > 0) {
djangoSettingsEnvEntry = djangoSettingsKey + "=" + settingsModule.trim();
}
}
} catch (Exception e1) {
Log.log(e1);
}
if (djangoSettingsEnvEntry == null && hasDjangoNature) {
// Default if not specified (only add it if the nature is there).
djangoSettingsEnvEntry = djangoSettingsKey + "=" + project.getName() + ".settings";
}
// Note: set flag even if not debugging as the user may use remote-debugging later on.
boolean geventSupport =
DebugPrefsPage.getGeventDebugging()
&& pythonNature.getInterpreterType() == IPythonNature.INTERPRETER_TYPE_PYTHON;
// Now, set the pythonpathUsed according to what's in the environment.
String p = "";
for (int i = 0; i < envp.length; i++) {
String s = envp[i];
Tuple<String, String> tup = StringUtils.splitOnFirst(s, '=');
String var = tup.o1;
if (win32) {
// On windows it doesn't matter, always consider uppercase.
var = var.toUpperCase();
}
if (var.equals("PYTHONPATH")) {
p = tup.o2;
} else if (var.equals(djangoSettingsKey)) {
// Update it.
if (djangoSettingsEnvEntry != null) {
envp[i] = djangoSettingsEnvEntry;
djangoSettingsEnvEntry = null;
}
}
if (geventSupport) {
if (var.equals("GEVENT_SUPPORT")) {
// Flag already set in the environment
geventSupport = false;
}
}
}
// Still not added, let's do that now.
if (djangoSettingsEnvEntry != null) {
envp = StringUtils.addString(envp, djangoSettingsEnvEntry);
}
if (geventSupport) {
envp = StringUtils.addString(envp, "GEVENT_SUPPORT=True");
}
this.pythonpathUsed = p;
}
/**
* @param topLevel
* @return
*/
private boolean createSourceFolderSelect(Composite topLevel) {
Label label;
label = new Label(topLevel, SWT.NONE);
label.setText("Source Folder");
textSourceFolder = new Text(topLevel, SWT.BORDER);
textSourceFolder.addKeyListener(this);
btBrowseSourceFolder = new Button(topLevel, SWT.NONE);
setLayout(label, textSourceFolder, btBrowseSourceFolder);
btBrowseSourceFolder.addSelectionListener(
new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
try {
PythonPackageSelectionDialog dialog =
new PythonPackageSelectionDialog(getShell(), true);
dialog.open();
Object firstResult = dialog.getFirstResult();
if (firstResult instanceof SourceFolder) {
SourceFolder f = (SourceFolder) firstResult;
textSourceFolder.setText(f.folder.getFullPath().toString());
}
} catch (Exception e1) {
Log.log(e1);
}
}
public void widgetDefaultSelected(SelectionEvent e) {}
});
Object element = selection.getFirstElement();
try {
if (element instanceof IAdaptable) {
IAdaptable adaptable = (IAdaptable) element;
element = adaptable.getAdapter(IFile.class);
if (element == null) {
element = adaptable.getAdapter(IProject.class);
}
if (element == null) {
element = adaptable.getAdapter(IFolder.class);
}
}
if (element instanceof IFile) {
IFile f = (IFile) element;
element = f.getParent();
}
if (element instanceof IProject) {
IPythonPathNature nature = PythonNature.getPythonPathNature((IProject) element);
if (nature != null) {
String[] srcPaths = PythonNature.getStrAsStrItems(nature.getProjectSourcePath(true));
if (srcPaths.length > 0) {
textSourceFolder.setText(srcPaths[0]);
return true;
}
}
}
if (element instanceof IFolder) {
IFolder f = (IFolder) element;
String srcPath = getSrcFolderFromFolder(f);
if (srcPath == null) {
return true;
}
textSourceFolder.setText(srcPath);
return true;
}
} catch (Exception e) {
Log.log(e);
}
return false;
}
/** When a console page is initialized, */
public void init(IPageBookViewPage page, final IConsole console) {
if (!(console instanceof ProcessConsole)) {
return;
}
ProcessConsole processConsole = (ProcessConsole) console;
IProcess process = processConsole.getProcess();
if (process == null) {
return;
}
if (!PyCodeCompletionPreferencesPage.useCodeCompletion()
|| !PyCodeCompletionPreferencesPage.useCodeCompletionOnDebug()) {
return;
}
String attribute = process.getAttribute(Constants.PYDEV_DEBUG_IPROCESS_ATTR);
if (!Constants.PYDEV_DEBUG_IPROCESS_ATTR_TRUE.equals(attribute)) {
// Only provide code-completion for pydev debug processes.
return;
}
Control control = page.getControl();
if (page instanceof IOConsolePage) {
// Note that completions on "all letters and '_'" are already activated just by installing
// the content assist, but the completions on the default keybinding is not, so, we have to
// call it ourselves here.
control.addKeyListener(
new KeyListener() {
public void keyPressed(KeyEvent e) {
if (KeyBindingHelper.matchesContentAssistKeybinding(e)) {
contentAssist.showPossibleCompletions();
}
}
public void keyReleased(KeyEvent e) {}
});
IOConsolePage consolePage = (IOConsolePage) page;
TextConsoleViewer viewer = consolePage.getViewer();
contentAssist =
new PyContentAssistant() {
public String showPossibleCompletions() {
// Only show completions if we're in a suspended console.
if (getCurrentSuspendedPyStackFrame(console) == null) {
return null;
}
return super.showPossibleCompletions();
};
};
contentAssist.setInformationControlCreator(
PyContentAssistant.createInformationControlCreator(viewer));
ILaunch launch = process.getLaunch();
IDebugTarget debugTarget = launch.getDebugTarget();
IInterpreterInfo projectInterpreter = null;
if (debugTarget instanceof PyDebugTarget) {
PyDebugTarget pyDebugTarget = (PyDebugTarget) debugTarget;
PythonNature nature = PythonNature.getPythonNature(pyDebugTarget.project);
if (nature != null) {
try {
projectInterpreter = nature.getProjectInterpreter();
} catch (Throwable e1) {
Log.log(e1);
}
}
}
contentAssist.install(new ScriptConsoleViewerWrapper(viewer, projectInterpreter));
PydevConsoleInterpreter interpreter = new PydevConsoleInterpreter();
interpreter.setConsoleCommunication(new GetCompletionsInDebug());
IContentAssistProcessor processor =
new PydevConsoleCompletionProcessor(interpreter, contentAssist);
contentAssist.setContentAssistProcessor(processor, IOConsolePartition.INPUT_PARTITION_TYPE);
contentAssist.setContentAssistProcessor(processor, IOConsolePartition.OUTPUT_PARTITION_TYPE);
contentAssist.enableAutoActivation(true);
contentAssist.enableAutoInsert(false);
contentAssist.setAutoActivationDelay(PyCodeCompletionPreferencesPage.getAutocompleteDelay());
}
}
/**
* @param name determines the name of the method to visit (added removed or changed)
* @param resource the resource to visit
* @param document the document from the resource
* @param monitor
*/
private void visitWith(
int visitType,
final IResource resource,
ICallback0<IDocument> document,
IProgressMonitor monitor) {
if (monitor.isCanceled()) {
return; // it's already cancelled
}
IPythonNature nature = PythonNature.getPythonNature(resource);
if (nature == null) {
return;
}
if (!nature.startRequests()) {
return;
}
try {
try {
// we visit external because we must index them
if (!isResourceInPythonpathProjectSources(resource, nature, true)) {
return; // we only analyze resources that are in the pythonpath
}
} catch (Exception e1) {
Log.log(e1);
return; // we only analyze resources that are in the pythonpath
}
VisitorMemo copyMemo = new VisitorMemo(this.memo);
FastStringBuffer bufferToCommunicateProgress = new FastStringBuffer();
for (PyDevBuilderVisitor visitor : visitors) {
// some visitors cannot visit too many elements because they do a lot of processing
if (visitor.maxResourcesToVisit() == PyDevBuilderVisitor.MAX_TO_VISIT_INFINITE
|| visitor.maxResourcesToVisit() >= totalResources) {
visitor.memo = copyMemo; // setting the memo must be the first thing.
try {
// communicate progress for each visitor
PyDevBuilder.communicateProgress(
monitor,
totalResources,
currentResourcesVisited,
resource,
visitor,
bufferToCommunicateProgress);
switch (visitType) {
case VISIT_ADD:
visitor.visitAddedResource(resource, document, monitor);
break;
case VISIT_CHANGE:
visitor.visitChangedResource(resource, document, monitor);
break;
case VISIT_REMOVE:
visitor.visitRemovedResource(resource, document, monitor);
break;
default:
throw new RuntimeException("Error: visit type not properly given!"); // $NON-NLS-1$
}
} catch (Exception e) {
Log.log(e);
}
}
}
} finally {
nature.endRequests();
}
}
