Java 类com.intellij.openapi.application.PathMacroFilter 实例源码

项目：intellij-ce-playground 文件：PathMacrosCollector.java

@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;
}

项目：intellij-ce-playground 文件：PathMacrosCollectorTest.java

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"));
}

项目：tools-idea 文件：PathMacrosCollectorTest.java

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"));
}

项目：tools-idea 文件：PathMacrosCollectorTest.java

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"));
}

项目：consulo 文件：PathMacrosCollectorTest.java

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"));
}

项目：consulo 文件：PathMacrosCollectorTest.java

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"));
}

项目：intellij-ce-playground 文件：PathMacroMap.java

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);
      }
    }
  }
}

项目：intellij-ce-playground 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(element)) return true;
  }
  return false;
}

项目：intellij-ce-playground 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(attribute)) return true;
  }
  return false;
}

项目：intellij-ce-playground 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(element)) return true;
  }
  return false;
}

项目：intellij-ce-playground 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(attribute)) return true;
  }
  return false;
}

项目：intellij-ce-playground 文件：PathMacrosCollectorTest.java

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");
}

项目：tools-idea 文件：PathMacroMap.java

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);
    }
  }
}

项目：tools-idea 文件：PathMacrosCollector.java

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;
}

项目：tools-idea 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(element)) return true;
  }
  return false;
}

项目：tools-idea 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(attribute)) return true;
  }
  return false;
}

项目：tools-idea 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(element)) return true;
  }
  return false;
}

项目：tools-idea 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(attribute)) return true;
  }
  return false;
}

项目：consulo 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(element)) return true;
  }
  return false;
}

项目：consulo 文件：CompositePathMacroFilter.java

@Override
public boolean skipPathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.skipPathMacros(attribute)) return true;
  }
  return false;
}

项目：consulo 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Text element) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(element)) return true;
  }
  return false;
}

项目：consulo 文件：CompositePathMacroFilter.java

@Override
public boolean recursePathMacros(Attribute attribute) {
  for (PathMacroFilter filter : myFilters) {
    if (filter.recursePathMacros(attribute)) return true;
  }
  return false;
}

项目：consulo 文件：PathMacroMap.java

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);
      }
    }
  }
}

项目：consulo 文件：PathMacrosCollectorImpl.java

@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;
}

项目：intellij-ce-playground 文件：CompositePathMacroFilter.java

public CompositePathMacroFilter(PathMacroFilter[] filters) {
  myFilters = filters;
}

项目：tools-idea 文件：CompositePathMacroFilter.java

public CompositePathMacroFilter(PathMacroFilter[] filters) {
  myFilters = filters;
}

项目：consulo 文件：CompositePathMacroFilter.java

public CompositePathMacroFilter(PathMacroFilter[] filters) {
  myFilters = filters;
}

项目：consulo 文件：PathMacrosService.java

@Nonnull
public Set<String> getMacroNames(@Nonnull final Element e) {
  return getMacroNames(e, new CompositePathMacroFilter(PathMacroFilter.EP_NAME.getExtensions()), PathMacros.getInstance());
}

项目：consulo 文件：PathMacrosServiceImpl.java

@Override
public Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @Nonnull PathMacros pathMacros) {
  return PathMacrosCollectorImpl.getMacroNames(root, filter, pathMacros);
}

项目：consulo 文件：MockApplicationEnvironment.java

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());
}

项目：consulo 文件：PathMacrosService.java

public abstract Set<String> getMacroNames(Element root, @Nullable PathMacroFilter filter, @Nonnull final PathMacros pathMacros);