@pranaysahith/decap-cms-core 3.9.1

package/src/formats/__tests__/frontmatter.spec.js

@@ -0,0 +1,429 @@
+import {
+  FrontmatterInfer,
+  frontmatterJSON,
+  frontmatterTOML,
+  frontmatterYAML,
+} from '../frontmatter';
+
+describe('Frontmatter', () => {
+  describe('yaml', () => {
+    it('should parse YAML with --- delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile('---\ntitle: YAML\ndescription: Something longer\n---\nContent'),
+      ).toEqual({
+        title: 'YAML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse YAML with --- delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterYAML().fromFile('---\ntitle: YAML\ndescription: Something longer\n---\nContent'),
+      ).toEqual({
+        title: 'YAML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse YAML with custom delimiters when it is explicitly set as the format with a custom delimiter', () => {
+      expect(
+        frontmatterYAML('~~~').fromFile(
+          '~~~\ntitle: YAML\ndescription: Something longer\n~~~\nContent',
+        ),
+      ).toEqual({
+        title: 'YAML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse YAML with custom delimiters when it is explicitly set as the format with different custom delimiters', () => {
+      expect(
+        frontmatterYAML(['~~~', '^^^']).fromFile(
+          '~~~\ntitle: YAML\ndescription: Something longer\n^^^\nContent',
+        ),
+      ).toEqual({
+        title: 'YAML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse YAML with ---yaml delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '---yaml\ntitle: YAML\ndescription: Something longer\n---\nContent',
+        ),
+      ).toEqual({
+        title: 'YAML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should overwrite any body param in the front matter', () => {
+      expect(
+        FrontmatterInfer.fromFile('---\ntitle: The Title\nbody: Something longer\n---\nContent'),
+      ).toEqual({
+        title: 'The Title',
+        body: 'Content',
+      });
+    });
+
+    it('should stringify YAML with --- delimiters', () => {
+      expect(
+        FrontmatterInfer.toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'yaml'],
+          title: 'YAML',
+        }),
+      ).toEqual(
+        [
+          '---',
+          'tags:',
+          '  - front matter',
+          '  - yaml',
+          'title: YAML',
+          '---',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should stringify YAML with missing body', () => {
+      expect(FrontmatterInfer.toFile({ tags: ['front matter', 'yaml'], title: 'YAML' })).toEqual(
+        ['---', 'tags:', '  - front matter', '  - yaml', 'title: YAML', '---', ''].join('\n'),
+      );
+    });
+
+    it('should stringify YAML with --- delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterYAML().toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'yaml'],
+          title: 'YAML',
+        }),
+      ).toEqual(
+        [
+          '---',
+          'tags:',
+          '  - front matter',
+          '  - yaml',
+          'title: YAML',
+          '---',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should stringify YAML with --- delimiters when it is explicitly set as the format with a custom delimiter', () => {
+      expect(
+        frontmatterYAML('~~~').toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'yaml'],
+          title: 'YAML',
+        }),
+      ).toEqual(
+        [
+          '~~~',
+          'tags:',
+          '  - front matter',
+          '  - yaml',
+          'title: YAML',
+          '~~~',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should stringify YAML with --- delimiters when it is explicitly set as the format with different custom delimiters', () => {
+      expect(
+        frontmatterYAML(['~~~', '^^^']).toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'yaml'],
+          title: 'YAML',
+        }),
+      ).toEqual(
+        [
+          '~~~',
+          'tags:',
+          '  - front matter',
+          '  - yaml',
+          'title: YAML',
+          '^^^',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should trim last line break if added by grey-matter', () => {
+      expect(
+        frontmatterYAML().toFile({
+          body: 'noLineBreak',
+        }),
+      ).toEqual('noLineBreak');
+    });
+
+    it('should not trim last line break if not added by grey-matter', () => {
+      expect(
+        frontmatterYAML().toFile({
+          body: 'withLineBreak\n',
+        }),
+      ).toEqual('withLineBreak\n');
+    });
+
+    it('should keep field types', () => {
+      const frontmatter = frontmatterYAML();
+      const file = frontmatter.toFile({
+        number: 1,
+        string: 'Hello World!',
+        date: new Date('2020-01-01'),
+        array: ['1', new Date('2020-01-01')],
+        body: 'Content',
+      });
+      expect(frontmatter.fromFile(file)).toEqual({
+        number: 1,
+        string: 'Hello World!',
+        date: new Date('2020-01-01'),
+        array: ['1', new Date('2020-01-01')],
+        body: 'Content',
+      });
+    });
+  });
+
+  describe('toml', () => {
+    it('should parse TOML with +++ delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '+++\ntitle = "TOML"\ndescription = "Front matter"\n+++\nContent',
+        ),
+      ).toEqual({
+        title: 'TOML',
+        description: 'Front matter',
+        body: 'Content',
+      });
+    });
+
+    it('should parse TOML with 0.5 style dates', () => {
+      expect(
+        FrontmatterInfer.fromFile('+++\ntitle = "TOML"\ndate = 2018-12-24\n+++\nContent'),
+      ).toEqual({
+        title: 'TOML',
+        date: new Date('2018-12-24T00:00:00.000Z'),
+        body: 'Content',
+      });
+    });
+
+    it('should parse TOML with +++ delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterTOML('~~~').fromFile(
+          '~~~\ntitle = "TOML"\ndescription = "Front matter"\n~~~\nContent',
+        ),
+      ).toEqual({
+        title: 'TOML',
+        description: 'Front matter',
+        body: 'Content',
+      });
+    });
+
+    it('should parse TOML with ---toml delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '---toml\ntitle = "TOML"\ndescription = "Something longer"\n---\nContent',
+        ),
+      ).toEqual({
+        title: 'TOML',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should stringify TOML with +++ delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterTOML().toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'toml'],
+          title: 'TOML',
+        }),
+      ).toEqual(
+        [
+          '+++',
+          'tags = ["front matter", "toml"]',
+          'title = "TOML"',
+          '+++',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should stringify TOML with +++ delimiters when it is explicitly set as the format with a custom delimiter', () => {
+      expect(
+        frontmatterTOML('~~~').toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'toml'],
+          title: 'TOML',
+        }),
+      ).toEqual(
+        [
+          '~~~',
+          'tags = ["front matter", "toml"]',
+          'title = "TOML"',
+          '~~~',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should keep field types', () => {
+      const frontmatter = frontmatterTOML();
+      const file = frontmatter.toFile({
+        number: 1,
+        string: 'Hello World!',
+        date: new Date('2020-01-01'),
+        // in toml arrays must contain the same type
+        array: ['1', new Date('2020-01-01').toISOString()],
+        body: 'Content',
+      });
+      expect(frontmatter.fromFile(file)).toEqual({
+        number: 1,
+        string: 'Hello World!',
+        date: new Date('2020-01-01'),
+        array: ['1', new Date('2020-01-01').toISOString()],
+        body: 'Content',
+      });
+    });
+  });
+
+  describe('json', () => {
+    it('should parse JSON with { } delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '{\n"title": "The Title",\n"description": "Something longer"\n}\nContent',
+        ),
+      ).toEqual({
+        title: 'The Title',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse JSON with { } delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterJSON().fromFile(
+          '{\n"title": "The Title",\n"description": "Something longer"\n}\nContent',
+        ),
+      ).toEqual({
+        title: 'The Title',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse JSON with { } delimiters when it is explicitly set as the format with a custom delimiter', () => {
+      expect(
+        frontmatterJSON('~~~').fromFile(
+          '~~~\n"title": "The Title",\n"description": "Something longer"\n~~~\nContent',
+        ),
+      ).toEqual({
+        title: 'The Title',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse JSON with ---json delimiters', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '---json\n{\n"title": "The Title",\n"description": "Something longer"\n}\n---\nContent',
+        ),
+      ).toEqual({
+        title: 'The Title',
+        description: 'Something longer',
+        body: 'Content',
+      });
+    });
+
+    it('should parse JSON with { } delimiters ending with a nested object', () => {
+      expect(
+        FrontmatterInfer.fromFile(
+          '{\n  "title": "The Title",\n  "nested": {\n    "inside": "Inside prop"\n  }\n}\nContent',
+        ),
+      ).toEqual({
+        title: 'The Title',
+        nested: { inside: 'Inside prop' },
+        body: 'Content',
+      });
+    });
+
+    it('should stringify JSON with { } delimiters when it is explicitly set as the format without a custom delimiter', () => {
+      expect(
+        frontmatterJSON().toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'json'],
+          title: 'JSON',
+        }),
+      ).toEqual(
+        [
+          '{',
+          '"tags": [',
+          '    "front matter",',
+          '    "json"',
+          '  ],',
+          '  "title": "JSON"',
+          '}',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should stringify JSON with { } delimiters when it is explicitly set as the format with a custom delimiter', () => {
+      expect(
+        frontmatterJSON('~~~').toFile({
+          body: 'Some content\nOn another line',
+          tags: ['front matter', 'json'],
+          title: 'JSON',
+        }),
+      ).toEqual(
+        [
+          '~~~',
+          '"tags": [',
+          '    "front matter",',
+          '    "json"',
+          '  ],',
+          '  "title": "JSON"',
+          '~~~',
+          'Some content',
+          'On another line',
+        ].join('\n'),
+      );
+    });
+
+    it('should keep field types', () => {
+      const frontmatter = frontmatterJSON();
+      const file = frontmatter.toFile({
+        number: 1,
+        string: 'Hello World!',
+        // no way to represent date in JSON
+        date: new Date('2020-01-01').toISOString(),
+        array: ['1', new Date('2020-01-01').toISOString()],
+        body: 'Content',
+      });
+      expect(frontmatter.fromFile(file)).toEqual({
+        number: 1,
+        string: 'Hello World!',
+        date: new Date('2020-01-01').toISOString(),
+        array: ['1', new Date('2020-01-01').toISOString()],
+        body: 'Content',
+      });
+    });
+  });
+});

package/src/formats/__tests__/toml.spec.js

@@ -0,0 +1,9 @@
+import tomlFormatter from '../toml';
+
+describe('tomlFormatter', () => {
+  it('should output TOML integer values without decimals', () => {
+    expect(tomlFormatter.toFile({ testFloat: 123.456, testInteger: 789, title: 'TOML' })).toEqual(
+      ['testFloat = 123.456', 'testInteger = 789', 'title = "TOML"'].join('\n'),
+    );
+  });
+});

package/src/formats/__tests__/yaml.spec.js

@@ -0,0 +1,162 @@
+import { stripIndent } from 'common-tags';
+
+import yaml from '../yaml';
+
+describe('yaml', () => {
+  describe('fromFile', () => {
+    test('loads valid yaml', () => {
+      expect(yaml.fromFile('[]')).toEqual([]);
+
+      const result = yaml.fromFile(stripIndent`
+      date: 2020-04-02T16:08:03.327Z
+      dateString: 2020-04-02
+      boolean: true
+      number: 1
+      `);
+      expect(result).toEqual({
+        date: new Date('2020-04-02T16:08:03.327Z'),
+        dateString: '2020-04-02',
+        boolean: true,
+        number: 1,
+      });
+      expect(yaml.fromFile('# Comment a\na: a\nb:\n  # Comment c\n  c:\n    d: d\n')).toEqual({
+        a: 'a',
+        b: { c: { d: 'd' } },
+      });
+      expect(
+        yaml.fromFile(stripIndent`
+      # template comment
+      template: post
+      # title comment
+      title: title
+      # image comment
+      image: /media/netlify.png
+      # date comment
+      date: 2020-04-02T13:27:48.617Z
+      # object comment
+      object:
+        # object_title comment
+        object_title: object_title
+        # object_list comment
+        object_list:
+          - object_list_item_1: "1"
+            object_list_item_2: "2"
+      # list comment
+      list:
+        - "1"
+      `),
+      ).toEqual({
+        list: ['1'],
+        object: {
+          object_title: 'object_title',
+          object_list: [{ object_list_item_1: '1', object_list_item_2: '2' }],
+        },
+        date: new Date('2020-04-02T13:27:48.617Z'),
+        image: '/media/netlify.png',
+        title: 'title',
+        template: 'post',
+      });
+    });
+    test('does not fail on closing separator', () => {
+      expect(yaml.fromFile('---\n[]\n---')).toEqual([]);
+    });
+
+    test('parses single quoted string as string', () => {
+      expect(yaml.fromFile('name: y')).toEqual({ name: 'y' });
+    });
+
+    test('parses ISO date string as date', () => {
+      expect(yaml.fromFile('date: 2020-04-02T16:08:03.327Z')).toEqual({
+        date: new Date('2020-04-02T16:08:03.327Z'),
+      });
+    });
+
+    test('parses partial date string as string', () => {
+      expect(yaml.fromFile('date: 2020-06-12')).toEqual({
+        date: '2020-06-12',
+      });
+      expect(yaml.fromFile('date: 12-06-2012')).toEqual({
+        date: '12-06-2012',
+      });
+    });
+
+    test('parses partial time value as string', () => {
+      expect(yaml.fromFile('time: 10:05')).toEqual({
+        time: '10:05',
+      });
+    });
+  });
+  describe('toFile', () => {
+    test('outputs valid yaml', () => {
+      expect(yaml.toFile([])).toEqual('[]\n');
+    });
+
+    test('should sort keys', () => {
+      expect(yaml.toFile({ a: 'a', b: 'b', c: 'c', d: 'd' })).toEqual('a: a\nb: b\nc: c\nd: d\n');
+      expect(yaml.toFile({ a: 'a', b: 'b', c: 'c', d: 'd' }, ['d', 'b', 'a', 'c'])).toEqual(
+        'd: d\nb: b\na: a\nc: c\n',
+      );
+      expect(yaml.toFile({ a: 'a', b: 'b', c: 'c', d: 'd' }, ['d', 'b', 'c'])).toEqual(
+        'a: a\nd: d\nb: b\nc: c\n',
+      );
+    });
+
+    test('should add comments', () => {
+      expect(
+        yaml.toFile({ a: 'a', b: { c: { d: 'd' } } }, [], { a: 'Comment a', 'b.c': 'Comment c' }),
+      ).toEqual('# Comment a\na: a\nb:\n  # Comment c\n  c:\n    d: d\n');
+
+      const expected = `# template comment
+template: post
+# title comment
+title: title
+# image comment
+image: /media/netlify.png
+# date comment
+date: 2020-04-02T13:27:48.617Z
+# object comment
+object:
+  # object_title comment
+  object_title: object_title
+  # object_list comment
+  object_list:
+    - object_list_item_1: "1"
+      object_list_item_2: "2"
+# list comment
+list:
+  - "1"
+`;
+
+      const result = yaml.toFile(
+        {
+          list: ['1'],
+          object: {
+            object_title: 'object_title',
+            object_list: [{ object_list_item_1: '1', object_list_item_2: '2' }],
+          },
+          date: new Date('2020-04-02T13:27:48.617Z'),
+          image: '/media/netlify.png',
+          title: 'title',
+          template: 'post',
+        },
+        ['template', 'title', 'image', 'date', 'object', 'list'],
+        {
+          list: 'list comment',
+          object: 'object comment',
+          'object.object_title': 'object_title comment',
+          'object.object_list': 'object_list comment',
+          date: 'date comment',
+          image: 'image comment',
+          title: 'title comment',
+          template: 'template comment',
+        },
+      );
+
+      expect(result).toEqual(expected);
+
+      expect(yaml.toFile({ a: 'a' }, [], { a: 'line 1\\nline 2' })).toEqual(
+        '# line 1\n# line 2\na: a\n',
+      );
+    });
+  });
+});

package/src/formats/formats.ts

@@ -0,0 +1,97 @@
+import { List } from 'immutable';
+import get from 'lodash/get';
+
+import yamlFormatter from './yaml';
+import tomlFormatter from './toml';
+import jsonFormatter from './json';
+import { FrontmatterInfer, frontmatterJSON, frontmatterTOML, frontmatterYAML } from './frontmatter';
+import { getCustomFormatsExtensions, getCustomFormatsFormatters } from '../lib/registry';
+
+import type { Delimiter } from './frontmatter';
+import type { Collection, EntryObject, Format } from '../types/redux';
+import type { EntryValue } from '../valueObjects/Entry';
+import type { Formatter } from 'decap-cms-core';
+
+export const frontmatterFormats = ['yaml-frontmatter', 'toml-frontmatter', 'json-frontmatter'];
+
+export const formatExtensions = {
+  yml: 'yml',
+  yaml: 'yml',
+  toml: 'toml',
+  json: 'json',
+  frontmatter: 'md',
+  'json-frontmatter': 'md',
+  'toml-frontmatter': 'md',
+  'yaml-frontmatter': 'md',
+};
+
+export function getFormatExtensions() {
+  return { ...formatExtensions, ...getCustomFormatsExtensions() };
+}
+
+export const extensionFormatters = {
+  yml: yamlFormatter,
+  yaml: yamlFormatter,
+  toml: tomlFormatter,
+  json: jsonFormatter,
+  md: FrontmatterInfer,
+  markdown: FrontmatterInfer,
+  html: FrontmatterInfer,
+};
+
+function formatByName(name: Format, customDelimiter?: Delimiter): Formatter {
+  const formatters: Record<string, Formatter> = {
+    yml: yamlFormatter,
+    yaml: yamlFormatter,
+    toml: tomlFormatter,
+    json: jsonFormatter,
+    frontmatter: FrontmatterInfer,
+    'json-frontmatter': frontmatterJSON(customDelimiter),
+    'toml-frontmatter': frontmatterTOML(customDelimiter),
+    'yaml-frontmatter': frontmatterYAML(customDelimiter),
+    ...getCustomFormatsFormatters(),
+  };
+  if (name in formatters) {
+    return formatters[name];
+  }
+  throw new Error(`No formatter available with name: ${name}`);
+}
+
+function frontmatterDelimiterIsList(
+  frontmatterDelimiter?: Delimiter | List<string>,
+): frontmatterDelimiter is List<string> {
+  return List.isList(frontmatterDelimiter);
+}
+
+export function resolveFormat(collection: Collection, entry: EntryObject | EntryValue) {
+  // Check for custom delimiter
+  const frontmatter_delimiter = collection.get('frontmatter_delimiter');
+  const customDelimiter = frontmatterDelimiterIsList(frontmatter_delimiter)
+    ? (frontmatter_delimiter.toArray() as [string, string])
+    : frontmatter_delimiter;
+
+  // If the format is specified in the collection, use that format.
+  const formatSpecification = collection.get('format');
+  if (formatSpecification) {
+    return formatByName(formatSpecification, customDelimiter);
+  }
+
+  // If a file already exists, infer the format from its file extension.
+  const filePath = entry && entry.path;
+  if (filePath) {
+    const fileExtension = filePath.split('.').pop();
+    if (fileExtension) {
+      return get(extensionFormatters, fileExtension);
+    }
+  }
+
+  // If creating a new file, and an `extension` is specified in the
+  //   collection config, infer the format from that extension.
+  const extension = collection.get('extension');
+  if (extension) {
+    return get(extensionFormatters, extension);
+  }
+
+  // If no format is specified and it cannot be inferred, return the default.
+  return formatByName('frontmatter', customDelimiter);
+}