public static String humanize(String s) { String[] strings = StringUtils.splitByCharacterTypeCamelCase(s); for (int i = 0; i < strings.length; i++) { String string = strings[i]; strings[i] = string.toLowerCase(); } return StringUtils.join(strings, " "); }
protected String getConstantName(String nodeName, String customName) { if (isNotBlank(customName)) { return customName; } List<String> enumNameGroups = new ArrayList<>(asList(splitByCharacterTypeCamelCase(nodeName))); String enumName = ""; for (Iterator<String> iter = enumNameGroups.iterator(); iter.hasNext();) { if (containsOnly(ruleFactory.getNameHelper().replaceIllegalCharacters(iter.next()), "_")) { iter.remove(); } } enumName = upperCase(join(enumNameGroups, "_")); if (isEmpty(enumName)) { enumName = "__EMPTY__"; } else if (Character.isDigit(enumName.charAt(0))) { enumName = "_" + enumName; } return enumName; }
private void checkPrefixedTransformMethods(ASTMethodDeclaration node, Object data, String nameOfMethod) { ASTResultType resultType = node.getResultType(); List<String> prefixes = getProperty(TRANSFORM_METHOD_NAMES_PROPERTY); String[] splitMethodName = StringUtils.splitByCharacterTypeCamelCase(nameOfMethod); if (resultType.isVoid() && splitMethodName.length > 0 && prefixes.contains(splitMethodName[0].toLowerCase(Locale.ROOT))) { // "To" or any other configured prefix found addViolationWithMessage(data, node, "Linguistics Antipattern - The transform method ''{0}'' should not return void linguistically", new Object[] { nameOfMethod }); } }
@Test public void testSplitByCharacterTypeCamelCase() { assertNull(StringUtils.splitByCharacterTypeCamelCase(null)); assertEquals(0, StringUtils.splitByCharacterTypeCamelCase("").length); assertTrue(Objects.deepEquals(new String[]{"ab", " ", "de", " ", "fg"}, StringUtils.splitByCharacterTypeCamelCase("ab de fg"))); assertTrue(Objects.deepEquals(new String[]{"ab", " ", "de", " ", "fg"}, StringUtils.splitByCharacterTypeCamelCase("ab de fg"))); assertTrue(Objects.deepEquals(new String[]{"ab", ":", "cd", ":", "ef"}, StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef"))); assertTrue(Objects.deepEquals(new String[]{"number", "5"}, StringUtils.splitByCharacterTypeCamelCase("number5"))); assertTrue(Objects.deepEquals(new String[]{"foo", "Bar"}, StringUtils.splitByCharacterTypeCamelCase("fooBar"))); assertTrue(Objects.deepEquals(new String[]{"foo", "200", "Bar"}, StringUtils.splitByCharacterTypeCamelCase("foo200Bar"))); assertTrue(Objects.deepEquals(new String[]{"ASF", "Rules"}, StringUtils.splitByCharacterTypeCamelCase("ASFRules"))); }
private LinkedList<String> splitAndReplace(String name) { LinkedList<String> result = new LinkedList<>(); for ( String part : StringUtils.splitByCharacterTypeCamelCase( name ) ) { if ( part == null || part.trim().isEmpty() ) { // skip null and space continue; } part = applyAbbreviationReplacement( part ); result.add( part.toLowerCase( Locale.ROOT ) ); } return result; }
/** * Returns a String with default label to show when cannot find the right * label code. * * @return a String with default field label */ private String getFieldDefaultLabelValue(String fieldName) { String[] splittedFieldName = StringUtils.splitByCharacterTypeCamelCase(fieldName); String label = ""; for (int i = 0; i < splittedFieldName.length; i++) { if (i != 0) { label = label.concat(" "); } label = label.concat(StringUtils.capitalize(splittedFieldName[i])); } return label; }
/** * This method builds the fieldname without the camel case style. * * @param fieldName * @return */ private String buildFieldWithoutCamelCase(String fieldName) { String fieldWithoutCamelCase = ""; String[] camelCase = StringUtils.splitByCharacterTypeCamelCase(fieldName); for (String part : camelCase) { fieldWithoutCamelCase = fieldWithoutCamelCase.concat(part).concat("-"); } if (fieldWithoutCamelCase.endsWith("-")) { fieldWithoutCamelCase = fieldWithoutCamelCase.substring(0, fieldWithoutCamelCase.length() - 1); } else { fieldWithoutCamelCase = fieldName; } return fieldWithoutCamelCase; }
String[] fieldNameParts = StringUtils.splitByCharacterTypeCamelCase(fieldName); String constantName = ""; for (String part : fieldNameParts) {
private static String[] toWordArray(String camelCaseString) { String[] wordsArray = StringUtils.splitByCharacterTypeCamelCase(camelCaseString); return wordsArray; }
@Override public String adapt(String name) { return String.join("_", StringUtils.splitByCharacterTypeCamelCase(name)).toLowerCase(); } }
private String camelToWords(String s) { String[] elements = StringUtils.splitByCharacterTypeCamelCase(StringUtils.capitalize(s)); return StringUtils.join(elements, "_"); } }
private String splitOnFirstAndLastNames(String author) { String[] parts = StringUtils.splitByCharacterTypeCamelCase(author); String firstName = parts[0]; if (parts.length == 1) { return firstName; } String lastName = StringUtils.substringAfter(author, firstName); return String.join(" ", firstName, lastName); }
public static String camelcaseToTitleCase(String camelcase) { return Arrays .stream(StringUtils.splitByCharacterTypeCamelCase(camelcase)) .map(StringUtils::capitalize) .collect(Collectors.joining(" ")); }
public static String prettifyClassname(String classname) { String display = ""; if (classname != null && classname.lastIndexOf(".") != -1) { String prettyclassname = classname.substring(classname.lastIndexOf(".") + 1); String[] splittedClassname = StringUtils.splitByCharacterTypeCamelCase(prettyclassname); for (int i = 0; i < splittedClassname.length; i++) { splittedClassname[i] = StringUtils.capitalize(splittedClassname[i]); } display = StringUtils.join(splittedClassname, " "); } return display; }
public static String normalizeColumn(String column, boolean mapUnderscoreToCamelCase) { Stream<String> stream = Arrays.stream(StringUtils.splitByCharacterTypeCamelCase(column)) .filter(it -> !Objects.equals(it, "_")); if (mapUnderscoreToCamelCase) { return stream.map(StringUtils::uncapitalize).collect(Collectors.joining("_")); } else { return stream.map(StringUtils::capitalize).collect(Collectors.joining()); } }
private static String summaryFromMethodName(MethodDoc methodDoc) { return StringUtils.capitalize( Arrays.stream(StringUtils.splitByCharacterTypeCamelCase(methodDoc.name())) .map(StringUtils::lowerCase) .collect(Collectors.joining(" "))); }
/** * Add combinations of resource names of given entity class. */ private void addCombinations(final String csvRoot, final Class<?> entityClass) { final String name = entityClass.getSimpleName(); addCombination(csvRoot + "/" + name.toLowerCase(Locale.ENGLISH) + ".csv"); addCombination(csvRoot + "/" + StringUtils.join(StringUtils.splitByCharacterTypeCamelCase(name), '-').toLowerCase(Locale.ENGLISH) + ".csv"); }
public static String[] splitByCharacterTypeCamelCase(ActionContext actionContext){ Thing self = actionContext.getObject("self"); String str = (String) self.doAction("getStr", actionContext); return StringUtils.splitByCharacterTypeCamelCase(str); }
private void checkPrefixedTransformMethods(ASTMethodDeclaration node, Object data, String nameOfMethod) { ASTResultType resultType = node.getResultType(); List<String> prefixes = getProperty(TRANSFORM_METHOD_NAMES_PROPERTY); String[] splitMethodName = StringUtils.splitByCharacterTypeCamelCase(nameOfMethod); if (resultType.isVoid() && splitMethodName.length > 0 && prefixes.contains(splitMethodName[0].toLowerCase(Locale.ROOT))) { // "To" or any other configured prefix found addViolationWithMessage(data, node, "Linguistics Antipattern - The transform method ''{0}'' should not return void linguistically", new Object[] { nameOfMethod }); } }
public Map<FaceAttributes, String> formattedValues() { return new HashMap<FaceAttributes, String>() {{ put(FaceAttributes.GENDER, WordUtils.capitalize(gender.name())); put(FaceAttributes.AGE, String.format("Age: %.2f", age)); put(FaceAttributes.SMILE, String.format("Smile: %.2f", smile)); put(FaceAttributes.FACIALHAIR, String.format("Beard:%.2f", facialHair.beard)); put(FaceAttributes.HEADPOSE, String.format("Pitch:%.2f", headPose.pitch)); put(FaceAttributes.GLASSES, WordUtils.capitalize(StringUtils.join( StringUtils.splitByCharacterTypeCamelCase(glasses.name()), ' ' ))); }}; }