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)) {
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>"; }
private void assertCase(Case _case, String expected, String... atoms) { assertEquals(expected, _case.format(Arrays.asList(atoms))); }
@Override public String filename(Model model) { Map<String, Object> vars = new HashMap<>(); vars.put("helper", new Helper()); vars.put("options", env.getOptions()); vars.put("fileSeparator", File.separator); vars.put("fqn", model.getFqn()); vars.put("module", model.getModule()); vars.put("model", model); vars.putAll(model.getVars()); vars.putAll(ClassKind.vars()); vars.putAll(MethodKind.vars()); vars.putAll(Case.vars()); vars.putAll(TypeNameTranslator.vars(name)); return (String) MVEL.executeExpression(filenameExpr, vars); }
/** * Generate the module name of a type */ protected String getModuleName(ClassTypeInfo type) { return type.getModuleName() + "-js/" + Case.CAMEL.to(Case.SNAKE, type.getSimpleName()); }
/** * Useful for formatting or parsing string, eg:CASE_CAMEL.format(CASE_SNAKE.parse("foo_bar")),it will return fooBar */ public static Map<String, Case> vars() { HashMap<String, Case> vars = new HashMap<>(); for (Case _case : Arrays.asList(CAMEL, QUALIFIED, SNAKE, KEBAB, LOWER_CAMEL)) { vars.put("CASE_" + _case.name(), _case); } return vars; } }
private void parseCase(Case _case, String s, String... expected) { assertEquals(Arrays.asList(expected), _case.parse(s)); } }
private String kotlinType(TypeInfo type) { if (type instanceof VoidTypeInfo) { return "Unit"; } else if (type instanceof PrimitiveTypeInfo) { return Case.CAMEL.format(Collections.singletonList(type.getSimpleName())); } else if (type.getKind() == ClassKind.BOXED_PRIMITIVE) { switch (type.getSimpleName()) { case "Integer": return "Int"; case "Character": return "Char"; default: return type.getSimpleName(); } } else if ("java.lang.Void".equals(type.getName())) { return "Unit"; } else if ("java.lang.Object".equals(type.getName())) { return "Any"; } else { if (type instanceof ParameterizedTypeInfo) { List<TypeInfo> args = ((ParameterizedTypeInfo) type).getArgs(); return type.getRaw().getSimpleName() + args.stream().map(this::kotlinType).collect(Collectors.joining(",", "<", ">")); } else { return type.getSimpleName(); } } }
vars.putAll(ClassKind.vars()); vars.putAll(MethodKind.vars()); vars.putAll(Case.vars());
@Test public void testConversion() { assertEquals("foo-bar-juu", Case.CAMEL.to(Case.KEBAB, "FooBarJuu")); assertEquals("foo_bar_juu", Case.CAMEL.to(Case.SNAKE, "FooBarJuu")); assertEquals("FooBarJuu", Case.SNAKE.to(Case.CAMEL, "foo_bar_juu")); assertEquals("FooBarJuu", Case.KEBAB.to(Case.CAMEL, "foo-bar-juu")); }
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); }
vars.putAll(ClassKind.vars()); vars.putAll(MethodKind.vars()); vars.putAll(Case.vars()); vars.put("classes", classes(superTypes)); vars.put("abstractClasses", abstractClasses(superTypes));
@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) { } } }
@Override public String render(Model model, int index, int size, Map<String, Object> session) { Map<String, Object> vars = new HashMap<>(); ClassTypeInfo type = ((ClassTypeInfo)model.getVars().get("type")); Set<TypeInfo> importedTypes = (Set<TypeInfo>)model.getVars().get("importedTypes"); Set<TypeInfo> superTypes = (Set<TypeInfo>)model.getVars().get("superTypes"); vars.putAll(TypeNameTranslator.vars(name)); vars.putAll(model.getVars()); vars.put("typeHelper", new TypeHelper()); vars.put("className", Helper.getSimpleName(type.getName())); vars.put("packageName", type.getRaw().translatePackageName("scala")); vars.put("imps", adjustedImports(type, importedTypes, superTypes)); vars.put("isAllSuperTypesAbstract",isAllSuperTypesAbstract(superTypes)); vars.putAll(ClassKind.vars()); vars.putAll(MethodKind.vars()); vars.putAll(Case.vars()); Writer writer = new StringWriter(); try { template.process(vars, writer); return writer.toString(); } catch (TemplateException e) { e.printStackTrace(); throw new RuntimeException(e); } catch (IOException e) { e.printStackTrace(); throw new RuntimeException(e); } }
@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 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) { } } }