Examples with MethodCallExpr org.drools.javaparser.ast.expr.MethodCallExpr used on opensource projects

Example 31 with MethodCallExpr

use of org.drools.javaparser.ast.expr.MethodCallExpr in project drools by kiegroup.

the class PackageModel method getRulesSource.

public RuleSourceResult getRulesSource() {
    CompilationUnit cu = new CompilationUnit();
    cu.setPackageDeclaration(name);
    manageImportForCompilationUnit(cu);
    ClassOrInterfaceDeclaration rulesClass = cu.addClass(rulesFileName);
    rulesClass.addImplementedType(Model.class);
    BodyDeclaration<?> dateFormatter = JavaParser.parseBodyDeclaration("public final static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DateUtils.getDateFormatMask());\n");
    rulesClass.addMember(dateFormatter);
    BodyDeclaration<?> getNameMethod = JavaParser.parseBodyDeclaration("    @Override\n" + "        public String getName() {\n" + "        return \"" + name + "\";\n" + "    }\n");
    rulesClass.addMember(getNameMethod);
    BodyDeclaration<?> getRulesMethod = JavaParser.parseBodyDeclaration("    @Override\n" + "    public List<Rule> getRules() {\n" + "        return rules;\n" + "    }\n");
    rulesClass.addMember(getRulesMethod);
    StringBuilder sb = new StringBuilder("\n");
    sb.append("With the following expression ID:\n");
    sb.append(exprIdGenerator.toString());
    sb.append("\n");
    JavadocComment exprIdComment = new JavadocComment(sb.toString());
    getRulesMethod.setComment(exprIdComment);
    BodyDeclaration<?> getGlobalsMethod = JavaParser.parseBodyDeclaration("    @Override\n" + "    public List<Global> getGlobals() {\n" + "        return globals;\n" + "    }\n");
    rulesClass.addMember(getGlobalsMethod);
    BodyDeclaration<?> getQueriesMethod = JavaParser.parseBodyDeclaration("    @Override\n" + "    public List<Query> getQueries() {\n" + "        return queries;\n" + "    }\n");
    rulesClass.addMember(getQueriesMethod);
    BodyDeclaration<?> getTypeMetaDataMethod = JavaParser.parseBodyDeclaration("    @Override\n" + "    public List<TypeMetaData> getTypeMetaDatas() {\n" + "        return typeMetaDatas;\n" + "    }\n");
    rulesClass.addMember(getTypeMetaDataMethod);
    for (Map.Entry<String, MethodCallExpr> windowReference : windowReferences.entrySet()) {
        FieldDeclaration f = rulesClass.addField(WINDOW_REFERENCE_TYPE, windowReference.getKey(), Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL);
        f.getVariables().get(0).setInitializer(windowReference.getValue());
    }
    for (Map.Entry<String, Class<?>> g : getGlobals().entrySet()) {
        addGlobalField(rulesClass, getName(), g.getKey(), g.getValue());
    }
    for (Map.Entry<String, QueryGenerator.QueryDefWithType> queryDef : queryDefWithType.entrySet()) {
        FieldDeclaration field = rulesClass.addField(queryDef.getValue().getQueryType(), queryDef.getKey(), Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL);
        field.getVariables().get(0).setInitializer(queryDef.getValue().getMethodCallExpr());
    }
    for (Map.Entry<String, MethodDeclaration> methodName : queryMethods.entrySet()) {
        FieldDeclaration field = rulesClass.addField(methodName.getValue().getType(), methodName.getKey(), Modifier.FINAL);
        field.getVariables().get(0).setInitializer(new MethodCallExpr(null, methodName.getKey()));
    }
    // instance initializer block.
    // add to `rules` list the result of invoking each method for rule
    InitializerDeclaration rulesListInitializer = new InitializerDeclaration();
    BlockStmt rulesListInitializerBody = new BlockStmt();
    rulesListInitializer.setBody(rulesListInitializerBody);
    queryMethods.values().forEach(rulesClass::addMember);
    buildArtifactsDeclaration(queryMethods.keySet(), rulesClass, rulesListInitializerBody, "Query", "queries", false);
    buildArtifactsDeclaration(windowReferences.keySet(), rulesClass, rulesListInitializerBody, "WindowReference", "windowReferences", false);
    buildArtifactsDeclaration(getGlobals().keySet(), rulesClass, rulesListInitializerBody, "Global", "globals", true);
    if (!typeMetaDataExpressions.isEmpty()) {
        BodyDeclaration<?> typeMetaDatasList = JavaParser.parseBodyDeclaration("List<TypeMetaData> typeMetaDatas = new ArrayList<>();");
        rulesClass.addMember(typeMetaDatasList);
        for (Expression expr : typeMetaDataExpressions) {
            addInitStatement(rulesListInitializerBody, expr, "typeMetaDatas");
        }
    } else {
        BodyDeclaration<?> typeMetaDatasList = JavaParser.parseBodyDeclaration("List<TypeMetaData> typeMetaDatas = Collections.emptyList();");
        rulesClass.addMember(typeMetaDatasList);
    }
    functions.forEach(rulesClass::addMember);
    RuleSourceResult results = new RuleSourceResult(cu);
    int ruleCount = ruleMethods.size();
    boolean requiresMultipleRulesLists = ruleCount >= RULES_DECLARATION_PER_CLASS - 1;
    MethodCallExpr rules = buildRulesField(rulesClass);
    if (requiresMultipleRulesLists) {
        addRulesList(rulesListInitializerBody, "rulesList");
    }
    // each method per Drlx parser result
    int count = -1;
    Map<Integer, ClassOrInterfaceDeclaration> splitted = new LinkedHashMap<>();
    for (Entry<String, MethodDeclaration> ruleMethodKV : ruleMethods.entrySet()) {
        ClassOrInterfaceDeclaration rulesMethodClass = splitted.computeIfAbsent(++count / RULES_PER_CLASS, i -> {
            CompilationUnit cuRulesMethod = new CompilationUnit();
            results.with(cuRulesMethod);
            cuRulesMethod.setPackageDeclaration(name);
            manageImportForCompilationUnit(cuRulesMethod);
            cuRulesMethod.addImport(JavaParser.parseImport("import static " + name + "." + rulesFileName + ".*;"));
            String currentRulesMethodClassName = rulesFileName + "RuleMethods" + i;
            return cuRulesMethod.addClass(currentRulesMethodClassName);
        });
        rulesMethodClass.addMember(ruleMethodKV.getValue());
        if (count % RULES_DECLARATION_PER_CLASS == RULES_DECLARATION_PER_CLASS - 1) {
            int index = count / RULES_DECLARATION_PER_CLASS;
            rules = buildRulesField(results, index);
            addRulesList(rulesListInitializerBody, rulesFileName + "Rules" + index + ".rulesList");
        }
        // manage in main class init block:
        rules.addArgument(new MethodCallExpr(new NameExpr(rulesMethodClass.getNameAsString()), ruleMethodKV.getKey()));
    }
    BodyDeclaration<?> rulesList = requiresMultipleRulesLists ? JavaParser.parseBodyDeclaration("List<Rule> rules = new ArrayList<>(" + ruleCount + ");") : JavaParser.parseBodyDeclaration("List<Rule> rules = rulesList;");
    rulesClass.addMember(rulesList);
    if (!rulesListInitializer.getBody().getStatements().isEmpty()) {
        rulesClass.addMember(rulesListInitializer);
    }
    return results;
}

Example 32 with MethodCallExpr

use of org.drools.javaparser.ast.expr.MethodCallExpr in project drools by kiegroup.

the class PackageModel method buildRulesField.

private MethodCallExpr buildRulesField(ClassOrInterfaceDeclaration rulesClass) {
    MethodCallExpr rulesInit = new MethodCallExpr(null, "Arrays.asList");
    ClassOrInterfaceType rulesType = new ClassOrInterfaceType(null, new SimpleName("List"), new NodeList<Type>(new ClassOrInterfaceType(null, "Rule")));
    VariableDeclarator rulesVar = new VariableDeclarator(rulesType, "rulesList", rulesInit);
    rulesClass.addMember(new FieldDeclaration(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC), rulesVar));
    return rulesInit;
}

Example 33 with MethodCallExpr

use of org.drools.javaparser.ast.expr.MethodCallExpr in project drools by kiegroup.

the class PackageModel method addGlobalField.

private static void addGlobalField(ClassOrInterfaceDeclaration classDeclaration, String packageName, String globalName, Class<?> globalClass) {
    ClassOrInterfaceType varType = JavaParser.parseClassOrInterfaceType(Global.class.getCanonicalName());
    varType.setTypeArguments(DrlxParseUtil.classToReferenceType(globalClass));
    Type declType = DrlxParseUtil.classToReferenceType(globalClass);
    MethodCallExpr declarationOfCall = new MethodCallExpr(null, "globalOf");
    declarationOfCall.addArgument(new ClassExpr(declType));
    declarationOfCall.addArgument(new StringLiteralExpr(packageName));
    declarationOfCall.addArgument(new StringLiteralExpr(globalName));
    FieldDeclaration field = classDeclaration.addField(varType, toVar(globalName), Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL);
    field.getVariables().get(0).setInitializer(declarationOfCall);
}

Example 34 with MethodCallExpr

use of org.drools.javaparser.ast.expr.MethodCallExpr in project drools by kiegroup.

the class Consequence method createCall.

public MethodCallExpr createCall(RuleDescr ruleDescr, String consequenceString, BlockStmt ruleVariablesBlock, boolean isBreaking) {
    BlockStmt ruleConsequence = rewriteConsequence(consequenceString);
    if (ruleConsequence != null) {
        ruleConsequence.findAll(Expression.class).stream().filter(s -> isNameExprWithName(s, "kcontext")).forEach(n -> n.replace(new NameExpr("drools")));
    }
    Collection<String> usedDeclarationInRHS = extractUsedDeclarations(ruleConsequence, consequenceString);
    MethodCallExpr onCall = onCall(usedDeclarationInRHS);
    if (isBreaking) {
        onCall = new MethodCallExpr(onCall, BREAKING_CALL);
    }
    MethodCallExpr executeCall = null;
    if (context.getRuleDialect() == RuleContext.RuleDialect.JAVA) {
        executeCall = executeCall(ruleVariablesBlock, ruleConsequence, usedDeclarationInRHS, onCall);
    } else if (context.getRuleDialect() == RuleContext.RuleDialect.MVEL) {
        executeCall = executeScriptCall(ruleDescr, onCall);
    }
    return executeCall;
}

Example 35 with MethodCallExpr

use of org.drools.javaparser.ast.expr.MethodCallExpr in project drools by kiegroup.

the class Consequence method executeScriptCall.

private MethodCallExpr executeScriptCall(RuleDescr ruleDescr, MethodCallExpr onCall) {
    MethodCallExpr executeCall = new MethodCallExpr(onCall, EXECUTESCRIPT_CALL);
    executeCall.addArgument(new StringLiteralExpr("mvel"));
    ObjectCreationExpr objectCreationExpr = new ObjectCreationExpr();
    objectCreationExpr.setType(StringBuilder.class.getCanonicalName());
    Expression mvelSB = objectCreationExpr;
    for (String i : packageModel.getImports()) {
        if (i.equals(packageModel.getName() + ".*")) {
            // skip same-package star import.
            continue;
        }
        MethodCallExpr appendCall = new MethodCallExpr(mvelSB, "append");
        StringLiteralExpr importAsStringLiteral = new StringLiteralExpr();
        // use the setter method in order for the string literal be properly escaped.
        importAsStringLiteral.setString("import " + i + ";\n");
        appendCall.addArgument(importAsStringLiteral);
        mvelSB = appendCall;
    }
    StringLiteralExpr mvelScriptBodyStringLiteral = new StringLiteralExpr();
    // use the setter method in order for the string literal be properly escaped.
    mvelScriptBodyStringLiteral.setString(ruleDescr.getConsequence().toString());
    MethodCallExpr appendCall = new MethodCallExpr(mvelSB, "append");
    appendCall.addArgument(mvelScriptBodyStringLiteral);
    executeCall.addArgument(new MethodCallExpr(appendCall, "toString"));
    return executeCall;
}