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; }
private Naming helperNaming(CharSequence encodedName) { return Naming.from("*_" + encodedName); }
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(); }
@Test(expected = IllegalArgumentException.class) public void wrongPlaceholder() { Naming.from("**"); }
@Test(expected = IllegalArgumentException.class) public void wrongChars() { Naming.from("???"); }
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)); }
@Test public void underscoreNaming() { Naming underscoreStar = Naming.from("_*"); String detect = underscoreStar.detect("_Abacus"); check(detect).is("abacus"); }
@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 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 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()); }
@Test public void verbatimNaming() { Naming aa = Naming.from("aa"); check(aa.apply("x")).is("aa"); check(aa.apply("aa")).is("aa"); check(aa.detect("aa")).is("aa"); check(aa.detect("ff")).isEmpty(); check(aa.detect("aaa")).isEmpty(); }
@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 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"); }
.naming(Naming.from(e.naming())) .standardNaming(StandardNaming.valueOf(e.stdNaming())) .type(parser.parse(e.type()))
@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 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"); }