Examples with YType org.springframework.ide.vscode.commons.yaml.schema.YType used on opensource projects

Example 6 with YType

use of org.springframework.ide.vscode.commons.yaml.schema.YType in project sts4 by spring-projects.

the class YTypeAssistContext method getKeyCompletions.

public List<ICompletionProposal> getKeyCompletions(YamlDocument doc, SNode node, int offset, String query) throws Exception {
    int queryOffset = offset - query.length();
    DynamicSchemaContext dynamicCtxt = getSchemaContext();
    List<YTypedProperty> allProperties = typeUtil.getProperties(type);
    if (CollectionUtil.hasElements(allProperties)) {
        List<List<YTypedProperty>> tieredProperties = sortIntoTiers(allProperties);
        Set<String> definedProps = dynamicCtxt.getDefinedProperties();
        List<ICompletionProposal> proposals = new ArrayList<>();
        boolean suggestDeprecated = typeUtil.suggestDeprecatedProperties();
        YamlIndentUtil indenter = new YamlIndentUtil(doc);
        for (List<YTypedProperty> thisTier : tieredProperties) {
            List<YTypedProperty> undefinedProps = thisTier.stream().filter(p -> !definedProps.contains(p.getName()) && (suggestDeprecated || !p.isDeprecated())).collect(Collectors.toList());
            if (!undefinedProps.isEmpty()) {
                for (YTypedProperty p : undefinedProps) {
                    String name = p.getName();
                    double score = FuzzyMatcher.matchScore(query, name);
                    if (score != 0) {
                        TypeBasedSnippetProvider snippetProvider = typeUtil.getSnippetProvider();
                        DocumentEdits edits;
                        if (snippetProvider != null) {
                            // Generate edits from snippet
                            Snippet snippet = snippetProvider.getSnippet(p);
                            edits = createEditFromSnippet(doc, node, offset, query, indenter, snippet);
                        } else {
                            // Generate edits the old-fashioned way
                            edits = new DocumentEdits(doc.getDocument());
                            YType YType = p.getType();
                            edits.delete(queryOffset, query);
                            int referenceIndent = doc.getColumn(queryOffset);
                            boolean needNewline = node.getNodeType() == SNodeType.KEY;
                            StringBuilder snippet = new StringBuilder();
                            if (needNewline) {
                                snippet.append("\n");
                                referenceIndent = YamlIndentUtil.getNewChildKeyIndent(node);
                            } else if (queryOffset > 0 && !Character.isWhitespace(doc.getChar(queryOffset - 1))) {
                                // See https://www.pivotaltracker.com/story/show/137722057
                                snippet.append(" ");
                                referenceIndent++;
                            }
                            snippet.append(p.getName());
                            snippet.append(":");
                            snippet.append(appendTextFor(YType));
                            edits.insert(queryOffset, indenter.applyIndentation(snippet.toString(), referenceIndent));
                        }
                        ICompletionProposal completion = completionFactory().beanProperty(doc.getDocument(), contextPath.toPropString(), getType(), query, p, score, edits, typeUtil);
                        if (p.isDeprecated() && completion instanceof ScoreableProposal) {
                            completion.deemphasize(DEEMP_DEPRECATION);
                        }
                        proposals.add(completion);
                    }
                }
            }
            // We should only move on to the next tier if all required properties in this tier are defined.
            if (undefinedProps.stream().anyMatch(p -> p.isRequired())) {
                // stop here, take no more from next tier!
                return proposals;
            }
        }
        return proposals;
    }
    return Collections.emptyList();
}

Example 7 with YType

use of org.springframework.ide.vscode.commons.yaml.schema.YType in project sts4 by spring-projects.

the class YPropertyInfoTemplates method createHover.

public static Renderable createHover(String contextProperty, YType contextType, YTypedProperty prop) {
    Builder<Renderable> html = ImmutableList.builder();
    if (StringUtil.hasText(contextProperty)) {
        html.add(text(contextProperty));
        html.add(text("."));
    }
    html.add(bold(text(prop.getName())));
    html.add(lineBreak());
    YType type = prop.getType();
    if (type != null) {
        html.add(link(type.toString(), /* no URL */
        null));
    }
    Renderable description = prop.getDescription();
    if (description != null) {
        html.add(lineBreak());
        html.add(lineBreak());
        html.add(description);
    }
    return concat(html.build());
}

Example 8 with YType

use of org.springframework.ide.vscode.commons.yaml.schema.YType in project sts4 by spring-projects.

the class SchemaBasedYamlASTReconciler method reconcile.

private void reconcile(YamlFileAST ast, YamlPath path, Node parent, Node node, YType _type) {
    // IDocument doc = ast.getDocument();
    if (_type != null && !skipReconciling(node)) {
        DynamicSchemaContext schemaContext = new ASTDynamicSchemaContext(ast, path, node);
        YType type = typeUtil.inferMoreSpecificType(_type, schemaContext);
        if (typeCollector != null) {
            typeCollector.accept(node, type);
        }
        checkConstraints(parent, node, type, schemaContext);
        switch(getNodeId(node)) {
            case mapping:
                MappingNode map = (MappingNode) node;
                checkForDuplicateKeys(map);
                if (typeUtil.isMap(type)) {
                    for (NodeTuple entry : map.getValue()) {
                        String key = NodeUtil.asScalar(entry.getKeyNode());
                        reconcile(ast, keyAt(path, key), map, entry.getKeyNode(), typeUtil.getKeyType(type));
                        reconcile(ast, valueAt(path, key), map, entry.getValueNode(), typeUtil.getDomainType(type));
                    }
                } else if (typeUtil.isBean(type)) {
                    Map<String, YTypedProperty> beanProperties = typeUtil.getPropertiesMap(type);
                    checkRequiredProperties(parent, map, type, beanProperties, schemaContext);
                    for (NodeTuple entry : map.getValue()) {
                        Node keyNode = entry.getKeyNode();
                        String key = NodeUtil.asScalar(keyNode);
                        if (key == null) {
                            expectScalar(node);
                        } else {
                            YTypedProperty prop = beanProperties.get(key);
                            if (prop == null) {
                                unknownBeanProperty(keyNode, type, key);
                            } else {
                                if (prop.isDeprecated()) {
                                    String msg = prop.getDeprecationMessage();
                                    if (StringUtil.hasText(msg)) {
                                        problems.accept(YamlSchemaProblems.deprecatedProperty(msg, keyNode));
                                    } else {
                                        problems.accept(YamlSchemaProblems.deprecatedProperty(keyNode, type, prop));
                                    }
                                }
                                reconcile(ast, valueAt(path, key), map, entry.getValueNode(), prop.getType());
                            }
                        }
                    }
                } else {
                    expectTypeButFoundMap(type, node);
                }
                break;
            case sequence:
                SequenceNode seq = (SequenceNode) node;
                if (typeUtil.isSequencable(type)) {
                    for (int i = 0; i < seq.getValue().size(); i++) {
                        Node el = seq.getValue().get(i);
                        reconcile(ast, valueAt(path, i), seq, el, typeUtil.getDomainType(type));
                    }
                } else {
                    expectTypeButFoundSequence(type, node);
                }
                break;
            case scalar:
                if (typeUtil.isAtomic(type)) {
                    SchemaContextAware<ValueParser> parserProvider = typeUtil.getValueParser(type);
                    if (parserProvider != null) {
                        // Take care not to execute parserProvider early just to check how long it should be delayed.
                        delayedConstraints.add(() -> {
                            parserProvider.safeWithContext(schemaContext).ifPresent(parser -> {
                                if (parser.longRunning()) {
                                    slowDelayedConstraints.add(() -> {
                                        parse(ast, node, type, parser);
                                    });
                                } else {
                                    parse(ast, node, type, parser);
                                }
                            });
                        });
                    }
                } else {
                    expectTypeButFoundScalar(type, node);
                }
                break;
            default:
        }
    }
}

Example 9 with YType

use of org.springframework.ide.vscode.commons.yaml.schema.YType in project sts4 by spring-projects.

the class SchemaBasedSnippetGenerator method generateFullSnippet.

private Snippet generateFullSnippet(YType type, int indent) {
    if (typeUtil.isBean(type)) {
        SnippetBuilder builder = snippetBuilderFactory.get();
        List<YTypedProperty> requiredProps = typeUtil.getProperties(type).stream().filter(p -> p.isRequired()).collect(CollectorUtil.toImmutableList());
        if (!requiredProps.isEmpty()) {
            generateBeanSnippet(requiredProps, builder, indent, maxNesting);
        }
        if (builder.getPlaceholderCount() >= 2) {
            return new Snippet(typeUtil.niceTypeName(type) + " Snippet", builder.build(), (dc) -> requiredProps.stream().noneMatch(p -> dc.getDefinedProperties().contains(p.getName())));
        }
    }
    return null;
}

Example 10 with YType

use of org.springframework.ide.vscode.commons.yaml.schema.YType in project sts4 by spring-projects.

the class BoshDeploymentManifestSchema method createV2Schema.

private YBeanType createV2Schema() {
    YBeanType v2Schema = f.ybean("BoshDeploymentManifest");
    addProp(v2Schema, "name", t_ne_string).isPrimary(true);
    addProp(v2Schema, "director_uuid", t_uuid).isDeprecated("bosh v2 CLI no longer checks or requires director_uuid in the deployment manifest. " + "To achieve similar safety make sure to give unique deployment names across environments.");
    t_instance_group_name_def = f.yatomic("InstanceGroupName").parseWith(ValueParsers.NE_STRING);
    t_stemcell_alias_def = f.yatomic("StemcellAlias").parseWith(ValueParsers.NE_STRING);
    t_stemcell_alias_ref = f.yenumFromDynamicValues("StemcellAlias", (dc) -> PartialCollection.compute(() -> astTypes.getDefinedNames(dc, t_stemcell_alias_def)));
    t_release_name_def = f.yenumFromDynamicValues("ReleaseName", (dc) -> {
        PartialCollection<String> releaseNames = PartialCollection.compute(() -> releasesProvider.getModel(dc).getReleaseNames());
        return StringUtil.hasText(getCurrentEntityProperty(dc, "url")) ? releaseNames.addUncertainty() : releaseNames;
    });
    t_release_name_ref = f.yenumFromDynamicValues("ReleaseName", (dc) -> PartialCollection.compute(() -> astTypes.getDefinedNames(dc, t_release_name_def)));
    t_var_name_def = f.yatomic("VariableName").parseWith(ValueParsers.NE_STRING);
    // TODO: some kind of checking?
    YAtomicType t_ip_address = f.yatomic("IPAddress");
    t_ip_address.parseWith(ValueParsers.NE_STRING);
    YAtomicType t_url = f.yatomic("URL");
    t_url.parseWith(BoshValueParsers.url("http", "https", "file"));
    YAtomicType t_network_name = f.yenumFromDynamicValues("NetworkName", (dc) -> PartialCollection.compute(() -> cloudConfigProvider.getModel(dc).getNetworkNames()));
    YAtomicType t_disk_type = f.yenumFromDynamicValues("DiskType", (dc) -> PartialCollection.compute(() -> cloudConfigProvider.getModel(dc).getDiskTypes()));
    YAtomicType t_vm_extension = f.yenumFromDynamicValues("VMExtension", (dc) -> PartialCollection.compute(() -> cloudConfigProvider.getModel(dc).getVMExtensions()));
    YAtomicType t_vm_type = f.yenumFromDynamicValues("VMType", (dc) -> PartialCollection.compute(() -> cloudConfigProvider.getModel(dc).getVMTypes()));
    YAtomicType t_az = f.yenumFromDynamicValues("AvailabilityZone", (dc) -> PartialCollection.compute(() -> cloudConfigProvider.getModel(dc).getAvailabilityZones()));
    YBeanType t_network = f.ybean("Network");
    addProp(t_network, "name", t_network_name).isRequired(true);
    addProp(t_network, "static_ips", f.yseq(t_ip_address));
    // TODO: Can we determine the set of valid values? How?
    addProp(t_network, "default", f.yseq(t_ne_string));
    YBeanType t_instance_group_env = f.ybean("InstanceGroupEnv");
    addProp(t_instance_group_env, "bosh", t_params);
    addProp(t_instance_group_env, "password", t_ne_string);
    YType t_release_version = f.yenumFromDynamicValues("ReleaseVersion", // message formatter:
    dc -> (s, values) -> {
        String name = getCurrentEntityProperty(dc, "name");
        if (StringUtil.hasText(name)) {
            return "'" + s + "' is an unknown 'ReleaseVersion[name=" + name + "]'. Valid values are: " + values;
        } else {
            return "'" + s + "' is an unknown 'ReleaseVersion'. Valid values are: " + values;
        }
    }, // value provider:
    dc -> {
        PartialCollection<ReleaseData> releases = PartialCollection.compute(() -> releasesProvider.getModel(dc).getReleases());
        if (StringUtil.hasText(getCurrentEntityProperty(dc, "url"))) {
            releases = releases.addUncertainty();
        } else {
            String name = getCurrentEntityProperty(dc, "name");
            if (StringUtil.hasText(name)) {
                releases = releases.map(r -> name.equals(r.getName()) ? r : null);
            }
        }
        return releases.map(r -> r.getVersion()).add("latest");
    });
    YBeanType t_release = f.ybean("Release");
    addProp(t_release, "name", t_release_name_def).isPrimary(true);
    addProp(t_release, "version", t_release_version).isRequired(true);
    addProp(t_release, "url", t_url);
    addProp(t_release, "sha1", t_ne_string);
    t_release.require(BoshConstraints.SHA1_REQUIRED_FOR_HTTP_URL);
    addProp(v2Schema, "releases", f.yseq(t_release)).isRequired(true);
    YBeanType t_stemcell = f.ybean("Stemcell");
    YType t_stemcell_name_ref = f.yenumFromDynamicValues("StemcellName", (dc) -> PartialCollection.compute(() -> stemcellsProvider.getModel(dc).getStemcellNames()));
    YType t_stemcell_os_ref = f.yenumFromDynamicValues("StemcellOs", (dc) -> PartialCollection.compute(() -> stemcellsProvider.getModel(dc).getStemcellOss()));
    YType t_stemcell_version_ref = f.yenumFromDynamicValues("StemcellVersion", (dc) -> (parseString, validValues) -> {
        try {
            Predicate<StemcellData> filter = getCurrentStemcell(dc).createVersionFilter();
            if (filter != StemcellModel.ALLWAYS_TRUE_FILTER) {
                return "'" + parseString + "' is an unknown 'StemcellVersion[" + filter + "]'. Valid values are: " + validValues;
            }
        } catch (Exception e) {
        // ignore (parse error most likely)
        }
        return "'" + parseString + "' is an unknown 'StemcellVersion'. Valid values are: " + validValues;
    }, (dc) -> {
        Predicate<StemcellData> filter = getCurrentStemcell(dc).createVersionFilter();
        return PartialCollection.compute(() -> stemcellsProvider.getModel(dc).getStemcells()).map(sc -> filter.test(sc) ? sc.getVersion() : null).add("latest");
    });
    addProp(t_stemcell, "alias", t_stemcell_alias_def).isPrimary(true);
    addProp(t_stemcell, "version", t_stemcell_version_ref).isRequired(true);
    addProp(t_stemcell, "name", t_stemcell_name_ref);
    addProp(t_stemcell, "os", t_stemcell_os_ref);
    t_stemcell.requireOneOf("name", "os");
    addProp(v2Schema, "stemcells", f.yseq(t_stemcell)).isRequired(true);
    YBeanType t_update = f.ybean("Update");
    addProp(t_update, "canaries", t_strictly_pos_integer).isRequired(true);
    addProp(t_update, "max_in_flight", t_pos_integer).isRequired(true);
    addProp(t_update, "canary_watch_time", t_integer_or_range).isRequired(true);
    addProp(t_update, "update_watch_time", t_integer_or_range).isRequired(true);
    addProp(t_update, "serial", t_boolean);
    addProp(v2Schema, "update", t_update).isRequired(true);
    YBeanType t_job = f.ybean("Job");
    addProp(t_job, "name", t_ne_string).isRequired(true);
    addProp(t_job, "release", t_release_name_ref).isRequired(true);
    addProp(t_job, "consumes", t_params);
    addProp(t_job, "provides", t_params);
    addProp(t_job, "properties", t_params);
    YBeanType t_instance_group = f.ybean("InstanceGroup");
    addProp(t_instance_group, "name", t_instance_group_name_def).isPrimary(true);
    addProp(t_instance_group, "azs", f.yseq(t_az)).isRequired(true);
    // Strictly positive? Or zero is okay?
    addProp(t_instance_group, "instances", t_pos_integer).isRequired(true);
    addProp(t_instance_group, "jobs", f.yseq(t_job)).isRequired(true);
    addProp(t_instance_group, "vm_type", t_vm_type).isRequired(true);
    addProp(t_instance_group, "vm_extensions", f.yseq(t_vm_extension));
    addProp(t_instance_group, "stemcell", t_stemcell_alias_ref).isRequired(true);
    addProp(t_instance_group, "persistent_disk_type", t_disk_type);
    addProp(t_instance_group, "networks", f.yseq(t_network)).isRequired(true);
    YType t_update_override = f.ybean("UpdateOverrides", t_update.getProperties().stream().map((YTypedProperty prop) -> f.yprop(prop).isRequired(false)).toArray(sz -> new YTypedProperty[sz]));
    addProp(t_instance_group, "update", t_update_override);
    // TODO: https://www.pivotaltracker.com/story/show/148712595
    YType t_migration = t_params;
    addProp(t_instance_group, "migrated_from", f.yseq(t_migration));
    addProp(t_instance_group, "lifecycle", f.yenum("WorkloadType", "service", "errand"));
    addProp(t_instance_group, "properties", t_params).isDeprecated("Deprecated in favor of job level properties and links");
    addProp(t_instance_group, "env", t_instance_group_env);
    addProp(v2Schema, "instance_groups", f.yseq(t_instance_group)).isRequired(true);
    addProp(v2Schema, "properties", t_params).isDeprecated("Deprecated in favor of job level properties and links");
    YBeanType t_variable = f.ybean("Variable");
    addProp(t_variable, "name", t_var_name_def).isPrimary(true);
    YType t_variable_type = f.yenum("VariableType", "certificate", "password", "rsa", "ssh").parseWith(// Override the parser -> no errors / warnings... in theory there could be other valid values.
    ValueParsers.NE_STRING);
    addProp(t_variable, "type", t_variable_type).isRequired(true);
    addProp(t_variable, "options", t_params);
    addProp(v2Schema, "variables", f.yseq(t_variable));
    addProp(v2Schema, "tags", t_params);
    for (String v1Prop : DEPRECATED_V1_PROPS) {
        addProp(v2Schema, v1Prop, t_any).isDeprecated("Deprecated: '" + v1Prop + "' is a V1 schema property. Consider migrating your deployment manifest to V2");
    }
    for (YType defType : getDefinitionTypes()) {
        v2Schema.require(Constraints.uniqueDefinition(this.astTypes, defType, YamlSchemaProblems.problemType("BOSH_DUPLICATE_" + defType)));
    }
    return v2Schema;
}