fixing order check

Author: sergical

scripts/check-redirects-on-rename.spec.ts

@@ -145,6 +145,93 @@ const userDocsRedirects = [
     expect(result.userDocsRedirects[0].source).toBe('/platforms/old/path/');
     expect(result.userDocsRedirects[0].destination).toBe('/platforms/new/path/');
   });
+
+  it('should handle property order flexibility (destination before source)', () => {
+    // Test that the parser works even when destination comes before source
+    const redirectsWithReversedOrder = `
+const developerDocsRedirects = [
+  {
+    destination: '/sdk/new-path/',
+    source: '/sdk/old-path/',
+  },
+];
+
+const userDocsRedirects = [
+  {
+    destination: '/platforms/javascript/new-guide/',
+    source: '/platforms/javascript/old-guide/',
+  },
+];
+`;
+    fs.writeFileSync(tempFile, redirectsWithReversedOrder);
+    const result = parseRedirectsJs(tempFile);
+
+    expect(result.developerDocsRedirects).toHaveLength(1);
+    expect(result.developerDocsRedirects[0].source).toBe('/sdk/old-path/');
+    expect(result.developerDocsRedirects[0].destination).toBe('/sdk/new-path/');
+
+    expect(result.userDocsRedirects).toHaveLength(1);
+    expect(result.userDocsRedirects[0].source).toBe('/platforms/javascript/old-guide/');
+    expect(result.userDocsRedirects[0].destination).toBe('/platforms/javascript/new-guide/');
+  });
+
+  it('should handle escaped quotes in URLs', () => {
+    // Test that URLs containing escaped quotes are parsed correctly
+    // In JavaScript strings, \" represents a literal quote character
+    // Note: In template literals (backticks), \" is NOT escaped - it's just \ + "
+    // So we write it as \\" in the template to get \" in the actual string
+    const redirectsWithEscapedQuotes = `
+const developerDocsRedirects = [
+  {
+    source: '/sdk/path/with\\"quotes/',
+    destination: '/sdk/new-path/',
+  },
+];
+
+const userDocsRedirects = [
+  {
+    source: '/platforms/javascript/guide\\"test/',
+    destination: '/platforms/javascript/new-guide/',
+  },
+];
+`;
+    fs.writeFileSync(tempFile, redirectsWithEscapedQuotes);
+    const result = parseRedirectsJs(tempFile);
+
+    expect(result.developerDocsRedirects).toHaveLength(1);
+    // The string contains \" (backslash + quote), which is preserved as-is
+    expect(result.developerDocsRedirects[0].source).toBe('/sdk/path/with\\"quotes/');
+    expect(result.developerDocsRedirects[0].destination).toBe('/sdk/new-path/');
+
+    expect(result.userDocsRedirects).toHaveLength(1);
+    expect(result.userDocsRedirects[0].source).toBe('/platforms/javascript/guide\\"test/');
+    expect(result.userDocsRedirects[0].destination).toBe('/platforms/javascript/new-guide/');
+  });
+
+  it('should handle escaped backslashes before quotes', () => {
+    // Test that \\" (escaped backslash + quote) in double-quoted strings is handled correctly
+    // In a double-quoted JavaScript string, \\" means:
+    //   \\ escapes to a single literal backslash
+    //   \" escapes to a literal quote
+    // So the string value contains \" (backslash + quote)
+    const redirectsWithEscapedBackslashQuote = `
+const developerDocsRedirects = [
+  {
+    source: "/sdk/path/with\\"quotes/",
+    destination: '/sdk/new-path/',
+  },
+];
+`;
+    fs.writeFileSync(tempFile, redirectsWithEscapedBackslashQuote);
+    const result = parseRedirectsJs(tempFile);
+
+    expect(result.developerDocsRedirects).toHaveLength(1);
+    // The string contains \" which should be parsed correctly
+    // When we read the file, \" is two characters: \ and "
+    // Our parser should handle this and include both in the value
+    expect(result.developerDocsRedirects[0].source).toBe('/sdk/path/with\\"quotes/');
+    expect(result.developerDocsRedirects[0].destination).toBe('/sdk/new-path/');
+  });
 });
 
 describe('redirectMatches', () => {

scripts/check-redirects-on-rename.ts

@@ -251,32 +251,113 @@ function parseRedirectsJs(filePath: string): {
   return {developerDocsRedirects, userDocsRedirects};
 }
 
+/**
+ * Extracts a string value from a JavaScript string literal, handling escaped quotes
+ * Supports both single and double quotes
+ */
+function extractStringValue(
+  content: string,
+  startIndex: number
+): {endIndex: number; value: string} | null {
+  const quoteChar = content[startIndex];
+  if (quoteChar !== '"' && quoteChar !== "'") {
+    return null;
+  }
+
+  let value = '';
+  let i = startIndex + 1; // Start after the opening quote
+
+  while (i < content.length) {
+    const char = content[i];
+
+    if (char === '\\') {
+      // Handle escaped characters
+      if (i + 1 < content.length) {
+        const nextChar = content[i + 1];
+
+        // Special case: \\" should be parsed as \" (escaped quote)
+        // In JavaScript: \\ escapes the backslash, \" escapes the quote
+        // So \\" becomes \" (backslash + quote) in the string value
+        if (nextChar === '\\' && i + 2 < content.length && content[i + 2] === quoteChar) {
+          // This is \\" which should be parsed as \" (escaped quote)
+          value += '\\' + quoteChar;
+          i += 3;
+          continue;
+        }
+
+        // Handle escaped quote, backslash, and other escape sequences
+        if (nextChar === quoteChar || nextChar === '\\') {
+          value += char + nextChar;
+          i += 2;
+          continue;
+        }
+        // Handle other escape sequences like \n, \t, etc.
+        value += char + nextChar;
+        i += 2;
+        continue;
+      }
+      // Backslash at end of string - treat as literal
+      value += char;
+      i++;
+    } else if (char === quoteChar) {
+      // Found closing quote (not escaped)
+      return {endIndex: i, value};
+    } else {
+      value += char;
+      i++;
+    }
+  }
+
+  // No closing quote found
+  return null;
+}
+
 /**
  * Extracts redirect objects from JavaScript array string
- * Handles both single and double quotes, and whitespace variations
+ * Handles both single and double quotes, escaped quotes, and flexible property order
  */
 function extractRedirectsFromArray(arrayContent: string): Redirect[] {
   const redirects: Redirect[] = [];
 
-  // Match redirect objects with more flexible whitespace handling
-  // Handles both ' and " quotes, and various whitespace patterns including multiline
-  // The pattern needs to match objects that span multiple lines
-  const redirectRegex =
-    /\{[\s\S]*?source:\s*['"]([^'"]+)['"][\s\S]*?destination:\s*['"]([^'"]+)['"][\s\S]*?\}/g;
+  // Match redirect objects - handle both source-first and destination-first orders
+  // Look for opening brace, then find source and destination properties in any order
+  const objectRegex = /\{[\s\S]*?\}/g;
+
+  let objectMatch: RegExpExecArray | null = objectRegex.exec(arrayContent);
+  while (objectMatch !== null) {
+    const objectContent = objectMatch[0];
+    let source: string | null = null;
+    let destination: string | null = null;
+
+    // Find source property
+    const sourceMatch = objectContent.match(/source\s*:\s*(['"])/);
+    if (sourceMatch && sourceMatch.index !== undefined) {
+      const stringStart = sourceMatch.index + sourceMatch[0].length - 1; // Position of quote char
+      const result = extractStringValue(objectContent, stringStart);
+      if (result) {
+        source = result.value;
+      }
+    }
 
-  let match: RegExpExecArray | null = redirectRegex.exec(arrayContent);
-  while (match !== null) {
-    const source = match[1];
-    const destination = match[2];
+    // Find destination property
+    const destMatch = objectContent.match(/destination\s*:\s*(['"])/);
+    if (destMatch && destMatch.index !== undefined) {
+      const stringStart = destMatch.index + destMatch[0].length - 1; // Position of quote char
+      const result = extractStringValue(objectContent, stringStart);
+      if (result) {
+        destination = result.value;
+      }
+    }
 
+    // If both properties found, add to redirects
     if (source && destination) {
       redirects.push({
         source,
         destination,
       });
     }
 
-    match = redirectRegex.exec(arrayContent);
+    objectMatch = objectRegex.exec(arrayContent);
   }
 
   return redirects;