mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
Removed mappings logic extracted from FileTypeManagerImpl and simplified
Get rid of Trinity, always store name instead of file type instance for removed mappings (making it unnecessary to track unresolved and resolved mappings separately) GitOrigin-RevId: 9aff3d15bf55870f37da8d9efa2e81b3e25eb8f8
This commit is contained in:
Dmitry Jemerov
committed by
intellij-monorepo-bot
intellij-monorepo-bot
parent
d8d2212be5
commit
765a1bf50b
+2
-40
@@ -304,11 +304,7 @@ public class AbstractFileType extends UserFileType<AbstractFileType> implements
|
||||
|
||||
@NonNls static final String ELEMENT_MAPPING = "mapping";
|
||||
@NonNls static final String ATTRIBUTE_EXT = "ext";
|
||||
@NonNls private static final String ATTRIBUTE_PATTERN = "pattern";
|
||||
/** Applied for removed mappings approved by user */
|
||||
@NonNls private static final String ATTRIBUTE_APPROVED = "approved";
|
||||
|
||||
@NonNls private static final String ELEMENT_REMOVED_MAPPING = "removed_mapping";
|
||||
@NonNls static final String ATTRIBUTE_PATTERN = "pattern";
|
||||
@NonNls static final String ATTRIBUTE_TYPE = "type";
|
||||
|
||||
@NotNull
|
||||
@@ -329,22 +325,6 @@ public class AbstractFileType extends UserFileType<AbstractFileType> implements
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<Trinity<FileNameMatcher, String, Boolean>> readRemovedAssociations(@NotNull Element element) {
|
||||
List<Element> children = element.getChildren(ELEMENT_REMOVED_MAPPING);
|
||||
if (children.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
List<Trinity<FileNameMatcher, String, Boolean>> result = new SmartList<>();
|
||||
for (Element mapping : children) {
|
||||
String ext = mapping.getAttributeValue(ATTRIBUTE_EXT);
|
||||
FileNameMatcher matcher = ext == null ? FileTypeManager.parseFromString(mapping.getAttributeValue(ATTRIBUTE_PATTERN)) : new ExtensionFileNameMatcher(ext);
|
||||
result.add(Trinity.create(matcher, mapping.getAttributeValue(ATTRIBUTE_TYPE), Boolean.parseBoolean(mapping.getAttributeValue(ATTRIBUTE_APPROVED))));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public static Element writeMapping(String typeName, @NotNull FileNameMatcher matcher, boolean specifyTypeName) {
|
||||
Element mapping = new Element(ELEMENT_MAPPING);
|
||||
@@ -362,25 +342,7 @@ public class AbstractFileType extends UserFileType<AbstractFileType> implements
|
||||
return mapping;
|
||||
}
|
||||
|
||||
static Element writeRemovedMapping(@NotNull FileType type, @NotNull FileNameMatcher matcher, boolean specifyTypeName, boolean approved) {
|
||||
Element mapping = new Element(ELEMENT_REMOVED_MAPPING);
|
||||
if (matcher instanceof ExtensionFileNameMatcher) {
|
||||
mapping.setAttribute(ATTRIBUTE_EXT, ((ExtensionFileNameMatcher)matcher).getExtension());
|
||||
}
|
||||
else if (writePattern(matcher, mapping)) {
|
||||
return null;
|
||||
}
|
||||
if (approved) {
|
||||
mapping.setAttribute(ATTRIBUTE_APPROVED, "true");
|
||||
}
|
||||
if (specifyTypeName) {
|
||||
mapping.setAttribute(ATTRIBUTE_TYPE, type.getName());
|
||||
}
|
||||
|
||||
return mapping;
|
||||
}
|
||||
|
||||
private static boolean writePattern(FileNameMatcher matcher, Element mapping) {
|
||||
static boolean writePattern(FileNameMatcher matcher, Element mapping) {
|
||||
if (matcher instanceof WildcardFileNameMatcher) {
|
||||
mapping.setAttribute(ATTRIBUTE_PATTERN, ((WildcardFileNameMatcher)matcher).getPattern());
|
||||
}
|
||||
|
||||
+8
-14
@@ -12,14 +12,12 @@ import com.intellij.openapi.fileTypes.FileTypeManager;
|
||||
import com.intellij.openapi.fileTypes.PlainTextFileType;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.openapi.startup.StartupActivity;
|
||||
import com.intellij.openapi.util.Pair;
|
||||
import com.intellij.openapi.util.registry.Registry;
|
||||
import com.intellij.util.ui.UIUtil;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import javax.swing.event.HyperlinkEvent;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author Dmitry Avdeev
|
||||
@@ -29,16 +27,13 @@ public class ApproveRemovedMappingsActivity implements StartupActivity {
|
||||
public void runActivity(@NotNull final Project project) {
|
||||
if (ApplicationManager.getApplication().isUnitTestMode() || !Registry.is("ide.restore.removed.mappings")) return;
|
||||
|
||||
final Map<FileNameMatcher,Pair<FileType,Boolean>> map = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappings();
|
||||
if (!map.isEmpty()) {
|
||||
RemovedMappingTracker removedMappings = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappingTracker();
|
||||
List<RemovedMappingTracker.RemovedMapping> list = removedMappings.retrieveUnapprovedMappings();
|
||||
if (!list.isEmpty()) {
|
||||
UIUtil.invokeAndWaitIfNeeded((Runnable)() -> {
|
||||
for (Iterator<Map.Entry<FileNameMatcher, Pair<FileType, Boolean>>> iterator = map.entrySet().iterator(); iterator.hasNext(); ) {
|
||||
Map.Entry<FileNameMatcher, Pair<FileType, Boolean>> entry = iterator.next();
|
||||
if (entry.getValue().getSecond()) {
|
||||
continue;
|
||||
}
|
||||
final FileNameMatcher matcher = entry.getKey();
|
||||
final FileType fileType = entry.getValue().getFirst();
|
||||
for (RemovedMappingTracker.RemovedMapping mapping : list) {
|
||||
final FileNameMatcher matcher = mapping.getFileNameMatcher();
|
||||
final FileType fileType = FileTypeManager.getInstance().findFileTypeByName(mapping.getFileTypeName());
|
||||
Notification notification = new Notification("File type recognized", "File type recognized",
|
||||
"File extension " + matcher.getPresentableString() +
|
||||
" was reassigned to " + fileType.getName() + " <a href='revert'>Revert</a>",
|
||||
@@ -47,14 +42,13 @@ public class ApproveRemovedMappingsActivity implements StartupActivity {
|
||||
protected void hyperlinkActivated(@NotNull Notification notification, @NotNull HyperlinkEvent e) {
|
||||
ApplicationManager.getApplication().runWriteAction(() -> {
|
||||
FileTypeManager.getInstance().associate(PlainTextFileType.INSTANCE, matcher);
|
||||
map.put(matcher, Pair.create(fileType, true));
|
||||
removedMappings.add(matcher, fileType.getName(), true);
|
||||
});
|
||||
notification.expire();
|
||||
}
|
||||
});
|
||||
Notifications.Bus.notify(notification, project);
|
||||
ApplicationManager.getApplication().runWriteAction(() -> FileTypeManager.getInstance().associate(fileType, matcher));
|
||||
iterator.remove();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
+29
-57
@@ -103,9 +103,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
|
||||
private final FileTypeAssocTable<FileType> myInitialAssociations = new FileTypeAssocTable<>();
|
||||
private final Map<FileNameMatcher, String> myUnresolvedMappings = new THashMap<>();
|
||||
private final Map<FileNameMatcher, Trinity<String, String, Boolean>> myUnresolvedRemovedMappings = new THashMap<>();
|
||||
/** This will contain removed mappings with "approved" states */
|
||||
private final Map<FileNameMatcher, Pair<FileType, Boolean>> myRemovedMappings = new THashMap<>();
|
||||
private final RemovedMappingTracker myRemovedMappingTracker = new RemovedMappingTracker();
|
||||
|
||||
@NonNls private static final String ELEMENT_FILETYPE = "filetype";
|
||||
@NonNls private static final String ELEMENT_IGNORE_FILES = "ignoreFiles";
|
||||
@@ -1127,7 +1125,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
if (PlainTextFileType.INSTANCE == type) {
|
||||
FileType newFileType = myPatternsTable.findAssociatedFileType(matcher);
|
||||
if (newFileType != null && newFileType != PlainTextFileType.INSTANCE && newFileType != UnknownFileType.INSTANCE) {
|
||||
myRemovedMappings.put(matcher, Pair.create(newFileType, false));
|
||||
myRemovedMappingTracker.add(matcher, newFileType.getName(), false);
|
||||
}
|
||||
}
|
||||
associate(type, matcher, false);
|
||||
@@ -1140,16 +1138,11 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
}
|
||||
}
|
||||
|
||||
List<Trinity<FileNameMatcher, String, Boolean>> removedAssociations = AbstractFileType.readRemovedAssociations(e);
|
||||
for (Trinity<FileNameMatcher, String, Boolean> trinity : removedAssociations) {
|
||||
FileType type = getFileTypeByName(trinity.getSecond());
|
||||
FileNameMatcher matcher = trinity.getFirst();
|
||||
if (type != null) {
|
||||
removeAssociation(type, matcher, false);
|
||||
myRemovedMappings.put(matcher, Pair.create(type, trinity.third));
|
||||
}
|
||||
else {
|
||||
myUnresolvedRemovedMappings.put(matcher, Trinity.create(trinity.getSecond(), myUnresolvedMappings.get(matcher), trinity.getThird()));
|
||||
myRemovedMappingTracker.load(e);
|
||||
for (RemovedMappingTracker.RemovedMapping mapping : myRemovedMappingTracker.getRemovedMappings()) {
|
||||
FileType fileType = getFileTypeByName(mapping.getFileTypeName());
|
||||
if (fileType != null) {
|
||||
removeAssociation(fileType, mapping.getFileNameMatcher(), false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1215,13 +1208,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
}
|
||||
|
||||
// https://youtrack.jetbrains.com/issue/IDEA-138366
|
||||
for (Map.Entry<FileNameMatcher, Pair<FileType, Boolean>> entry : myRemovedMappings.entrySet()) {
|
||||
Pair<FileType, Boolean> value = entry.getValue();
|
||||
Element content = AbstractFileType.writeRemovedMapping(value.first, entry.getKey(), true, value.second);
|
||||
if (content != null) {
|
||||
map.addContent(content);
|
||||
}
|
||||
}
|
||||
myRemovedMappingTracker.save(map);
|
||||
|
||||
if (!myUnresolvedMappings.isEmpty()) {
|
||||
FileNameMatcher[] unresolvedMappingKeys = myUnresolvedMappings.keySet().toArray(new FileNameMatcher[0]);
|
||||
@@ -1259,23 +1246,13 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
}
|
||||
}
|
||||
|
||||
for (FileNameMatcher matcher : defaultAssociations) {
|
||||
Element content = AbstractFileType.writeRemovedMapping(type, matcher, specifyTypeName, isApproved(matcher));
|
||||
if (content != null) {
|
||||
map.addContent(content);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isApproved(@NotNull FileNameMatcher matcher) {
|
||||
Pair<FileType, Boolean> pair = myRemovedMappings.get(matcher);
|
||||
return pair != null && pair.getSecond();
|
||||
myRemovedMappingTracker.saveRemovedMappingsForFileType(map, type.getName(), defaultAssociations, specifyTypeName);
|
||||
}
|
||||
|
||||
public void approveRemoval(@NotNull FileNameMatcher matcher) {
|
||||
FileType type = getExtensionMap().findAssociatedFileType(matcher);
|
||||
if (type != null) {
|
||||
myRemovedMappings.put(matcher, Pair.create(type, true));
|
||||
myRemovedMappingTracker.approveRemoval(type.getName(), matcher);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1328,12 +1305,8 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
}
|
||||
}
|
||||
|
||||
for (FileNameMatcher matcher : new THashSet<>(myUnresolvedRemovedMappings.keySet())) {
|
||||
Trinity<String, String, Boolean> trinity = myUnresolvedRemovedMappings.get(matcher);
|
||||
if (Comparing.equal(trinity.getFirst(), fileType.getName())) {
|
||||
removeAssociation(fileType, matcher, false);
|
||||
myUnresolvedRemovedMappings.remove(matcher);
|
||||
}
|
||||
for (FileNameMatcher matcher : myRemovedMappingTracker.getMappingsForFileType(fileType.getName())) {
|
||||
removeAssociation(fileType, matcher, false);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1389,8 +1362,8 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
associate(type, association.getFirst(), false);
|
||||
}
|
||||
|
||||
for (Trinity<FileNameMatcher, String, Boolean> removedAssociation : AbstractFileType.readRemovedAssociations(extensions)) {
|
||||
removeAssociation(type, removedAssociation.getFirst(), false);
|
||||
for (RemovedMappingTracker.RemovedMapping removedAssociation : RemovedMappingTracker.readRemovedMappings(extensions)) {
|
||||
removeAssociation(type, removedAssociation.getFileNameMatcher(), false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1459,14 +1432,12 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
myPatternsTable = assocTable.copy();
|
||||
fireFileTypesChanged();
|
||||
|
||||
Iterator<Map.Entry<FileNameMatcher, Pair<FileType, Boolean>>> iterator = myRemovedMappings.entrySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Map.Entry<FileNameMatcher, Pair<FileType, Boolean>> entry = iterator.next();
|
||||
if (assocTable.isAssociatedWith(entry.getValue().first, entry.getKey()))
|
||||
iterator.remove();
|
||||
}
|
||||
myRemovedMappingTracker.removeMatching((matcher, fileTypeName) -> {
|
||||
FileType fileType = getFileTypeByName(fileTypeName);
|
||||
return fileType != null && assocTable.isAssociatedWith(fileType, matcher);
|
||||
});
|
||||
for (FileNameMatcher matcher : removedMappings.keySet()) {
|
||||
myRemovedMappings.put(matcher, Pair.create(removedMappings.get(matcher), true));
|
||||
myRemovedMappingTracker.add(matcher, removedMappings.get(matcher).getName(), true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1514,27 +1485,28 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
FileType fileType = pair.fileType;
|
||||
if (fileType == PlainTextFileType.INSTANCE) return;
|
||||
for (FileNameMatcher matcher : pair.matchers) {
|
||||
registerReDetectedMapping(fileType, matcher);
|
||||
registerReDetectedMapping(fileType.getName(), matcher);
|
||||
if (matcher instanceof ExtensionFileNameMatcher) {
|
||||
// also check exact file name matcher
|
||||
ExtensionFileNameMatcher extMatcher = (ExtensionFileNameMatcher)matcher;
|
||||
registerReDetectedMapping(fileType, new ExactFileNameMatcher("." + extMatcher.getExtension()));
|
||||
registerReDetectedMapping(fileType.getName(), new ExactFileNameMatcher("." + extMatcher.getExtension()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void registerReDetectedMapping(@NotNull FileType fileType, @NotNull FileNameMatcher matcher) {
|
||||
private void registerReDetectedMapping(String fileTypeName, @NotNull FileNameMatcher matcher) {
|
||||
String typeName = myUnresolvedMappings.get(matcher);
|
||||
if (typeName != null && !typeName.equals(fileType.getName())) {
|
||||
Trinity<String, String, Boolean> trinity = myUnresolvedRemovedMappings.get(matcher);
|
||||
myRemovedMappings.put(matcher, Pair.create(fileType, trinity != null && trinity.third));
|
||||
if (typeName != null && !typeName.equals(fileTypeName)) {
|
||||
if (!myRemovedMappingTracker.hasRemovedMapping(matcher)) {
|
||||
myRemovedMappingTracker.add(matcher, fileTypeName, false);
|
||||
}
|
||||
myUnresolvedMappings.remove(matcher);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
Map<FileNameMatcher, Pair<FileType, Boolean>> getRemovedMappings() {
|
||||
return myRemovedMappings;
|
||||
RemovedMappingTracker getRemovedMappingTracker() {
|
||||
return myRemovedMappingTracker;
|
||||
}
|
||||
|
||||
@TestOnly
|
||||
@@ -1544,7 +1516,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent
|
||||
}
|
||||
myStandardFileTypes.clear();
|
||||
myUnresolvedMappings.clear();
|
||||
myRemovedMappings.clear();
|
||||
myRemovedMappingTracker.clear();
|
||||
mySchemeManager.setSchemes(Collections.emptyList());
|
||||
}
|
||||
|
||||
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
|
||||
package com.intellij.openapi.fileTypes.impl;
|
||||
|
||||
import com.intellij.openapi.fileTypes.ExtensionFileNameMatcher;
|
||||
import com.intellij.openapi.fileTypes.FileNameMatcher;
|
||||
import com.intellij.openapi.fileTypes.FileTypeManager;
|
||||
import org.jdom.Element;
|
||||
import org.jetbrains.annotations.NonNls;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.function.BiPredicate;
|
||||
|
||||
class RemovedMappingTracker {
|
||||
public static class RemovedMapping {
|
||||
private final FileNameMatcher myFileNameMatcher;
|
||||
private final String myFileTypeName;
|
||||
private boolean myApproved;
|
||||
|
||||
private RemovedMapping(FileNameMatcher matcher, String name, boolean approved) {
|
||||
myFileNameMatcher = matcher;
|
||||
myFileTypeName = name;
|
||||
myApproved = approved;
|
||||
}
|
||||
|
||||
public FileNameMatcher getFileNameMatcher() {
|
||||
return myFileNameMatcher;
|
||||
}
|
||||
|
||||
public String getFileTypeName() {
|
||||
return myFileTypeName;
|
||||
}
|
||||
|
||||
public boolean isApproved() {
|
||||
return myApproved;
|
||||
}
|
||||
|
||||
public void setApproved(boolean approved) {
|
||||
myApproved = approved;
|
||||
}
|
||||
}
|
||||
|
||||
private final Map<FileNameMatcher, RemovedMapping> myRemovedMappings = new HashMap<>();
|
||||
|
||||
@NonNls private static final String ELEMENT_REMOVED_MAPPING = "removed_mapping";
|
||||
/** Applied for removed mappings approved by user */
|
||||
@NonNls private static final String ATTRIBUTE_APPROVED = "approved";
|
||||
@NonNls static final String ATTRIBUTE_TYPE = "type";
|
||||
|
||||
void clear() {
|
||||
myRemovedMappings.clear();
|
||||
}
|
||||
|
||||
public void add(FileNameMatcher matcher, String fileTypeName, boolean approved) {
|
||||
myRemovedMappings.put(matcher, new RemovedMapping(matcher, fileTypeName, approved));
|
||||
}
|
||||
|
||||
public void load(@NotNull Element e) {
|
||||
for (RemovedMapping mapping : readRemovedMappings(e)) {
|
||||
myRemovedMappings.put(mapping.myFileNameMatcher, mapping);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
static List<RemovedMapping> readRemovedMappings(@NotNull Element e) {
|
||||
List<Element> children = e.getChildren(ELEMENT_REMOVED_MAPPING);
|
||||
if (children.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
List<RemovedMapping> result = new ArrayList<>();
|
||||
for (Element mapping : children) {
|
||||
String ext = mapping.getAttributeValue(AbstractFileType.ATTRIBUTE_EXT);
|
||||
FileNameMatcher matcher = ext == null ? FileTypeManager.parseFromString(mapping.getAttributeValue(AbstractFileType.ATTRIBUTE_PATTERN)) : new ExtensionFileNameMatcher(ext);
|
||||
boolean approved = Boolean.parseBoolean(mapping.getAttributeValue(ATTRIBUTE_APPROVED));
|
||||
String fileTypeName = mapping.getAttributeValue(ATTRIBUTE_TYPE);
|
||||
if (fileTypeName == null) continue;
|
||||
|
||||
RemovedMapping removedMapping = new RemovedMapping(matcher, fileTypeName, approved);
|
||||
result.add(removedMapping);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public void save(Element element) {
|
||||
for (RemovedMapping mapping : myRemovedMappings.values()) {
|
||||
Element content = writeRemovedMapping(mapping.myFileTypeName, mapping.myFileNameMatcher, true, mapping.myApproved);
|
||||
if (content != null) {
|
||||
element.addContent(content);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void saveRemovedMappingsForFileType(Element map, String fileTypeName, Set<FileNameMatcher> associations, boolean specifyTypeName) {
|
||||
for (FileNameMatcher matcher : associations) {
|
||||
Element content = writeRemovedMapping(fileTypeName, matcher, specifyTypeName, isApproved(matcher));
|
||||
if (content != null) {
|
||||
map.addContent(content);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
boolean hasRemovedMapping(FileNameMatcher matcher) {
|
||||
return myRemovedMappings.containsKey(matcher);
|
||||
}
|
||||
|
||||
boolean isApproved(FileNameMatcher matcher) {
|
||||
RemovedMapping mapping = myRemovedMappings.get(matcher);
|
||||
return mapping != null && mapping.isApproved();
|
||||
}
|
||||
|
||||
public void approveRemoval(String fileTypeName, FileNameMatcher matcher) {
|
||||
myRemovedMappings.put(matcher, new RemovedMapping(matcher, fileTypeName, true));
|
||||
}
|
||||
|
||||
public List<RemovedMapping> getRemovedMappings() {
|
||||
return new ArrayList<>(myRemovedMappings.values());
|
||||
}
|
||||
|
||||
public List<FileNameMatcher> getMappingsForFileType(String name) {
|
||||
List<FileNameMatcher> result = new ArrayList<>();
|
||||
for (RemovedMapping mapping : myRemovedMappings.values()) {
|
||||
if (mapping.myFileTypeName.equals(name)) {
|
||||
result.add(mapping.myFileNameMatcher);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void removeMatching(BiPredicate<FileNameMatcher, String> predicate) {
|
||||
for (Iterator<Map.Entry<FileNameMatcher, RemovedMapping>> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) {
|
||||
Map.Entry<FileNameMatcher, RemovedMapping> next = it.next();
|
||||
if (predicate.test(next.getValue().myFileNameMatcher, next.getValue().myFileTypeName)) {
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
List<RemovedMapping> retrieveUnapprovedMappings() {
|
||||
List<RemovedMapping> result = new ArrayList<>();
|
||||
for (Iterator<Map.Entry<FileNameMatcher, RemovedMapping>> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) {
|
||||
Map.Entry<FileNameMatcher, RemovedMapping> next = it.next();
|
||||
if (!next.getValue().isApproved()) {
|
||||
result.add(next.getValue());
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static Element writeRemovedMapping(@NotNull String fileTypeName,
|
||||
@NotNull FileNameMatcher matcher,
|
||||
boolean specifyTypeName,
|
||||
boolean approved) {
|
||||
Element mapping = new Element(ELEMENT_REMOVED_MAPPING);
|
||||
if (matcher instanceof ExtensionFileNameMatcher) {
|
||||
mapping.setAttribute(AbstractFileType.ATTRIBUTE_EXT, ((ExtensionFileNameMatcher)matcher).getExtension());
|
||||
}
|
||||
else if (AbstractFileType.writePattern(matcher, mapping)) {
|
||||
return null;
|
||||
}
|
||||
if (approved) {
|
||||
mapping.setAttribute(ATTRIBUTE_APPROVED, "true");
|
||||
}
|
||||
if (specifyTypeName) {
|
||||
mapping.setAttribute(ATTRIBUTE_TYPE, fileTypeName);
|
||||
}
|
||||
|
||||
return mapping;
|
||||
}
|
||||
}
|
||||
+20
-21
@@ -377,19 +377,19 @@ public class FileTypesTest extends PlatformTestCase {
|
||||
table.removeAssociation(matcher, fileType);
|
||||
|
||||
WriteAction.run(() -> myFileTypeManager.setPatternsTable(fileTypes, table));
|
||||
myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true));
|
||||
myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true);
|
||||
|
||||
Element state = myFileTypeManager.getState();
|
||||
|
||||
myFileTypeManager.getRemovedMappings().clear();
|
||||
myFileTypeManager.getRemovedMappingTracker().clear();
|
||||
myFileTypeManager.initStandardFileTypes();
|
||||
myFileTypeManager.loadState(state);
|
||||
myFileTypeManager.initializeComponent();
|
||||
|
||||
Map<FileNameMatcher, Pair<FileType, Boolean>> mappings = myFileTypeManager.getRemovedMappings();
|
||||
Pair<FileType, Boolean> pair = mappings.get(matcher);
|
||||
assertNotNull(pair);
|
||||
assertTrue(pair.second);
|
||||
List<RemovedMappingTracker.RemovedMapping> mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings();
|
||||
assertEquals(1, mappings.size());
|
||||
assertTrue(mappings.get(0).isApproved());
|
||||
assertEquals(matcher, mappings.get(0).getFileNameMatcher());
|
||||
}
|
||||
|
||||
public void testRemovedExactNameMapping() {
|
||||
@@ -403,19 +403,18 @@ public class FileTypesTest extends PlatformTestCase {
|
||||
table.removeAssociation(matcher, fileType);
|
||||
|
||||
WriteAction.run(() -> myFileTypeManager.setPatternsTable(fileTypes, table));
|
||||
myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true));
|
||||
myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true);
|
||||
|
||||
Element state = myFileTypeManager.getState();
|
||||
|
||||
myFileTypeManager.getRemovedMappings().clear();
|
||||
myFileTypeManager.getRemovedMappingTracker().clear();
|
||||
myFileTypeManager.initStandardFileTypes();
|
||||
myFileTypeManager.loadState(state);
|
||||
myFileTypeManager.initializeComponent();
|
||||
|
||||
Map<FileNameMatcher, Pair<FileType, Boolean>> mappings = myFileTypeManager.getRemovedMappings();
|
||||
Pair<FileType, Boolean> pair = mappings.get(matcher);
|
||||
assertNotNull(pair);
|
||||
assertTrue(pair.second);
|
||||
List<RemovedMappingTracker.RemovedMapping> mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings();
|
||||
assertTrue(mappings.get(0).isApproved());
|
||||
assertEquals(matcher, mappings.get(0).getFileNameMatcher());
|
||||
}
|
||||
|
||||
public void testReassignedPredefinedFileType() {
|
||||
@@ -428,18 +427,18 @@ public class FileTypesTest extends PlatformTestCase {
|
||||
public void testReAddedMapping() {
|
||||
ArchiveFileType fileType = ArchiveFileType.INSTANCE;
|
||||
FileNameMatcher matcher = myFileTypeManager.getAssociations(fileType).get(0);
|
||||
myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true));
|
||||
myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true);
|
||||
|
||||
WriteAction.run(() -> myFileTypeManager
|
||||
.setPatternsTable(new HashSet<>(Arrays.asList(myFileTypeManager.getRegisteredFileTypes())), myFileTypeManager.getExtensionMap().copy()));
|
||||
assertEquals(0, myFileTypeManager.getRemovedMappings().size());
|
||||
assertEquals(0, myFileTypeManager.getRemovedMappingTracker().getRemovedMappings().size());
|
||||
}
|
||||
|
||||
public void testPreserveRemovedMappingForUnknownFileType() {
|
||||
myFileTypeManager.getRemovedMappings().put(new ExtensionFileNameMatcher("xxx"), Pair.create(createTestFileType(), true));
|
||||
myFileTypeManager.getRemovedMappingTracker().add(new ExtensionFileNameMatcher("xxx"), "Foo Files", true);
|
||||
WriteAction.run(() -> myFileTypeManager
|
||||
.setPatternsTable(new HashSet<>(Arrays.asList(myFileTypeManager.getRegisteredFileTypes())), myFileTypeManager.getExtensionMap().copy()));
|
||||
assertEquals(1, myFileTypeManager.getRemovedMappings().size());
|
||||
assertEquals(1, myFileTypeManager.getRemovedMappingTracker().getRemovedMappings().size());
|
||||
}
|
||||
|
||||
public void testGetRemovedMappings() {
|
||||
@@ -492,9 +491,9 @@ public class FileTypesTest extends PlatformTestCase {
|
||||
myFileTypeManager.loadState(element);
|
||||
|
||||
myFileTypeManager.initializeComponent();
|
||||
Map<FileNameMatcher, Pair<FileType, Boolean>> mappings = myFileTypeManager.getRemovedMappings();
|
||||
List<RemovedMappingTracker.RemovedMapping> mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings();
|
||||
assertEquals(1, mappings.size());
|
||||
assertEquals(typeFromPlugin, mappings.values().iterator().next().first);
|
||||
assertEquals(typeFromPlugin.getName(), mappings.get(0).getFileTypeName());
|
||||
}
|
||||
|
||||
public void testPreserveUninstalledPluginAssociations() {
|
||||
@@ -562,10 +561,10 @@ public class FileTypesTest extends PlatformTestCase {
|
||||
|
||||
myFileTypeManager.loadState(element);
|
||||
myFileTypeManager.initializeComponent();
|
||||
Map<FileNameMatcher, Pair<FileType, Boolean>> mappings = myFileTypeManager.getRemovedMappings();
|
||||
List<RemovedMappingTracker.RemovedMapping> mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings();
|
||||
assertEquals(1, mappings.size());
|
||||
assertEquals(ArchiveFileType.INSTANCE, mappings.values().iterator().next().first);
|
||||
mappings.clear();
|
||||
assertEquals(ArchiveFileType.INSTANCE.getName(), mappings.get(0).getFileTypeName());
|
||||
myFileTypeManager.getRemovedMappingTracker().clear();
|
||||
assertEquals(ArchiveFileType.INSTANCE, myFileTypeManager.getFileTypeByExtension("zip"));
|
||||
Element map = myFileTypeManager.getState().getChild("extensionMap");
|
||||
if (map != null) {
|
||||
|
||||
Reference in New Issue
Block a user