@evfrenkel/decap-cms-core 3.13.0-image-conversions.0

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

@@ -0,0 +1,450 @@
+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 throw on duplicate frontmatter keys', () => {
+      expect(() =>
+        FrontmatterInfer.fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should throw on duplicate frontmatter keys with explicit YAML format', () => {
+      expect(() =>
+        frontmatterYAML().fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should not throw when body contains YAML-like patterns', () => {
+      expect(
+        FrontmatterInfer.fromFile('---\ntitle: Hello\n---\ntitle: this is not a duplicate'),
+      ).toEqual({
+        title: 'Hello',
+        body: 'title: this is not a duplicate',
+      });
+    });
+
+    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,189 @@
+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',
+      });
+    });
+
+    test('throws on duplicate keys', () => {
+      expect(() => yaml.fromFile('title: Hello\ntitle: World')).toThrow(
+        /Map keys must be unique; "title" is repeated/,
+      );
+    });
+
+    test('throws on duplicate nested keys', () => {
+      expect(() => yaml.fromFile('nested:\n  a: 1\n  a: 2')).toThrow(
+        /Map keys must be unique; "a" is repeated/,
+      );
+    });
+
+    test('does not throw when same key appears in different nested objects', () => {
+      expect(yaml.fromFile('obj1:\n  name: foo\nobj2:\n  name: bar')).toEqual({
+        obj1: { name: 'foo' },
+        obj2: { name: 'bar' },
+      });
+    });
+
+    test('logs warnings to console.warn', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      // Valid YAML should produce no warnings
+      yaml.fromFile('title: Hello');
+      expect(warnSpy).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+  });
+  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',
+      );
+    });
+  });
+});