public static Naming[] fromAll(String... templates) { Naming[] namings = new Naming[templates.length]; for (int i = 0; i < templates.length; i++) { namings[i] = from(templates[i]); } return namings; }
public final String builder() { return scheme.builder.apply(raw); }
String detectRawFromAttributeBuilder(String attributeBuilderName) { for (Naming naming : scheme.attributeBuilder) { String raw = naming.detect(attributeBuilderName); if (!raw.isEmpty()) { return raw; } } return ""; }
String applySingular(Naming naming) { if (singularIsKeyword && naming.isIdentity()) { return applyRegular(naming); } return naming.apply(singular); } }
private boolean isConstantNamingEquals(Naming naming, String name) { return naming.isConstant() && naming.apply("").equals(name); }
@Test public void requireNonConstant() { check(Naming.identity().requireNonConstant(Preference.PREFIX)).same(Naming.identity()); check(Naming.from("Create").requireNonConstant(Preference.PREFIX).apply("x")).is("CreateX"); check(Naming.from("Create").requireNonConstant(Preference.SUFFIX).apply("x")).is("xCreate"); check(Naming.from("new*").requireNonConstant(Preference.SUFFIX).apply("x")).is("newX"); }
@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"); } }
SwitcherModel(SwitchMirror mirror, Styles.UsingName.AttributeNames names, TypeElement containedTypeElement) { this.switcherNaming = Naming.from(names.raw).requireNonConstant(Preference.SUFFIX); this.containedTypeElement = Preconditions.checkNotNull(containedTypeElement); this.defaultName = mirror.defaultName(); this.options = constructOptions(); }
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 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); }
.type(typesReader.get(method.getReturnType())) .addTags(Tag.EXPOSE) .naming(Naming.identity()) .typeParameters(typesReader.parameters) .addAllDoc(docFrom(method))
public boolean isImmutableIdentityNaming() { return scheme.typeImmutable.isIdentity(); }
@Test public void underscoreCharacter() { Naming oneOf = Naming.from("Builder_*"); check(oneOf.apply("x")).is("Builder_X"); check(oneOf.apply("X")).is("Builder_X"); check(oneOf.apply("__")).is("Builder___"); check(oneOf.detect("Builder_X")).is("x"); check(oneOf.detect("Builder__X")).isEmpty(); check(oneOf.detect("BuilderX")).isEmpty(); }
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)); }
private String applyRegular(Naming naming) { if (rawIsKeyword && naming.isIdentity()) { return name; } return naming.apply(raw); }
.type(typesReader.get(field.asType())) .addTags(Tag.IMPL, Tag.FINAL, Tag.PRIVATE, virtual ? Tag.VIRTUAL : Tag.FIELD) .naming(Naming.identity()) .typeParameters(typesReader.parameters) .addAllDoc(docFrom(field))
private boolean isDefaultUnspecifiedValue(EncodedElement element) { return element.naming().isIdentity() && !element.depluralize(); }