gray-matter

Parse front-matter from a string or file. Fast, reliable and easy to use. Parses YAML front matter by default, but also has support for YAML, JSON, TOML or Coffee Front-Matter, with options to set custom delimiters. Used by metalsmith, assemble, verb and many other projects.

Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your :heart: and support.

NOTE: in this release we have switched over to ES Modules in the core code but both ESM and CJS are exported for users of this library.

Install

Install with npm:

1npm install --save gray-matter

Heads up

Please see the changelog to learn about breaking changes that were made in v3.0.

What does this do?

1import fs from 'node:fs';
2import matter from 'gray-matter';
3const str = fs.readFileSync('example.html', 'utf8');
4console.log(matter(str));

Converts a string with front-matter, like this:

1---
2title: Hello
3slug: home
4---
5<h1>Hello world!</h1>

Into an object like this:

1{
2  content: '<h1>Hello world!</h1>',
3  data: { 
4    title: 'Hello', 
5    slug: 'home' 
6  }
7}

Why use gray-matter?

• simple: main function takes a string and returns an object
• accurate: better at catching and handling edge cases than front-matter parsers that rely on regex for parsing
• fast: faster than other front-matter parsers that use regex for parsing
• flexible: By default, gray-matter is capable of parsing YAML, JSON and JavaScript front-matter. But other engines may be added.
• extensible: Use custom delimiters, or add support for any language, like TOML, CoffeeScript, or CSON
• battle-tested: used by assemble, metalsmith, phenomic, verb, generate, update and many others.

Usage

Both JS and TS use the modern "import" signature that hopefully you are familiar with:

1import matter from 'gray-matter';

Pass a string and options to gray-matter:

1console.log(matter('---\ntitle: Front Matter\n---\nThis is content.'));

Returns:

1{
2  content: '\nThis is content.',
3  data: { 
4    title: 'Front Matter' 
5  } 
6}

More about the returned object in the following section.

Returned object

gray-matter returns a file object with the following properties.

Enumerable

• file.data {Object}: the object created by parsing front-matter
• file.content {String}: the input string, with matter stripped
• file.excerpt {String}: an excerpt, if defined on the options
• file.empty {String}: when the front-matter is "empty" (either all whitespace, nothing at all, or just comments and no data), the original string is set on this property. See #65 for details regarding use case.
• file.isEmpty {Boolean}: true if front-matter is empty.

Non-enumerable

In addition, the following non-enumberable properties are added to the object to help with debugging.

• file.orig {Buffer}: the original input string (or buffer)
• file.language {String}: the front-matter language that was parsed. yaml is the default
• file.matter {String}: the raw, un-parsed front-matter string
• file.stringify {Function}: stringify the file by converting file.data to a string in the given language, wrapping it in delimiters and prepending it to file.content.

Run the examples

If you'd like to test-drive the examples, first clone gray-matter into my-project (or wherever you want):

1git clone https://github.com/jonschlinkert/gray-matter my-project

CD into my-project and install dependencies:

1cd my-project && npm install

Then run any of the examples to see how gray-matter works:

1node examples/<example_name>

Links to examples

• coffee
• excerpt-separator
• excerpt-stringify
• excerpt
• javascript
• json-stringify
• json
• restore-empty
• sections-excerpt
• sections
• toml
• yaml-stringify
• yaml

API

matter

Takes a string or object with content property, extracts and parses front-matter from the string, then returns an object with data, content and other useful properties.

Params

• input {Object|String}: String, or object with content string
• options {Object}
• returns {Object}

Example

1import matter from 'gray-matter';
2console.log(matter('---\ntitle: Home\n---\nOther stuff'));
3//=> { data: { title: 'Home'}, content: 'Other stuff' }

.stringify

Stringify an object to YAML or the specified language, and append it to the given string. By default, only YAML and JSON can be stringified. See the engines section to learn how to stringify other languages.

Params

• file {String|Object}: The content string to append to stringified front-matter, or a file object with file.content string.
• data {Object}: Front matter to stringify.
• options {Object}: Options to pass to gray-matter and js-yaml.
• returns {String}: Returns a string created by wrapping stringified yaml with delimiters, and appending that to the given string.

Example

1console.log(matter.stringify('foo bar baz', {title: 'Home'}));
2// results in:
3// ---
4// title: Home
5// ---
6// foo bar baz

.read

Synchronously read a file from the file system and parse front matter. Returns the same object as the main function.

Params

• filepath {String}: file path of the file to read.
• options {Object}: Options to pass to gray-matter.
• returns {Object}: Returns an object with data and content

Example

1const file = matter.read('./content/blog-post.md');

.test

Returns true if the given string has front matter.

Params

• string {String}
• options {Object}
• returns {Boolean}: True if front matter exists.

Options

options.excerpt

Type: Boolean|Function

Default: undefined

Extract an excerpt that directly follows front-matter, or is the first thing in the string if no front-matter exists.

If set to excerpt: true, it will look for the frontmatter delimiter, --- by default and grab everything leading up to it.

Example

1const str = '---\nfoo: bar\n---\nThis is an excerpt.\n---\nThis is content';
2const file = matter(str, { excerpt: true });

Results in:

1{ 
2  content: 'This is an excerpt.\n---\nThis is content',
3  data: { foo: 'bar' },
4  excerpt: 'This is an excerpt.\n' 
5}

You can also set excerpt to a function. This function uses the 'file' and 'options' that were initially passed to gray-matter as parameters, so you can control how the excerpt is extracted from the content.

Example

1// returns the first 4 lines of the contents
2function firstFourLines(file, options) {
3  file.excerpt = file.content.split('\n').slice(0, 4).join(' ');
4}
5
6const file =  matter([
7  '---',
8  'foo: bar',
9  '---',
10  'Only this',
11  'will be',
12  'in the',
13  'excerpt',
14  'but not this...'
15].join('\n'), {excerpt: firstFourLines});

Results in:

1{ 
2  content: 'Only this\nwill be\nin the\nexcerpt\nbut not this...',
3  data: { foo: 'bar' },
4  excerpt: 'Only this will be in the excerpt'
5}

options.excerpt_separator

Type: String

Default: undefined

Define a custom separator to use for excerpts.

1console.log(matter(string, {excerpt_separator: '<!-- end -->'}));

Example

The following HTML string:

1---
2title: Blog
3---
4My awesome blog.
5<!-- end -->
6<h1>Hello world</h1>

Results in:

1{ 
2  data: { title: 'Blog'}, 
3  excerpt: 'My awesome blog.', 
4  content: 'My awesome blog.\n<!-- end -->\n<h1>Hello world</h1>' 
5}

options.engines

Define custom engines for parsing and/or stringifying front-matter.

Type: Object Object of engines

Default: JSON, YAML and JavaScript are already handled by default.

Engine format

Engines may either be an object with parse and (optionally) stringify methods, or a function that will be used for parsing only.

Examples

1const toml = require('toml');
2
3/**
4 * defined as a function
5 */
6
7const file = matter(str, {
8  engines: {
9    toml: toml.parse.bind(toml),
10  }
11});
12
13/**
14 * Or as an object
15 */
16
17const file = matter(str, {
18  engines: {
19    toml: {
20      parse: toml.parse.bind(toml),
21
22      // example of throwing an error to let users know stringifying is
23      // not supported (a TOML stringifier might exist, this is just an example)
24      stringify: function() {
25        throw new Error('cannot stringify to TOML');
26      }
27    }
28  }
29});
30
31console.log(file);

options.language

Type: String

Default: yaml

Define the engine to use for parsing front-matter.

1console.log(matter(string, {language: 'toml'}));

Example

The following HTML string:

1---
2title = "TOML"
3description = "Front matter"
4categories = "front matter toml"
5---
6This is content

Results in:

1{ content: 'This is content',
2  excerpt: '',
3  data:
4   { title: 'TOML',
5     description: 'Front matter',
6     categories: 'front matter toml' } }

Dynamic language detection

Instead of defining the language on the options, gray-matter will automatically detect the language defined after the first delimiter and select the correct engine to use for parsing.

1---toml
2title = "TOML"
3description = "Front matter"
4categories = "front matter toml"
5---
6This is content

options.delimiters

Type: String

Default: ---

Open and close delimiters can be passed in as an array of strings.

Example:

1// format delims as a string
2matter.read('file.md', {delims: '~~~'});
3// or an array (open/close)
4matter.read('file.md', {delims: ['~~~', '~~~']});

would parse:

1~~~
2title: Home
3~~~
4This is the {{title}} page.

Deprecated options

options.lang

Decrecated, please use options.language instead.

options.delims

Decrecated, please use options.delimiters instead.

options.parsers

Decrecated, please use options.engines instead.

About

1npm install && npm test

1npm install -g verbose/verb#dev verb-generate-readme && verb

Related projects

You might also be interested in these projects:

• assemble: Get the rocks out of your socks! Assemble makes you fast at creating web projects… more | homepage
• metalsmith: An extremely simple, pluggable static site generator. | homepage
• verb: Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used… more | homepage
• gray-matter-loader: A webpack loader for gray-matter. homepage

Contributors

Author

Jon Schlinkert

• LinkedIn Profile
• GitHub Profile
• Twitter Profile

License

Copyright © 2018, Jon Schlinkert. Released under the MIT License.

This file was generated by verb-generate-readme, v0.6.0, on April 01, 2018.