@Override
public void writeExternal(Element element) throws WriteExternalException {
final CodeStyleSettings parentSettings = new CodeStyleSettings();
DefaultJDOMExternalizer.writeExternal(
this, element, new DifferenceFilter<CodeStyleSettings>(this, parentSettings));
List<CustomCodeStyleSettings> customSettings =
new ArrayList<CustomCodeStyleSettings>(getCustomSettingsValues());
Collections.sort(
customSettings,
new Comparator<CustomCodeStyleSettings>() {
@Override
public int compare(final CustomCodeStyleSettings o1, final CustomCodeStyleSettings o2) {
return o1.getTagName().compareTo(o2.getTagName());
}
});
for (final CustomCodeStyleSettings settings : customSettings) {
final CustomCodeStyleSettings parentCustomSettings =
parentSettings.getCustomSettings(settings.getClass());
if (parentCustomSettings == null) {
throw new WriteExternalException("Custom settings are null for " + settings.getClass());
}
settings.writeExternal(element, parentCustomSettings);
}
final FileType[] fileTypes =
myAdditionalIndentOptions
.keySet()
.toArray(new FileType[myAdditionalIndentOptions.keySet().size()]);
Arrays.sort(
fileTypes,
new Comparator<FileType>() {
@Override
public int compare(final FileType o1, final FileType o2) {
return o1.getDefaultExtension().compareTo(o2.getDefaultExtension());
}
});
for (FileType fileType : fileTypes) {
final IndentOptions indentOptions = myAdditionalIndentOptions.get(fileType);
Element additionalIndentOptions = new Element(ADDITIONAL_INDENT_OPTIONS);
indentOptions.serialize(additionalIndentOptions, getDefaultIndentOptions(fileType));
additionalIndentOptions.setAttribute(FILETYPE, fileType.getDefaultExtension());
if (!additionalIndentOptions.getChildren().isEmpty()) {
element.addContent(additionalIndentOptions);
}
}
myCommonSettingsManager.writeExternal(element);
}
/**
* remove highlights (bounded with <marker>...</marker>) from test case file
*
* @param document document to process
*/
private void extractExpectedHighlightsSet(final Document document) {
final String text = document.getText();
final Set<String> markers = myHighlightingTypes.keySet();
final String typesRx = "(?:" + StringUtil.join(markers, ")|(?:") + ")";
final String openingTagRx =
"<("
+ typesRx
+ ")"
+ "(?:\\s+descr=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?"
+ "(?:\\s+type=\"([0-9A-Z_]+)\")?"
+ "(?:\\s+foreground=\"([0-9xa-f]+)\")?"
+ "(?:\\s+background=\"([0-9xa-f]+)\")?"
+ "(?:\\s+effectcolor=\"([0-9xa-f]+)\")?"
+ "(?:\\s+effecttype=\"([A-Z]+)\")?"
+ "(?:\\s+fonttype=\"([0-9]+)\")?"
+ "(?:\\s+textAttributesKey=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?"
+ "(?:\\s+bundleMsg=\"((?:[^\"]|\\\\\"|\\\\\\\\\")*)\")?"
+ "(/)?>";
final Matcher matcher = Pattern.compile(openingTagRx).matcher(text);
int pos = 0;
final Ref<Integer> textOffset = Ref.create(0);
while (matcher.find(pos)) {
textOffset.set(textOffset.get() + matcher.start() - pos);
pos = extractExpectedHighlight(matcher, text, document, textOffset);
}
}
private void runAfterCommitActions(@NotNull Document document) {
ApplicationManager.getApplication().assertIsDispatchThread();
List<Runnable> list;
synchronized (ACTION_AFTER_COMMIT) {
list = document.getUserData(ACTION_AFTER_COMMIT);
if (list != null) {
list = new ArrayList<Runnable>(list);
document.putUserData(ACTION_AFTER_COMMIT, null);
}
}
if (list != null) {
for (final Runnable runnable : list) {
runnable.run();
}
}
if (!hasUncommitedDocuments() && !actionsWhenAllDocumentsAreCommitted.isEmpty()) {
List<Object> keys = new ArrayList<Object>(actionsWhenAllDocumentsAreCommitted.keySet());
for (Object key : keys) {
try {
Runnable action = actionsWhenAllDocumentsAreCommitted.remove(key);
myDocumentCommitProcessor.log(
"Running after commit runnable: ", null, false, key, action);
action.run();
} catch (Throwable e) {
LOG.error(e);
}
}
}
}
private void registerAdditionalIndentOptions(FileType fileType, IndentOptions options) {
boolean exist = false;
for (final FileType existing : myAdditionalIndentOptions.keySet()) {
if (Comparing.strEqual(existing.getDefaultExtension(), fileType.getDefaultExtension())) {
exist = true;
break;
}
}
if (!exist) {
myAdditionalIndentOptions.put(fileType, options);
}
}
@Override
@Nullable
public Project newProject(
final String projectName,
@NotNull String filePath,
boolean useDefaultProjectSettings,
boolean isDummy) {
filePath = toCanonicalName(filePath);
//noinspection ConstantConditions
if (LOG_PROJECT_LEAKAGE_IN_TESTS && ApplicationManager.getApplication().isUnitTestMode()) {
for (int i = 0; i < 42; i++) {
if (myProjects.size() < MAX_LEAKY_PROJECTS) break;
System.gc();
TimeoutUtil.sleep(100);
System.gc();
}
if (myProjects.size() >= MAX_LEAKY_PROJECTS) {
List<Project> copy = new ArrayList<Project>(myProjects.keySet());
myProjects.clear();
throw new TooManyProjectLeakedException(copy);
}
}
ProjectImpl project =
createProject(
projectName, filePath, false, ApplicationManager.getApplication().isUnitTestMode());
try {
initProject(project, useDefaultProjectSettings ? (ProjectImpl) getDefaultProject() : null);
if (LOG_PROJECT_LEAKAGE_IN_TESTS) {
myProjects.put(project, null);
}
return project;
} catch (final Exception e) {
LOG.info(e);
Messages.showErrorDialog(message(e), ProjectBundle.message("project.load.default.error"));
}
return null;
}
private static Graph<PluginId> createPluginIdGraph(
final Map<PluginId, IdeaPluginDescriptorImpl> idToDescriptorMap) {
final List<PluginId> ids = new ArrayList<PluginId>(idToDescriptorMap.keySet());
// this magic ensures that the dependent plugins always follow their dependencies in
// lexicographic order
// needed to make sure that extensions are always in the same order
Collections.sort(
ids,
new Comparator<PluginId>() {
@Override
public int compare(PluginId o1, PluginId o2) {
return o2.getIdString().compareTo(o1.getIdString());
}
});
return GraphGenerator.create(
CachingSemiGraph.create(
new GraphGenerator.SemiGraph<PluginId>() {
@Override
public Collection<PluginId> getNodes() {
return ids;
}
@Override
public Iterator<PluginId> getIn(PluginId pluginId) {
final IdeaPluginDescriptor descriptor = idToDescriptorMap.get(pluginId);
ArrayList<PluginId> plugins = new ArrayList<PluginId>();
for (PluginId dependentPluginId : descriptor.getDependentPluginIds()) {
// check for missing optional dependency
if (idToDescriptorMap.containsKey(dependentPluginId)) {
plugins.add(dependentPluginId);
}
}
return plugins.iterator();
}
}));
}
@NotNull
private Set<InlineProgressIndicator> getCurrentInlineIndicators() {
synchronized (myOriginals) {
return myInline2Original.keySet();
}
}
@TestOnly
int numberOfListeners() {
return myPointers.keySet().size();
}
@Override
public void before(@NotNull final List<? extends VFileEvent> events) {
List<FilePointerPartNode> toFireEvents = new ArrayList<FilePointerPartNode>();
List<FilePointerPartNode> toUpdateUrl = new ArrayList<FilePointerPartNode>();
VirtualFilePointer[] toFirePointers;
synchronized (this) {
incModificationCount();
for (VFileEvent event : events) {
if (event instanceof VFileDeleteEvent) {
final VFileDeleteEvent deleteEvent = (VFileDeleteEvent) event;
addPointersUnder(deleteEvent.getFile(), false, "", toFireEvents);
} else if (event instanceof VFileCreateEvent) {
final VFileCreateEvent createEvent = (VFileCreateEvent) event;
addPointersUnder(createEvent.getParent(), true, createEvent.getChildName(), toFireEvents);
} else if (event instanceof VFileCopyEvent) {
final VFileCopyEvent copyEvent = (VFileCopyEvent) event;
addPointersUnder(
copyEvent.getNewParent(), true, copyEvent.getFile().getName(), toFireEvents);
} else if (event instanceof VFileMoveEvent) {
final VFileMoveEvent moveEvent = (VFileMoveEvent) event;
VirtualFile eventFile = moveEvent.getFile();
addPointersUnder(moveEvent.getNewParent(), true, eventFile.getName(), toFireEvents);
List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
addPointersUnder(eventFile, false, "", nodes);
for (FilePointerPartNode pair : nodes) {
VirtualFile file = pair.leaf.getFile();
if (file != null) {
toUpdateUrl.add(pair);
}
}
} else if (event instanceof VFilePropertyChangeEvent) {
final VFilePropertyChangeEvent change = (VFilePropertyChangeEvent) event;
if (VirtualFile.PROP_NAME.equals(change.getPropertyName())) {
VirtualFile eventFile = change.getFile();
VirtualFile parent = eventFile.getParent(); // e.g. for LightVirtualFiles
addPointersUnder(parent, true, change.getNewValue().toString(), toFireEvents);
List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
addPointersUnder(eventFile, false, "", nodes);
for (FilePointerPartNode pair : nodes) {
VirtualFile file = pair.leaf.getFile();
if (file != null) {
toUpdateUrl.add(pair);
}
}
}
}
}
myEvents = new ArrayList<EventDescriptor>();
toFirePointers = toPointers(toFireEvents);
for (final VirtualFilePointerListener listener : myPointers.keySet()) {
if (listener == null) continue;
List<VirtualFilePointer> filtered =
ContainerUtil.filter(
toFirePointers,
new Condition<VirtualFilePointer>() {
@Override
public boolean value(VirtualFilePointer pointer) {
return ((VirtualFilePointerImpl) pointer).getListener() == listener;
}
});
if (!filtered.isEmpty()) {
EventDescriptor event =
new EventDescriptor(
listener, filtered.toArray(new VirtualFilePointer[filtered.size()]));
myEvents.add(event);
}
}
}
for (EventDescriptor descriptor : myEvents) {
descriptor.fireBefore();
}
if (!toFireEvents.isEmpty()) {
myBus.syncPublisher(VirtualFilePointerListener.TOPIC).beforeValidityChanged(toFirePointers);
}
myPointersToFire = toFireEvents;
myPointersToUpdateUrl = toUpdateUrl;
}