FileObject obj = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, "", typeElt.getQualifiedName().toString().replace('.', '/') + ".java"); File srcFolder = new File(obj.toUri()).getParentFile(); String filename = Case.SNAKE.format(Case.CAMEL.parse(typeElt.getSimpleName().toString())); for (Lang lang : langs) { if (isSkipped(typeElt, lang)) {
/** * Convert a name from this case to the {@literal dest} case * @param dest the destination case * @param name the name to convert * @return the converted name */ public String to(Case dest, String name) { return dest.format(parse(name)); }
/** * @param _case the formatting case * @return the module name in the specified case */ public String getName(Case _case) { return _case.format(Case.KEBAB.parse(name)); } }
public String getSimpleName(Case _case) { return _case.format(Case.CAMEL.parse(simpleName)); }
public String getName(Case _case) { return _case.format(Case.CAMEL.parse(name)); }
public String getName(Case _case) { return _case.format(Case.CAMEL.parse(name)); }
public static String renderDataObjectHtmlLink(TypeInfo type, TypeInfo dataObjectType) { StringBuilder link = new StringBuilder(); for (String name : Case.QUALIFIED.parse(type.getRaw().getPackageName())) { link.append("../"); } link.append("../../../cheatsheet/").append(dataObjectType.getSimpleName()).append(".html"); return "<a href=\"" + link + "\">" + dataObjectType.getSimpleName() + "</a>"; }
static TypeNameTranslator composite(String lang) { return (module, qualifiedName) -> { List<String> def = new ArrayList<>(Case.QUALIFIED.parse(module.getGroupPackage())); def.add(lang); List<String> abc = Case.KEBAB.parse(module.getName()); if (abc.get(0).equals("vertx")) { // Special case if (abc.size() == 1) { def.add("core"); } else { for (int i = 1;i < abc.size();i++) { def.add(abc.get(i)); } } } else { def.addAll(abc); } if (qualifiedName.startsWith(module.getPackageName())) { if (qualifiedName.equals(module.getPackageName())) { } else { String nameInPackage = qualifiedName.substring(module.getPackageName().length() + 1); def.addAll(Case.QUALIFIED.parse(nameInPackage)); } return Case.QUALIFIED.format(def); } return qualifiedName; }; }
private void parseCase(Case _case, String s, String... expected) { assertEquals(Arrays.asList(expected), _case.parse(s)); } }
public ModuleModel getModuleModel(String modulePackage) { PackageElement element = modules.get(modulePackage); ModuleGen annotation = element.getAnnotation(ModuleGen.class); String moduleName = annotation.name(); if (moduleName.isEmpty()) { throw new GenException(element, "A module name cannot be empty"); } try { Case.KEBAB.parse(moduleName); } catch (IllegalArgumentException e) { throw new GenException(element, "Module name '" + moduleName + "' does not follow the snake case format (dash separated name)"); } String groupPackage = annotation.groupPackage(); if (groupPackage.equals("")) { groupPackage = modulePackage; } else if (!modulePackage.startsWith(groupPackage)) { throw new GenException(element, "A module package (" + modulePackage + ") must be prefixed by the group package (" + groupPackage + ")"); } try { Case.QUALIFIED.parse(groupPackage); } catch (Exception e) { throw new GenException(element, "Invalid group package name " + groupPackage); } ModuleInfo info = new ModuleInfo(modulePackage, moduleName, groupPackage); AnnotationValueInfoFactory annotationFactory = new AnnotationValueInfoFactory(new TypeMirrorFactory(elementUtils,typeUtils)); List<AnnotationValueInfo> annotationValueInfos = element.getAnnotationMirrors().stream().map(annotationFactory::processAnnotation).collect(Collectors.toList()); return new ModuleModel(element, info, annotationValueInfos); }
ClassTypeInfo ct = type.getRaw(); return "../../jsdoc/module-" + ct.getModule().getName(Case.KEBAB) + "-js_" + Case.SNAKE.format(Case.CAMEL.parse(elt.getSimpleName().toString())) + "-" + elt.getSimpleName() + ".html";
@Test public void testParseKebabCase() { parseKebabCase(""); parseKebabCase("foo", "foo"); parseKebabCase("foo-bar", "foo", "bar"); parseKebabCase("foo-bar-juu", "foo", "bar", "juu"); for (String test : Arrays.asList("-", "-foo", "foo-", "foo--bar")) { try { Case.KEBAB.parse(test); fail("Was expecting " + test + " to be rejected"); } catch (Exception ignore) { } } }
@Test public void testParseQualifiedCase() { parseQualifiedCase(""); parseQualifiedCase("foo", "foo"); parseQualifiedCase("foo.bar", "foo", "bar"); parseQualifiedCase("foo.bar.juu", "foo", "bar", "juu"); for (String test : Arrays.asList(".", ".foo", "foo.", "foo..bar")) { try { Case.QUALIFIED.parse(test); fail("Was expecting " + test + " to be rejected"); } catch (Exception ignore) { } } }
@Test public void testParseSnakeCase() { parseSnakeCase(""); parseSnakeCase("foo", "foo"); parseSnakeCase("foo_bar", "foo", "bar"); parseSnakeCase("foo_bar_juu", "foo", "bar", "juu"); for (String test : Arrays.asList("_", "_foo", "foo_", "foo__bar")) { try { Case.SNAKE.parse(test); fail("Was expecting " + test + " to be rejected"); } catch (Exception ignore) { } } }