Examples with Template com.redhat.qute.parser.template.Template used on opensource projects

Example 21 with Template

use of com.redhat.qute.parser.template.Template in project quarkus-ls by redhat-developer.

the class QuteAssert method createTemplate.

private static Template createTemplate(String value, String fileUri, String projectUri, String templateBaseDir, QuteProjectRegistry projectRegistry) {
    Template template = TemplateParser.parse(value, fileUri != null ? fileUri : FILE_URI);
    template.setProjectUri(projectUri);
    projectRegistry.getProject(new ProjectInfo(projectUri, templateBaseDir));
    template.setProjectRegistry(projectRegistry);
    return template;
}

Example 22 with Template

use of com.redhat.qute.parser.template.Template in project quarkus-ls by redhat-developer.

the class QutePositionUtility method createLocation.

/**
 * Returns the location for the given <code>target</code> node.
 *
 * @param target the target node.
 * @return the location for the given <code>target</code> node.
 */
public static Location createLocation(Node target) {
    Template targetDocument = target.getOwnerTemplate();
    Range targetRange = createRange(target.getStart(), target.getEnd(), targetDocument);
    return new Location(targetDocument.getUri(), targetRange);
}

Example 23 with Template

use of com.redhat.qute.parser.template.Template in project quarkus-ls by redhat-developer.

the class QutePositionUtility method selectClassName.

public static Range selectClassName(ParameterDeclaration parameter) {
    Template template = parameter.getOwnerTemplate();
    int startOffset = parameter.getClassNameStart();
    int endOffset = parameter.getClassNameEnd();
    return createRange(startOffset, endOffset, template);
}

Example 24 with Template

use of com.redhat.qute.parser.template.Template in project quarkus-ls by redhat-developer.

the class ExpressionParser method parse.

/**
 * Returns the parsing result of the given expression content.
 *
 * @param expression    the content to parse.
 * @param cancelChecker the cancel checker.
 *
 * @return the parsing result of the given expression content.
 */
public static List<Node> parse(Expression expression, CancelChecker cancelChecker) {
    if (cancelChecker == null) {
        cancelChecker = DEFAULT_CANCEL_CHECKER;
    }
    Template template = expression.getOwnerTemplate();
    String text = template.getText();
    int start = expression.getStartContentOffset();
    int end = expression.getEndContentOffset();
    ExpressionScanner scanner = ExpressionScanner.createScanner(text, start, end);
    TokenType token = scanner.scan();
    List<Node> expressionContent = new ArrayList<>();
    Parts currentParts = null;
    while (token != TokenType.EOS) {
        cancelChecker.checkCanceled();
        int tokenOffset = scanner.getTokenOffset();
        int tokenEnd = scanner.getTokenEnd();
        switch(token) {
            case Whitespace:
                currentParts = null;
                break;
            case NamespacePart:
                currentParts = new Parts(tokenOffset, tokenEnd);
                currentParts.setExpressionParent(expression);
                expressionContent.add(currentParts);
                NamespacePart namespacePart = new NamespacePart(tokenOffset, tokenEnd);
                currentParts.addPart(namespacePart);
                break;
            case ObjectPart:
                if (!(currentParts != null && currentParts.getChildCount() == 1 && currentParts.getChild(0).getPartKind() == PartKind.Namespace)) {
                    currentParts = new Parts(tokenOffset, tokenEnd);
                    currentParts.setExpressionParent(expression);
                    expressionContent.add(currentParts);
                }
                if (currentParts != null) {
                    ObjectPart objectPart = new ObjectPart(tokenOffset, tokenEnd);
                    currentParts.addPart(objectPart);
                }
                break;
            case PropertyPart:
                if (currentParts != null) {
                    PropertyPart propertyPart = new PropertyPart(tokenOffset, tokenEnd);
                    currentParts.addPart(propertyPart);
                }
                break;
            case MethodPart:
                if (currentParts != null) {
                    MethodPart methodPart = new MethodPart(tokenOffset, tokenEnd);
                    currentParts.addPart(methodPart);
                }
                break;
            case Dot:
                if (currentParts != null) {
                    currentParts.addDot(tokenOffset);
                }
                break;
            case ColonSpace:
                if (currentParts != null) {
                    currentParts.addColonSpace(tokenOffset);
                }
                break;
            case OpenBracket:
                if (currentParts != null) {
                    Node last = currentParts.getLastChild();
                    if (last instanceof MethodPart) {
                        ((MethodPart) last).setOpenBracket(tokenOffset);
                    }
                }
                break;
            case CloseBracket:
                if (currentParts != null) {
                    Node last = currentParts.getLastChild();
                    if (last instanceof MethodPart) {
                        ((MethodPart) last).setCloseBracket(tokenOffset);
                    }
                }
                break;
            case StartString:
            case String:
            case EndString:
                // ignore string tokens
                break;
            default:
                currentParts = null;
                break;
        }
        token = scanner.scan();
    }
    // adjust end offset for the current parts
    if (currentParts != null) {
        currentParts.setEnd(end);
        Node last = currentParts.getLastChild();
        if (last instanceof MethodPart) {
            if (!last.isClosed()) {
                // the current method is not closed with ')', adjust end method with the end
                // offset.
                ((MethodPart) last).setEnd(end);
            }
        }
    }
    return expressionContent;
}

Example 25 with Template

use of com.redhat.qute.parser.template.Template in project quarkus-ls by redhat-developer.

the class ParameterParser method parse.

public static List<Parameter> parse(ParametersContainer expression, boolean methodParameters, CancelChecker cancelChecker) {
    if (cancelChecker == null) {
        cancelChecker = DEFAULT_CANCEL_CHECKER;
    }
    Template template = expression.getOwnerTemplate();
    String text = template.getText();
    int start = expression.getStartParametersOffset();
    int end = expression.getEndParametersOffset();
    ParameterScanner scanner = ParameterScanner.createScanner(text, start, end, methodParameters);
    TokenType token = scanner.scan();
    List<Parameter> parameters = new ArrayList<>();
    Parameter currentParameter = null;
    while (token != TokenType.EOS) {
        cancelChecker.checkCanceled();
        int tokenOffset = scanner.getTokenOffset();
        int tokenEnd = scanner.getTokenEnd();
        switch(token) {
            case Whitespace:
                currentParameter = null;
                break;
            case ParameterName:
                currentParameter = new Parameter(tokenOffset, tokenEnd);
                currentParameter.setParameterParent(expression);
                parameters.add(currentParameter);
                break;
            case ParameterValue:
                if (currentParameter != null) {
                    // current parameter can be null when parameter name is not defined
                    // ex : {#let =123} (instead of {#let name=123})
                    currentParameter.setStartValue(tokenOffset);
                    currentParameter.setEndValue(tokenEnd);
                }
                break;
            default:
        }
        token = scanner.scan();
    }
    return parameters;
}