public final String builder() { return scheme.builder.apply(raw); }
public final String create() { return scheme.create.apply(raw); }
public final String buildOrThrow() { return scheme.buildOrThrow.apply(raw); }
public final String canBuild() { return scheme.canBuild.apply(raw); }
private String deriveSwitcherName(String constantName) { return switcherNaming.apply( CaseFormat.UPPER_UNDERSCORE.to( CaseFormat.LOWER_CAMEL, constantName)); } }
String applySingular(Naming naming) { if (singularIsKeyword && naming.isIdentity()) { return applyRegular(naming); } return naming.apply(singular); } }
private String applyRegular(Naming naming) { if (rawIsKeyword && naming.isIdentity()) { return name; } return naming.apply(raw); }
private boolean isConstantNamingEquals(Naming naming, String name) { return naming.isConstant() && naming.apply("").equals(name); }
private AppliedNameForms factoryImplementationBuilder() { boolean isOutside = isOutsideBuilder(); Naming methodBuilderNaming = isOutside ? names().namings.newBuilder : names().namings.builder; boolean haveConstructorOnBuilder = isOutside || isConstantNamingEquals(methodBuilderNaming, NEW_KEYWORD); NameForms typeNameForms = haveConstructorOnBuilder ? typeBuilder() : typeImmutable(); return typeNameForms.applied(methodBuilderNaming.apply(names().raw)); }
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"); } }
@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(); }
@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 prefixAndSuffixNaming() { Naming oneOf = Naming.from("one*Of"); check(oneOf.apply("x")).is("oneXOf"); check(oneOf.apply("X")).is("oneXOf"); check(oneOf.apply("__")).is("one__Of"); check(oneOf.detect("oneOf")).isEmpty(); check(oneOf.detect("oneX")).isEmpty(); check(oneOf.detect("xOf")).isEmpty(); check(oneOf.detect("oneXOf")).is("x"); }
@Test public void lowercaseSuffix() { check(Naming.from("check*out").detect("checkThisout")).is("this"); check(Naming.from("check*out").apply("it")).is("checkItout"); }
@Test public void prefixNaming() { Naming set = Naming.from("set*"); check(set.apply("x")).is("setX"); check(set.apply("X")).is("setX"); check(set.apply("__")).is("set__"); check(set.detect("se")).isEmpty(); check(set.detect("set")).isEmpty(); check(set.detect("sets")).isEmpty(); check(set.detect("setSe")).is("se"); check(set.detect("setXXX")).is("xXX"); }
@Test public void suffixNaming() { Naming added = Naming.from("*Added"); check(added.apply("x")).is("xAdded"); check(added.apply("X")).is("XAdded"); check(added.apply("__")).is("__Added"); check(added.detect("Added")).isEmpty(); check(added.detect("dded")).isEmpty(); check(added.detect("moreAdded")).is("more"); check(added.detect("XAdded")).is("X"); check(added.detect("XXXAdded")).is("XXX"); }
@Test public void sameNaming() { Naming star = Naming.from("*"); check(star.apply("x")).is("x"); check(star.detect("x")).is("x"); check(star.detect("__")).is("__"); check(star).same(Naming.identity()); }