@NotNull public static Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @NotNull PathMacros pathMacros) { final PathMacrosCollector collector = new PathMacrosCollector(); collector.substitute(root, true, false, filter); Set<String> preResult = collector.myMacroMap.keySet(); if (preResult.isEmpty()) { return Collections.emptySet(); } Set<String> result = new SmartHashSet<String>(preResult); result.removeAll(pathMacros.getSystemMacroNames()); result.removeAll(pathMacros.getLegacyMacroNames()); result.removeAll(PathMacrosImpl.getToolMacroNames()); result.removeAll(pathMacros.getIgnoredMacroNames()); return result; }
public void testWithFilter() throws Exception { Element root = new Element("root"); final Element testTag = new Element("test"); testTag.setAttribute("path", "$MACRO$"); testTag.setAttribute("ignore", "$PATH$"); root.addContent(testTag); final Set<String> macros = PathMacrosCollector.getMacroNames(root, null, new PathMacrosImpl()); assertEquals(2, macros.size()); assertTrue(macros.contains("MACRO")); assertTrue(macros.contains("PATH")); final Set<String> filtered = PathMacrosCollector.getMacroNames(root, new PathMacroFilter() { @Override public boolean skipPathMacros(Attribute attribute) { return "ignore".equals(attribute.getName()); } }, new PathMacrosImpl()); assertEquals(1, filtered.size()); assertTrue(macros.contains("MACRO")); }
public void testWithRecursiveFilter() throws Exception { Element root = new Element("root"); final Element configuration = new Element("configuration"); configuration.setAttribute("value", "some text$macro5$fdsjfhdskjfsd$MACRO$"); root.addContent(configuration); final Set<String> macros = PathMacrosCollector.getMacroNames(root, new PathMacroFilter() { @Override public boolean recursePathMacros(Attribute attribute) { return "value".equals(attribute.getName()); } }, new PathMacrosImpl()); assertEquals(2, macros.size()); assertTrue(macros.contains("macro5")); assertTrue(macros.contains("MACRO")); }
public void testWithRecursiveFilter() throws Exception { Element root = new Element("root"); final Element configuration = new Element("configuration"); configuration.setAttribute("value", "some text$macro5$fdsjfhdskjfsd$MACRO$"); root.addContent(configuration); final Set<String> macros = PathMacrosCollectorImpl.getMacroNames(root, new PathMacroFilter() { @Override public boolean recursePathMacros(Attribute attribute) { return "value".equals(attribute.getName()); } }, new PathMacrosImpl()); assertEquals(2, macros.size()); assertTrue(macros.contains("macro5")); assertTrue(macros.contains("MACRO")); }
public void testWithFilter() throws Exception { Element root = new Element("root"); final Element testTag = new Element("test"); testTag.setAttribute("path", "$MACRO$"); testTag.setAttribute("ignore", "$PATH$"); root.addContent(testTag); final Set<String> macros = PathMacrosCollectorImpl.getMacroNames(root, null, new PathMacrosImpl()); assertEquals(2, macros.size()); assertTrue(macros.contains("MACRO")); assertTrue(macros.contains("PATH")); final Set<String> filtered = PathMacrosCollectorImpl.getMacroNames(root, new PathMacroFilter() { @Override public boolean skipPathMacros(Attribute attribute) { return "ignore".equals(attribute.getName()); } }, new PathMacrosImpl()); assertEquals(1, filtered.size()); assertTrue(macros.contains("MACRO")); }
public final void substitute(@NotNull Element e, boolean caseSensitive, boolean recursively, @Nullable PathMacroFilter filter) { for (Content child : e.getContent()) { if (child instanceof Element) { substitute((Element)child, caseSensitive, recursively, filter); } else if (child instanceof Text) { Text t = (Text)child; if (filter == null || !filter.skipPathMacros(t)) { String oldText = t.getText(); String newText = (recursively || (filter != null && filter.recursePathMacros(t))) ? substituteRecursively(oldText, caseSensitive) : substitute(oldText, caseSensitive); if (oldText != newText) { // it is faster to call 'setText' right away than perform additional 'equals' check t.setText(newText); } } } else if (!(child instanceof Comment)) { LOG.error("Wrong content: " + child.getClass()); } } for (Attribute attribute : e.getAttributes()) { if (filter == null || !filter.skipPathMacros(attribute)) { String oldValue = attribute.getValue(); String newValue = (recursively || (filter != null && filter.recursePathMacros(attribute))) ? substituteRecursively(oldValue, caseSensitive) : substitute(oldValue, caseSensitive); if (oldValue != newValue) { // it is faster to call 'setValue' right away than perform additional 'equals' check attribute.setValue(newValue); } } } }
@Override public boolean skipPathMacros(Text element) { for (PathMacroFilter filter : myFilters) { if (filter.skipPathMacros(element)) return true; } return false; }
@Override public boolean skipPathMacros(Attribute attribute) { for (PathMacroFilter filter : myFilters) { if (filter.skipPathMacros(attribute)) return true; } return false; }
@Override public boolean recursePathMacros(Text element) { for (PathMacroFilter filter : myFilters) { if (filter.recursePathMacros(element)) return true; } return false; }
@Override public boolean recursePathMacros(Attribute attribute) { for (PathMacroFilter filter : myFilters) { if (filter.recursePathMacros(attribute)) return true; } return false; }
public void testWithRecursiveFilter() throws Exception { Element root = new Element("root"); final Element configuration = new Element("configuration"); configuration.setAttribute("value", "some text$macro5$fdsjfhdskjfsd$MACRO$"); configuration.setAttribute("value2", "file://$root$/some/path/just$file$name.txt"); root.addContent(configuration); final Set<String> macros = PathMacrosCollector.getMacroNames(root, new PathMacroFilter() { @Override public boolean recursePathMacros(Attribute attribute) { return "value".equals(attribute.getName()); } }, new PathMacrosImpl()); UsefulTestCase.assertSameElements(macros, "macro5", "MACRO", "root"); }
public final void substitute(@NotNull Element e, boolean caseSensitive, final boolean recursively, @Nullable PathMacroFilter filter) { List content = e.getContent(); //noinspection ForLoopReplaceableByForEach for (int i = 0, contentSize = content.size(); i < contentSize; i++) { Object child = content.get(i); if (child instanceof Element) { Element element = (Element)child; substitute(element, caseSensitive, recursively, filter); } else if (child instanceof Text) { Text t = (Text)child; if (filter == null || !filter.skipPathMacros(t)) { t.setText((recursively || (filter != null && filter.recursePathMacros(t))) ? substituteRecursively(t.getText(), caseSensitive) : substitute(t.getText(), caseSensitive)); } } else if (!(child instanceof Comment)) { LOG.error("Wrong content: " + child.getClass()); } } List attributes = e.getAttributes(); //noinspection ForLoopReplaceableByForEach for (int i = 0, attributesSize = attributes.size(); i < attributesSize; i++) { Object attribute1 = attributes.get(i); Attribute attribute = (Attribute)attribute1; if (filter == null || !filter.skipPathMacros(attribute)) { final String value = (recursively || (filter != null && filter.recursePathMacros(attribute))) ? substituteRecursively(attribute.getValue(), caseSensitive) : substitute(attribute.getValue(), caseSensitive); attribute.setValue(value); } } }
public static Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @NotNull final PathMacros pathMacros) { final PathMacrosCollector collector = new PathMacrosCollector(); collector.substitute(root, true, false, filter); final HashSet<String> result = new HashSet<String>(collector.myMacroMap.keySet()); result.removeAll(pathMacros.getSystemMacroNames()); result.removeAll(pathMacros.getLegacyMacroNames()); result.removeAll(PathMacrosImpl.getToolMacroNames()); result.removeAll(pathMacros.getIgnoredMacroNames()); return result; }
public final void substitute(@Nonnull Element e, boolean caseSensitive, boolean recursively, @Nullable PathMacroFilter filter) { for (Content child : e.getContent()) { if (child instanceof Element) { substitute((Element)child, caseSensitive, recursively, filter); } else if (child instanceof Text) { Text t = (Text)child; if (filter == null || !filter.skipPathMacros(t)) { String oldText = t.getText(); String newText = (recursively || (filter != null && filter.recursePathMacros(t))) ? substituteRecursively(oldText, caseSensitive) : substitute(oldText, caseSensitive); if (oldText != newText) { t.setText(newText); } } } else if (!(child instanceof Comment)) { LOGGER.error("Wrong content: " + child.getClass()); } } for (Attribute attribute : e.getAttributes()) { if (filter == null || !filter.skipPathMacros(attribute)) { String oldValue = attribute.getValue(); String newValue = (recursively || (filter != null && filter.recursePathMacros(attribute))) ? substituteRecursively(oldValue, caseSensitive) : substitute(oldValue, caseSensitive); if (oldValue != newValue) { attribute.setValue(newValue); } } } }
@Nonnull public static Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @Nonnull final PathMacros pathMacros) { final PathMacrosCollectorImpl collector = new PathMacrosCollectorImpl(); collector.substitute(root, true, false, filter); final HashSet<String> result = new HashSet<String>(collector.myMacroMap.keySet()); result.removeAll(pathMacros.getSystemMacroNames()); result.removeAll(pathMacros.getLegacyMacroNames()); for (Macro macro : MacroManager.getInstance().getMacros()) { result.remove(macro.getName()); } result.removeAll(MacroManager.getInstance().getMacros()); result.removeAll(pathMacros.getIgnoredMacroNames()); return result; }
public CompositePathMacroFilter(PathMacroFilter[] filters) { myFilters = filters; }
@Nonnull public Set<String> getMacroNames(@Nonnull final Element e) { return getMacroNames(e, new CompositePathMacroFilter(PathMacroFilter.EP_NAME.getExtensions()), PathMacros.getInstance()); }
@Override public Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @Nonnull PathMacros pathMacros) { return PathMacrosCollectorImpl.getMacroNames(root, filter, pathMacros); }
public MockApplicationEnvironment(@Nonnull Disposable parentDisposable) { super(parentDisposable); registerApplicationService(PathMacrosService.class, new PathMacrosServiceImpl()); registerApplicationExtensionPoint(Macro.EP_NAME, Macro.class); registerApplicationExtensionPoint(PathMacroFilter.EP_NAME, PathMacroFilter.class); registerApplicationComponent(PathMacros.class, new PathMacrosImpl()); registerApplicationService(MacroManager.class, new MacroManager()); registerApplicationService(UISettings.class, new UISettings()); }
public abstract Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @Nonnull final PathMacros pathMacros);