Home

Index

How to use the parse function from yaml

Find comprehensive JavaScript yaml.parse code examples handpicked from public code repositorys.

yaml.parse is a function in the YAML library that converts a YAML-formatted string into a JavaScript object.

prerender.js

51
52
53
54
55
56
57
58
59
60
	path.resolve(__dirname, `../content/en/${url == '/' ? 'index' : url}.md`),
	{ encoding: 'utf8' }
);
const name = (route.name && route.name.en) || route.name;
const fm = (content.match(FRONT_MATTER_REG) || [])[1];
const meta = (fm && yaml.parse(`---\n${fm.replace(/^/gm, '  ')}\n`)) || {};
const contentBody = content.replace(FRONT_MATTER_REG, '');
let suffix = '';
for (let pattern in groups) {
	if (url.match(pattern)) {

475

331

+ 6 other calls in file

generate-images.js

GitHub: eBay/skin

8
9
10
11
12
13
14
15
16
17
const prettier = require('prettier');
const { JSDOM } = jsdom;
const configFilePath = path.resolve(currentDir, 'docs', '_data', 'icons.yaml');
const file = fs.readFileSync(configFilePath, 'utf8');
const YAML = require('yaml');
const config = YAML.parse(file);
const { html2xhtml } = require('./util');
const { query } = require('winston');
const genText = 'This is a generated file, DO NOT EDIT';

161

How does yaml.parse work?

yaml.parse works by taking a YAML-formatted string as input and parsing it into a JavaScript object.

The function uses a YAML parser to interpret the string and convert it into a data structure that can be manipulated in JavaScript.

The resulting object may contain nested objects, arrays, and scalar values such as strings, numbers, and booleans, depending on the contents of the YAML input.

If the YAML input is invalid or cannot be parsed for any reason, an error is thrown.

yaml.parse is useful when working with configuration files, data interchange formats, and other text-based data that is often stored or transmitted in a YAML format.

helper.js

GitHub: project-chip/zap

940
941
942
943
944
945
946
947
948
949
if (weakEnumList === undefined) {
  let f = this.global.resource('weak-enum-list');
  // NOTE: This has to be sync, so we can use this data in if conditions.
  if (f) {
    let rawData = fs.readFileSync(f, { encoding: 'utf8', flag: 'r' });
    weakEnumList = YAML.parse(rawData);
  } else {
    weakEnumList = [
      'AttributeWritePermission',
      'BarrierControlBarrierPosition',

+ 2 other calls in file

utils.js

GitHub: datagir/nosgestesclimat

14
15
16
17
18
19
20
21
22
23
24
25
26


const availableLanguages = ['fr', 'en-us'] //, 'es', 'it'] For now, we don't want es and it to be compile (it could create compilation errors).
const defaultLang = availableLanguages[0]


const readYAML = (path) => {
	return yaml.parse(fs.readFileSync(path, 'utf-8'))
}


const writeYAML = (path, content, blockQuote = 'literal', sortMapEntries) => {
	resolveConfig(process.cwd()).then((prettierConfig) =>

122

+ 3 other calls in file

Ai Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const yaml = require("js-yaml");

const yamlString = `
- name: John
age: 32
interests:
- programming
- hiking
- name: Sarah
age: 28
interests:
- photography
- yoga
`;

const data = yaml.safeLoad(yamlString);

console.log(data);

In this example, we use yaml.parse to convert a YAML-formatted string into a JavaScript object. We define a YAML-formatted string that contains an array of objects, each representing a person with a name, age, and list of interests. We then call yaml.safeLoad with the YAML string to parse it into a JavaScript object, which we store in the data variable. We log the contents of data to the console, which will display an array of JavaScript objects representing the people and their attributes. By using yaml.parse in this way, we can easily convert YAML-formatted data into a format that can be manipulated in JavaScript.

metaTransaction_swapNativeTokenForBOBA.js

GitHub: bobanetwork/boba

20
21
22
23
24
25
26
27
28
29
const loadContracts = () => {
  // Load env
  let env = process.env
  if (fs.existsSync('./env.yml')) {
    const file = fs.readFileSync('./env.yml', 'utf8')
    env = YAML.parse(file)
  }
  const L2_NODE_WEB3_URL = env.L2_NODE_WEB3_URL || process.env.L2_NODE_WEB3_URL
  const PRIVATE_KEY = env.PRIVATE_KEY || process.env.PRIVATE_KEY
  const BOBA_GASPRICEORACLE_ADDRESS =

project.js

GitHub: wordup-dev/wordup-cli

376
377
378
379
380
381
382
383
384
385

const projectTitle = this.wPkg('slugName')

const file = fs.readFileSync( this.wordupDockerPath('docker-compose.dev.yml') , 'utf8')

let dockerComposeSettings = YAML.parse(file)

// Check if WP docker container should be build on system
if(build){
  let buildArgs = {}

119

build.js

GitHub: Awes0meHub/caprover-one-click-apps

135
136
137
138
139
140
141
142
143
144

const pathOfAppFileInSource = path.join(
    pathOfSourceDirectoryApps,
    appFileName
)
const contentParsed = yaml.parse(
    fs.readFileSync(pathOfAppFileInSource, 'utf-8')
)

//v4

+ 3 other calls in file

graphql-ld-parser.js

GitHub: KNowledgeOnWebScale/walder

7
8
9
10
11
12
13
14
15
16
17
18
19


describe('GraphQLLDParser', function () {


  before(function () {
    const file = fs.readFileSync(path.resolve(__dirname, CONFIG_FILE), 'utf8');
    this.yamlData = YAML.parse(file);
    const options = {defaultDataSources: this.yamlData['x-walder-datasources'], cache: true};


    this.output = parseGraphQLLD(this.yamlData.paths['/movies/{actor}']['get']['x-walder-query'], options);
    this.sortingOptionsOutput = parseGraphQLLD(this.yamlData.paths['/music/{musician}/sorted']['get']['x-walder-query'], options);

+ 5 other calls in file

graphQLLDValidator.js

GitHub: KNowledgeOnWebScale/walder

13
14
15
16
17
18
19
20
21
22
23
24


describe('GraphQLLDValidator', function () {
  {
    before(function () {
      const file = fs.readFileSync(Path.resolve(__dirname, CONFIG_FILE), 'utf8');
      const yamlData = YAML.parse(file);


      const path = '/movies/{actor}';
      const method = 'get';

+ 5 other calls in file

index.js

GitHub: buxlabs/boxwood

453
454
455
456
457
458
459
460
461
462
463
const yaml = {
  load() {
    const path = join(...arguments)
    const file = path.endsWith(".yaml") ? path : join(path, "index.yaml")
    const content = readFileSync(path, "utf8")
    return YAML.parse(content)
  },
}


const json = {

+ 20 other calls in file

docusaurus.config.js

GitHub: Bandwidth/api-docs

160
161
162
163
164
165
166
167
168
169
      },
    },
  ],
],
customFields: {
  numbersSpec: YAML.parse(numbersSpec),
  numbersSpecLink: `${customConfig.numbersSpecLink}`,
  phoneNumberLookupSpec: YAML.parse(phoneNumberLookupSpec),
  phoneNumberLookupSpecLink: `${customConfig.phoneNumberLookupSpecLink}`,
  voiceSpec: YAML.parse(voiceSpec),

+ 35 other calls in file

loader.js

GitHub: tomcollins/json-schema-static-docs

16
17
18
19
20
21
22
23
24
25
fileContent = fileContent.toString();
const extension = file.split(".").pop();

try {
  if (extension === "yml" || extension == "yaml") {
    dataObject = YAML.parse(fileContent);
  } else {
    dataObject = JSON.parse(fileContent);
  }
} catch (e) {

+ 4 other calls in file

index.js

GitHub: acvigue/SmartMatrixServer

316
317
318
319
320
321
322
323
324
325
    } else {
        configValues.push(`${k}=${v}`);
    }
}
let outputError = "";
let manifest = YAML.parse(fs.readFileSync(`${APPLET_FOLDER}/${name}/manifest.yaml`, 'utf-8'));
let appletContents = fs.readFileSync(`${APPLET_FOLDER}/${name}/${manifest.fileName}`).toString();
if(process.env.REDIS_HOSTNAME != undefined) {
    if(appletContents.indexOf(`load("cache.star", "cache")`) != -1) {
        const redis_connect_string = `cache_redis.connect("${ process.env.REDIS_HOSTNAME }", "${ process.env.REDIS_USERNAME }", "${ process.env.REDIS_PASSWORD }")`

index.js

GitHub: silverfin/sf-toolkit

576
577
578
579
580
581
582
583
584
585
586
    errorHandler(error);
  }
}


function findTestRows(testContent) {
  const testYAML = yaml.parse(testContent, (options = { maxAliasCount: -1 }));
  const testNames = Object.keys(testYAML);
  const testRows = testContent.split("\n");
  const indexes = {};
  testNames.forEach((testName) => {

stack.js

GitHub: 131/docker-dspp

307
308
309
310
311
312
313
314
315

  return {cas, current, ...{compiled, stack_revision, stack_path}, services_slices};
}


async parse() {
  let {compiled} = await this._compute();
  return compiled;
}

+ 8 other calls in file

config.js

GitHub: lando/core-next

19
20
21
22
23
24
25
26
27
28
29
const {basename, dirname, extname} = require('path');


// custom yml/yaml formatter
['yaml', 'yml'].forEach(format => {
  nconf.formats[format] = {
    parse: (obj, options) => yaml.parse(obj, options),
    stringify: (obj, options) => yaml.stringify(obj, options),
  };
});

+ 15 other calls in file

plugin.js

GitHub: lando/core-next

209
210
211
212
213
214
215
216
217
  // return the plugin.js return first
  if (fs.existsSync(path.join(this.root, 'plugin.js'))) return require(path.join(this.root, 'plugin.js'))(config);
  // otherwise return the plugin.yaml content
  if (fs.existsSync(path.join(this.root, 'plugin.yaml'))) return yaml.parse(fs.readFileSync(path.join(this.root, 'plugin.yaml'), 'utf8'));
  // otherwise return the plugin.yml content
  if (fs.existsSync(path.join(this.root, 'plugin.yml'))) return yaml.parse(fs.readFileSync(path.join(this.root, 'plugin.yml'), 'utf8'));
  // otherwise return uh, nothing?
  return {};
}

+ 31 other calls in file

ValueEditor.js

GitHub: Flagsmith/flagsmith

53
54
55
56
57
58
59
60
61
62
    }
    break;
}
case 'yaml': {
    try {
        yaml.parse(value);
        resolve(false);
    } catch (e) {
        resolve(e.message);
    }

162

+ 2 other calls in file

platform.js

GitHub: suculent/thinx-device-api

54
55
56
57
58
59
60
61
62
63
	console.log("No YAML " + yml_path + ")");
	return null;
}

const y_file = fs.readFileSync(yml_path, 'utf8');
const yml = YAML.parse(y_file);
var platform = null;

if (typeof (yml) !== "undefined") {
	platform = Object.keys(yml)[0];

+ 4 other calls in file

generate_types.js

GitHub: talaub/LowZero

769
770
771
772
773
774
775
776
777
778
779
780
781
782
}


function process_file(p_FileName) {
    const l_FileContent = read_file(`${g_Directory}\\${p_FileName}`);


    const l_Config = YAML.parse(l_FileContent);


    const l_Types = [];


    for (let [i_TypeName, i_Type] of Object.entries(l_Config.types)) {

Other functions in yaml

Sorted by popularity

yaml.parse is the most popular function in yaml (1035 examples)

Other popular packages:

Home

About