refactor: add support for relative export and import expression matching

Author: jedwards1211

src/compileMatcher/CallExpression.ts

@@ -1,6 +1,7 @@
 import { NodePath, CallExpression } from '../types'
 import { CompiledMatcher, CompileOptions } from '.'
 import compileSpecialMatcher from './SpecialMatcher'
+import { compileRelativeSourceMatcher } from './RelativeSource'
 
 export default function compileCallExpressionMatcher(
   path: NodePath<CallExpression, CallExpression>,
@@ -19,4 +20,29 @@ export default function compileCallExpressionMatcher(
 
     if (special) return special
   }
+  if (n.Import.check(callee)) {
+    const sourceMatcher = compileRelativeSourceMatcher(
+      path.get('arguments').get(0),
+      compileOptions
+    )
+    if (sourceMatcher) {
+      return {
+        pattern: path,
+        match: (path, matchSoFar, options) => {
+          const { value } = path
+          if (
+            value.type !== 'CallExpression' ||
+            !n.Import.check(value.callee)
+          ) {
+            return null
+          }
+          return sourceMatcher.match(
+            path.get('arguments').get(0),
+            matchSoFar,
+            options
+          )
+        },
+      }
+    }
+  }
 }

src/compileMatcher/ExportAllDeclaration.ts

@@ -0,0 +1,35 @@
+import { ExportAllDeclaration, NodePath } from '../types'
+import { CompiledMatcher, CompileOptions, MatchResult } from '.'
+import compileGenericNodeMatcher from './GenericNodeMatcher'
+import { compileRelativeSourceMatcher } from './RelativeSource'
+
+export default function compileImportSpecifierMatcher(
+  path: NodePath<ExportAllDeclaration, ExportAllDeclaration>,
+  compileOptions: CompileOptions
+): CompiledMatcher | void {
+  const pattern: ExportAllDeclaration = path.value
+
+  const importKind = (pattern as any).importKind || 'value'
+
+  const sourceMatcher = compileRelativeSourceMatcher(
+    path.get('source'),
+    compileOptions
+  )
+
+  return compileGenericNodeMatcher(path, compileOptions, {
+    keyMatchers: {
+      importKind: {
+        pattern: path.get('importKind') as any,
+        match: (
+          path: NodePath<any, any>,
+          matchSoFar: MatchResult
+        ): MatchResult => {
+          return (path.value || 'value') === importKind
+            ? matchSoFar || {}
+            : null
+        },
+      },
+      ...(sourceMatcher ? { source: sourceMatcher } : {}),
+    },
+  })
+}

src/compileMatcher/ExportNamedDeclaration.ts

@@ -0,0 +1,35 @@
+import { ExportNamedDeclaration, NodePath } from '../types'
+import { CompiledMatcher, CompileOptions, MatchResult } from '.'
+import compileGenericNodeMatcher from './GenericNodeMatcher'
+import { compileRelativeSourceMatcher } from './RelativeSource'
+
+export default function compileImportSpecifierMatcher(
+  path: NodePath<ExportNamedDeclaration, ExportNamedDeclaration>,
+  compileOptions: CompileOptions
+): CompiledMatcher | void {
+  const pattern: ExportNamedDeclaration = path.value
+
+  const importKind = (pattern as any).importKind || 'value'
+
+  const sourceMatcher = compileRelativeSourceMatcher(
+    path.get('source'),
+    compileOptions
+  )
+
+  return compileGenericNodeMatcher(path, compileOptions, {
+    keyMatchers: {
+      importKind: {
+        pattern: path.get('importKind') as any,
+        match: (
+          path: NodePath<any, any>,
+          matchSoFar: MatchResult
+        ): MatchResult => {
+          return (path.value || 'value') === importKind
+            ? matchSoFar || {}
+            : null
+        },
+      },
+      ...(sourceMatcher ? { source: sourceMatcher } : {}),
+    },
+  })
+}

src/compileMatcher/ImportExpression.ts

@@ -0,0 +1,20 @@
+import { ImportExpression, NodePath } from '../types'
+import { CompiledMatcher, CompileOptions } from '.'
+import compileGenericNodeMatcher from './GenericNodeMatcher'
+import { compileRelativeSourceMatcher } from './RelativeSource'
+
+export default function compileImportExpressionMatcher(
+  path: NodePath<ImportExpression, ImportExpression>,
+  compileOptions: CompileOptions
+): CompiledMatcher | void {
+  const sourceMatcher = compileRelativeSourceMatcher(
+    path.get('source'),
+    compileOptions
+  )
+
+  return compileGenericNodeMatcher(path, compileOptions, {
+    keyMatchers: {
+      ...(sourceMatcher ? { source: sourceMatcher } : {}),
+    },
+  })
+}

src/compileMatcher/index.ts

@@ -9,12 +9,15 @@ import ClassImplements from './ClassImplements'
 import ClassProperty from './ClassProperty'
 import compileGenericArrayMatcher from './GenericArrayMatcher'
 import compileGenericNodeMatcher from './GenericNodeMatcher'
+import ExportAllDeclaration from './ExportAllDeclaration'
+import ExportNamedDeclaration from './ExportNamedDeclaration'
 import ExportSpecifier from './ExportSpecifier'
 import ExpressionStatement from './ExpressionStatement'
 import FunctionTypeParam from './FunctionTypeParam'
 import GenericTypeAnnotation from './GenericTypeAnnotation'
 import Identifier from './Identifier'
 import ImportDeclaration from './ImportDeclaration'
+import ImportExpression from './ImportExpression'
 import ImportSpecifier from './ImportSpecifier'
 import JSXAttribute from './JSXAttribute'
 import JSXElement from './JSXElement'
@@ -139,12 +142,15 @@ const nodeMatchers: Record<
   CallExpression,
   ClassImplements,
   ClassProperty,
+  ExportAllDeclaration,
+  ExportNamedDeclaration,
   ExportSpecifier,
   ExpressionStatement,
   FunctionTypeParam,
   GenericTypeAnnotation,
   Identifier,
   ImportDeclaration,
+  ImportExpression,
   ImportSpecifier,
   JSXAttribute,
   JSXElement,

src/types.ts

@@ -104,6 +104,9 @@ export type CallExpression = b.CallExpression | k.CallExpressionKind
 export type ClassDeclaration = b.ClassImplements | k.ClassImplementsKind
 export type ClassImplements = b.ClassImplements | k.ClassImplementsKind
 export type ClassProperty = b.ClassProperty | k.ClassPropertyKind
+export type ExportAllDeclaration =
+  | b.ExportAllDeclaration
+  | k.ExportAllDeclarationKind
 export type ExportDeclaration = b.ExportDeclaration | k.ExportDeclarationKind
 export type ExportDefaultSpecifier =
   | b.ExportDefaultSpecifier
@@ -127,6 +130,7 @@ export type ImportDefaultSpecifier =
   | b.ImportDefaultSpecifier
   | k.ImportDefaultSpecifierKind
 export type ImportDeclaration = b.ImportDeclaration | k.ImportDeclarationKind
+export type ImportExpression = b.ImportExpression | k.ImportExpressionKind
 export type ImportNamespaceSpecifier =
   | b.ImportNamespaceSpecifier
   | k.ImportNamespaceSpecifierKind

test/findReplace/relativeExportAllMatch.ts

@@ -0,0 +1,20 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+import path from 'path'
+
+findReplaceTestcase({
+  file: __filename,
+  transformFile: path.resolve(__dirname, 'test/transform.ts'),
+  input: dedent`
+    export * from '../foo' 
+    export * from './foo' 
+  `,
+  find: dedent`
+    export * from '../../foo' 
+  `,
+  expectedFind: [
+    {
+      node: `export * from '../foo'`,
+    },
+  ],
+})

test/findReplace/relativeExportNamedMatch.ts

@@ -0,0 +1,21 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+import path from 'path'
+
+findReplaceTestcase({
+  file: __filename,
+  transformFile: path.resolve(__dirname, 'test/transform.ts'),
+  input: dedent`
+    export { a } from '../foo' 
+    export { b } from './foo' 
+  `,
+  find: dedent`
+    export { $$a } from '../../foo' 
+  `,
+  expectedFind: [
+    {
+      arrayCaptures: { $$a: ['a'] },
+      node: `export { a } from '../foo'`,
+    },
+  ],
+})

test/findReplace/relativeImportExpressionMatch.ts

@@ -0,0 +1,20 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+import path from 'path'
+
+findReplaceTestcase({
+  file: __filename,
+  transformFile: path.resolve(__dirname, 'test/transform.ts'),
+  input: dedent`
+    import('../foo')
+    import('./foo')
+  `,
+  find: dedent`
+    import('../../foo')
+  `,
+  expectedFind: [
+    {
+      node: `import('../foo')`,
+    },
+  ],
+})