@Override public String apply(String input) { Usage resultFormat = prefix.isEmpty() ? Usage.INDIFFERENT : Usage.CAPITALIZED; return prefix + resultFormat.apply(input) + suffix; }
private Naming inferNaming(Element element, EnumSet<Tag> tags, AtomicReference<StandardNaming> standardNaming) { Optional<NamingMirror> namingAnnotation = NamingMirror.find(element); if (namingAnnotation.isPresent()) { try { NamingMirror mirror = namingAnnotation.get(); Naming naming = Naming.from(mirror.value()); if (mirror.depluralize()) { tags.add(Tag.DEPLURALIZE); } standardNaming.set(mirror.standard()); return naming; } catch (IllegalArgumentException ex) { reporter.withElement(element) .annotationNamed(NamingMirror.simpleName()) .error(ex.getMessage()); } } if (element.getKind() == ElementKind.FIELD || (element.getKind() == ElementKind.METHOD && (element.getModifiers().contains(Modifier.PRIVATE) || tags.contains(Tag.PRIVATE)))) { return helperNaming(element.getSimpleName()); } if (tags.contains(Tag.INIT) || tags.contains(Tag.COPY)) { return Naming.identity(); } String encodedMethodName = element.getSimpleName().toString(); return Naming.from("*" + Naming.Usage.CAPITALIZED.apply(encodedMethodName)); }
private String synthName(String name) { return Usage.LOWERIZED.apply(this.name) + "_" + name; }
private AppliedNameForms applyFactoryNaming(Naming naming) { String raw = names().raw; boolean hasForwardingFactoryMethods = isImplementationHidden() && protoclass().kind().isNested(); NameForms nameForms = hasForwardingFactoryMethods ? typeEnclosingFactory() : typeImmutable(); if (hasForwardingFactoryMethods) { naming = naming.requireNonConstant(Preference.PREFIX); } String applyName = Naming.Usage.LOWERIZED.apply(naming.apply(raw)); return nameForms.applied(applyName); }
private String typeBuilderSimpleName() { boolean isOutside = isOutsideBuilder(); Naming typeBuilderNaming = names().namings.typeBuilder; if (isOutside) { // For outer builder we can override with constant builder naming, but not the default. boolean isPlainDefault = isConstantNamingEquals(typeBuilderNaming, protoclass().environment().defaultStyles().typeBuilder()); if (isPlainDefault) { typeBuilderNaming = typeBuilderNaming.requireNonConstant(Preference.SUFFIX); } } return Naming.Usage.CAPITALIZED.apply(typeBuilderNaming.apply(names().raw)); }
@Test public void usageCorrection() { String suffix = Naming.from("of").requireNonConstant(Preference.SUFFIX).apply("Hen"); check(Naming.Usage.LOWERIZED.apply(suffix)).is("henOf"); String prefix = Naming.from("of").requireNonConstant(Preference.PREFIX).apply("Hen"); check(Naming.Usage.CAPITALIZED.apply(prefix)).is("OfHen"); } }
@Override public Naming requireNonConstant(Preference preference) { switch (preference) { case SUFFIX: return new PrefixSuffixNaming("", Usage.CAPITALIZED.apply(name)); case PREFIX: default: return new PrefixSuffixNaming(name, ""); } }