redhat-developer/yaml-language-server

Language Server for YAML Files

YAML Language Server

Supports JSON Schema 7 and below. Starting from 1.0.0 the language server uses eemeli/yaml as the new YAML parser, which strictly enforces the specified YAML spec version. Default YAML spec version is 1.2, it can be changed with yaml.yamlVersion setting.

Features

1. YAML validation:
   • Detects whether the entire file is valid yaml
2. Validation:
   • Detects errors such as:
     • Node is not found
     • Node has an invalid key node type
     • Node has an invalid type
     • Node is not a valid child node
   • Detects warnings such as:
     • Node is an additional property of parent
3. Auto completion:
   • Auto completes on all commands
   • Scalar nodes autocomplete to schema's defaults if they exist
4. Hover support:
   • Hovering over a node shows description if available
5. Document outlining:
   • Shows a complete document outline of all nodes in the document

Language Server Settings

The following settings are supported:

• yaml.yamlVersion: Set default YAML spec version (1.2 or 1.1)
• yaml.format.enable: Enable/disable default YAML formatter (requires restart)
• yaml.format.singleQuote: Use single quotes instead of double quotes
• yaml.format.bracketSpacing: Print spaces between brackets in objects
• yaml.format.proseWrap: Always: wrap prose if it exceeds the print width, Never: never wrap the prose, Preserve: wrap prose as-is
• yaml.format.printWidth: Specify the line length that the printer will wrap on
• yaml.validate: Enable/disable validation feature
• yaml.hover: Enable/disable hover
• yaml.completion: Enable/disable autocompletion
• yaml.schemas: Helps you associate schemas with files in a glob pattern
• yaml.schemaStore.enable: When set to true the YAML language server will pull in all available schemas from JSON Schema Store
• yaml.schemaStore.url: URL of a schema store catalog to use when downloading schemas.
• yaml.customTags: Array of custom tags that the parser will validate against. It has two ways to be used. Either an item in the array is a custom tag such as "!Ref" and it will automatically map !Ref to scalar or you can specify the type of the object !Ref should be e.g. "!Ref sequence". The type of object can be either scalar (for strings and booleans), sequence (for arrays), map (for objects).
• yaml.maxItemsComputed: The maximum number of outline symbols and folding regions computed (limited for performance reasons).
• [yaml].editor.tabSize: the number of spaces to use when autocompleting. Takes priority over editor.tabSize.
• editor.tabSize: the number of spaces to use when autocompleting. Default is 2.
• http.proxy: The URL of the proxy server that will be used when attempting to download a schema. If it is not set or it is undefined no proxy server will be used.
• http.proxyStrictSSL: If true the proxy server certificate should be verified against the list of supplied CAs. Default is false.
• [yaml].editor.formatOnType: Enable/disable on type indent and auto formatting array
• yaml.disableDefaultProperties: Disable adding not required properties with default values into completion text
• yaml.suggest.parentSkeletonSelectedFirst: If true, the user must select some parent skeleton first before autocompletion starts to suggest the rest of the properties.\nWhen yaml object is not empty, autocompletion ignores this setting and returns all properties and skeletons.
• yaml.style.flowMapping : Forbids flow style mappings if set to forbid
• yaml.style.flowSequence : Forbids flow style sequences if set to forbid
• yaml.keyOrdering : Enforces alphabetical ordering of keys in mappings when set to true. Default is false

Adding custom tags

In order to use the custom tags in your YAML file you need to first specify the custom tags in the setting of your code editor. For example, we can have the following custom tags:

"yaml.customTags": [
    "!Scalar-example scalar",
    "!Seq-example sequence",
    "!Mapping-example mapping"
]

The !Scalar-example would map to a scalar custom tag, the !Seq-example would map to a sequence custom tag, the !Mapping-example would map to a mapping custom tag.

We can then use the newly defined custom tags inside our YAML file:

some_key: !Scalar-example some_value
some_sequence: !Seq-example
  - some_seq_key_1: some_seq_value_1
  - some_seq_key_2: some_seq_value_2
some_mapping: !Mapping-example
  some_mapping_key_1: some_mapping_value_1
  some_mapping_key_2: some_mapping_value_2

Associating a schema to a glob pattern via yaml.schemas:

yaml.schemas applies a schema to a file. In other words, the schema (placed on the left) is applied to the glob pattern on the right. Your schema can be local or online. Your schema path must be relative to the project root and not an absolute path to the schema.

For example: If you have project structure

myProject

   > myYamlFile.yaml

you can do

yaml.schemas: {
    "https://json.schemastore.org/composer": "/myYamlFile.yaml"
}

and that will associate the composer schema with myYamlFile.yaml.

More examples of schema association:

Using yaml.schemas settings

Single root schema association:

When associating a schema it should follow the format below

yaml.schemas: {
    "url": "globPattern",
    "Kubernetes": "globPattern"
}

e.g.

yaml.schemas: {
    "https://json.schemastore.org/composer": "/*"
}

e.g.

yaml.schemas: {
    "kubernetes": "/myYamlFile.yaml"
}

e.g.

yaml.schemas: {
    "https://json.schemastore.org/composer": "/*",
    "kubernetes": "/myYamlFile.yaml"
}

On Windows with full path:

yaml.schemas: {
    "C:\\Users\\user\\Documents\\custom_schema.json": "someFilePattern.yaml",
}

On Mac/Linux with full path:

yaml.schemas: {
    "/home/user/custom_schema.json": "someFilePattern.yaml",
}

Since 0.11.0 YAML Schemas can be used for validation:

 "/home/user/custom_schema.yaml": "someFilePattern.yaml"

A schema can be associated with multiple globs using a json array, e.g.

yaml.schemas: {
    "kubernetes": ["filePattern1.yaml", "filePattern2.yaml"]
}

e.g.

"yaml.schemas": {
    "http://json.schemastore.org/composer": ["/*"],
    "file:///home/johnd/some-schema.json": ["some.yaml"],
    "../relative/path/schema.json": ["/config*.yaml"],
    "/Users/johnd/some-schema.json": ["some.yaml"],
}

e.g.

"yaml.schemas": {
    "kubernetes": ["/myYamlFile.yaml"]
}

e.g.

"yaml.schemas": {
    "http://json.schemastore.org/composer": ["/*"],
    "kubernetes": ["/myYamlFile.yaml"]
}

Multi root schema association:

You can also use relative paths when working with multi root workspaces.

Suppose you have a multi root workspace that is laid out like:

My_first_project:
   test.yaml
   my_schema.json
My_second_project:
   test2.yaml
   my_schema2.json

You must then associate schemas relative to the root of the multi root workspace project.

yaml.schemas: {
    "My_first_project/my_schema.json": "test.yaml",
    "My_second_project/my_schema2.json": "test2.yaml"
}

yaml.schemas allows you to specify json schemas that you want to validate against the yaml that you write. Kubernetes is an optional field. It does not require a url as the language server will provide that. You just need the keyword kubernetes and a glob pattern.

Nested Schema References

Suppose a file is meant to be a component of an existing schema (like a job.yaml file in a circleci orb), but there isn't a standalone schema that you can reference. If there is a nested schema definition for this subcomponent, you can reference it using a url fragment, e.g.:

yaml.schemas: {
    "https://json.schemastore.org/circleciconfig#/definitions/jobs/additionalProperties": "/src/jobs/*.yaml",
}

Note This will require reading your existing schema and understanding the schemastore structure a bit. (TODO: link to a documentation or blog post here?)

Using inlined schema

It is possible to specify a yaml schema using a modeline.

# yaml-language-server: $schema=<urlToTheSchema>

Also it is possible to use relative path in a modeline:

# yaml-language-server: $schema=../relative/path/to/schema

or absolute path:

# yaml-language-server: $schema=/absolute/path/to/schema

Schema priority

The following is the priority of schema association in highest to lowest priority:

1. Modeline
2. CustomSchemaProvider API
3. yaml.settings
4. Schema association notification
5. Schema Store

Containerized Language Server

An image is provided for users who would like to use the YAML language server without having to install dependencies locally.

The image is located at quay.io/redhat-developer/yaml-language-server

To run the image you can use:

docker run -it quay.io/redhat-developer/yaml-language-server:latest

Language Server Protocol version

yaml-language-server use [email protected] which implements LSP 3.16

Language Server Protocol extensions

SchemaSelectionRequests

SupportSchemaSelection Notification

The support schema selection notification is sent from a client to the server to inform server that client supports JSON Schema selection.

Notification:

• method: 'yaml/supportSchemaSelection'
• params: void

SchemaStoreInitialized Notification

The schema store initialized notification is sent from the server to a client to inform client that server has finished initializing/loading schemas from schema store, and client now can ask for schemas.

Notification:

• method: 'yaml/schema/store/initialized'
• params: void

GetAllSchemas Request

The get all schemas request sent from a client to server to get all known schemas.

Request:

• method: 'yaml/get/all/jsonSchemas';
• params: the document uri, server will mark used schema for document

Response:

• result: JSONSchemaDescriptionExt[]

interface JSONSchemaDescriptionExt {
  /**
   * Schema URI
   */
  uri: string;
  /**
   * Schema name, from schema store
   */
  name?: string;
  /**
   * Schema description, from schema store
   */
  description?: string;
  /**
   * Is schema used for current document
   */
  usedForCurrentFile: boolean;
  /**
   * Is schema from schema store
   */
  fromStore: boolean;
}

GetSchemas Request

The request sent from a client to server to get schemas used for current document. Client can use this method to indicate in UI which schemas used for current YAML document.

Request:

• method: 'yaml/get/jsonSchema';
• params: the document uri to get used schemas

Response:

• result: JSONSchemaDescription[]

interface JSONSchemaDescriptionExt {
  /**
   * Schema URI
   */
  uri: string;
  /**
   * Schema name, from schema store
   */
  name?: string;
  /**
   * Schema description, from schema store
   */
  description?: string;
}

Clients

This repository only contains the server implementation. Here are some known clients consuming this server:

• Eclipse Che
• vscode-yaml for VSCode
• coc-yaml for coc.nvim
• Eclipse Wild Web Developer for Eclipse IDE
• lsp-mode for Emacs
• vim-lsp for Vim
• LSP-yaml for Sublime Text
• monaco-yaml for Monaco editor
• Vim-EasyComplete for Vim/NeoVim
• nova-yaml for Nova
• volar-service-yaml for Volar

Developer Support

Getting started

1. Install prerequisites:
   • latest Visual Studio Code
   • Node.js v12.0.0 or higher
2. Fork and clone this repository
3. Install the dependencies

   cd yaml-language-server
   $ yarn install

4. Build the language server

   $ yarn run build

5. The new built server is now located in ./out/server/src/server.js.

   node (Yaml Language Server Location)/out/server/src/server.js [--stdio]

Connecting to the language server via stdio

We have included the option to connect to the language server via stdio to help with integrating the language server into different clients.

ESM and UMD Modules

Building the YAML Language Server produces CommonJS modules in the /out/server/src directory. In addition, a build also produces UMD (Universal Module Definition) modules and ES Modules (ESM) in the /lib directory. That gives you choices in using the YAML Language Server with different module loaders on the server side and in the browser with bundlers like webpack.

CI

We use a GitHub Action to publish each change in the main branch to npm registry with the next tag. You may use the next version to adopt the latest changes into your project.

yaml-language-server's Issues

Support for large schema files

I have a JSON schema generated for Ansible modules to simplify writing of Ansible roles:

"yaml.schemas": {
  "/opt/ansible-schemas/": "ansible.json"
}

(you can find the file here https://raw.githubusercontent.com/shaded-enmity/ansible-schema-generator/master/examples/ansible.json and some example Ansible role here https://raw.githubusercontent.com/shaded-enmity/prototype/master/ansible_roles/docker/tasks/main.yml)

The problem is that the completion doesn't really work properly and I'm seeing suggestions that are out of context - for example the state key under yum is not suggested at all.

NPM Publishing

Thanks for your awesome YAML language server implementation 💯
I would like to develop yaml-plugin for another editor.

Are you planning to publish the ./server/* on NPM?

duplicate "yaml.format.enable" entry

After installing the redhat.vscode-yaml, my global default settings file has duplicate entries foryaml.format.enable.

Detect common schemas

Is it possible to add some automatic detection of the schema type for a yaml file (for popular schemas)? This is to allow zero configuration in many cases. For example when looking at kubernetes resources the presence of apiVersion, spec and type is a really good indicator.

Remove console.log from jsonSchemaService

https://github.com/redhat-developer/yaml-language-server/blob/master/src/languageService/services/jsonSchemaService.ts#L505

Hovers escape markdown

I have this in a JSON schema:

"working_directory": {
  "description":
    "In which directory to run the steps. (default: `~/project`. `project` is a literal string, not the name of the project.) You can also refer the directory with `$CIRCLE_WORKING_DIRECTORY` environment variable.",
  "type": "string",
  "default": "~/project"
},

Intead of rendering this as markdown, this is what the hover looks like:

This is the hover result:

[Trace - 01:47:59] Received response 'textDocument/hover - (21)' in 3ms.
Result: {
    "contents": [
        "In which directory to run the steps\\. \\(default: \\`~/project\\`\\. \\`project\\` is a literal string, not the name of the project\\.\\) You can also refer the directory with \\`$CIRCLE\\_WORKING\\_DIRECTORY\\` environment variable\\."
    ],
    "range": {
        "start": {
            "line": 3,
            "character": 4
        },
        "end": {
            "line": 3,
            "character": 21
        }
    }
}

Apparently the language server escapes the markdown

Changelog for yaml-language-server

Currently vscode-yaml has all the changelog information pertaining to both vscode-yaml and yaml-language-server. We should maintain a changelog in this repo as well as vscode-yaml.

Autocompletion for root shows if you completion right after semi-colon with no space

E.g. If you do autocompletion right after the ":" it will show additionalSecrets, allowed, etc

apiVersion:

Occasionally get hover failed with getText of undefined from Eclipse Che

document how to use it with other editors

I'd like to use it with neovim's language-server client. How do I start it? For e.g. rust, I'll just have to provide the path to start it. How do I integrate yaml-language-server?

URI tests fail on Windows

I'm assuming the first one can be ignored but the other ones are presumably valid errors.

  1) Yaml Validation with kubernetes Test that validation does not throw errors Basic test:
     Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.


  2) URI Parse Basic:

      AssertionError: '\\bar.html' == '/bar.html'
      + expected - actual

      -\bar.html
      +/bar.html

      at Context.it (test\uri.test.ts:15:20)

  3) URI Create Basic:

      AssertionError: '\\bar.html' == '/bar.html'
      + expected - actual

      -\bar.html
      +/bar.html

      at Context.it (test\uri.test.ts:27:20)

  4) URI File Basic:

      AssertionError: '\\..\\uri.test.ts' == '/../uri.test.ts'
      + expected - actual

      -\..\uri.test.ts
      +/../uri.test.ts

      at Context.it (test\uri.test.ts:38:20)

  5) URI toJson toJson with system file:

      AssertionError: 'c:\\test.txt' == 'c:/test.txt'
      + expected - actual

      -c:\test.txt
      +c:/test.txt

      at Context.it (test\uri.test.ts:86:20)

Yaml parser diagnostic message showing wrong line on malformed yaml

Semi-related: #19

project-specific config

For example I have a project using !Sub (For AWS CloudFormation) but this is not something that all projects share.

From what I can tell, in vscode, the settings are global.

A solution might be to read from a config file local to the project e.g. .ide-yaml.config (or whatever better standard).

Format does not preserve comments

#comment
apiVersion: v1

The above is changed to the following after format.

apiVersion: v1

yaml-language-server: v0.0.12

Incorrect yaml.customTags description in README.md

README.md states (also vscode-yaml's README.md):

The following settings are supported:

• yaml.customTags: Array of custom tags that the parser will validate against. It has two ways to be used. Either an item in the array is a custom tag such as "!Ref" or you can specify the type of the object !Ref should be by doing "!Ref Scalar". For example: ["!Ref", "!Some-Tag Scalar"]. The type of object can be one of Scalar, Sequence, Mapping, Map.

However if I add the following to .vscode\settings.json:

{
  "yaml.customTags": [
      "!Ref Scalar"
      ]
}

The Yaml Support server crashes:

c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\node_modules\js-yaml\lib\js-yaml\type.js:57
    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
    ^
YAMLException: Unknown kind "Scalar" is specified for "!Ref" YAML type.
    at new Type (c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\node_modules\js-yaml\lib\js-yaml\type.js:57:11)
    at js_yaml_1.Schema.create.customTags.map (c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\src\languageservice\parser\yamlParser.js:198:16)
    at Array.map (native)
    at Object.parse (c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\src\languageservice\parser\yamlParser.js:196:71)
    at validateTextDocument (c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\src\server.js:338:37)
    at Timeout.pendingValidationRequests.(anonymous function).setTimeout [as _onTimeout] (c:\Users\semidefinite\.vscode\extensions\redhat.vscode-yaml-0.0.13\node_modules\yaml-language-server\out\server\src\server.js:327:9)
    at ontimeout (timers.js:386:14)
    at tryOnTimeout (timers.js:250:5)
    at Timer.listOnTimeout (timers.js:214:5)
[Info  - 8:46:15 PM] Connection to server got closed. Server will restart.

Inspection of js-yaml\lib\js-yaml\type.js reveals the following definition:

var YAML_NODE_KINDS = [
  'scalar',
  'sequence',
  'mapping'
];

If I replace "!Ref Scalar" with "!Ref scalar" all is well.

Server returning nothing on things such as completion errors Eclipse Che

kind: PersistentVolume
apiVersion: v1
metadata: <- Autocompletion right after :

returns

[Trace - 16:51:10] Received response 'textDocument/completion - (48)' in 1ms.
No result returned.

but should return

Result: {
    "items": [],
    "isIncomplete": false
}

Part of: eclipse-che/che#9725

when will you release a new version npm package

since this PR is merged.

Provide full autocompletion when there are multiple requires and only one is fullfilled

E.g. In a case when you have multiple require statements that have the same elements in the same context

required: [
"name",
"age"
]
....
required: [
"name"
]

and a schema so far consists of

name: Josh

Auto completion should autocomplete from both of the fields but currently just autocomplete from the second one because the second one is technically valid as well

Add validation/autocompletion for multiple schemas in one glob location

Currently it only works when one schema is listed. We need to add support for multiple schemas to be listed.

Operations don't work without textDocument/didOpen

According to microsoft/language-server-protocol#177 operations should work even if textDocument/didOpen was not called for a language server. Opening a document or closing it only shifts where the content is managed (in memory or on disk) but shouldn't prevent an operation.

Path fix of npm run watch

it seems that watch section of package.json script has path issues

yaml-language-server/package.json

Line 43 in 655b869

"watch": "installServerIntoExtension ../out ./package.json ./tsconfig.json && tsc --watch -p .",

../out is not existed in the repo currently

related commit is 668c1204

Use custom tags in autocompletion

With the addition of custom tags in 0.0.12 we can use them for autocompletion

New Kubernetes Schema + Updated support for Kubernetes

As far as I can see anyOfMatching is not needed anymore and we can just redirect it to using the normal anyOf function again.

completionHelper will break yaml file if it contains \r charactor

Here is the code to repro the test

let content = "test\r\nfoo:bar\r\n";
let position = 3;
let testTextDocument = TextDocument.create("file://~/Desktop/vscode-k8s/test.yaml", "yaml", 0, content);
let res = completionHelper(testTextDocument, testTextDocument.positionAt(position), false);
console.log(JSON.stringify(res.newText));

The test has output of "test\r:\r\no:bar\r\n" (foo has been cut off first two charactors 'fo'

Is it possible to support Helm.sh templating in option please?

Hi !
Helm is now the official package manager of Kubernetes. K8s configuration is a lot based under yaml files, and Helm have a templating system to help to replace values in the yaml configuration, but also to control the flow ( {{ if ... }} {{ end }} ).
Of course, it's not YAML compatible ( at least fo the flow control https://docs.helm.sh/chart_template_guide/#flow-control ).
May be it's possible to bypass the errors/warning, based on the extension (eg: file.helm) ?
Regards,

clientSnippetSupport field in server.ts is unused

It's not clear to me what this field is for. It gets initialized by reading the client's textDocument.completion.completionItem.snippetSupport capability but is then never read or used.

yaml-language-server/src/server.ts

Lines 63 to 91 in d332a84

	let clientSnippetSupport = false;
	let clientDynamicRegisterSupport = false;
	// After the server has started the client sends an initilize request. The server receives
	// in the passed params the rootPath of the workspace plus the client capabilities.
	let workspaceRoot: URI;
	connection.onInitialize((params: InitializeParams): InitializeResult => {
	workspaceRoot = URI.parse(params.rootPath);
	function hasClientCapability(...keys: string[]) {
	let c = params.capabilities;
	for (let i = 0; c && i < keys.length; i++) {
	c = c[keys[i]];
	}
	return !!c;
	}
	clientSnippetSupport = hasClientCapability('textDocument', 'completion', 'completionItem', 'snippetSupport');
	clientDynamicRegisterSupport = hasClientCapability('workspace', 'symbol', 'dynamicRegistration');
	return {
	capabilities: {
	textDocumentSync: documents.syncKind,
	completionProvider: { resolveProvider: true },
	hoverProvider: true,
	documentSymbolProvider: true,
	documentFormattingProvider: false
	}
	};
	});

Kubernetes apiVersion of extensions is not supoported

It seems that the following YAML file for a cert-manager configuration is not supported (getting Value is not accepted. Valid values: "v1"):

apiVersion: certmanager.k8s.io/v1alpha1
kind: Certificate
...

It also seems to be the case with other extension versions, e.g. certificates./v1beta1 and extensions/v1beta1.

Autocompletion fails on value item mid typing only on first line (Only kubernetes schema)

When you're typing something like

kind: Ima

with kubernetes schema it fails to autocomplete only on the first line

best way to pass schema in nvim via LanguageClientNeovim

Just wondering what would be the best way to define new schemas using neovim and LanguageClient

Diagnostics shouldn't span the entire document

With large files ~10k lines, Monaco/VSCode performance degrades when a diagnostic spans a large number of those lines.

Syntax errors can cause the YAML Language Server to report a diagnostic from the location of the error all the way to EOF. Is it possible to force these errors to be restricted to a single line? Or even character when they cause unrecoverable parser errors?

Multiple YAML documents in single file features work for first section but not the rest

Currently hover, document outlining, validation, and auto completion when using multiple Yaml Documents does not work as expected. These features only operate on the first yaml document in the file but should operate on all yaml documents in the file.

• Hover
• Document outlining
• Validation
• Autocompletion

We should allow users to enter their glob pattern as an array

We should allow users to enter their glob pattern as an array

The validator should support null values

Current yaml validator will report an error for null value when the schema type is string.

Actually, null is a valid string type. Similarly, array/object type should support null, too.

Use textDocument.formatting.dynamicRegistration?

yaml-language-server currently uses workspace.symbol.dynamicRegistration to determine whether it registers textDocument/formatting capability.

According to the language-server-protocol spec, textDocument.formatting.dynamicRegistration looks appropriate for the purpose.

/**
 * Text document specific client capabilities.
 */
export interface TextDocumentClientCapabilities {
...
	/**
	 * Capabilities specific to the `textDocument/formatting`
	 */
	formatting?: {
		/**
		 * Whether formatting supports dynamic registration.
		 */
		dynamicRegistration?: boolean;
	};

Support for custom yaml tags (e.g. "!include")

Hi!

There is an issue in YAML plugin for VS Code redhat-developer/vscode-yaml#76
In short: custom YAML tags such as !include, !vault (and many others) that are used in Ansible, CloudFomation, JenkinsJobBuilder and many other utilities are not supported. But these tags are Language feature (see more details in attached link)

As far as I understand, the problem is somewhere in lang. server. because it's used as backend for mentioned plugin.

Could you please investigate possibilities to implement this in language server, so folks from vscode-yaml will be able to support this in plugin?

Expose Atom edit

I see config options exposed in vscode but not atom

vscode:

atom:

?

Local schema changes are not reflected in real-time

First thank you for creating this extension / language server!

I've noticed one problem in my particular usecase.
There I'm using JSON Schema definitions which are available locally. In case of VSCodes default JSON implementation, when the local Schema updates, the affected JSON files get re-evaluated and immediately reflect the updated Schema.

The yaml-language-server seems to cache those local schemas. I need to restart the VSCode (i guess the language-server really) to get the Schemas reloaded.

Best,
Simon

Support multiple ressources with different schemas in kubernetes files

With kubernetes, it is possible to have multiple resources in one file, separated by ---.

Currently, if the resources have different apiVersion, we get the following errors for each apiVersion:

Matches multiple schemas when only one must validate.

I think the language server should be able to handle this situation.

Functionality without specifying yaml.schemas

I was wondering how good the support is when not specifying yaml.schemas?
Does it automatically query schemas from http://schemastore.org/json/?
Does it support $schema?

Schema doesn't seem to remove itself from glob after you delete [Multi-Root Branch]

Configuration to enable/disable schema store

@JPinkney @gorkem

If you happen to be working in a workspace that has a folder/file path that matches one of the schema store json files, it supersedes what is set by the user. I am guessing this is because it comes later in the array.

Can we add a configuration option to not call:

setSchemaStoreSettingsIfNotSet()

I would prefer to not make the HTTP request in the first place.

Yaml parser as separate NPM module

👋

I really like how you've wrapped yaml-ast-parser and would be keen to use your version of parser, which calculates line and column numbers in the AST. It'd be great if you published it as a separate npm module and provided TS typings so that people could use it in their projects.

In particular, I'm interested in using your parser in markdown frontmatter to be able to point to a particular semantic issue if it occurs (e.g. when a document references another document that does not exist). Perhaps, guys from Prettier could be also take it on board later to prettify YAMLS?

Show errors if schema cannot be grabbed

Doesn't like AWS CloudFormation templates

I understand the CloudFormation format is a bit non-standard, but it would at least be nice to have an option in this extension to disable syntax-checking. I mostly want it since it adds the YAML structure to the Code Outline extension.

Remove snippits

The snippits no longer fit with the theme of the LS. Remove them

Cannot read property getNodeFromOffset of null

I am getting this error in the console a lot:

[Error - 11:20:19] Request textDocument/hover failed.
  Message: Request textDocument/hover failed with message: Cannot read property 'getNodeFromOffset' of null
  Code: -32603 

Error with formatter in logs

[Info  - 13:47:47] Registering request handler for textDocument/formatting failed.
[Error - 13:47:47] (node:18851) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): Error: Unhandled method client/registerCapability
[Error - 13:47:47] (node:18851) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

Some source files are missing license headers

The following files are missing license headers:

• src/languageservice/yamlLanguageService.ts
• src/languageservice/parser/yamlParser.ts
• src/languageservice/utils/arrUtils.ts
• src/languageservice/utils/documentPositionCalculator.ts

[Regression] Cloudformation Support

Originally closed issue in #20 but it looks like Cloudformation support is no longer present.

This is with the following tags:

...
    "yaml.customTags": [
        "!Ref",
        "!GetAtt",
        "!FindInMap sequence",
        "!FindInMap scalar",
        "!GetAtt",
        "!GetAZs",
        "!Cidr",
        "!ImportValue",
        "!Join sequence",
        "!Select",
        "!Split",
        "!Sub sequence",
        "!Sub scalar",
        "!And",
        "!Equals",
        "!If",
        "!Not",
        "!Or"
    ]

Change "Property {$property_name} is not allowed" error message

Changed to "Unexpected property ${property_name}"