How to use yaml - 10 common examples

vscode.window.showWarningMessage('You must have an open editor window to resolve an OpenAPI document');
        return; // No open text editor
    }
    if (editor.document.isUntitled) {
        vscode.window.showWarningMessage('Document must be saved in order to resolve correctly');
        return; // No open text editor
    }
    let text = editor.document.getText();
    let yamlMode = false;
    let obj = {};
    try {
        obj = JSON.parse(text);
    }
    catch (ex) {
        try {
            obj = yaml.parse(text);
            yamlMode = true;
        }
        catch (ex) {
            vscode.window.showErrorMessage('Could not parse OpenAPI document as JSON or YAML');
            console.warn(ex.message);
            return;
        }
    }
    resolver.resolve(obj, editor.document.fileName, {})
    .then(function(options){
        if (yamlMode) {
            vscode.workspace.openTextDocument({ language: 'yaml', content: yaml.stringify(options.openapi) })
            .then(function(doc) {
                vscode.window.showTextDocument(doc);
            })
            .then(function(ex) {

const description = pathOr('', [...path, 'description'], schema);
  if (description) {
    comments.push(' ' + description.split('\n').join('\n '), '');
  }

  const defaultValue = pathOr('', [...path, 'default'], schema);
  if (defaultValue || defaultValue === false) {
    comments.push(' Default value: ' + defaultValue, '');
  }

  const examples = pathOr('', [...path, 'examples'], schema);
  if (examples) {
    comments.push(
      ' Examples:',
      ...YAML.stringify(examples)
        .split('\n')
        .map(i => ` ${i}`)
    ); // split always returns one empty object so no need for newline
  }

  let hasChildren;
  if (item.value.items) {
    item.value.items.forEach(item => {
      if (item.key) {
        enhance(schema, [...parents, key])(item);
        hasChildren = true;
      }
    });
  }

  if (!hasChildren) {

func => func && func.key && func.key.value === name
    );
    const attributes = new Map();
    if (functionNode) {
      console.log(`Function "${name}" already found on the configuration file. \
function add command will OVERRIDE the current function`);
      functionNode.value = attributes;
    } else {
      logger.log(`Adding function ${name} into configuration file ${this._path}`);
      functionNode = new Pair(new Scalar(name), attributes);
      functions.value.items.push(functionNode);
    }
    if (antFunction instanceof BinFunction) {
      attributes.items.push(new Pair(new Scalar('bin'), new Scalar(bin)));
    } else {
      attributes.items.push(new Pair(new Scalar('handler'), new Scalar(handler)));
      attributes.items.push(new Pair(new Scalar('runtime'), new Scalar(
        specifyRuntimeVersion ? `${runtime.name} ${runtime.version}` : runtime.name
      )));
    }
    console.log(`Function "${name}" successfully added on configuration file ${this._path}`);
    // Document has changed, resets the cached JSON
    this._cachedJson = null;
    return this;
  }

}
    let configCategory = templates.value.items.find(item => item.key.value === category);
    if (!configCategory) {
      configCategory = new Pair(new Scalar(category), new Map());
      templates.value.items.push(configCategory);
    }
    let configTemplate = configCategory.value.items.find(item => item.key.value === template);
    logger.log(`Adding template "${template}" with category "${category}" and path \
"${templatePath}" into configuration file ${this._path}`);
    if (!configTemplate) {
      configTemplate = new Pair(new Scalar(template), new Scalar(templatePath));
      configCategory.value.items.push(configTemplate);
    } else {
      console.log(`Template "${template}" already found on current config. \
template add command will OVERRIDE the current template`);
      configTemplate.value = new Scalar(templatePath);
    }
    console.log(`Template "${template}" successfully added on configuration file ${this._path}`);

    // Document has changed, resets the cached JSON
    this._cachedJson = null;
    return this;
  }

}
    let functionNode = functions.value && functions.value.items && functions.value.items.find(
      func => func && func.key && func.key.value === name
    );
    const attributes = new Map();
    if (functionNode) {
      console.log(`Function "${name}" already found on the configuration file. \
function add command will OVERRIDE the current function`);
      functionNode.value = attributes;
    } else {
      logger.log(`Adding function ${name} into configuration file ${this._path}`);
      functionNode = new Pair(new Scalar(name), attributes);
      functions.value.items.push(functionNode);
    }
    if (antFunction instanceof BinFunction) {
      attributes.items.push(new Pair(new Scalar('bin'), new Scalar(bin)));
    } else {
      attributes.items.push(new Pair(new Scalar('handler'), new Scalar(handler)));
      attributes.items.push(new Pair(new Scalar('runtime'), new Scalar(
        specifyRuntimeVersion ? `${runtime.name} ${runtime.version}` : runtime.name
      )));
    }
    console.log(`Function "${name}" successfully added on configuration file ${this._path}`);
    // Document has changed, resets the cached JSON
    this._cachedJson = null;
    return this;
  }

test('should create attributes Map', () => {
    const config = new Config({});
    const map = config._createAttributeMap({
      foo: 'a',
      bar: 'b',
      abc: 1,
      err: undefined // should be ignored
    });
    expect(map).toBeInstanceOf(Map);
    expect(map.items.length).toBe(3);
    expect(map.items[0].key).toBeInstanceOf(Scalar);
    expect(map.items[0].key.value).toBe('foo');
    expect(map.items[0].value).toBeInstanceOf(Scalar);
    expect(map.items[0].value.value).toBe('a');

    expect(map.items[1].key).toBeInstanceOf(Scalar);
    expect(map.items[1].key.value).toBe('bar');
    expect(map.items[1].value).toBeInstanceOf(Scalar);
    expect(map.items[1].value.value).toBe('b');

    expect(map.items[2].key).toBeInstanceOf(Scalar);
    expect(map.items[2].key.value).toBe('abc');
    expect(map.items[2].value).toBeInstanceOf(Scalar);
    expect(map.items[2].value.value).toBe(1);
  });

addPlugin(plugin) {
    assert(plugin, 'Could not add plugin: param "plugin" is required');
    assert(
      typeof plugin === 'string',
      'Could not add plugin: param "plugin" should be String'
    );

    let plugins = this._config.contents.items.find(
      item => item.key.value === 'plugins'
    );
    if (!plugins) {
      plugins = new Pair(new Scalar('plugins'), new Seq());
      this._config.contents.items.push(plugins);
    }
    if (plugins.value && plugins.value.items && plugins.value.items.find(
      item => item.value === plugin
    )) {
      console.log(`Plugin "${plugin}" already found on current config. \
plugin add command should do nothing`);
      return this;
    }
    logger.log(`Adding plugin ${plugin} into configuration file ${this._path}`);
    plugins.value.items.push(new Scalar(plugin));
    console.log(`Plugin "${plugin}" successfully added on configuration file ${this._path}`);

    // Document has changed, resets the cached JSON
    this._cachedJson = null;
    return this;

generateTagpack () {
    return YAML.stringify({
      title: 'Tagpack exported from GraphSense ' + VERSION, // eslint-disable-line no-undef
      creator: this.rest.username,
      lastmod: moment().format('YYYY-MM-DD'),
      tags: this.store.getNotes()
    })
  }
  generateTagsJSON () {

if (schema.definitions) {
      Object.keys(schema.definitions).forEach((key) => {
        removeAdditionalProperties(schema.definitions[key])
        enableAll(schema.definitions[key])
      })
    }

    jsf.option({
      useExamplesValue: true,
      useDefaultValue: false, // do not change this!!
      fixedProbabilities: true,
      alwaysFakeOptionals: true
    })

    const values = jsf.generate(schema)
    const doc = YAML.parseDocument(YAML.stringify(values))

    const comments = [`# ${pathOr(config.projectSlug, ['title'], schema)}`, '']

    const description = pathOr('', ['description'], schema)
    if (description) {
      comments.push(' ' + description)
    }

    doc.commentBefore = comments.join('\n')
    doc.spaceAfter = false
    doc.spaceBefore = false

    doc.contents.items.forEach(enhance(schema, []))

    return Promise.resolve({
      // schema,

directives = new Map();
      graphQLNode.items.push(new Pair(new Scalar('directives'), directives));
    } else {
      // Since "directives" is a Pair node, we need to access its value
      // to reach the Map of directives
      directives = directives.value;
    }

    // Given the directives map, we need to find the entry whose key is the name
    // of the target directive; either to update it with the new configurations or
    // to know if a brand new entry needs to be created.
    const directive = directives.items.find(
      item => item.key.value === name
    );
    const resolverAttributes = new Map();
    resolverAttributes.items.push(new Pair(new Scalar('handler'), new Scalar(handler)));
    resolverAttributes.items.push(new Pair(new Scalar('runtime'), new Scalar(runtime || this.ant.runtimeController.defaultRuntime.name)));

    const directiveAttributes = new Map();
    directiveAttributes.items.push(new Pair(new Scalar('resolver'), resolverAttributes));
    directiveAttributes.items.push(new Pair(new Scalar('definition'), new Scalar(definition)));
    if (!directive) {
      directives.items.push(new Pair(new Scalar(name), directiveAttributes));
    } else {
      directive.value = directiveAttributes;
    }
    return config.save();
  }