@Override
public Object findElement(String s) {
List<ObjectWithWeight> elements = new ArrayList<ObjectWithWeight>();
s = s.trim();
final ListIterator<Object> it = getElementIterator(0);
while (it.hasNext()) {
final ObjectWithWeight o = new ObjectWithWeight(it.next(), s, getComparator());
if (!o.weights.isEmpty()) {
elements.add(o);
}
}
ObjectWithWeight cur = null;
ArrayList<ObjectWithWeight> current = new ArrayList<ObjectWithWeight>();
for (ObjectWithWeight element : elements) {
if (cur == null) {
cur = element;
current.add(cur);
continue;
}
final int i = element.compareWith(cur);
if (i == 0) {
current.add(element);
} else if (i < 0) {
cur = element;
current.clear();
current.add(cur);
}
}
return current.isEmpty() ? null : findClosestTo(myInitialPsiElement, current);
}
public void addProgress(@NotNull ProgressIndicatorEx original, @NotNull TaskInfo info) {
synchronized (myOriginals) {
final boolean veryFirst = !hasProgressIndicators();
myOriginals.add(original);
myInfos.add(info);
final InlineProgressIndicator expanded = createInlineDelegate(info, original, false);
final InlineProgressIndicator compact = createInlineDelegate(info, original, true);
myPopup.addIndicator(expanded);
myProgressIcon.resume();
if (veryFirst && !myPopup.isShowing()) {
buildInInlineIndicator(compact);
} else {
buildInProcessCount();
if (myInfos.size() > 1 && Registry.is("ide.windowSystem.autoShowProcessPopup")) {
openProcessPopup(false);
}
}
runQuery();
}
}
static {
ourAbstractUrlProviders.add(new ModuleUrl(null, null));
ourAbstractUrlProviders.add(new DirectoryUrl(null, null));
ourAbstractUrlProviders.add(new ModuleGroupUrl(null));
ourAbstractUrlProviders.add(new PsiFileUrl(null));
ourAbstractUrlProviders.add(new LibraryModuleGroupUrl(null));
ourAbstractUrlProviders.add(new NamedLibraryUrl(null, null));
}
private void mergeWithDefaultConfiguration() {
final ArrayList<Configuration> cfgList = new ArrayList<Configuration>();
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
final String config = support.getDefaultConfigUrl();
final URL url = config == null ? null : support.getClass().getResource(config);
if (url != null) {
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
}
final THashSet<Object> visited = new THashSet<Object>();
for (IdeaPluginDescriptor pluginDescriptor : PluginManager.getPlugins()) {
if (pluginDescriptor instanceof IdeaPluginDescriptorImpl
&& !((IdeaPluginDescriptorImpl) pluginDescriptor).isEnabled()) continue;
final ClassLoader loader = pluginDescriptor.getPluginClassLoader();
if (!visited.add(loader)) continue;
if (loader instanceof PluginClassLoader && ((PluginClassLoader) loader).getUrls().isEmpty())
continue;
try {
final Enumeration<URL> enumeration = loader.getResources("META-INF/languageInjections.xml");
if (enumeration == null) continue;
while (enumeration.hasMoreElements()) {
URL url = enumeration.nextElement();
if (!visited.add(url.getFile())) continue; // for DEBUG mode
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
} catch (Exception e) {
LOG.warn(e);
}
}
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
myDefaultInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
for (Configuration cfg : cfgList) {
final List<BaseInjection> imported = cfg.getInjections(supportId);
myDefaultInjections.addAll(imported);
importInjections(getInjections(supportId), imported, originalInjections, newInjections);
}
}
replaceInjections(newInjections, originalInjections);
}
@Nullable
private Object findClosestTo(PsiElement path, ArrayList<ObjectWithWeight> paths) {
if (path == null || myInitialPsiElement == null) {
return paths.get(0).node;
}
final Set<PsiElement> parents = getAllParents(myInitialPsiElement);
ArrayList<ObjectWithWeight> cur = new ArrayList<ObjectWithWeight>();
int max = -1;
for (ObjectWithWeight p : paths) {
final Object last = ((TreePath) p.node).getLastPathComponent();
final List<PsiElement> elements = new ArrayList<PsiElement>();
final Object object = ((DefaultMutableTreeNode) last).getUserObject();
if (object instanceof FilteringTreeStructure.FilteringNode) {
FilteringTreeStructure.FilteringNode node = (FilteringTreeStructure.FilteringNode) object;
FilteringTreeStructure.FilteringNode candidate = node;
while (node != null) {
elements.add(getPsi(node));
node = node.getParentNode();
}
final int size = ContainerUtil.intersection(parents, elements).size();
if (size == elements.size() - 1
&& size == parents.size() - (myInitialNodeIsLeaf ? 1 : 0)
&& candidate.children().isEmpty()) {
return p.node;
}
if (size > max) {
max = size;
cur.clear();
cur.add(p);
} else if (size == max) {
cur.add(p);
}
}
}
Collections.sort(
cur,
new Comparator<ObjectWithWeight>() {
@Override
public int compare(ObjectWithWeight o1, ObjectWithWeight o2) {
final int i = o1.compareWith(o2);
return i != 0
? i
: ((TreePath) o2.node).getPathCount() - ((TreePath) o1.node).getPathCount();
}
});
return cur.isEmpty() ? null : cur.get(0).node;
}
@Nullable
public static Configuration load(final InputStream is) throws IOException, JDOMException {
try {
final Document document = JDOMUtil.loadDocument(is);
final ArrayList<Element> elements = new ArrayList<Element>();
elements.add(document.getRootElement());
elements.addAll(document.getRootElement().getChildren("component"));
final Element element =
ContainerUtil.find(
elements,
new Condition<Element>() {
public boolean value(final Element element) {
return "component".equals(element.getName())
&& COMPONENT_NAME.equals(element.getAttributeValue("name"));
}
});
if (element != null) {
final Configuration cfg = new Configuration();
cfg.loadState(element, false);
return cfg;
}
return null;
} finally {
is.close();
}
}
private List<InjInfo> getSelectedInjections() {
final ArrayList<InjInfo> toRemove = new ArrayList<InjInfo>();
for (int row : myInjectionsTable.getSelectedRows()) {
toRemove.add(myInjectionsTable.getItems().get(myInjectionsTable.convertRowIndexToModel(row)));
}
return toRemove;
}
@NotNull
public List<EditorWindow> findWindows(final VirtualFile file) {
final ArrayList<EditorWindow> res = new ArrayList<EditorWindow>();
for (final EditorWindow window : myWindows) {
if (window.findFileComposite(file) != null) {
res.add(window);
}
}
return res;
}
@NotNull
public List<EditorWithProviderComposite> findEditorComposites(final VirtualFile file) {
final ArrayList<EditorWithProviderComposite> res = new ArrayList<EditorWithProviderComposite>();
for (final EditorWindow window : myWindows) {
final EditorWithProviderComposite fileComposite = window.findFileComposite(file);
if (fileComposite != null) {
res.add(fileComposite);
}
}
return res;
}
/**
* @return breakpoints of one of the category: LINE_BREAKPOINTS, EXCEPTION_BREAKPOINTS,
* FIELD_BREAKPOINTS, METHOD_BREAKPOINTS
*/
public <T extends Breakpoint> Breakpoint[] getBreakpoints(@NotNull final Key<T> category) {
ApplicationManager.getApplication().assertIsDispatchThread();
removeInvalidBreakpoints();
final ArrayList<Breakpoint> breakpoints = new ArrayList<Breakpoint>();
for (Breakpoint breakpoint : getBreakpoints()) {
if (category.equals(breakpoint.getCategory())) {
breakpoints.add(breakpoint);
}
}
return breakpoints.toArray(new Breakpoint[breakpoints.size()]);
}
private void removeInvalidBreakpoints() {
ArrayList<Breakpoint> toDelete = new ArrayList<Breakpoint>();
for (Breakpoint breakpoint : getBreakpoints()) {
if (!breakpoint.isValid()) {
toDelete.add(breakpoint);
}
}
for (final Breakpoint aToDelete : toDelete) {
removeBreakpoint(aToDelete);
}
}
public boolean setHostInjectionEnabled(
final PsiLanguageInjectionHost host,
final Collection<String> languages,
final boolean enabled) {
final ArrayList<BaseInjection> originalInjections = new ArrayList<BaseInjection>();
final ArrayList<BaseInjection> newInjections = new ArrayList<BaseInjection>();
for (String supportId : getAllInjectorIds()) {
for (BaseInjection injection : getInjections(supportId)) {
if (!languages.contains(injection.getInjectedLanguageId())) continue;
boolean replace = false;
final ArrayList<InjectionPlace> newPlaces = new ArrayList<InjectionPlace>();
for (InjectionPlace place : injection.getInjectionPlaces()) {
if (place.isEnabled() != enabled
&& place.getElementPattern() != null
&& (place.getElementPattern().accepts(host)
|| place.getElementPattern().accepts(host.getParent()))) {
newPlaces.add(new InjectionPlace(place.getText(), place.getElementPattern(), enabled));
replace = true;
} else newPlaces.add(place);
}
if (replace) {
originalInjections.add(injection);
final BaseInjection newInjection = injection.copy();
newInjection.getInjectionPlaces().clear();
newInjection.getInjectionPlaces().addAll(newPlaces);
newInjections.add(newInjection);
}
}
}
if (!originalInjections.isEmpty()) {
replaceInjectionsWithUndo(
host.getProject(),
newInjections,
originalInjections,
Collections.<PsiElement>emptyList());
return true;
}
return false;
}
private static List<ShelvedBinaryFile> getBinaryFilesToUnshelve(
final ShelvedChangeList changeList,
final List<ShelvedBinaryFile> binaryFiles,
final List<ShelvedBinaryFile> remainingBinaries) {
if (binaryFiles == null) {
return new ArrayList<ShelvedBinaryFile>(changeList.getBinaryFiles());
}
ArrayList<ShelvedBinaryFile> result = new ArrayList<ShelvedBinaryFile>();
for (ShelvedBinaryFile file : changeList.getBinaryFiles()) {
if (binaryFiles.contains(file)) {
result.add(file);
} else {
remainingBinaries.add(file);
}
}
return result;
}
public static <T> void assertOrderedEquals(
final String erroMsg,
final Iterable<? extends T> actual,
final Collection<? extends T> expected) {
ArrayList<T> list = new ArrayList<T>();
for (T t : actual) {
list.add(t);
}
if (!list.equals(new ArrayList<T>(expected))) {
String expectedString = toString(expected);
String actualString = toString(actual);
Assert.assertEquals(erroMsg, expectedString, actualString);
Assert.fail(
"Warning! 'toString' does not reflect the difference.\nExpected: "
+ expectedString
+ "\nActual: "
+ actualString);
}
}
private void baseRevisionsOfDvcsIntoContext(
List<Change> textChanges, CommitContext commitContext) {
ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (vcsManager.dvcsUsedInProject()
&& VcsConfiguration.getInstance(myProject).INCLUDE_TEXT_INTO_SHELF) {
final Set<Change> big = SelectFilesToAddTextsToPatchPanel.getBig(textChanges);
final ArrayList<FilePath> toKeep = new ArrayList<FilePath>();
for (Change change : textChanges) {
if (change.getBeforeRevision() == null || change.getAfterRevision() == null) continue;
if (big.contains(change)) continue;
FilePath filePath = ChangesUtil.getFilePath(change);
final AbstractVcs vcs = vcsManager.getVcsFor(filePath);
if (vcs != null && VcsType.distibuted.equals(vcs.getType())) {
toKeep.add(filePath);
}
}
commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, true);
commitContext.putUserData(BaseRevisionTextPatchEP.ourBaseRevisionPaths, toKeep);
}
}
private static List<BaseInjection> loadDefaultInjections() {
final ArrayList<Configuration> cfgList = new ArrayList<Configuration>();
final THashSet<Object> visited = new THashSet<Object>();
for (LanguageInjectionConfigBean configBean :
Extensions.getExtensions(LanguageInjectionSupport.CONFIG_EP_NAME)) {
PluginDescriptor descriptor = configBean.getPluginDescriptor();
final ClassLoader loader = descriptor.getPluginClassLoader();
try {
final Enumeration<URL> enumeration = loader.getResources(configBean.getConfigUrl());
if (enumeration == null || !enumeration.hasMoreElements()) {
LOG.warn(descriptor.getPluginId() + ": " + configBean.getConfigUrl() + " was not found");
} else {
while (enumeration.hasMoreElements()) {
URL url = enumeration.nextElement();
if (!visited.add(url.getFile())) continue; // for DEBUG mode
try {
cfgList.add(load(url.openStream()));
} catch (Exception e) {
LOG.warn(e);
}
}
}
} catch (Exception e) {
LOG.warn(e);
}
}
final ArrayList<BaseInjection> defaultInjections = new ArrayList<BaseInjection>();
for (String supportId : InjectorUtils.getActiveInjectionSupportIds()) {
for (Configuration cfg : cfgList) {
final List<BaseInjection> imported = cfg.getInjections(supportId);
defaultInjections.addAll(imported);
}
}
return defaultInjections;
}
