From 765a1bf50baabd2a911f85a91b20992c7500889d Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 29 May 2019 19:32:46 +0200 Subject: [PATCH] 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 --- .../fileTypes/impl/AbstractFileType.java | 42 +---- .../impl/ApproveRemovedMappingsActivity.java | 22 +-- .../fileTypes/impl/FileTypeManagerImpl.java | 86 +++------ .../fileTypes/impl/RemovedMappingTracker.java | 171 ++++++++++++++++++ .../openapi/fileTypes/impl/FileTypesTest.java | 41 ++--- 5 files changed, 230 insertions(+), 132 deletions(-) create mode 100644 platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java index 368679aa2bfc..ebf9a736a8b5 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java @@ -304,11 +304,7 @@ public class AbstractFileType extends UserFileType 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 implements return result; } - @NotNull - public static List> readRemovedAssociations(@NotNull Element element) { - List children = element.getChildren(ELEMENT_REMOVED_MAPPING); - if (children.isEmpty()) { - return Collections.emptyList(); - } - - List> 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 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()); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java index 4a7bfeb7587b..1b2b4e1fa80c 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java @@ -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> map = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappings(); - if (!map.isEmpty()) { + RemovedMappingTracker removedMappings = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappingTracker(); + List list = removedMappings.retrieveUnapprovedMappings(); + if (!list.isEmpty()) { UIUtil.invokeAndWaitIfNeeded((Runnable)() -> { - for (Iterator>> iterator = map.entrySet().iterator(); iterator.hasNext(); ) { - Map.Entry> 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() + " Revert", @@ -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(); } }); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java index 76a27418fc2e..e43456ed27bb 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java @@ -103,9 +103,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent private final FileTypeAssocTable myInitialAssociations = new FileTypeAssocTable<>(); private final Map myUnresolvedMappings = new THashMap<>(); - private final Map> myUnresolvedRemovedMappings = new THashMap<>(); - /** This will contain removed mappings with "approved" states */ - private final Map> 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> removedAssociations = AbstractFileType.readRemovedAssociations(e); - for (Trinity 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> entry : myRemovedMappings.entrySet()) { - Pair 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 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 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 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>> iterator = myRemovedMappings.entrySet().iterator(); - while (iterator.hasNext()) { - Map.Entry> 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 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> 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()); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java new file mode 100644 index 000000000000..7760a3d086c1 --- /dev/null +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java @@ -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 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 readRemovedMappings(@NotNull Element e) { + List children = e.getChildren(ELEMENT_REMOVED_MAPPING); + if (children.isEmpty()) { + return Collections.emptyList(); + } + + List 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 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 getRemovedMappings() { + return new ArrayList<>(myRemovedMappings.values()); + } + + public List getMappingsForFileType(String name) { + List result = new ArrayList<>(); + for (RemovedMapping mapping : myRemovedMappings.values()) { + if (mapping.myFileTypeName.equals(name)) { + result.add(mapping.myFileNameMatcher); + } + } + return result; + } + + void removeMatching(BiPredicate predicate) { + for (Iterator> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) { + Map.Entry next = it.next(); + if (predicate.test(next.getValue().myFileNameMatcher, next.getValue().myFileTypeName)) { + it.remove(); + } + } + } + + List retrieveUnapprovedMappings() { + List result = new ArrayList<>(); + for (Iterator> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) { + Map.Entry 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; + } +} diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java index 5d1e5e73fdb1..c625d262ecef 100644 --- a/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java +++ b/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java @@ -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> mappings = myFileTypeManager.getRemovedMappings(); - Pair pair = mappings.get(matcher); - assertNotNull(pair); - assertTrue(pair.second); + List 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> mappings = myFileTypeManager.getRemovedMappings(); - Pair pair = mappings.get(matcher); - assertNotNull(pair); - assertTrue(pair.second); + List 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> mappings = myFileTypeManager.getRemovedMappings(); + List 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> mappings = myFileTypeManager.getRemovedMappings(); + List 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) {