Add return types

Author: kklisura

cdt-java-client/src/main/java/com/github/kklisura/cdt/protocol/support/annotations/ReturnTypeParameter.java

@@ -0,0 +1,40 @@
+package com.github.kklisura.cdt.protocol.support.annotations;
+
+/*-
+ * #%L
+ * cdt-java-client
+ * %%
+ * Copyright (C) 2018 - 2019 Kenan Klisura
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+import static java.lang.annotation.ElementType.METHOD;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This describes a type parameter for generics return types, if for return type of List<Metrics>
+ * this will contain Metrics class. If the type parameter is Object or is of primitive type, this
+ * annotation will not be present.
+ *
+ * @author Kenan Klisura
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {METHOD})
+public @interface ReturnTypeParameter {
+  Class<?>[] value();
+}

cdt-java-protocol-builder/src/main/java/com/github/kklisura/cdt/definition/builder/support/java/builder/impl/JavaInterfaceBuilderImpl.java

@@ -24,21 +24,26 @@
 import static com.github.kklisura.cdt.definition.builder.support.java.builder.utils.JavadocUtils.INDENTATION_TAB;
 
 import com.github.javaparser.ast.ImportDeclaration;
+import com.github.javaparser.ast.NodeList;
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.MethodDeclaration;
 import com.github.javaparser.ast.body.Parameter;
-import com.github.javaparser.ast.expr.AnnotationExpr;
-import com.github.javaparser.ast.expr.MarkerAnnotationExpr;
-import com.github.javaparser.ast.expr.Name;
-import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
 import com.github.kklisura.cdt.definition.builder.support.java.builder.JavaInterfaceBuilder;
 import com.github.kklisura.cdt.definition.builder.support.java.builder.impl.utils.CompilationUnitUtils;
 import com.github.kklisura.cdt.definition.builder.support.java.builder.support.MethodParam;
 import com.github.kklisura.cdt.definition.builder.support.java.builder.utils.JavadocUtils;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Java interface builder.
@@ -48,10 +53,25 @@
 public class JavaInterfaceBuilderImpl extends BaseBuilder implements JavaInterfaceBuilder {
   private static final String DEPRECATED_ANNOTATION = "Deprecated";
 
+  private static final Pattern SINGLE_CLASS = Pattern.compile("\\s*\\S+\\.class\\s*");
+  private static final Pattern CLASS_LIST =
+      Pattern.compile("\\{(\\s*\\S+\\.class)(\\s*,\\s*\\S+\\.class)*\\s*}");
+  private static final Pattern CLASS_LIST_CONTENT = Pattern.compile("\\{(.*)}");
+
   private String name;
   private ClassOrInterfaceDeclaration declaration;
   private String annotationsPackage;
 
+  private static final Logger LOGGER = LoggerFactory.getLogger("TestLogger");
+
+  public static void main(String[] args) {
+    final String name = "test";
+    final RuntimeException e = new RuntimeException("Test exception");
+
+    LOGGER.error("Error while processing event " + name, e);
+    LOGGER.error("Error while processing event {}", name, e);
+  }
+
   /**
    * Instantiates a new class builder implementation.
    *
@@ -107,8 +127,28 @@ public void addParametrizedMethodAnnotation(
     for (MethodDeclaration methodDeclaration : methods) {
       Optional<AnnotationExpr> annotation = methodDeclaration.getAnnotationByName(annotationName);
       if (!annotation.isPresent()) {
-        methodDeclaration.addSingleMemberAnnotation(
-            annotationName, new StringLiteralExpr(parameter));
+
+        if (isClassList(parameter)) {
+          final List<String> classList = getClassList(parameter);
+
+          if (classList.size() == 1) {
+            methodDeclaration.addSingleMemberAnnotation(
+                annotationName,
+                new ClassExpr(new ClassOrInterfaceType(getClassName(classList.get(0)))));
+          } else {
+            final List<Expression> nodes =
+                classList
+                    .stream()
+                    .map(clazz -> new ClassExpr(new ClassOrInterfaceType(getClassName(clazz))))
+                    .collect(Collectors.toList());
+
+            methodDeclaration.addSingleMemberAnnotation(
+                annotationName, new ArrayInitializerExpr(new NodeList<>(nodes)));
+          }
+        } else {
+          methodDeclaration.addSingleMemberAnnotation(
+              annotationName, new StringLiteralExpr(parameter));
+        }
       }
     }
 
@@ -179,4 +219,47 @@ private void importAnnotation(String annotationName) {
       addImport(annotationsPackage, annotationName);
     }
   }
+
+  /**
+   * Given a class property accessor ie TestClass.class, return a class name ie TestClass.
+   *
+   * @param classPropertyAccessor Class property accessor string.
+   * @return Class name.
+   */
+  private static String getClassName(String classPropertyAccessor) {
+    final int i = classPropertyAccessor.indexOf(".class");
+    return classPropertyAccessor.substring(0, i);
+  }
+
+  static boolean isClassList(String value) {
+    if (SINGLE_CLASS.matcher(value).matches()) {
+      return true;
+    }
+
+    return CLASS_LIST.matcher(value).matches();
+  }
+
+  static List<String> getClassList(String value) {
+    final List<String> result = new ArrayList<>();
+
+    if (isClassList(value)) {
+      if (SINGLE_CLASS.matcher(value).matches()) {
+        result.add(value.trim());
+        return result;
+      }
+
+      final Matcher matcher = CLASS_LIST_CONTENT.matcher(value);
+      if (matcher.matches()) {
+        final String content = matcher.group(1);
+
+        final String[] items = content.trim().split(",");
+
+        for (int i = 0; i < items.length; i++) {
+          result.add(items[i].trim());
+        }
+      }
+    }
+
+    return result;
+  }
 }

cdt-java-protocol-builder/src/main/java/com/github/kklisura/cdt/definition/builder/support/protocol/builder/CommandBuilder.java

@@ -21,9 +21,7 @@
  */
 
 import static com.github.kklisura.cdt.definition.builder.support.protocol.builder.TypesBuilder.LIST_CLASS_NAME;
-import static com.github.kklisura.cdt.definition.builder.support.utils.StringUtils.buildPackageName;
-import static com.github.kklisura.cdt.definition.builder.support.utils.StringUtils.getReturnTypeFromGetter;
-import static com.github.kklisura.cdt.definition.builder.support.utils.StringUtils.toEnumClass;
+import static com.github.kklisura.cdt.definition.builder.support.utils.StringUtils.*;
 
 import com.github.kklisura.cdt.definition.builder.support.java.builder.Builder;
 import com.github.kklisura.cdt.definition.builder.support.java.builder.JavaBuilderFactory;
@@ -62,6 +60,7 @@ public class CommandBuilder {
 
   private static final String COMMENT_PARAM = "@param";
   private static final String EMPTY_SPACE = " ";
+  private static final String OBJECT_CLASS_PROPERTY = ".class";
 
   private String basePackageName;
   private String typesPackageName;
@@ -221,12 +220,12 @@ private void addCommand(
     List<MethodParam> methodParams =
         buildMethodParams(command, domain, interfaceBuilder, domainTypeResolver, builders);
 
-    String returnType =
+    ReturnType returnType =
         buildReturnType(command, domain, interfaceBuilder, domainTypeResolver, builders);
     String description =
         buildMethodParamDescription(command.getDescription(), command.getParameters());
 
-    interfaceBuilder.addMethod(method, description, methodParams, returnType);
+    interfaceBuilder.addMethod(method, description, methodParams, returnType.getType());
 
     if (Boolean.TRUE.equals(command.getDeprecated())) {
       interfaceBuilder.addMethodAnnotation(method, TypesBuilder.DEPRECATED_ANNOTATION);
@@ -241,6 +240,13 @@ private void addCommand(
       if (returns.size() == 1) {
         interfaceBuilder.addParametrizedMethodAnnotation(
             method, TypesBuilder.RETURNS_ANNOTATION, returns.get(0).getName());
+
+        if (returnType.isTyped()) {
+          interfaceBuilder.addParametrizedMethodAnnotation(
+              method,
+              TypesBuilder.RETURN_TYPE_PARAMETER_ANNOTATION,
+              buildReturnClasses(returnType.getSubType()));
+        }
       }
     }
   }
@@ -268,7 +274,37 @@ private String buildMethodParamDescription(String description, List<Property> pa
     return result.toString();
   }
 
-  private String buildReturnType(
+  public static class ReturnType {
+    private static final ReturnType VOID = new ReturnType(null);
+
+    private final String type;
+    private final String subType;
+    private final boolean typed;
+
+    public ReturnType(String type) {
+      this(type, null, false);
+    }
+
+    public ReturnType(String type, String subType, boolean typed) {
+      this.type = type;
+      this.subType = subType;
+      this.typed = typed;
+    }
+
+    public String getType() {
+      return type;
+    }
+
+    public String getSubType() {
+      return subType;
+    }
+
+    public boolean isTyped() {
+      return typed;
+    }
+  }
+
+  private ReturnType buildReturnType(
       Command command,
       Domain domain,
       JavaInterfaceBuilder interfaceBuilder,
@@ -292,7 +328,7 @@ private String buildReturnType(
 
         addBuilder(domain, property, result, interfaceBuilder, builders);
 
-        return result.getType();
+        return new ReturnType(result.getType(), result.getSubType(), result.isTyped());
       } else {
         String name = getReturnTypeFromGetter(command.getName());
 
@@ -311,11 +347,11 @@ private String buildReturnType(
         String packageName = buildPackageName(typesPackageName, domain.getDomain().toLowerCase());
         interfaceBuilder.addImport(packageName, name);
 
-        return name;
+        return new ReturnType(name);
       }
     }
 
-    return null;
+    return ReturnType.VOID;
   }
 
   private List<MethodParam> buildMethodParams(
@@ -410,4 +446,22 @@ private String getTypeName(PropertyHandlerResult propertyHandlerResult) {
 
     return type;
   }
+
+  static String buildReturnClasses(String returnType) {
+    return "{" + buildReturnClassesRecursive(returnType) + "}";
+  }
+
+  private static String buildReturnClassesRecursive(String returnType) {
+    if (!returnType.contains("<")) {
+      return returnType + OBJECT_CLASS_PROPERTY;
+    }
+
+    final int start = returnType.indexOf("<");
+    final int end = returnType.lastIndexOf(">");
+
+    final String clazz = returnType.substring(0, start);
+    final String parameter = returnType.substring(start + 1, end);
+
+    return clazz + OBJECT_CLASS_PROPERTY + "," + buildReturnClassesRecursive(parameter);
+  }
 }