Java Code Examples for org.eclipse.jgit.util.StringUtils#isEmptyOrNull()

/**
 * Compare the two given git remote URIs. This method is a reimplementation of {@link URIish#equals(Object)} with
 * one difference. The scheme of the URIs is only considered if both URIs have a non-null and non-empty scheme part.
 *
 * @param lhs
 *            the left hand side
 * @param rhs
 *            the right hand side
 * @return <code>true</code> if the two URIs are to be considered equal and <code>false</code> otherwise
 */
private static boolean equals(URIish lhs, URIish rhs) {
	// We only consider the scheme if both URIs have one
	if (!StringUtils.isEmptyOrNull(lhs.getScheme()) && !StringUtils.isEmptyOrNull(rhs.getScheme())) {
		if (!Objects.equals(lhs.getScheme(), rhs.getScheme()))
			return false;
	}
	if (!equals(lhs.getUser(), rhs.getUser()))
		return false;
	if (!equals(lhs.getPass(), rhs.getPass()))
		return false;
	if (!equals(lhs.getHost(), rhs.getHost()))
		return false;
	if (lhs.getPort() != rhs.getPort())
		return false;
	if (!pathEquals(lhs.getPath(), rhs.getPath()))
		return false;
	return true;
}
 

private static boolean pathEquals(String lhs, String rhs) {
	if (StringUtils.isEmptyOrNull(lhs) && StringUtils.isEmptyOrNull(rhs))
		return true;

	// Skip leading slashes in both paths.
	int lhsIndex = 0;
	while (lhsIndex < lhs.length() && lhs.charAt(lhsIndex) == '/')
		++lhsIndex;

	int rhsIndex = 0;
	while (rhsIndex < rhs.length() && rhs.charAt(rhsIndex) == '/')
		++rhsIndex;

	String lhsRel = lhs.substring(lhsIndex);
	String rhsRel = rhs.substring(rhsIndex);
	return lhsRel.equals(rhsRel);
}
 

private String retrievePushedBy(final PushHook hook) {
    final String userName = hook.getUserName();
    if (!StringUtils.isEmptyOrNull(userName)) {
        return userName;
    }

    final String userUsername = hook.getUserUsername();
    if (!StringUtils.isEmptyOrNull(userUsername)) {
        return userUsername;
    }

    final List<Commit> commits = hook.getCommits();
    if (commits != null && !commits.isEmpty()) {
        return commits.get(commits.size() - 1).getAuthor().getName();
    }

    return null;
}
 

private Link createToken(
    @NotNull HttpServletRequest req,
    @Nullable URI uri,
    @Nullable String secretToken,
    @Nullable String userId,
    @Nullable String mode
) throws ServerError {
  // Check secretToken
  if (StringUtils.isEmptyOrNull(secretToken))
    throw new ServerError(HttpServletResponse.SC_BAD_REQUEST, "Parameter \"secretToken\" not specified");

  if (!this.secretToken.equals(secretToken))
    throw new ServerError(HttpServletResponse.SC_FORBIDDEN, "Invalid secretToken");

  final LfsAuthHelper.AuthMode authMode = LfsAuthHelper.AuthMode.find(mode);
  if (authMode == null)
    throw new ServerError(HttpServletResponse.SC_BAD_REQUEST, String.format("Unsupported mode: %s", mode));

  return LfsAuthHelper.createToken(context.getShared(), uri != null ? uri : getWebServer().getUrl(req).resolve(baseLfsUrl), userId, authMode, tokenExpireSec, tokenExpireTime);
}
 

private static List<File> getGitDiffFilesToProcess(List<Pattern> patternsToExclude, CommandLine commandLine) {
    String gitDirPath = commandLine.getOptionValue(OPTION_GIT_DIR_NAME);
    File repoDir = new File(gitDirPath);
    if (!repoDir.isDirectory()) {
        System.out.println("git directory " + gitDirPath + " is not a directory!");
        System.exit(1);
    }
    String oldRev = commandLine.getOptionValue(OPTION_GIT_BASE_REV_NAME);
    boolean includeStagedCodes = commandLine.hasOption(OPTION_GIT_INCLUDE_STAGED_CODES_NAME);
    if (StringUtils.isEmptyOrNull(oldRev)) {
        oldRev = includeStagedCodes ? "HEAD" : "HEAD~";
    }
    String newRev = "HEAD";
    DiffCalculator calculator = DiffCalculator.builder().diffAlgorithm(new HistogramDiff()).build();
    try {
        List<DiffEntryWrapper> diffEntryList = calculator.calculateDiff(repoDir, oldRev, newRev, includeStagedCodes)
                .stream()
                .filter(diffEntry -> !diffEntry.isDeleted())
                .filter(diffEntry -> patternsToExclude.stream()
                        .noneMatch(p -> p.matcher(diffEntry.getNewPath()).matches()))
                .collect(Collectors.toList());

        DIFF_ENTRY_LIST.addAll(diffEntryList);

        return diffEntryList.stream()
                .map(DiffEntryWrapper::getNewFile)
                .collect(Collectors.toList());

    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("error happened when calculate git diff");
        return Collections.emptyList();
    }
}
 

private static String retrievePushedBy(final PushHook hook) {
    String userName = hook.getUserName();
    if (!StringUtils.isEmptyOrNull(userName)) {
        return userName;
    }

    final List<Commit> commits = hook.getCommits();
    if (commits != null && !commits.isEmpty()) {
        return commits.get(commits.size() - 1).getAuthor().getName();
    }

    return null;
}
 

public FormValidation doCheckName(@QueryParameter String id, @QueryParameter String value) {
    if (StringUtils.isEmptyOrNull(value)) {
        return FormValidation.error(Messages.name_required());
    } else {
        return FormValidation.ok();
    }
}
 

public FormValidation doCheckUrl(@QueryParameter String value) {
    if (StringUtils.isEmptyOrNull(value)) {
        return FormValidation.error(Messages.url_required());
    } else {
        return FormValidation.ok();
    }
}
 

public FormValidation doCheckApiTokenId(@QueryParameter String value) {
    if (StringUtils.isEmptyOrNull(value)) {
        return FormValidation.error(Messages.apiToken_required());
    } else {
        return FormValidation.ok();
    }
}
 

/**
 * A helper method for comparing strings. If both of the given strings are empty or <code>null</code>, they are
 * considered equal.
 *
 * @param lhs
 *            the left hand side
 * @param rhs
 *            the right hand side
 * @return <code>true</code> if the two strings are to be considered equal and <code>false</code> otherwise
 */
private static boolean equals(String lhs, String rhs) {
	if (StringUtils.isEmptyOrNull(lhs) && StringUtils.isEmptyOrNull(rhs))
		return true;
	return Objects.equals(lhs, rhs);
}