com.intellij.codeInsight.completion.PrefixMatcher Java Examples

private static boolean completeTillTypedCharOccurrence(char charTyped, LookupImpl lookup, LookupElement item) {
  PrefixMatcher matcher = lookup.itemMatcher(item);
  final String oldPrefix = matcher.getPrefix() + lookup.getAdditionalPrefix();
  PrefixMatcher expanded = matcher.cloneWithPrefix(oldPrefix + charTyped);
  if (expanded.prefixMatches(item)) {
    for (String s : item.getAllLookupStrings()) {
      if (matcher.prefixMatches(s)) {
        int i = -1;
        while (true) {
          i = s.indexOf(charTyped, i + 1);
          if (i < 0) break;
          final String newPrefix = s.substring(0, i + 1);
          if (expanded.prefixMatches(newPrefix)) {
            lookup.replacePrefix(oldPrefix, newPrefix);
            return true;
          }
        }
      }
    }
  }
  return false;
}
 

@NotNull
@Override
public Collection<LookupElement> getLookupElements(@NotNull PhpToolboxCompletionContributorParameter parameter) {
    return PhpIndex.getInstance(parameter.getProject())
        .getAllFunctionNames(PrefixMatcher.ALWAYS_TRUE).stream().map(
            s -> LookupElementBuilder.create(s).withIcon(PhpIcons.FUNCTION)
        )
        .collect(Collectors.toCollection(HashSet::new));
}
 

public final void prefixReplaced(Lookup lookup, String newPrefix) {
  ArrayList<LookupElement> itemCopy = new ArrayList<>(myItems);
  myItems.clear();
  for (LookupElement item : itemCopy) {
    if (item.isValid()) {
      PrefixMatcher matcher = itemMatcher(item).cloneWithPrefix(newPrefix);
      if (matcher.prefixMatches(item)) {
        item.putUserData(myMatcherKey, matcher);
        myItems.add(item);
      }
    }
  }

  prefixChanged(lookup);
}
 

private boolean prefixMatches(LookupElement item) {
  PrefixMatcher matcher = itemMatcher(item);
  if (!myAdditionalPrefix.isEmpty()) {
    matcher = matcher.cloneWithPrefix(matcher.getPrefix() + myAdditionalPrefix);
  }
  return matcher.prefixMatches(item);
}
 

@Override
@Nonnull
public PrefixMatcher itemMatcher(@Nonnull LookupElement item) {
  PrefixMatcher matcher = item.getUserData(myMatcherKey);
  if (matcher == null) {
    throw new AssertionError("Item not in lookup: item=" + item + "; lookup items=" + myItems);
  }
  return matcher;
}
 

@NotNull
@Override
public Collection<LookupElement> getLookupElements(@NotNull PhpToolboxCompletionContributorParameter parameter) {
    return PhpIndex.getInstance(parameter.getProject())
        .getAllFunctionNames(PrefixMatcher.ALWAYS_TRUE).stream().map(
            s -> LookupElementBuilder.create(s).withIcon(PhpIcons.FUNCTION)
        )
        .collect(Collectors.toCollection(HashSet::new));
}
 

@Override
@Nonnull
public PrefixMatcher cloneWithPrefix(@Nonnull final String prefix) {
  if (prefix.equals(myPrefix)) {
    return this;
  }

  return new CamelHumpMatcher(prefix, myCaseSensitive, myTypoTolerant);
}
 

public static int getBestMatchingDegree(LookupElement element, PrefixMatcher matcher) {
  int max = Integer.MIN_VALUE;
  for (String lookupString : element.getAllLookupStrings()) {
    max = Math.max(max, matcher.matchingDegree(lookupString));
  }
  return -max;
}
 

@Nonnull
protected BetterPrefixMatcher createCopy(PrefixMatcher original, int degree) {
  return new BetterPrefixMatcher(original, degree);
}
 

@Nullable
public PrefixMatcher createPrefixMatcher(@Nonnull final String prefix) {
  return new PlainPrefixMatcher(prefix);
}
 

public void registerMatcher(@Nonnull LookupElement item, @Nonnull PrefixMatcher matcher) {
  item.putUserData(myMatcherKey, matcher);
}
 

@Nonnull
@Override
protected BetterPrefixMatcher createCopy(PrefixMatcher original, int degree) {
  return new AutoRestarting(myResult, original, degree);
}
 

private AutoRestarting(CompletionResultSet result, PrefixMatcher original, int minMatchingDegree) {
  super(original, minMatchingDegree);
  myResult = result;
}
 

@Nonnull
@Override
public PrefixMatcher cloneWithPrefix(@Nonnull String prefix) {
  return createCopy(myOriginal.cloneWithPrefix(prefix), myMinMatchingDegree);
}
 

private static CompletionResult createCompletionResultFor(PsiClass cls) {
  TestLookupElement lookupElement = new TestLookupElement(cls);
  PrefixMatcher matcher = Mockito.mock(PrefixMatcher.class);
  Mockito.when(matcher.prefixMatches(any(LookupElement.class))).thenReturn(true);
  return CompletionResult.wrap(lookupElement, matcher, Mockito.mock(CompletionSorter.class));
}
 

public BetterPrefixMatcher(PrefixMatcher original, int minMatchingDegree) {
  super(original.getPrefix());
  myOriginal = original;
  myHumpMatcher = original instanceof CamelHumpMatcher ? (CamelHumpMatcher)original : null;
  myMinMatchingDegree = minMatchingDegree;
}
 

@Nonnull
PrefixMatcher itemMatcher(@Nonnull LookupElement item);
 

@Nonnull
PrefixMatcher itemMatcher(@Nonnull LookupElement item);
 

public static Collection<String> getAllExistingClassNames(Project project, PrefixMatcher prefixMatcher) {
    return getPhpIndex(project).getAllClassNames(prefixMatcher);
}
 

public static Collection<String> getAllExistingFunctionNames(Project project, PrefixMatcher prefixMatcher) {
    return getPhpIndex(project).getAllFunctionNames(prefixMatcher);
}
 

@NotNull
@Override
public PrefixMatcher cloneWithPrefix(@NotNull String prefix) {
    return new GaugePrefixMatcher(prefix);
}
 

@Override
public CompletionResultSet withPrefixMatcher(PrefixMatcher matcher) {
  return null;
}
 

TestCompletionResultSet() {
  super(
      Mockito.mock(PrefixMatcher.class),
      Mockito.mock(Consumer.class),
      Mockito.mock(CompletionContributor.class));
}