documentation/test/lib/sort.js

'use strict';

var test = require('tap').test,
  sort = require('../../lib/sort'),
  path = require('path');

test('sort stream alphanumeric', function(t) {
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var banana = { context: { sortKey: 'c' }, name: 'bananas' };

  t.deepEqual(
    sort([apples, carrot, banana]),
    [apples, carrot, banana],
    'sort stream alphanumeric'
  );

  t.deepEqual(
    sort([carrot, apples, banana]),
    [apples, carrot, banana],
    'sort stream alphanumeric'
  );

  t.end();
});

test('sort stream with configuration', function(t) {
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var bananas = { context: { sortKey: 'c' }, name: 'bananas' };

  t.deepEqual(
    sort([apples, carrot, bananas], {
      toc: ['carrot', 'bananas']
    }),
    [carrot, bananas, apples],
    'with configuration'
  );

  t.end();
});

test('sort stream with configuration and a section', function(t) {
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var bananas = { context: { sortKey: 'c' }, name: 'bananas' };

  var section = {
    name: 'This is the banana type',
    description: 'here lies bananas'
  };

  var sectionMarkdown = {
    name: 'This is the banana type',
    description: {
      type: 'root',
      children: [
        {
          type: 'paragraph',
          children: [
            {
              type: 'text',
              value: 'here lies bananas',
              position: {
                start: {
                  line: 1,
                  column: 1,
                  offset: 0
                },
                end: {
                  line: 1,
                  column: 18,
                  offset: 17
                },
                indent: []
              }
            }
          ],
          position: {
            start: {
              line: 1,
              column: 1,
              offset: 0
            },
            end: {
              line: 1,
              column: 18,
              offset: 17
            },
            indent: []
          }
        }
      ],
      position: {
        start: {
          line: 1,
          column: 1,
          offset: 0
        },
        end: {
          line: 1,
          column: 18,
          offset: 17
        }
      }
    },
    kind: 'note'
  };

  t.deepEqual(
    sort([apples, carrot, bananas], {
      toc: ['carrot', section, 'bananas']
    }),
    [carrot, sectionMarkdown, bananas, apples],
    'with configuration'
  );

  t.end();
});

test('sort an already-sorted stream containing a section/description', function(t) {
  // this happens in the 'serve' task
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var bananas = { context: { sortKey: 'c' }, name: 'bananas' };

  var section = {
    name: 'This is the banana type',
    description: 'here lies bananas'
  };
  var sectionMarkdown = {
    name: 'This is the banana type',
    description: {
      type: 'root',
      children: [
        {
          type: 'paragraph',
          children: [
            {
              type: 'text',
              value: 'here lies bananas',
              position: {
                start: {
                  line: 1,
                  column: 1,
                  offset: 0
                },
                end: {
                  line: 1,
                  column: 18,
                  offset: 17
                },
                indent: []
              }
            }
          ],
          position: {
            start: {
              line: 1,
              column: 1,
              offset: 0
            },
            end: {
              line: 1,
              column: 18,
              offset: 17
            },
            indent: []
          }
        }
      ],
      position: {
        start: {
          line: 1,
          column: 1,
          offset: 0
        },
        end: {
          line: 1,
          column: 18,
          offset: 17
        }
      }
    },
    kind: 'note'
  };

  var config = {
    toc: ['carrot', section, 'bananas']
  };

  var sortOnce = sort([apples, carrot, bananas], config);
  var sortTwice = sort(sortOnce, config);
  t.deepEqual(sortTwice, [carrot, sectionMarkdown, bananas, apples]);
  t.end();
});

test('sort toc with files', function(t) {
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var bananas = { context: { sortKey: 'c' }, name: 'bananas' };

  var snowflake = {
    name: 'snowflake',
    file: 'test/fixture/snowflake.md'
  };

  var processedSnowflake = {
    name: 'snowflake',
    kind: 'note',
    description: {
      children: [
        {
          children: [
            {
              position: {
                end: { column: 16, line: 1, offset: 15 },
                indent: [],
                start: { column: 3, line: 1, offset: 2 }
              },
              type: 'text',
              value: 'The Snowflake'
            }
          ],
          depth: 1,
          position: {
            end: { column: 16, line: 1, offset: 15 },
            indent: [],
            start: { column: 1, line: 1, offset: 0 }
          },
          type: 'heading'
        }
      ],
      position: {
        end: { column: 1, line: 2, offset: 16 },
        start: { column: 1, line: 1, offset: 0 }
      },
      type: 'root'
    }
  };
  t.deepEqual(
    sort([apples, carrot, bananas], {
      toc: [snowflake]
    }),
    [processedSnowflake, apples, carrot, bananas],
    'with configuration'
  );

  t.end();
});

test('sort toc with files absolute path', function(t) {
  var apples = { context: { sortKey: 'a' }, name: 'apples' };
  var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
  var bananas = { context: { sortKey: 'c' }, name: 'bananas' };

  var snowflake = {
    name: 'snowflake',
    file: path.join(__dirname, '../fixture/snowflake.md')
  };

  var processedSnowflake = {
    name: 'snowflake',
    kind: 'note',
    description: {
      children: [
        {
          children: [
            {
              position: {
                end: { column: 16, line: 1, offset: 15 },
                indent: [],
                start: { column: 3, line: 1, offset: 2 }
              },
              type: 'text',
              value: 'The Snowflake'
            }
          ],
          depth: 1,
          position: {
            end: { column: 16, line: 1, offset: 15 },
            indent: [],
            start: { column: 1, line: 1, offset: 0 }
          },
          type: 'heading'
        }
      ],
      position: {
        end: { column: 1, line: 2, offset: 16 },
        start: { column: 1, line: 1, offset: 0 }
      },
      type: 'root'
    }
  };
  t.deepEqual(
    sort([apples, carrot, bananas], {
      toc: [snowflake]
    }),
    [processedSnowflake, apples, carrot, bananas],
    'with configuration'
  );

  t.end();
});