Updated to v1.3.0

Prunoideae · Prunoideae · commit 5a70bca0bffd · 2022-03-03T22:58:21.000+08:00
Added supports for beans. However, this comes with some extra rules since KubeJS is not completely JS.
diff --git a/README.md b/README.md
@@ -35,3 +35,18 @@ Auto-completion, type-hinting for most of the functions and classes:
 3. Reload your IDE if your IDE doesn't know about the changes of typings, you will see the `onEvent` and `captureEvent`
    with correct typings now.
 4. If you want to remove the mod, don't forget to replace all `captureEvent` back to `onEvent`.
+
+## 4. Beaning
+
+Bean conversions are added now, however, to make generated typing information comfort with VSCode's TS language server
+while applying beaning as much as possible, a few rules are added:
+
+1. Beans will not have naming conflicts with methods/fields existed, if a bean has a conflicted name, the bean will not
+   be compiled to declaration.
+2. For beans with only `.getX()` implemented, `readonly` will be automatically added to prevent coincidental writes to
+   the field. For beans with any `.setX()` implemented, the bean will be able to read/write, regardless of it has
+   a `.getX()` or not, as `writeonly` does not exist in TypeScript. This applies to `.isX()` beans too.
+3. If `.isX()` has a `.setX()` or `.getX()` part with same name, the latter will override `.isX()` to prevent loss of
+   information.
+4. Original getter and setter methods are hidden, but still callable, however, calling them will not have typing support
+   as these methods are ignored in method dumping.
diff --git a/build.gradle b/build.gradle
@@ -9,7 +9,7 @@ apply from: 'https://files.latmod.com/public/markdown-git-changelog.gradle'
 sourceCompatibility = targetCompatibility = JavaVersion.VERSION_17
 
 def ENV = System.getenv()
-version = "${mod_version}-build.17"
+version = "${mod_version}-build.18"
 archivesBaseName = project.archives_base_name
 group = project.maven_group
 
diff --git a/gradle.properties b/gradle.properties
@@ -3,7 +3,7 @@ org.gradle.daemon=false
 loom.platform=forge
 mod_id=probejs
 archives_base_name=probejs
-mod_version=1.2.0
+mod_version=1.3.0
 maven_group=com.prunoideae
 mod_author=Prunoideae
 minecraft_version=1.18.1
diff --git a/src/main/java/com/prunoideae/probejs/toucher/ClassInfo.java b/src/main/java/com/prunoideae/probejs/toucher/ClassInfo.java
@@ -91,6 +91,19 @@ public TypeInfo getReturnTypeInfo() {
             return new TypeInfo(this.method.getGenericReturnType(), this.method.getReturnType());
         }
 
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            MethodInfo that = (MethodInfo) o;
+            return method.equals(that.method);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(method);
+        }
+
         @Override
         public String toString() {
             return "MethodInfo[" +
@@ -137,6 +150,10 @@ public boolean isStatic() {
             return Modifier.isStatic(this.field.getModifiers());
         }
 
+        public boolean isFinal() {
+            return Modifier.isFinal(this.field.getModifiers());
+        }
+
         public TypeInfo getTypeInfo() {
             return new TypeInfo(this.field.getGenericType(), this.field.getType());
         }
diff --git a/src/main/java/com/prunoideae/probejs/typings/TSGlobalClassFormatter.java b/src/main/java/com/prunoideae/probejs/typings/TSGlobalClassFormatter.java
@@ -2,6 +2,7 @@
 
 import com.mojang.datafixers.util.Pair;
 import com.prunoideae.probejs.toucher.ClassInfo;
+import dev.latvian.mods.kubejs.recipe.RecipeEventJS;
 
 import java.lang.reflect.*;
 import java.util.*;
@@ -15,6 +16,10 @@ public class TSGlobalClassFormatter {
     public static HashMap<Class<?>, Function<Object, String>> staticValueTransformer = new HashMap<>();
     public static HashMap<String, String> resolvedClassName = new HashMap<>();
 
+    private static String getCamelCase(String text) {
+        return Character.toLowerCase(text.charAt(0)) + text.substring(1);
+    }
+
     private static Pair<Class<?>, Integer> getClassOrComponent(Class<?> clazz) {
         if (clazz == null)
             return null;
@@ -72,6 +77,11 @@ public String format() {
             String resolvedType = specialTypeFormatter.containsKey(clazz)
                     ? specialTypeFormatter.get(clazz).apply(this.typeInfo)
                     : serializeType(this.typeInfo.getType());
+            //Ensure to resolve type since TS does not allow non-parameterized types.
+            if (this.typeInfo.getType() instanceof Class<?> type) {
+                if (type.getTypeParameters().length != 0)
+                    resolvedType += "<%s>".formatted(String.join(",", Collections.nCopies(type.getTypeParameters().length, "unknown")));
+            }
             if (arrayDepth != -1)
                 resolvedType += "[]".repeat(arrayDepth);
             return resolvedType;
@@ -136,6 +146,8 @@ public String format() {
             String formatted = "%s: %s;".formatted(this.fieldInfo.getName(), resolvedAnnotation);
             if (this.fieldInfo.isStatic())
                 formatted = "static " + formatted;
+            if (this.fieldInfo.isFinal())
+                formatted = "readonly " + formatted;
             return formatted;
         }
     }
@@ -205,9 +217,106 @@ public ClassFormatter setNameGuard(Predicate<String> predicate) {
         protected List<String> compileMethods() {
             int linesIdent = this.indentation + stepIndentation;
             List<String> innerLines = new ArrayList<>();
+            /* TODO: add support for beans
+             * Criteria: tranfsorm .get?() methods to .? fields.
+             * If an field of same name exist, ignore it.
+             * .get() beans will be readonly, having a .set() will remove the readonly statement.
+             * Only having a .set() will NOT make this write-only as TS does not have such a thing.
+             * */
+
+            Set<ClassInfo.MethodInfo> beaned = new HashSet<>();
+            Set<String> existedNames = classInfo.getFields().stream().map(ClassInfo.FieldInfo::getName).collect(Collectors.toSet());
+            existedNames.addAll(classInfo.getMethods().stream().map(ClassInfo.MethodInfo::getName).collect(Collectors.toSet()));
+
+            //Add class getters/setters to beaned
+            classInfo.getMethods()
+                    .stream()
+                    .filter(methodInfo -> !methodInfo.getName().equals("get"))
+                    .filter(methodInfo -> methodInfo.getName().startsWith("get"))
+                    .filter(methodInfo -> !Character.isDigit(methodInfo.getName().substring(3).charAt(0)))
+                    .filter(methodInfo -> !existedNames.contains(getCamelCase(methodInfo.getName().substring(3))))
+                    .filter(methodInfo -> methodInfo.getParamsInfo().size() == 0)
+                    .forEach(beaned::add);
+
+            classInfo.getMethods()
+                    .stream()
+                    .filter(methodInfo -> !methodInfo.getName().equals("set"))
+                    .filter(methodInfo -> methodInfo.getName().startsWith("set"))
+                    .filter(methodInfo -> !Character.isDigit(methodInfo.getName().substring(3).charAt(0)))
+                    .filter(methodInfo -> methodInfo.getParamsInfo().size() == 1)
+                    .filter(methodInfo -> !existedNames.contains(getCamelCase(methodInfo.getName().substring(3))))
+                    .forEach(beaned::add);
+
+            //Iterate through getter/setters, generate beans.
+            Set<String> beanedNames = new HashSet<>();
+            HashMap<String, ClassInfo.MethodInfo> cachedGetterNames = new HashMap<>();
+            beaned.forEach(methodInfo -> {
+                //TODO: Make it more convenient, although idk how
+                if (classInfo.getClazz() == RecipeEventJS.class) {
+                    if (methodInfo.getName().equals("getRecipes"))
+                        return;
+                }
+                String beanName = getCamelCase(methodInfo.getName().substring(3));
+                if (methodInfo.getName().startsWith("get")) {
+                    if (beanedNames.contains(beanName))
+                        return;
+                    cachedGetterNames.put(beanName, methodInfo);
+                } else if (methodInfo.getName().startsWith("set")) {
+                    beanedNames.add(beanName);
+                    cachedGetterNames.remove(beanName);
+                    Type type = methodInfo.getParamsInfo().get(0).getType();
+                    String resolved = serializeType(type);
+                    if (type instanceof Class<?> clazz) {
+                        if (clazz.getTypeParameters().length != 0)
+                            resolved += "<%s>".formatted(String.join(",", Collections.nCopies(clazz.getTypeParameters().length, "unknown")));
+                    }
+                    String formatted = "%s: %s;".formatted(beanName, resolved);
+                    if (methodInfo.isStatic())
+                        formatted = "static " + formatted;
+                    innerLines.add(" ".repeat(linesIdent) + formatted);
+                }
+            });
+
+            classInfo.getMethods()
+                    .stream()
+                    .filter(methodInfo -> !methodInfo.getName().equals("is"))
+                    .filter(methodInfo -> methodInfo.getName().startsWith("is"))
+                    .filter(methodInfo -> !Character.isDigit(methodInfo.getName().substring(2).charAt(0)))
+                    .filter(methodInfo -> !existedNames.contains(getCamelCase(methodInfo.getName().substring(2))))
+                    .filter(methodInfo -> methodInfo.getParamsInfo().size() == 0)
+                    .filter(methodInfo -> {
+                        Type type = methodInfo.getReturnTypeInfo().getType();
+                        return type instanceof Class && (type == Boolean.TYPE || type == Boolean.class);
+                    })
+                    .filter(methodInfo -> !beanedNames.contains(getCamelCase(methodInfo.getName().substring(2))))
+                    .forEach(methodInfo -> {
+                        beaned.add(methodInfo);
+                        String formatted = "%s: boolean;".formatted(getCamelCase(methodInfo.getName().substring(2)));
+                        if (methodInfo.isStatic())
+                            formatted = "static " + formatted;
+                        formatted = "readonly " + formatted;
+                        innerLines.add(" ".repeat(linesIdent) + formatted);
+                    });
+
+
+            cachedGetterNames.forEach((k, v) -> {
+                Type type = v.getReturnTypeInfo().getType();
+                String resolved = serializeType(v.getReturnTypeInfo().getType());
+                if (type instanceof Class<?> clazz) {
+                    if (clazz.getTypeParameters().length != 0)
+                        resolved += "<%s>".formatted(String.join(",", Collections.nCopies(clazz.getTypeParameters().length, "any")));
+                }
+                String formatted = "%s: %s;".formatted(k, resolved);
+                if (v.isStatic())
+                    formatted = "static " + formatted;
+                formatted = "readonly " + formatted;
+                innerLines.add(" ".repeat(linesIdent) + formatted);
+            });
+
             classInfo.getMethods()
                     .stream()
                     .filter(methodInfo -> this.namePredicate.test(methodInfo.getName()))
+                    .filter(methodInfo -> !beaned.contains(methodInfo))
                     .forEach(methodInfo -> innerLines.add(" ".repeat(linesIdent) + new MethodFormatter(methodInfo).format()));
             return innerLines;
         }
