fix(cli): write-heading-id should not generate colliding slugs when not overwriting (#6849)

packages/docusaurus/src/commands/__tests__/writeHeadingIds.test.ts

@@ -5,91 +5,63 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {
+import {transformMarkdownContent} from '../writeHeadingIds';
-  transformMarkdownHeadingLine,
-  transformMarkdownContent,
-} from '../writeHeadingIds';
-import {createSlugger} from '@docusaurus/utils';
-
-describe('transformMarkdownHeadingLine', () => {
-  test('throws when not a heading', () => {
-    expect(() =>
-      transformMarkdownHeadingLine('ABC', createSlugger()),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"Line is not a Markdown heading: ABC."`,
-    );
-  });
 
+describe('transformMarkdownContent', () => {
   test('works for simple level-2 heading', () => {
-    expect(transformMarkdownHeadingLine('## ABC', createSlugger())).toEqual(
+    expect(transformMarkdownContent('## ABC')).toEqual('## ABC {#abc}');
-      '## ABC {#abc}',
-    );
   });
 
   test('works for simple level-3 heading', () => {
-    expect(transformMarkdownHeadingLine('### ABC', createSlugger())).toEqual(
+    expect(transformMarkdownContent('### ABC')).toEqual('### ABC {#abc}');
-      '### ABC {#abc}',
-    );
   });
 
   test('works for simple level-4 heading', () => {
-    expect(transformMarkdownHeadingLine('#### ABC', createSlugger())).toEqual(
+    expect(transformMarkdownContent('#### ABC')).toEqual('#### ABC {#abc}');
-      '#### ABC {#abc}',
-    );
   });
 
   test('unwraps markdown links', () => {
     const input = `## hello [facebook](https://facebook.com) [crowdin](https://crowdin.com/translate/docusaurus-v2/126/en-fr?filter=basic&value=0)`;
-    expect(transformMarkdownHeadingLine(input, createSlugger())).toEqual(
+    expect(transformMarkdownContent(input)).toEqual(
       `${input} {#hello-facebook-crowdin}`,
     );
   });
 
   test('can slugify complex headings', () => {
     const input = '## abc [Hello] How are you %Sébastien_-_$)( ## -56756';
-    expect(transformMarkdownHeadingLine(input, createSlugger())).toEqual(
+    expect(transformMarkdownContent(input)).toEqual(
       `${input} {#abc-hello-how-are-you-sébastien_-_---56756}`,
     );
   });
 
   test('does not duplicate duplicate id', () => {
-    expect(
+    expect(transformMarkdownContent('## hello world {#hello-world}')).toEqual(
-      transformMarkdownHeadingLine(
+      '## hello world {#hello-world}',
-        '## hello world {#hello-world}',
+    );
-        createSlugger(),
-      ),
-    ).toEqual('## hello world {#hello-world}');
   });
 
   test('respects existing heading', () => {
-    expect(
+    expect(transformMarkdownContent('## New heading {#old-heading}')).toEqual(
-      transformMarkdownHeadingLine(
+      '## New heading {#old-heading}',
-        '## New heading {#old-heading}',
+    );
-        createSlugger(),
-      ),
-    ).toEqual('## New heading {#old-heading}');
   });
 
   test('overwrites heading ID when asked to', () => {
     expect(
-      transformMarkdownHeadingLine(
+      transformMarkdownContent('## New heading {#old-heading}', {
-        '## New heading {#old-heading}',
+        overwrite: true,
-        createSlugger(),
+      }),
-        {overwrite: true},
-      ),
     ).toEqual('## New heading {#new-heading}');
   });
 
   test('maintains casing when asked to', () => {
     expect(
-      transformMarkdownHeadingLine('## getDataFromAPI()', createSlugger(), {
+      transformMarkdownContent('## getDataFromAPI()', {
         maintainCase: true,
       }),
     ).toEqual('## getDataFromAPI() {#getDataFromAPI}');
   });
-});
 
-describe('transformMarkdownContent', () => {
   test('transform the headings', () => {
     const input = `
 
@@ -113,14 +85,11 @@ describe('transformMarkdownContent', () => {
 
     `;
 
-    // TODO the first heading should probably rather be slugified to abc-1
-    // otherwise we end up with 2 x "abc" anchors
-    // not sure how to implement that atm
     const expected = `
 
 # Ignored title
 
-## abc {#abc}
+## abc {#abc-1}
 
 ### Hello world {#hello-world}
 

packages/docusaurus/src/commands/writeHeadingIds.ts

@@ -38,66 +38,52 @@ function addHeadingId(
 
   const headingText = line.slice(headingLevel).trimEnd();
   const headingHashes = line.slice(0, headingLevel);
-  const slug = slugger
+  const slug = slugger.slug(unwrapMarkdownLinks(headingText).trim(), {
-    .slug(unwrapMarkdownLinks(headingText).trim(), {maintainCase})
+    maintainCase,
-    .replace(/^-+/, '')
+  });
-    .replace(/-+$/, '');
 
   return `${headingHashes}${headingText} {#${slug}}`;
 }
 
-export function transformMarkdownHeadingLine(
+export function transformMarkdownContent(
-  line: string,
+  content: string,
-  slugger: Slugger,
   options: Options = {maintainCase: false, overwrite: false},
 ): string {
   const {maintainCase = false, overwrite = false} = options;
-  if (!line.startsWith('#')) {
+  const lines = content.split('\n');
-    throw new Error(`Line is not a Markdown heading: ${line}.`);
-  }
-
-  const parsedHeading = parseMarkdownHeadingId(line);
-
-  // Do not process if id is already there
-  if (parsedHeading.id && !overwrite) {
-    return line;
-  }
-  return addHeadingId(parsedHeading.text, slugger, maintainCase);
-}
-
-function transformMarkdownLine(
-  line: string,
-  slugger: Slugger,
-  options?: Options,
-): string {
-  // Ignore h1 headings on purpose, as we don't create anchor links for those
-  if (line.startsWith('##')) {
-    return transformMarkdownHeadingLine(line, slugger, options);
-  }
-  return line;
-}
-
-function transformMarkdownLines(lines: string[], options?: Options): string[] {
-  let inCode = false;
   const slugger = createSlugger();
 
-  return lines.map((line) => {
+  // If we can't overwrite existing slugs, make sure other headings don't
-    if (line.startsWith('```')) {
+  // generate colliding slugs by first marking these slugs as occupied
-      inCode = !inCode;
+  if (!overwrite) {
-      return line;
+    lines.forEach((line) => {
-    }
+      const parsedHeading = parseMarkdownHeadingId(line);
-    if (inCode) {
+      if (parsedHeading.id) {
-      return line;
+        slugger.slug(parsedHeading.id);
-    }
+      }
-    return transformMarkdownLine(line, slugger, options);
+    });
-  });
+  }
-}
 
-export function transformMarkdownContent(
+  let inCode = false;
-  content: string,
+  return lines
-  options?: Options,
+    .map((line) => {
-): string {
+      if (line.startsWith('```')) {
-  return transformMarkdownLines(content.split('\n'), options).join('\n');
+        inCode = !inCode;
+        return line;
+      }
+      // Ignore h1 headings, as we don't create anchor links for those
+      if (inCode || !line.startsWith('##')) {
+        return line;
+      }
+      const parsedHeading = parseMarkdownHeadingId(line);
+
+      // Do not process if id is already there
+      if (parsedHeading.id && !overwrite) {
+        return line;
+      }
+      return addHeadingId(parsedHeading.text, slugger, maintainCase);
+    })
+    .join('\n');
 }
 
 async function transformMarkdownFile(
@@ -105,10 +91,7 @@ async function transformMarkdownFile(
   options?: Options,
 ): Promise<string | undefined> {
   const content = await fs.readFile(filepath, 'utf8');
-  const updatedContent = transformMarkdownLines(
+  const updatedContent = transformMarkdownContent(content, options);
-    content.split('\n'),
-    options,
-  ).join('\n');
   if (content !== updatedContent) {
     await fs.writeFile(filepath, updatedContent);
     return filepath;