refactor(sort-regexp): extract helpers into modules

Author: azat-io

rules/sort-regexp.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts the provided code point into its string representation.
+ *
+ * @param value - Code point to convert.
+ * @returns String representation of the code point.
+ */
+export function codePointToString(value: number): string {
+  return String.fromCodePoint(value)
+}

rules/sort-regexp/code-point-to-string.ts

@@ -0,0 +1,31 @@
+import type { CharacterClass } from '@eslint-community/regexpp/ast'
+import type { TSESTree } from '@typescript-eslint/types'
+
+import type { SortingNode } from '../../types/sorting-node'
+
+import { getCharacterClassElementSortKey } from './get-character-class-element-sort-key'
+
+/**
+ * Creates a sorting node for a character class element.
+ *
+ * @param parameters - Character class element metadata.
+ * @returns Sorting node describing the element.
+ */
+export function createCharacterClassSortingNode({
+  literalNode,
+  element,
+}: {
+  element: CharacterClass['elements'][number]
+  literalNode: TSESTree.Literal
+}): SortingNode<TSESTree.Literal> {
+  let key = getCharacterClassElementSortKey(element)
+
+  return {
+    group: 'character-class',
+    isEslintDisabled: false,
+    size: key.raw.length,
+    name: key.normalized,
+    node: literalNode,
+    partitionId: 0,
+  }
+}

rules/sort-regexp/create-character-class-sorting-node.ts

@@ -0,0 +1,32 @@
+import type { TSESTree } from '@typescript-eslint/types'
+
+import type { SortingNode } from '../../types/sorting-node'
+
+import { isNodeEslintDisabled } from '../../utils/is-node-eslint-disabled'
+
+/**
+ * Builds sorting nodes for every flag attached to a regular expression literal.
+ *
+ * @param parameters - Literal context alongside enabled flags.
+ * @returns Sorting nodes representing each flag.
+ */
+export function createFlagSortingNodes({
+  eslintDisabledLines,
+  literalNode,
+  flags,
+}: {
+  eslintDisabledLines: number[]
+  literalNode: TSESTree.Literal
+  flags: string
+}): SortingNode<TSESTree.Literal>[] {
+  let isDisabled = isNodeEslintDisabled(literalNode, eslintDisabledLines)
+
+  return [...flags].map(flag => ({
+    isEslintDisabled: isDisabled,
+    node: literalNode,
+    partitionId: 0,
+    group: 'flags',
+    name: flag,
+    size: 1,
+  }))
+}

rules/sort-regexp/create-flag-sorting-nodes.ts

@@ -0,0 +1,39 @@
+import type { Alternative } from '@eslint-community/regexpp/ast'
+import type { TSESTree } from '@typescript-eslint/types'
+import type { TSESLint } from '@typescript-eslint/utils'
+
+import { AST_NODE_TYPES } from '@typescript-eslint/types'
+
+/**
+ * Produces a pseudo literal node representing a regex alternative.
+ *
+ * @param parameters - Source literal context and alternative.
+ * @returns Literal node mirroring the alternative segment.
+ */
+export function createPseudoLiteralNode({
+  literalNode,
+  alternative,
+  sourceCode,
+}: {
+  sourceCode: TSESLint.SourceCode
+  literalNode: TSESTree.Literal
+  alternative: Alternative
+}): TSESTree.Literal {
+  let [literalStart] = literalNode.range
+  let offsetStart = literalStart + alternative.start
+  let offsetEnd = literalStart + alternative.end
+  let range: TSESTree.Range = [offsetStart, offsetEnd]
+  let loc = {
+    start: sourceCode.getLocFromIndex(range[0]),
+    end: sourceCode.getLocFromIndex(range[1]),
+  }
+
+  return {
+    type: AST_NODE_TYPES.Literal,
+    value: alternative.raw,
+    raw: alternative.raw,
+    parent: literalNode,
+    range,
+    loc,
+  } as TSESTree.Literal
+}

rules/sort-regexp/create-pseudo-literal-node.ts

@@ -0,0 +1,74 @@
+import type { Alternative } from '@eslint-community/regexpp/ast'
+import type { TSESLint } from '@typescript-eslint/utils'
+import type { TSESTree } from '@typescript-eslint/types'
+
+import type { SortingNode } from '../../types/sorting-node'
+import type { Options } from './types'
+
+import { doesCustomGroupMatch } from '../../utils/does-custom-group-match'
+import { isNodeEslintDisabled } from '../../utils/is-node-eslint-disabled'
+import { createPseudoLiteralNode } from './create-pseudo-literal-node'
+import { getAlternativeAlias } from './get-alternative-alias'
+import { getSortingNodeName } from './get-sorting-node-name'
+import { computeGroup } from '../../utils/compute-group'
+import { getSelector } from './get-selector'
+
+interface CreateSortingNodeParameters {
+  sourceCode: TSESLint.SourceCode
+  literalNode: TSESTree.Literal
+  eslintDisabledLines: number[]
+  alternative: Alternative
+  options: ResolvedOptions
+}
+
+type ResolvedOptions = Required<Options[0]>
+
+/**
+ * Builds a sortable node representation for a regex alternative.
+ *
+ * @param parameters - Alternative context with rule settings.
+ * @returns Sorting node ready for ordering logic.
+ */
+export function createSortingNode({
+  eslintDisabledLines,
+  literalNode,
+  alternative,
+  sourceCode,
+  options,
+}: CreateSortingNodeParameters): SortingNode<TSESTree.Literal> {
+  let alternativeAlias = getAlternativeAlias(alternative)
+  let selector = getSelector({ alternativeAlias })
+  let name = getSortingNodeName({
+    alternativeAlias,
+    alternative,
+    options,
+  })
+
+  let group = computeGroup({
+    customGroupMatcher: customGroup =>
+      doesCustomGroupMatch({
+        elementValue: alternative.raw,
+        selectors: [selector],
+        elementName: name,
+        modifiers: [],
+        customGroup,
+      }),
+    predefinedGroups: [selector],
+    options,
+  })
+
+  let pseudoNode = createPseudoLiteralNode({
+    literalNode,
+    alternative,
+    sourceCode,
+  })
+
+  return {
+    isEslintDisabled: isNodeEslintDisabled(literalNode, eslintDisabledLines),
+    size: pseudoNode.range[1] - pseudoNode.range[0],
+    node: pseudoNode,
+    partitionId: 0,
+    group,
+    name,
+  }
+}

rules/sort-regexp/create-sorting-node.ts

@@ -0,0 +1,25 @@
+/**
+ * Detects whether one alternative shadows (is a prefix of) another.
+ *
+ * @param first - First alternative text.
+ * @param second - Second alternative text.
+ * @returns True when either alternative makes the other unreachable.
+ */
+export function doesAlternativeShadowOther(
+  first: string,
+  second: string,
+): boolean {
+  if (first.length === 0 || second.length === 0) {
+    return true
+  }
+
+  if (first.length === second.length) {
+    return first === second
+  }
+
+  if (first.length < second.length) {
+    return second.startsWith(first)
+  }
+
+  return first.startsWith(second)
+}

rules/sort-regexp/does-alternative-shadow-other.ts

@@ -0,0 +1,20 @@
+import type { Alternative } from '@eslint-community/regexpp/ast'
+
+/**
+ * Extracts an alias name for a given alternative, if present.
+ *
+ * @param alternative - Alternative to inspect.
+ * @returns Alias name or null when absent.
+ */
+export function getAlternativeAlias(alternative: Alternative): string | null {
+  let [element] = alternative.elements
+  if (element && element.type === 'CapturingGroup' && element.name) {
+    return element.name
+  }
+
+  if (alternative.parent.type === 'CapturingGroup' && alternative.parent.name) {
+    return alternative.parent.name
+  }
+
+  return null
+}

rules/sort-regexp/get-alternative-alias.ts

@@ -0,0 +1,80 @@
+import type { CharacterClass } from '@eslint-community/regexpp/ast'
+
+import { isLowercaseCharacter } from './is-lowercase-character'
+import { isUppercaseCharacter } from './is-uppercase-character'
+import { isDigitCharacter } from './is-digit-character'
+
+/**
+ * Maps a character class element to a sortable category bucket.
+ *
+ * @param element - Character class element to categories.
+ * @returns Numeric category representing the element group.
+ */
+export function getCharacterClassElementCategory(
+  element: CharacterClass['elements'][number],
+): number {
+  let category = 4
+
+  switch (element.type) {
+    case 'CharacterClassRange': {
+      if (
+        isDigitCharacter(element.min.value) &&
+        isDigitCharacter(element.max.value)
+      ) {
+        category = 0
+      } else if (
+        isUppercaseCharacter(element.min.value) &&
+        isUppercaseCharacter(element.max.value)
+      ) {
+        category = 1
+      } else if (
+        isLowercaseCharacter(element.min.value) &&
+        isLowercaseCharacter(element.max.value)
+      ) {
+        category = 2
+      } else {
+        category = 3
+      }
+
+      break
+    }
+    case 'CharacterSet': {
+      switch (element.kind) {
+        case 'digit': {
+          category = 0
+
+          break
+        }
+        case 'space': {
+          category = 3
+
+          break
+        }
+        case 'word': {
+          category = 2
+
+          break
+        }
+        // No default
+      }
+
+      break
+    }
+    case 'Character': {
+      if (isDigitCharacter(element.value)) {
+        category = 0
+      } else if (isUppercaseCharacter(element.value)) {
+        category = 1
+      } else if (isLowercaseCharacter(element.value)) {
+        category = 2
+      } else {
+        category = 3
+      }
+
+      break
+    }
+    /* No default. */
+  }
+
+  return category
+}

rules/sort-regexp/get-character-class-element-category.ts

@@ -0,0 +1,13 @@
+import type { CharacterClass } from '@eslint-community/regexpp/ast'
+
+/**
+ * Returns the raw representation of a character class element.
+ *
+ * @param element - Character class element to read.
+ * @returns Raw text of the element.
+ */
+export function getCharacterClassElementRaw(
+  element: CharacterClass['elements'][number],
+): string {
+  return element.raw
+}