private static boolean isExpression(String valueExpression) { return ! NameUtils.isJavaIdentifier(NameUtils.decapitalize(valueExpression)); }
public static String toJavaIdentifierForm(String name) { return removeNonJavaIdentifierCharacters(StringUtils.stripAccents(toLowerCamelCase(name))); }
@Override public Type<T> loadType(String name) { Type<T> type = parent.loadType(name); if (type == null) { type = parent.loadType(NameUtils.toClassName(name)); } return type; } }
private void addExpression(List<String> expressionsList, String[] parts, boolean[] dots) { StringBuilder addExpression = new StringBuilder(); StringBuilder identifier = new StringBuilder(); for (int i = 0; i < parts.length; i ++ ) { if (startAsAnIdentifier(parts[i])) { identifier.append(parts[i]).append(' '); if (identifierComplete(parts, dots, i)) { addExpression.append(NameUtils.toLowerCamelCase(identifier.toString())); addExpression.append( insertDot(parts, dots, i) ? "." : " " ); identifier.setLength(0); } } else { addExpression.append(parts[i]); addExpression.append(insertDot(parts, dots, i) ? "." : " " ); } } addToList(expressionsList, addExpression.toString()); }
private boolean compareWithAlias(Alias aliasAnnotation, String name) { for (String alias : aliasAnnotation.value()) { String formattedAlias = NameUtils.toJavaIdentifierForm(alias); if (formattedAlias.equalsIgnoreCase(name)) { return true; } } return false; }
@Override public int compare(String s1, String s2) { return NameUtils.decapitalize(s1).compareTo(NameUtils.decapitalize(s2)); }
return s; return removeNonJavaIdentifierCharacters(StringUtils.stripAccents(StringUtils.deleteWhitespace(WordUtils .capitalizeFully(s))));
@Test public void testCanTellIfAnIdentifierIsAValidJavaIdentifier() { assertTrue(NameUtils.isJavaIdentifier("valididentifierName")); assertFalse(NameUtils.isJavaIdentifier("0invalididentifierName")); }
@Test public void testHumanizesJavaIdentifierNames() { assertEquals("an identifier name", NameUtils.humanize("anIdentifierName")); }
@Test public void testCanConvertAStringToLowerCamelCase() { assertEquals("aLongClassName", NameUtils.toLowerCamelCase("a lONG class nAMe")); assertEquals("alongclassname", NameUtils.toLowerCamelCase("aLongClassName")); }
protected Method getSetter(Class< ? extends Object> type, String name) { return introspector(type).getSetter(toJavaIdentifierForm(name)); }
@Test public void testDecapitalizesNamesToValidJavaIdentifiers() { assertEquals("URL", NameUtils.decapitalize("URL")); assertEquals("anURL", NameUtils.decapitalize("an URL")); assertEquals("anURL", NameUtils.decapitalize("anURL")); assertEquals("anUrl", NameUtils.decapitalize("an url")); }
@Test public void testRemovingNonJavaIdentifiers() { assertEquals("AlongclassName", NameUtils.removeNonJavaIdentifierCharacters("A long class Name")); assertEquals("ab", NameUtils.removeNonJavaIdentifierCharacters("a'b")); } }
@Test public void testHumanizesJavaClassNames() { assertEquals("A class name", NameUtils.humanize("AClassName")); }
public Type<T> getAnnotatedFixture(String name) { String fixturename = "(?i)" + NameUtils.toClassName(name) + "(Fixture)?"; List<Class< ? >> matchingAnnotatedClasses = findMatchingAnnotatedFixtures(fixturename); List<Class< ? >> matchingAliases = null; if (matchingAnnotatedClasses.size() != 1) { matchingAliases = findFixtureByAlias(name); } if (matchingAliases != null && matchingAliases.size() == 1) { return getClassType(matchingAliases.get(0).getName()); } if (matchingAnnotatedClasses.size() == 1) { return getClassType(matchingAnnotatedClasses.get(0).getName()); } if (matchingAnnotatedClasses.size() > 1 || matchingAliases.size() > 1) { throw new DuplicateAnnotatedFixturesFoundException(matchingAnnotatedClasses, matchingAliases); } return null; }
@Test public void testExpressionsGeneratedFromThreeTokens() { String token1 = "token1"; String token2 = "token2"; String token3 = "token3"; OgnlResolution resolution = new OgnlResolution(token1 + " " + token2 + " " + token3); Collection<String> expressions = resolution.expressionsListToResolve(); assertEquals(5, expressions.size()); assertTrue(expressions.contains(token1 + "." + token2 + "." + token3)); assertTrue(expressions.contains(token1 + "." + NameUtils.toLowerCamelCase(token2 + " " + token3))); assertTrue(expressions.contains(NameUtils.toLowerCamelCase(token1 + " " + token2) + "." + token3)); assertTrue(expressions.contains(NameUtils.toLowerCamelCase(token1 + " " + token2 + " " + token3))); assertTrue(expressions.contains(token1 + " " + token2 + " " + token3)); }
protected Field getField(Class< ? extends Object> type, String name) { return introspector(type).getField(toJavaIdentifierForm(name)); }
private static Class< ? > getClass(String typename) throws ClassNotFoundException { return ClassUtils.loadClass("info.novatec.testit.livingdoc.fixture.interpreter.CollectionResolutionFixture$" + NameUtils.toClassName(typename)); }
@Test public void testExpressionsGeneratedFromTwoTokens() { String token1 = "token1"; String token2 = "token2"; OgnlResolution resolution = new OgnlResolution(token1 + " " + token2); Collection<String> expressions = resolution.expressionsListToResolve(); assertEquals(3, expressions.size()); assertTrue(expressions.contains(token1 + "." + token2)); assertTrue(expressions.contains(NameUtils.toLowerCamelCase(token1 + " " + token2))); assertTrue(expressions.contains(token1 + " " + token2)); }
protected List<Method> getMethods(Class< ? extends Object> type, String name) { return introspector(type).getMethods(toJavaIdentifierForm(name)); }