misc(v2): make packages dir more consistent

packages/docusaurus-utils/src/__tests__/index.test.js

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import path from 'path';
+import {
+  fileToPath,
+  fileToComponentName,
+  generateChunkName,
+  idx,
+  getSubFolder,
+  normalizeUrl,
+} from '../index';
+
+describe('load utils', () => {
+  test('fileToComponentName', () => {
+    const asserts = {
+      'index.md': 'MDIndex',
+      'hello/index.md': 'MDHelloIndex',
+      'foo.md': 'MDFoo',
+      'foo-bar.md': 'MDFooBar',
+      'index.js': 'JSIndex',
+      'foobar.js': 'JSFoobar',
+      'docusaurus/index.js': 'JSDocusaurusIndex',
+      '234.md': 'MD234',
+      '2018-07-08-test.md': 'MD20180708Test',
+      '%asd.md': 'MDAsd',
+    };
+    Object.keys(asserts).forEach(file => {
+      expect(fileToComponentName(file)).toBe(asserts[file]);
+    });
+  });
+
+  test('fileToPath', () => {
+    const asserts = {
+      'index.md': '/',
+      'hello/index.md': '/hello/',
+      'foo.md': '/foo',
+      'foo/bar.md': '/foo/bar',
+      'index.js': '/',
+      'hello/index.js': '/hello/',
+      'foo.js': '/foo',
+      'foo/bar.js': '/foo/bar',
+    };
+    Object.keys(asserts).forEach(file => {
+      expect(fileToPath(file)).toBe(asserts[file]);
+    });
+  });
+
+  test('generateChunkName', () => {
+    const asserts = {
+      '/docs/adding-blog': 'docs-adding-blog-062',
+      '/docs/versioning': 'docs-versioning-8a8',
+      '/': 'index',
+      '/blog/2018/04/30/How-I-Converted-Profilo-To-Docusaurus':
+        'blog-2018-04-30-how-i-converted-profilo-to-docusaurus-4f2',
+      '/youtube': 'youtube-429',
+      '/users/en/': 'users-en-f7a',
+      '/blog': 'blog-c06',
+    };
+    Object.keys(asserts).forEach(str => {
+      expect(generateChunkName(str)).toBe(asserts[str]);
+    });
+  });
+
+  test('idx', () => {
+    const a = {};
+    const b = {hello: 'world'};
+    const env = {
+      translation: {
+        enabled: true,
+        enabledLanguages: [
+          {
+            enabled: true,
+            name: 'English',
+            tag: 'en',
+          },
+          {
+            enabled: true,
+            name: '日本語',
+            tag: 'ja',
+          },
+        ],
+      },
+      versioning: {
+        enabled: false,
+        versions: [],
+      },
+    };
+    const test = {arr: [1, 2, 3]};
+    const variable = 'enabledLanguages';
+    expect(idx(a, [('b', 'c')])).toBeUndefined();
+    expect(idx(b, ['hello'])).toEqual('world');
+    expect(idx(b, 'hello')).toEqual('world');
+    expect(idx(env, 'typo')).toBeUndefined();
+    expect(idx(env, 'versioning')).toEqual({
+      enabled: false,
+      versions: [],
+    });
+    expect(idx(env, ['translation', 'enabled'])).toEqual(true);
+    expect(idx(env, ['translation', variable]).map(lang => lang.tag)).toEqual([
+      'en',
+      'ja',
+    ]);
+    expect(idx(test, ['arr', 0])).toEqual(1);
+    expect(idx(undefined)).toBeUndefined();
+    expect(idx(null)).toBeNull();
+  });
+
+  test('getSubFolder', () => {
+    const testA = path.join('folder', 'en', 'test.md');
+    const testB = path.join('folder', 'ja', 'test.md');
+    const testC = path.join('folder', 'ja', 'en', 'test.md');
+    const testD = path.join('docs', 'ro', 'test.md');
+    const testE = path.join('docs', 'test.md');
+    expect(getSubFolder(testA, 'folder')).toBe('en');
+    expect(getSubFolder(testB, 'folder')).toBe('ja');
+    expect(getSubFolder(testC, 'folder')).toBe('ja');
+    expect(getSubFolder(testD, 'docs')).toBe('ro');
+    expect(getSubFolder(testE, 'docs')).toBeNull();
+  });
+
+  test('normalizeUrl', () => {
+    const asserts = [
+      {
+        input: ['/', '/'],
+        output: '/',
+      },
+      {
+        input: ['/', 'docs'],
+        output: '/docs',
+      },
+      {
+        input: ['/', 'docs', 'en', 'next', 'blog'],
+        output: '/docs/en/next/blog',
+      },
+      {
+        input: ['/test/', '/docs', 'ro', 'doc1'],
+        output: '/test/docs/ro/doc1',
+      },
+      {
+        input: ['', '/', 'ko', 'hello'],
+        output: '/ko/hello',
+      },
+      {
+        input: ['hello', 'world'],
+        output: 'hello/world',
+      },
+      {
+        input: ['http://www.google.com/', 'foo/bar', '?test=123'],
+        output: 'http://www.google.com/foo/bar?test=123',
+      },
+      {
+        input: ['http:', 'www.google.com///', 'foo/bar', '?test=123'],
+        output: 'http://www.google.com/foo/bar?test=123',
+      },
+      {
+        input: ['http://foobar.com', '', 'test'],
+        output: 'http://foobar.com/test',
+      },
+    ];
+    asserts.forEach(testCase => {
+      expect(normalizeUrl(testCase.input)).toBe(testCase.output);
+    });
+  });
+});

packages/docusaurus-utils/src/index.js

@@ -0,0 +1,156 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const path = require('path');
+const fm = require('front-matter');
+
+const kebabHash = require('kebab-hash');
+const escapeStringRegexp = require('escape-string-regexp');
+const fs = require('fs-extra');
+
+const genCache = new Map();
+async function generate(generatedFilesDir, file, content) {
+  const cached = genCache.get(file);
+  if (cached !== content) {
+    await fs.ensureDir(generatedFilesDir);
+    await fs.writeFile(path.join(generatedFilesDir, file), content);
+    genCache.set(file, content);
+  }
+}
+
+const indexRE = /(^|.*\/)index\.(md|js)$/i;
+const extRE = /\.(md|js)$/;
+
+function fileToPath(file) {
+  if (indexRE.test(file)) {
+    return file.replace(indexRE, '/$1');
+  }
+  return `/${file.replace(extRE, '').replace(/\\/g, '/')}`;
+}
+
+function encodePath(userpath) {
+  return userpath
+    .split('/')
+    .map(item => encodeURIComponent(item))
+    .join('/');
+}
+
+function fileToComponentName(file) {
+  const ext = extRE.exec(file)[1];
+  let str = file.replace(extRE, '');
+  str = str.replace(/([A-Z])/g, ' $1');
+  str = str.replace(/^[\W_]+|[\W_]+$/g, '').toLowerCase();
+  str = str.charAt(0).toUpperCase() + str.slice(1);
+  str = str.replace(/[\W_]+(\w|$)/g, (_, ch) => ch.toUpperCase());
+  return ext ? ext.toUpperCase() + str : str;
+}
+
+function generateChunkName(str, prefix) {
+  const name = str === '/' ? 'index' : kebabHash(str);
+  return prefix ? `${prefix}---${name}` : name;
+}
+
+function idx(target, keyPaths) {
+  return (
+    target &&
+    (Array.isArray(keyPaths)
+      ? keyPaths.reduce((obj, key) => obj && obj[key], target)
+      : target[keyPaths])
+  );
+}
+
+function getSubFolder(file, refDir) {
+  const separator = escapeStringRegexp(path.sep);
+  const baseDir = escapeStringRegexp(path.basename(refDir));
+  const regexSubFolder = new RegExp(
+    `${baseDir}${separator}(.*?)${separator}.*`,
+  );
+  const match = regexSubFolder.exec(file);
+  return match && match[1];
+}
+
+function parse(fileString) {
+  if (!fm.test(fileString)) {
+    return {metadata: null, content: fileString};
+  }
+  const {attributes: metadata, body: content} = fm(fileString);
+
+  return {metadata, content};
+}
+
+function normalizeUrl(rawUrls) {
+  const urls = rawUrls;
+  const resultArray = [];
+
+  // If the first part is a plain protocol, we combine it with the next part.
+  if (urls[0].match(/^[^/:]+:\/*$/) && urls.length > 1) {
+    const first = urls.shift();
+    urls[0] = first + urls[0];
+  }
+
+  // There must be two or three slashes in the file protocol, two slashes in anything else.
+  if (urls[0].match(/^file:\/\/\//)) {
+    urls[0] = urls[0].replace(/^([^/:]+):\/*/, '$1:///');
+  } else {
+    urls[0] = urls[0].replace(/^([^/:]+):\/*/, '$1://');
+  }
+
+  // eslint-disable-next-line
+  for (let i = 0; i < urls.length; i++) {
+    let component = urls[i];
+
+    if (typeof component !== 'string') {
+      throw new TypeError(`Url must be a string. Received ${component}`);
+    }
+
+    if (component === '') {
+      // eslint-disable-next-line
+      continue;
+    }
+
+    if (i > 0) {
+      // Removing the starting slashes for each component but the first.
+      component = component.replace(/^[/]+/, '');
+    }
+    if (i < urls.length - 1) {
+      // Removing the ending slashes for each component but the last.
+      component = component.replace(/[/]+$/, '');
+    } else {
+      // For the last component we will combine multiple slashes to a single one.
+      component = component.replace(/[/]+$/, '/');
+    }
+
+    resultArray.push(component);
+  }
+
+  let str = resultArray.join('/');
+  // Each input component is now separated by a single slash except the possible first plain protocol part.
+
+  // remove trailing slash before parameters or hash
+  str = str.replace(/\/(\?|&|#[^!])/g, '$1');
+
+  // replace ? in parameters with &
+  const parts = str.split('?');
+  str = parts.shift() + (parts.length > 0 ? '?' : '') + parts.join('&');
+
+  // dedupe forward slashes
+  str = str.replace(/^\/+/, '/');
+
+  return str;
+}
+
+module.exports = {
+  encodePath,
+  generate,
+  fileToPath,
+  fileToComponentName,
+  generateChunkName,
+  getSubFolder,
+  idx,
+  normalizeUrl,
+  parse,
+};