@Override public String toString() { return item + "[" + StringUtils.join(transitions, ",") + "]"; } }
public static String toInterfaceName(String name) { if (name.endsWith(INTERFACE_SUFFIX)) { return name; } return capitalizeFirst(name) + INTERFACE_SUFFIX; }
public String apply(Collection<ClassRef> types) { final Function<ClassRef, String> toString = new Function<ClassRef, String>() { public String apply(ClassRef item) { return stripSuffix(item.getDefinition().getName()); } }; final String prefix = StringUtils.getPrefix(types, toString); return toInterfaceName(prefix + StringUtils.compact(StringUtils.join(types, new Function<ClassRef, String>() { public String apply(ClassRef item) { String str = stripPrefix(stripSuffix(item.getDefinition().getName())); if (str.length() > prefix.length()) { return str.substring(prefix.length()); } else { return str; } } }, ""))); } };
/** * Converts the string into a safe field name. * @param name The field name. * @return The safe field name. */ public static final String toFieldName(String name) { return compact(prefixKeywords(name)); }
private static final String classNameOf(Set<JavaType> types) { final Function<JavaType, String> toString = new Function<JavaType, String>() { @Override public String apply(JavaType item) { return stripSuffix(item.getClassName()); } }; final String prefix = StringUtils.getPrefix(types, toString); return toInterfaceName(prefix + StringUtils.join(types, new Function<JavaType, String>() { @Override public String apply(JavaType item) { return stripSuffix(item.getClassName()).substring(prefix.length()); } }, "Or")); }
String pojoName = StringUtils.toPojoName(item.getName(), "Default", ""); String relativePath = "."; String prefix = String.valueOf(r.getParameters().getOrDefault("prefix", "")); String suffix = String.valueOf(r.getParameters().getOrDefault("suffix", "")); pojoName = StringUtils.toPojoName(item.getName(), prefix, suffix); } else if (params.containsKey("relativePath")) { .withName(StringUtils.toFieldName(name)) .withTypeRef(returnType) .withModifiers(mutable ? TypeUtils.modifiersToInt(Modifier.PRIVATE) : TypeUtils.modifiersToInt(Modifier.PRIVATE, Modifier.FINAL)) .withModifiers(modifiersToInt(Modifier.PUBLIC)) .withNewBlock() .withStatements(new StringStatement("return this." + StringUtils.toFieldName(name) + ";")) .endBlock() .build()); String name = StringUtils.toFieldName(p.getName()); for (Property f : fields) { if (name.equals(f.getName())) { sb.append(StringUtils.join(constructor.getArguments(), new Function<Property, String>(){ @Override public String apply(Property item) { if (StringUtils.isNullOrEmpty(name) && StringUtils.isNullOrEmpty(prefix) && StringUtils.isNullOrEmpty(suffix)) { suffix = "Adapter";
@Override public Set<JavaMethod> apply(JavaProperty property) { Set<JavaMethod> result = new LinkedHashSet<JavaMethod>(); JavaClazz clazz = PropertyAs.CLASS.apply(property); for (JavaMethod constructor : getInlineableConstructors(property)) { String ownPrefix = property.getType().isCollection() ? "addNew" : "withNew"; String ownName = ownPrefix + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()); String delegatePrefix = property.getType().isCollection() ? "addTo" : "with"; String delegateName = delegatePrefix + captializeFirst(property.getName()); String args = StringUtils.join(constructor.getArguments(), new Function<JavaProperty, String>() { @Override public String apply(JavaProperty item) { return item.getName(); } }, ", "); result.add(new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(T) .withArguments(constructor.getArguments()) .withName(ownName) .addToAttributes(BODY, "return " + delegateName + "(new " + clazz.getType().getSimpleName() + "(" + args + "));") .build()); } return result; } };
private void writeMethod(Writer writer, Method method, String block, Boolean isInterface) throws IOException { if (method != null) { writer.append(method.toString()); if (!method.isAbstract() && !isInterface && !StringUtils.isNullOrEmpty(block)) { writer.append("{\n"); writer.append(block).append("}\n"); } else { writer.append(";"); } } } }
String trimmedName = StringUtils.deCapitalizeFirst(m.getName().replaceAll("^get", "").replaceAll("^is", "")); if (m.getReturnType() instanceof ClassRef) { ClassRef ref = (ClassRef) m.getReturnType(); Method ctor = BuilderUtils.findBuildableConstructor(generatedType); if (m.getReturnType().getDimensions() > 0) { sb.append(".addAllTo").append(StringUtils.capitalizeFirst(trimmedName)).append("(") .append("Arrays.asList(") .append("instance.").append(m.getName()).append("())") .append(".collect(Collectors.toList()))"); } else { sb.append(".with").append(StringUtils.capitalizeFirst(trimmedName)).append("(") .append("new ").append(generatedType.getName()).append("(") .append(ctor.getArguments().stream() String withMethod = "with" + (StringUtils.capitalizeFirst(trimmedName));
public static String getPrefix(Iterable<String> items) { return getPrefix(items, new Function<String, String>() { public String apply(String item) { return item; } }); }
.build(); String propertyName = compact(deCapitalizeFirst(descendant.getName()) + property.getNameCapitalized()); result.add(new PropertyBuilder(property) .withName(propertyName) String propertyName = compact(deCapitalizeFirst(descendant.getName() + property.getNameCapitalized())); result.add(new PropertyBuilder(property) .withName(propertyName)
@Override public String apply(List<String> item) { if (StringUtils.isNullOrEmpty(staticFactoryMethod)) { return usingConstructor(item); } return usingStaticFactoryMethod(item); }
@Override public String toString() { return item + "[" + StringUtils.join(transitions, ",") + "]"; } }
public String apply(Collection<TypeDef> types) { final Function<TypeDef, String> toString = new Function<TypeDef, String>() { public String apply(TypeDef item) { return stripSuffix(item.getName()); } }; final String prefix = StringUtils.getPrefix(types, toString); return toInterfaceName(prefix + StringUtils.compact(StringUtils.join(types, new Function<TypeDef, String>() { public String apply(TypeDef item) { String str = stripPrefix(stripSuffix(item.getName())); if (str.length() > prefix.length()) { return str.substring(prefix.length()); } else { return str; } } }, ""))); } };
/** * Returns true if method is a getter of property. * In strict mode it will not strip non-alphanumeric characters. */ private static boolean isApplicable(Method method, Property property, boolean strict) { if (method.getArguments().size() != 1) { return false; } if (!method.getArguments().get(0).getTypeRef().equals(property.getTypeRef())) { return false; } String capitalized = capitalizeFirst(property.getName()); if (method.getName().endsWith("set" + capitalized)) { return true; } if (!strict && method.getName().endsWith("set" + property.getNameCapitalized())) { return true; } return false; }
public static boolean isInlineable(JavaMethod method) { if (method.getArguments().length == 0 || method.getArguments().length > 5) { return false; } for (JavaProperty argument : method.getArguments()) { if (StringUtils.isNullOrEmpty(argument.getType().getPackageName())) { continue; } else if (argument.getType().getPackageName().startsWith("java.lang")) { continue; } else { return false; } } return true; }
private static String createKeyForTypes(Collection<TypeDef> alternatives) { List<TypeDef> clazzes = new LinkedList<TypeDef>(alternatives); Collections.sort(clazzes, new Comparator<TypeDef>() { public int compare(TypeDef left, TypeDef right) { return left.getFullyQualifiedName().compareTo(right.getFullyQualifiedName()); } }); return StringUtils.join(clazzes, new Function<TypeDef, String>() { public String apply(TypeDef item) { return item.getFullyQualifiedName(); } }, "#"); }
public static String fullyQualifiedNameDiff(TypeRef typeRef, TypeDef originType) { Map<String, String> map = DefinitionRepository.getRepository().getReferenceMap(); String currentPackage = originType != null ? originType.getPackageName() : null; if (typeRef instanceof ClassRef) { TypeRef unwrapped = TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(typeRef); if (unwrapped instanceof ClassRef) { ClassRef classRef = (ClassRef) unwrapped; String candidateFqn = classRef.getFullyQualifiedName().replace(classRef.getDefinition().getPackageName(), currentPackage); //If classRef is inside the current package. if (candidateFqn.equals(classRef.getFullyQualifiedName())) { return ""; } //If candidate is imported and different that the actual name, do a diff if (originType.getImports().contains(candidateFqn) && !classRef.getDefinition().getFullyQualifiedName().equals(candidateFqn)) { return capitalizeFirst(TypeUtils.fullyQualifiedNameDiff(candidateFqn, classRef.getFullyQualifiedName())); } //If not then we compare against what has been found in the map. String fqn = map.get(classRef.getDefinition().getName()); if (fqn == null) { System.out.println("Warning: Expected to find class with name:" + classRef.getDefinition().getName()); } else if (!classRef.getDefinition().getFullyQualifiedName().equals(fqn)) { return capitalizeFirst(TypeUtils.fullyQualifiedNameDiff(fqn, classRef.getFullyQualifiedName())); } } } return ""; }
private static String createKey(Collection<JavaClazz> alternatives) { List<JavaClazz> clazzes = new LinkedList<JavaClazz>(alternatives); Collections.sort(clazzes, new Comparator<JavaClazz>() { @Override public int compare(JavaClazz left, JavaClazz right) { return left.getType().getFullyQualifiedName().compareTo(right.getType().getFullyQualifiedName()); } }); return StringUtils.join(clazzes, new Function<JavaClazz, String>() { @Override public String apply(JavaClazz item) { return item.getType().getSimpleName(); } }, "#"); }
String capitalized = capitalizeFirst(property.getName()); if (method.getName().endsWith(GET_PREFIX + capitalized)) { return true;