public static void show() {
if (shownInSession) {
return;
}
shownInSession = true;
if (SharedCorePlugin.inTestMode()) {
return;
}
String hide = System.getProperty("pydev.funding.hide");
if (hide != null && (hide.equals("1") || hide.equals("true"))) {
return;
}
IPreferenceStore preferenceStore = PydevPrefs.getPreferenceStore();
boolean shownOnce = preferenceStore.getBoolean(PYDEV_FUNDING_SHOWN);
if (!shownOnce) {
boolean runNowIfInUiThread = false;
RunInUiThread.async(
new Runnable() {
@Override
public void run() {
Display disp = Display.getCurrent();
Shell shell = new Shell(disp);
DialogNotifier notifier = new DialogNotifier(shell);
notifier.open();
}
},
runNowIfInUiThread);
}
}
public void checkAllNow() {
// Add all to be tracked
Map<IInterpreterManager, Map<String, IInterpreterInfo>> addedToTrack = job.addAllToTrack();
// remove from the preferences any ignore the user had set previously
Set<Entry<IInterpreterManager, Map<String, IInterpreterInfo>>> entrySet =
addedToTrack.entrySet();
IPreferenceStore preferences = PydevPrefs.getPreferences();
for (Entry<IInterpreterManager, Map<String, IInterpreterInfo>> entry : entrySet) {
Set<Entry<String, IInterpreterInfo>> entrySet2 = entry.getValue().entrySet();
for (Entry<String, IInterpreterInfo> entry2 : entrySet2) {
String key = SynchSystemModulesManager.createKeyForInfo(entry2.getValue());
preferences.setValue(key, "");
}
}
if (preferences instanceof IPersistentPreferenceStore) {
IPersistentPreferenceStore iPersistentPreferenceStore =
(IPersistentPreferenceStore) preferences;
try {
iPersistentPreferenceStore.save();
} catch (IOException e) {
Log.log(e);
}
}
// schedule changes to be executed.
job.scheduleLater(0);
}
/**
* To be called when we start the plugin.
*
* <p>Should be called only once (when we'll make a full check for the current integrity of the
* information) Later on, we'll start to check if things change in the PYTHONPATH based on changes
* in the filesystem.
*/
public void start() {
boolean scheduleInitially = false;
boolean reCheckOnFilesystemChanges =
InterpreterGeneralPreferencesPage.getReCheckOnFilesystemChanges();
IInterpreterManager[] managers = PydevPlugin.getAllInterpreterManagers();
for (IInterpreterManager iInterpreterManager : managers) {
if (iInterpreterManager != null) {
IInterpreterInfo[] interpreterInfos = iInterpreterManager.getInterpreterInfos();
if (reCheckOnFilesystemChanges) {
this.registerInterpreterManager(iInterpreterManager, interpreterInfos);
}
scheduleInitially =
scheduleInitially || (interpreterInfos != null && interpreterInfos.length > 0);
}
}
int timeout = 1000 * 30; // Default is waiting 30 seconds after startup
IPreferenceStore preferences = PydevPrefs.getPreferences();
boolean alreadyChecked =
preferences.getBoolean(
"INTERPRETERS_CHECKED_ONCE"); // Now we add builtin indexing on our checks (so, force it
// at least once).
boolean force = false;
if (!alreadyChecked) {
preferences.setValue(
"INTERPRETERS_CHECKED_ONCE",
true); // Now we add builtin indexing on our checks (so, force it at least once).
force = true;
timeout = 1000 * 7; // In this case, wait only 7 seconds after startup
}
if (force || InterpreterGeneralPreferencesPage.getCheckConsistentOnStartup()) {
if (scheduleInitially) {
// Only do the initial schedule if there's something to be tracked (otherwise, wait for some
// interpreter
// to be configured and work only on deltas already).
// The initial job will do a full check on what's available and if it's synched with the
// filesystem.
job.addAllToTrack();
job.scheduleLater(timeout); // Wait a minute before starting our sync process.
}
}
}
/**
* Adds a set of arguments used to wrap executed file with unittest runner.
*
* @param actualRun in an actual run we'll start the xml-rpc server.
* @param coverageRun whether we should add the flags to do a coverage run.
*/
private void addUnittestArgs(List<String> cmdArgs, boolean actualRun, boolean coverageRun)
throws CoreException {
if (isUnittest()) {
// The tests are either written to a configuration file or passed as a parameter.
String configurationFile =
this.configuration.getAttribute(Constants.ATTR_UNITTEST_CONFIGURATION_FILE, "");
if (configurationFile.length() > 0) {
cmdArgs.add("--config_file");
if (actualRun) {
// We should write the contents to a temporary file (because it may be too long, so,
// always write
// to a file and read from it later on).
File tempFile = PydevPlugin.getDefault().getTempFile("custom_pydev_unittest_launch_");
try {
OutputStream fileOutputStream = new FileOutputStream(tempFile);
try {
try {
fileOutputStream.write(configurationFile.getBytes());
} catch (IOException e) {
throw new CoreException(
PydevPlugin.makeStatus(IStatus.ERROR, "Error writing to: " + tempFile, e));
}
} finally {
fileOutputStream.close();
}
} catch (Exception e) {
if (e instanceof CoreException) {
throw (CoreException) e;
}
throw new CoreException(
PydevPlugin.makeStatus(IStatus.ERROR, "Error writing to: " + tempFile, e));
}
cmdArgs.add(tempFile.toString());
} else {
cmdArgs.add(configurationFile);
}
} else {
String tests = this.configuration.getAttribute(Constants.ATTR_UNITTEST_TESTS, "");
if (tests.length() > 0) {
cmdArgs.add("--tests");
cmdArgs.add(tests);
}
}
if (PyUnitPrefsPage2.getUsePyUnitView()) {
// If we want to use the PyUnitView, we need to get the port used so that the python side
// can connect.
cmdArgs.add("--port");
if (actualRun) {
cmdArgs.add(String.valueOf(getPyUnitServer().getPort()));
} else {
cmdArgs.add("0");
}
}
if (coverageRun) {
cmdArgs.add("--coverage_output_dir");
cmdArgs.add(PyCoverage.getCoverageDirLocation().getAbsolutePath());
cmdArgs.add("--coverage_include");
cmdArgs.add(PyCodeCoverageView.getChosenDir().getLocation().toOSString());
if (actualRun) {
IPreferenceStore prefs = PydevPrefs.getPreferenceStore();
int testRunner = prefs.getInt(PyUnitPrefsPage2.TEST_RUNNER);
switch (testRunner) {
case PyUnitPrefsPage2.TEST_RUNNER_NOSE:
RunInUiThread.async(
new Runnable() {
public void run() {
PyDialogHelpers.openWarningWithIgnoreToggle(
"Notes for coverage with the nose test runner.",
"Note1: When using the coverage with the nose test runner, "
+ "please don't pass any specific parameter related to "
+ "the run in the arguments, as that's already handled by PyDev "
+ "(i.e.: don't use the builtin cover plugin from nose).\n"
+ "\n"
+ "Note2: It's currently not possible to use coverage with the multi-process "
+ "plugin in nose.",
"KEY_COVERAGE_WITH_NOSE_TEST_RUNNER");
}
});
break;
case PyUnitPrefsPage2.TEST_RUNNER_PY_TEST:
RunInUiThread.async(
new Runnable() {
public void run() {
PyDialogHelpers.openCritical(
"PyUnit coverage not compatible with the Py.test test runner.",
"Currently the PyDev PyUnit integration is not able to provide coverage "
+ "info using the py.test test runner (please enter a "
+ "feature request if you'd like that added)\n"
+ "\n"
+ "Note: the run will be continued anyways (without gathering coverage info).");
}
});
break;
}
}
}
// Last thing: nose parameters or parameters the user configured.
for (String s :
parseStringIntoList(
PyUnitPrefsPage2.getTestRunnerParameters(this.configuration, this.project))) {
cmdArgs.add(s);
}
}
}
/**
* 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;
}
/** @return */
public static boolean isFoldingEnabled() {
return PydevPrefs.getPreferences().getBoolean(PyDevCodeFoldingPrefPage.USE_CODE_FOLDING);
}
public static boolean getReCheckOnFilesystemChanges() {
return PydevPrefs.getPreferences().getBoolean(UPDATE_INTERPRETER_INFO_ON_FILESYSTEM_CHANGES);
}
public static boolean getCheckConsistentOnStartup() {
return PydevPrefs.getPreferences().getBoolean(CHECK_CONSISTENT_ON_STARTUP);
}
@Override
protected IStatus run(IProgressMonitor monitor) {
boolean selectingElementsInDialog = fSynchManager.getSelectingElementsInDialog();
if (selectingElementsInDialog) {
// No point in starting a process if the user already has a dialog related to this process
// open.
if (SynchSystemModulesManager.DEBUG) {
System.out.println("Dialog already showing: rescheduling new check for later.");
}
this.scheduleLater(20000);
return Status.OK_STATUS;
}
if (SynchSystemModulesManager.DEBUG) {
System.out.println("Running SynchJob!");
}
if (monitor == null) {
monitor = new NullProgressMonitor();
}
ManagerInfoToUpdate managerToNameToInfo;
synchronized (fManagerToNameToInfoLock) {
if (this.fManagerToNameToInfo == null || this.fManagerToNameToInfo.size() == 0) {
return Status.OK_STATUS; // nothing to do if there's nothing there...
}
managerToNameToInfo = new ManagerInfoToUpdate(this.fManagerToNameToInfo);
this.fManagerToNameToInfo = null;
}
long initialTime = System.currentTimeMillis();
ThreadPriorityHelper priorityHelper = new ThreadPriorityHelper(this.getThread());
priorityHelper.setMinPriority();
try {
final DataAndImageTreeNode root = new DataAndImageTreeNode(null, null, null);
if (monitor.isCanceled()) {
return Status.OK_STATUS;
}
fSynchManager.updateStructures(
monitor, root, managerToNameToInfo, new CreateInterpreterInfoCallback());
long delta = System.currentTimeMillis() - initialTime;
if (SynchSystemModulesManager.DEBUG) {
System.out.println(
"Time to check polling for changes in interpreters: " + delta / 1000.0 + " secs.");
}
List<TreeNode> initialSelection = new ArrayList<>(0);
if (root.hasChildren()) {
initialSelection =
fSynchManager.createInitialSelectionForDialogConsideringPreviouslyIgnored(
root, PydevPrefs.getPreferences());
}
if (root.hasChildren() && initialSelection.size() > 0) {
if (SynchSystemModulesManager.DEBUG) {
System.out.println("Changes found in PYTHONPATH.");
}
fSynchManager.asyncSelectAndScheduleElementsToChangePythonpath(
root, managerToNameToInfo, initialSelection);
} else {
if (SynchSystemModulesManager.DEBUG) {
System.out.println("PYTHONPATH remained the same.");
}
fSynchManager.synchronizeManagerToNameToInfoPythonpath(
monitor, managerToNameToInfo, null);
}
} finally {
// As jobs are from a thread pool, restore the priority afterwards
priorityHelper.restoreInitialPriority();
}
return Status.OK_STATUS;
}
/**
* Note: This apply is not directly called (it's called through {@link
* CtxInsensitiveImportComplProposal#apply(ITextViewer, char, int, int)})
*
* <p>This is the point where the completion is written. It has to be written and if some import
* is also available it should be inserted at this point.
*
* <p>We have to be careful to only add an import if that's really needed (e.g.: there's no other
* import that equals the import that should be added).
*
* <p>Also, we have to check if this import should actually be grouped with another import that
* already exists. (and it could be a multi-line import)
*/
public void apply(IDocument document, char trigger, int stateMask, int offset) {
if (this.indentString == null) {
throw new RuntimeException("Indent string not set (not called with a PyEdit as viewer?)");
}
if (!triggerCharAppliesCurrentCompletion(trigger, document, offset)) {
newForcedOffset = offset + 1; // +1 because that's the len of the trigger
return;
}
try {
PySelection selection = new PySelection(document);
int lineToAddImport = -1;
ImportHandleInfo groupInto = null;
ImportHandleInfo realImportHandleInfo = null;
boolean groupImports = ImportsPreferencesPage.getGroupImports();
LineStartingScope previousLineThatStartsScope = null;
PySelection ps = null;
if (this.addLocalImport) {
ps = new PySelection(document, offset);
int startLineIndex = ps.getStartLineIndex();
if (startLineIndex == 0) {
this.addLocalImport = false;
} else {
previousLineThatStartsScope =
ps.getPreviousLineThatStartsScope(
PySelection.INDENT_TOKENS,
startLineIndex - 1,
PySelection.getFirstCharPosition(ps.getCursorLineContents()));
if (previousLineThatStartsScope == null) {
// note that if we have no previous scope, it means we're actually on the global scope,
// so,
// proceed as usual...
this.addLocalImport = false;
}
}
}
if (realImportRep.length() > 0 && !this.addLocalImport) {
// Workaround for:
// https://sourceforge.net/tracker/?func=detail&aid=2697165&group_id=85796&atid=577329
// when importing from __future__ import with_statement, we actually want to add a 'with'
// token, not
// with_statement token.
boolean isWithStatement = realImportRep.equals("from __future__ import with_statement");
if (isWithStatement) {
this.fReplacementString = "with";
}
if (groupImports) {
try {
realImportHandleInfo = new ImportHandleInfo(realImportRep);
PyImportsHandling importsHandling = new PyImportsHandling(document);
for (ImportHandle handle : importsHandling) {
if (handle.contains(realImportHandleInfo)) {
lineToAddImport =
-2; // signal that there's no need to find a line available to add the import
break;
} else if (groupInto == null && realImportHandleInfo.getFromImportStr() != null) {
List<ImportHandleInfo> handleImportInfo = handle.getImportInfo();
for (ImportHandleInfo importHandleInfo : handleImportInfo) {
if (realImportHandleInfo
.getFromImportStr()
.equals(importHandleInfo.getFromImportStr())) {
List<String> commentsForImports = importHandleInfo.getCommentsForImports();
if (commentsForImports.size() > 0
&& commentsForImports.get(commentsForImports.size() - 1).length() == 0) {
groupInto = importHandleInfo;
break;
}
}
}
}
}
} catch (ImportNotRecognizedException e1) {
Log.log(e1); // that should not happen at this point
}
}
if (lineToAddImport == -1) {
boolean isFutureImport = PySelection.isFutureImportLine(this.realImportRep);
lineToAddImport = selection.getLineAvailableForImport(isFutureImport);
}
} else {
lineToAddImport = -1;
}
String delimiter = PyAction.getDelimiter(document);
appliedWithTrigger = trigger == '.' || trigger == '(';
String appendForTrigger = "";
if (appliedWithTrigger) {
if (trigger == '(') {
appendForTrigger = "()";
} else if (trigger == '.') {
appendForTrigger = ".";
}
}
// if the trigger is ')', just let it apply regularly -- so, ')' will only be added if it's
// already in the completion.
// first do the completion
if (fReplacementString.length() > 0) {
int dif = offset - fReplacementOffset;
document.replace(offset - dif, dif + this.fLen, fReplacementString + appendForTrigger);
}
if (this.addLocalImport) {
// All the code below is because we don't want to work with a generated AST (as it may not
// be there),
// so, we go to the previous scope, find out the valid indent inside it and then got
// backwards
// from the position we're in now to find the closer location to where we're now where we're
// actually able to add the import.
try {
int iLineStartingScope;
if (previousLineThatStartsScope != null) {
iLineStartingScope = previousLineThatStartsScope.iLineStartingScope;
// Go to a non-empty line from the line we have and the line we're currently in.
int iLine = iLineStartingScope + 1;
String line = ps.getLine(iLine);
int startLineIndex = ps.getStartLineIndex();
while (iLine < startLineIndex && (line.startsWith("#") || line.trim().length() == 0)) {
iLine++;
line = ps.getLine(iLine);
}
if (iLine >= startLineIndex) {
// Sanity check!
iLine = startLineIndex;
line = ps.getLine(iLine);
}
int firstCharPos = PySelection.getFirstCharPosition(line);
// Ok, all good so far, now, this would add the line to the beginning of
// the element (after the if statement, def, etc.), let's try to put
// it closer to where we're now (but still in a valid position).
int j = startLineIndex;
while (j >= 0) {
String line2 = ps.getLine(j);
if (PySelection.getFirstCharPosition(line2) == firstCharPos) {
iLine = j;
break;
}
if (j == iLineStartingScope) {
break;
}
j--;
}
String indent = line.substring(0, firstCharPos);
String strToAdd = indent + realImportRep + delimiter;
ps.addLine(
strToAdd, iLine - 1); // Will add it just after the line passed as a parameter.
importLen = strToAdd.length();
return;
}
} catch (Exception e) {
Log.log(e); // Something went wrong, add it as global (i.e.: BUG)
}
}
if (groupInto != null && realImportHandleInfo != null) {
// let's try to group it
final int maxCols;
if (SharedCorePlugin.inTestMode()) {
maxCols = 80;
} else {
IPreferenceStore chainedPrefStore = PydevPrefs.getChainedPrefStore();
maxCols =
chainedPrefStore.getInt(
AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN);
}
int endLine = groupInto.getEndLine();
IRegion lineInformation = document.getLineInformation(endLine);
String strToAdd = ", " + realImportHandleInfo.getImportedStr().get(0);
String line = PySelection.getLine(document, endLine);
if (line.length() + strToAdd.length() > maxCols) {
if (line.indexOf('#') == -1) {
// no comments: just add it in the next line
int len = line.length();
if (line.trim().endsWith(")")) {
len = line.indexOf(")");
strToAdd =
"," + delimiter + indentString + realImportHandleInfo.getImportedStr().get(0);
} else {
strToAdd =
",\\" + delimiter + indentString + realImportHandleInfo.getImportedStr().get(0);
}
int end = lineInformation.getOffset() + len;
importLen = strToAdd.length();
document.replace(end, 0, strToAdd);
return;
}
} else {
// regular addition (it won't pass the number of columns expected).
line = PySelection.getLineWithoutCommentsOrLiterals(line);
int len = line.length();
if (line.trim().endsWith(")")) {
len = line.indexOf(")");
}
int end = lineInformation.getOffset() + len;
importLen = strToAdd.length();
document.replace(end, 0, strToAdd);
return;
}
}
// if we got here, it hasn't been added in a grouped way, so, let's add it in a new import
if (lineToAddImport >= 0 && lineToAddImport <= document.getNumberOfLines()) {
IRegion lineInformation = document.getLineInformation(lineToAddImport);
String strToAdd = realImportRep + delimiter;
importLen = strToAdd.length();
document.replace(lineInformation.getOffset(), 0, strToAdd);
return;
}
} catch (BadLocationException x) {
Log.log(x);
}
}