ember-codemod-v1-to-v2 0.1.0

package/src/migration/ember-addon/steps/update-test-app-package-json.js

@@ -0,0 +1,85 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  convertToMap,
+  convertToObject,
+} from '../../../utils/convert-json-object.js';
+import { decideVersion } from '../../../utils/decide-version.js';
+
+function moveDependenciesToDevDependencies(packageJson, options) {
+  const { packages } = options;
+
+  const dependencies = convertToMap(packageJson['dependencies']);
+  const devDependencies = convertToMap(packageJson['devDependencies']);
+
+  const packagesToMove = packages.addon.hasTypeScript
+    ? [
+        'ember-auto-import',
+        'ember-cli-babel',
+        'ember-cli-htmlbars',
+        'ember-cli-typescript',
+      ]
+    : ['ember-auto-import', 'ember-cli-babel', 'ember-cli-htmlbars'];
+
+  packagesToMove.forEach((packageName) => {
+    const version = decideVersion(packageName, dependencies);
+
+    devDependencies.set(packageName, version);
+
+    dependencies.delete(packageName);
+  });
+
+  packageJson['dependencies'] = convertToObject(dependencies);
+  packageJson['devDependencies'] = convertToObject(devDependencies);
+}
+
+function updateDependencies(packageJson) {
+  const dependencies = convertToMap(packageJson['dependencies']);
+
+  // May be easier to start over and add missing dependencies
+  dependencies.clear();
+
+  packageJson['dependencies'] = convertToObject(dependencies);
+}
+
+function updateDevDependencies(packageJson, options) {
+  const { packages } = options;
+
+  const devDependencies = convertToMap(packageJson['devDependencies']);
+
+  devDependencies.set(packages.addon.name, packages.addon.version);
+
+  packageJson['devDependencies'] = convertToObject(devDependencies);
+}
+
+function updateOtherFields(packageJson, options) {
+  const { packages } = options;
+
+  delete packageJson['ember-addon'];
+
+  packageJson['keywords'] = packageJson['keywords'].filter((keyword) => {
+    return keyword !== 'ember-addon';
+  });
+
+  packageJson['name'] = packages.testApp.name;
+
+  packageJson['private'] = true;
+}
+
+export function updateTestAppPackageJson(options) {
+  const { locations, projectRoot } = options;
+
+  const oldPath = join(projectRoot, locations.testApp, 'package.json');
+  const oldFile = readFileSync(oldPath, 'utf8');
+  const packageJson = JSON.parse(oldFile);
+
+  moveDependenciesToDevDependencies(packageJson, options);
+  updateDependencies(packageJson);
+  updateDevDependencies(packageJson, options);
+  updateOtherFields(packageJson, options);
+
+  const newFile = JSON.stringify(packageJson, null, 2) + '\n';
+
+  writeFileSync(oldPath, newFile, 'utf8');
+}

package/src/migration/ember-addon/steps/update-test-app-tsconfig-json.js

@@ -0,0 +1,47 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  convertToMap,
+  convertToObject,
+} from '../../../utils/convert-json-object.js';
+
+function updateCompilerOptions(tsconfigJson, options) {
+  const { packages } = options;
+
+  const compilerOptions = convertToMap(tsconfigJson['compilerOptions']);
+
+  compilerOptions.set('paths', {
+    [`${packages.testApp.name}/tests/*`]: ['tests/*'],
+    [`${packages.testApp.name}/*`]: ['app/*'],
+    '*': ['types/*'],
+  });
+
+  tsconfigJson['compilerOptions'] = convertToObject(compilerOptions);
+}
+
+function updateInclude(tsconfigJson) {
+  tsconfigJson['include'] = ['app/**/*', 'tests/**/*', 'types/**/*'];
+}
+
+export function updateTestAppTsconfigJson(options) {
+  const { locations, packages, projectRoot } = options;
+
+  if (!packages.addon.hasTypeScript) {
+    return;
+  }
+
+  const oldPath = join(projectRoot, locations.testApp, 'tsconfig.json');
+  const oldFile = readFileSync(oldPath, 'utf8');
+  const tsconfigJson = JSON.parse(
+    // Remove comments
+    oldFile.replace(new RegExp('//.*', 'mg'), '')
+  );
+
+  updateCompilerOptions(tsconfigJson, options);
+  updateInclude(tsconfigJson);
+
+  const newFile = JSON.stringify(tsconfigJson, null, 2) + '\n';
+
+  writeFileSync(oldPath, newFile, 'utf8');
+}

package/src/migration/ember-addon/steps/use-relative-paths.js

@@ -0,0 +1,88 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+
+import glob from 'glob';
+
+function normalizeRelativePath(relativePath) {
+  if (!relativePath.startsWith('..')) {
+    return `./${relativePath}`;
+  }
+
+  return relativePath;
+}
+
+function updateFile(oldFile, { filePath, projectName, projectRoot }) {
+  const regex = new RegExp(`\\b${projectName}/(.*/)*(.*)\\b`, 'g');
+  const matchResults = [...oldFile.matchAll(regex)];
+
+  let newFile = oldFile;
+
+  matchResults.forEach((matchResult) => {
+    const [magicImportPath, remainingDirectories, fileName] = matchResult;
+
+    const from = dirname(filePath);
+    const to = join(projectRoot, remainingDirectories);
+
+    const relativePath = join(relative(from, to), fileName);
+    const trueImportPath = normalizeRelativePath(relativePath);
+
+    newFile = newFile.replace(magicImportPath, trueImportPath);
+  });
+
+  return newFile;
+}
+
+function useRelativePathInAddonFolder(options) {
+  const { packages, projectRoot } = options;
+
+  // File extensions had been specified, partly to encode assumptions
+  // about Ember, and partly to avoid corrupting non-text files
+  const filePaths = glob.sync('addon/**/*.{d.ts,js,ts}', {
+    cwd: projectRoot,
+    dot: true,
+    nodir: true,
+  });
+
+  filePaths.forEach((filePath) => {
+    const oldPath = join(projectRoot, filePath);
+    const oldFile = readFileSync(oldPath, 'utf8');
+
+    const newFile = updateFile(oldFile, {
+      filePath,
+      projectName: packages.addon.name,
+      projectRoot: 'addon',
+    });
+
+    writeFileSync(oldPath, newFile, 'utf8');
+  });
+}
+
+function useRelativePathInTestsDummyFolder(options) {
+  const { projectRoot } = options;
+
+  // File extensions had been specified, partly to encode assumptions
+  // about Ember, and partly to avoid corrupting non-text files
+  const filePaths = glob.sync('tests/dummy/**/*.{d.ts,js,ts}', {
+    cwd: projectRoot,
+    dot: true,
+    nodir: true,
+  });
+
+  filePaths.forEach((filePath) => {
+    const oldPath = join(projectRoot, filePath);
+    const oldFile = readFileSync(oldPath, 'utf8');
+
+    const newFile = updateFile(oldFile, {
+      filePath,
+      projectName: 'dummy',
+      projectRoot: 'tests/dummy/app',
+    });
+
+    writeFileSync(oldPath, newFile, 'utf8');
+  });
+}
+
+export function useRelativePaths(options) {
+  useRelativePathInAddonFolder(options);
+  useRelativePathInTestsDummyFolder(options);
+}

package/src/migration/index.js

@@ -0,0 +1 @@
+export * from './ember-addon/index.js';

package/src/utils/convert-json-object.js

@@ -0,0 +1,9 @@
+export function convertToMap(object = {}) {
+  return new Map(Object.entries(object));
+}
+
+export function convertToObject(map) {
+  const sortedMap = new Map([...map.entries()].sort());
+
+  return Object.fromEntries(sortedMap);
+}

package/src/utils/decide-version.js

@@ -0,0 +1,24 @@
+const latestVersions = new Map([
+  ['@babel/core', '7.20.12'],
+  ['@babel/plugin-proposal-class-properties', '7.18.6'],
+  ['@babel/plugin-proposal-decorators', '7.20.7'],
+  ['@babel/preset-typescript', '7.18.6'],
+  ['@embroider/addon-dev', '3.0.0'],
+  ['@embroider/addon-shim', '1.8.4'],
+  ['@rollup/plugin-babel', '6.0.3'],
+  ['concurrently', '7.6.0'],
+  ['ember-auto-import', '2.5.0'],
+  ['ember-cli-babel', '7.26.11'],
+  ['ember-cli-htmlbars', '6.1.11'],
+  ['prettier', '2.8.3'],
+  ['rollup', '3.10.0'],
+  ['rollup-plugin-copy', '3.4.0'],
+  ['rollup-plugin-ts', '3.1.1'],
+]);
+
+export function decideVersion(packageName, projectDependencies) {
+  const installedVersion = projectDependencies.get(packageName);
+  const latestVersion = `^${latestVersions.get(packageName)}`;
+
+  return installedVersion ?? latestVersion;
+}

package/src/utils/files.js

@@ -0,0 +1,88 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+
+function removeDirectoryIfEmpty({ oldPath, projectRoot }) {
+  const directories = dirname(oldPath).split('/');
+  const depth = directories.length;
+
+  for (let i = 0; i < depth; i++) {
+    const directory = join(projectRoot, ...directories);
+    const numFilesLeft = readdirSync(directory).length;
+
+    if (numFilesLeft > 0) {
+      continue;
+    }
+
+    rmSync(directory, { recursive: true });
+    directories.pop();
+  }
+}
+
+export function copyFiles(pathMapping, options) {
+  const { projectRoot } = options;
+
+  pathMapping.forEach((newPath, oldPath) => {
+    const oldAbsolutePath = join(projectRoot, oldPath);
+
+    const newAbsolutePath = join(projectRoot, newPath);
+    const newDirectory = dirname(newAbsolutePath);
+
+    if (!existsSync(newDirectory)) {
+      mkdirSync(newDirectory, { recursive: true });
+    }
+
+    copyFileSync(oldAbsolutePath, newAbsolutePath);
+  });
+}
+
+export function createFiles(fileMapping, options) {
+  const { projectRoot } = options;
+
+  fileMapping.forEach((file, newPath) => {
+    const newAbsolutePath = join(projectRoot, newPath);
+    const newDirectory = dirname(newAbsolutePath);
+
+    if (!existsSync(newDirectory)) {
+      mkdirSync(newDirectory, { recursive: true });
+    }
+
+    writeFileSync(newAbsolutePath, file, 'utf8');
+  });
+}
+
+export function moveFiles(pathMapping, options) {
+  const { projectRoot } = options;
+
+  pathMapping.forEach((newPath, oldPath) => {
+    const oldAbsolutePath = join(projectRoot, oldPath);
+
+    const newAbsolutePath = join(projectRoot, newPath);
+    const newDirectory = dirname(newAbsolutePath);
+
+    if (!existsSync(newDirectory)) {
+      mkdirSync(newDirectory, { recursive: true });
+    }
+
+    renameSync(oldAbsolutePath, newAbsolutePath);
+    removeDirectoryIfEmpty({ oldPath, projectRoot });
+  });
+}
+
+export function removeFiles(pathMapping, options) {
+  const { projectRoot } = options;
+
+  pathMapping.forEach((newPath, oldPath) => {
+    const oldAbsolutePath = join(projectRoot, oldPath);
+
+    rmSync(oldAbsolutePath);
+    removeDirectoryIfEmpty({ oldPath, projectRoot });
+  });
+}

package/src/utils/map-file-paths.js

@@ -0,0 +1,20 @@
+function changeDirectory(oldPath, from, to) {
+  if (!oldPath.startsWith(from)) {
+    throw new RangeError(
+      `The provided path \`${oldPath}\` does not start with \`${from}\`.`
+    );
+  }
+
+  const relativePath = oldPath.replace(new RegExp(`^${from}/`), '');
+  const newPath = `${to}/${relativePath}`;
+
+  return [oldPath, newPath];
+}
+
+export function mapFilePaths(filePaths, directory) {
+  const { from, to } = directory;
+
+  return new Map(
+    filePaths.map((filePath) => changeDirectory(filePath, from, to))
+  );
+}

package/src/utils/process-template.js

@@ -0,0 +1,12 @@
+/* https://github.com/ember-cli/ember-cli/blob/v4.9.2/lib/utilities/process-template.js */
+import template from 'lodash.template';
+
+export function processTemplate(content, context) {
+  const options = {
+    escape: /<%-([\s\S]+?)%>/g,
+    evaluate: /<%([\s\S]+?)%>/g,
+    interpolate: /<%=([\s\S]+?)%>/g,
+  };
+
+  return template(content, options)(context);
+}