Java Code Examples for com.intellij.openapi.util.text.StringUtil#startsWithIgnoreCase()

private String replacePathMacro(String text, final String path, boolean caseSensitive) {
  if (text.length() < path.length() || path.isEmpty()) {
    return text;
  }

  boolean startsWith = caseSensitive ? text.startsWith(path) : StringUtil.startsWithIgnoreCase(text, path);

  if (!startsWith) return text;

  //check that this is complete path (ends with "/" or "!/")
  // do not collapse partial paths, i.e. do not substitute "/a/b/cd" in paths like "/a/b/cdeFgh"
  int endOfOccurrence = path.length();
  final boolean isWindowsRoot = path.endsWith(":/");
  if (!isWindowsRoot &&
      endOfOccurrence < text.length() &&
      text.charAt(endOfOccurrence) != '/' &&
      !text.substring(endOfOccurrence).startsWith("!/")) {
    return text;
  }

  return myMacroMap.get(path) + text.substring(endOfOccurrence);
}
 

private LoadingOrder(@NonNls @Nonnull String text) {
  myName = text;
  boolean last = false;
  boolean first = false;
  for (final String string : StringUtil.split(text, ORDER_RULE_SEPARATOR)) {
    String trimmed = string.trim();
    if (trimmed.equalsIgnoreCase(FIRST_STR)) first = true;
    else if (trimmed.equalsIgnoreCase(LAST_STR)) last = true;
    else if (StringUtil.startsWithIgnoreCase(trimmed, BEFORE_STR)) myBefore.add(trimmed.substring(BEFORE_STR.length()).trim());
    else if (StringUtil.startsWithIgnoreCase(trimmed, BEFORE_STR_OLD)) myBefore.add(trimmed.substring(BEFORE_STR_OLD.length()).trim());
    else if (StringUtil.startsWithIgnoreCase(trimmed, AFTER_STR)) myAfter.add(trimmed.substring(AFTER_STR.length()).trim());
    else if (StringUtil.startsWithIgnoreCase(trimmed, AFTER_STR_OLD)) myAfter.add(trimmed.substring(AFTER_STR_OLD.length()).trim());
    else throw new AssertionError("Invalid specification: " + trimmed + "; should be one of FIRST, LAST, BEFORE <id> or AFTER <id>");
  }
  myFirst = first;
  myLast = last;
}
 

private static boolean filenameMatchesPrefixOrType(final String fileName,
                                                   final String prefix,
                                                   final FileType[] suitableFileTypes,
                                                   final int invocationCount) {
  final boolean prefixMatched = prefix.length() == 0 || StringUtil.startsWithIgnoreCase(fileName, prefix);
  if (prefixMatched && (suitableFileTypes.length == 0 || invocationCount > 2)) return true;

  if (prefixMatched) {
    final String extension = FileUtilRt.getExtension(fileName);
    if (extension.length() == 0) return false;

    for (final FileType fileType : suitableFileTypes) {
      for (final FileNameMatcher matcher : FileTypeManager.getInstance().getAssociations(fileType)) {
        if (matcher.accept(fileName)) return true;
      }
    }
  }

  return false;
}
 

public static boolean isGenTarget(@NotNull String address) {
  return StringUtil.startsWithIgnoreCase(address, ".pants.d") ||
         StringUtil.startsWithIgnoreCase(address, PantsConstants.PANTS_PROJECT_MODULE_ID_PREFIX) ||
         // Checking "_synthetic_resources" is a temporary fix. It also needs to match the postfix added from pants in
         // src.python.pants.backend.python.targets.python_target.PythonTarget#_synthetic_resources_target
         // TODO: The long term solution is collect non-synthetic targets at pre-compile stage
         // https://github.com/pantsbuild/intellij-pants-plugin/issues/83
         address.toLowerCase().endsWith("_synthetic_resources");
}
 

public boolean prefixMatches(@NotNull String prefix, @NotNull String variant) {
	boolean matches = new CamelHumpMatcher(prefix, false).prefixMatches(variant.replace(' ', '_'));
	if (matches && StringUtil.isWhiteSpace(prefix.charAt(prefix.length() - 1))) {
		return StringUtil.startsWithIgnoreCase(variant, prefix);
	}
	return matches;
}
 

private boolean prefixMatchersInternal(final LookupElement element, final boolean itemCaseInsensitive) {
  for (final String name : element.getAllLookupStrings()) {
    if (itemCaseInsensitive && StringUtil.startsWithIgnoreCase(name, myPrefix) || prefixMatches(name)) {
      return true;
    }
    if (itemCaseInsensitive && CodeInsightSettings.ALL != CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE) {
      if (myCaseInsensitiveMatcher.matches(name)) {
        return true;
      }
    }
  }
  return false;
}
 

@Nullable
public static UnityProcess tryParseIfUnityProcess(ProcessInfo processInfo)
{
	String name = processInfo.getName();

	// Unity 2019.3 linux bug - 2020.1 ok
	if(name.equals("Main"))
	{
		List<String> list = StringUtil.split(processInfo.getCommand(), " ");
		String first = ContainerUtil.getFirstItem(list);
		if(first != null && first.endsWith("/Editor/Unity"))
		{
			return new UnityProcess(processInfo.getPid(), name, "localhost", buildDebuggerPort(processInfo.getPid()));
		}
	}

	if(StringUtil.startsWithIgnoreCase(name, "unity") || StringUtil.containsIgnoreCase(name, "Unity.app"))
	{
		// ignore 'UnityHelper' and 'Unity Helper'
		if(StringUtil.containsIgnoreCase(name, "Unity") && StringUtil.containsIgnoreCase(name, "Helper"))
		{
			return null;
		}

		if(StringUtil.containsIgnoreCase(name, "Unity") && StringUtil.containsIgnoreCase(name, "Hub") || StringUtil.containsIgnoreCase(name, "unityhub"))
		{
			return null;
		}

		if(StringUtil.containsIgnoreCase(name, "Unity") && StringUtil.containsIgnoreCase(name, "CrashHandler"))
		{
			return null;
		}

		// UnityShader - Package Manager - Hub compiler
		if(StringUtil.containsIgnoreCase(name, "UnityShader") || StringUtil.containsIgnoreCase(name, "UnityPackageMan"))
		{
			return null;
		}

		return new UnityProcess(processInfo.getPid(), name, "localhost", buildDebuggerPort(processInfo.getPid()));
	}

	return null;
}
 

public static boolean isParent(String parent, String path) {
  if (equals(parent, path)) return true;
  parent = appendParent(parent);
  return myIsCaseSensitive ? path.startsWith(parent) : StringUtil.startsWithIgnoreCase(path, parent);
}
 

@Override
public boolean value(CommitId commitId) {
  return StringUtil.startsWithIgnoreCase(commitId.getHash().asString(), myHashString);
}
 

private static double parseUnit(String unitString) {
  if (StringUtil.startsWithIgnoreCase(unitString, "k")) return (double)1 / 1024;
  if (StringUtil.startsWithIgnoreCase(unitString, "g")) return 1024;
  return 1;
}
 

@Override
public boolean isStartMatch(String name) {
  return StringUtil.startsWithIgnoreCase(name, getPrefix());
}
 

public static boolean isWrappedInHtml(@Nonnull String tooltip) {
  return StringUtil.startsWithIgnoreCase(tooltip, HTML_START) &&
         StringUtil.endsWithIgnoreCase(tooltip, HTML_END);
}
 

private int getRank(@Nonnull String text) {
  if (StringUtil.equalsIgnoreCase(StringUtil.trimEnd(text, "..."), pattern)) return 3;
  if (StringUtil.startsWithIgnoreCase(text, pattern)) return 2;
  if (StringUtil.containsIgnoreCase(text, pattern)) return 1;
  return 0;
}