@toptal/davinci-syntax 14.0.9-alpha-fx-try-engines-version-dependency.7 → 15.0.0

package/src/__tests__/eslint.test.ts

@@ -0,0 +1,347 @@
+/* eslint-disable max-lines */
+import path from 'path'
+import { ESLint, Linter } from 'eslint'
+import json5 from 'json5'
+
+const getConfig = () => {
+  const pathToEslintrc = path.join(__dirname, '../../src/configs/.eslintrc')
+
+  return new ESLint({
+    useEslintrc: false, // don't use any other eslintrc files (higher in the folder tree)
+    overrideConfigFile: pathToEslintrc, // use this exact eslintrc file
+  }).calculateConfigForFile(pathToEslintrc)
+}
+
+// Eslint config file snapshot file to prevent unexpected updates
+describe('eslint config', () => {
+  let fileConfig: Record<string, unknown>
+
+  beforeAll(async () => {
+    fileConfig = await getConfig()
+  })
+
+  it('verifies eslint rules are not updated silently', () => {
+    const serializedRules = json5.stringify(fileConfig.rules, null, 2)
+
+    expect(serializedRules).toMatchSnapshot()
+  })
+})
+
+/* eslint-disable max-statements */
+/* eslint-disable max-lines-per-function */
+// Testing basic rules with the davinci eslint
+describe('eslint rules', () => {
+  let engine: ESLint
+
+  beforeAll(async () => {
+    engine = new ESLint({ baseConfig: await getConfig() })
+  })
+
+  const findMessage = (ruleId: string, results: ESLint.LintResult[]) => {
+    return results.reduce<Linter.LintMessage | undefined>(
+      (_, result) => result.messages.find(message => message.ruleId === ruleId),
+      undefined
+    )
+  }
+
+  interface TestRulesArgs {
+    ruleId: string
+    validCases?: string[]
+    invalidCases?: string[]
+  }
+
+  const testRule = ({
+    ruleId,
+    validCases = [],
+    invalidCases = [],
+  }: TestRulesArgs) => {
+    it(`verifies that ${ruleId} works`, async () => {
+      for (const validText of validCases) {
+        const results = await engine.lintText(validText)
+
+        expect(findMessage(ruleId, results)).toBeUndefined()
+      }
+
+      for (const invalidText of invalidCases) {
+        const results = await engine.lintText(invalidText)
+
+        expect(findMessage(ruleId, results)).toBeDefined()
+      }
+    })
+  }
+
+  testRule({
+    ruleId: '@typescript-eslint/space-before-function-paren',
+    invalidCases: [
+      'function withoutSpace (x) {}',
+      'var anonymousWithoutSpace = function() {};',
+    ],
+    validCases: [
+      'function withoutSpace(x) {}',
+      'var anonymousWithoutSpace = function () {};',
+      'var anonymousWithoutSpace = function <T>() {};',
+    ],
+  })
+
+  testRule({
+    ruleId: 'padding-line-between-statements',
+    invalidCases: [
+      `
+        function foo() {
+          bar();
+          return;
+        }
+        `,
+    ],
+    validCases: [
+      `
+        function foo() {
+          bar();
+
+          return;
+        }
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'prefer-const',
+    invalidCases: [
+      `
+        let a = 3
+        console.log(a)
+        `,
+    ],
+    validCases: [
+      `
+        let a = 3
+        a = 0
+        console.log(a)
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'id-length',
+    invalidCases: ['const x = 5'],
+    validCases: [
+      'var ok = 5',
+      'const foo = { ok: 1 }',
+      `const _ = 'unused'`,
+      `
+        try {
+          throw new Error();
+        } catch (e) {
+          console.error(e)
+        }
+        `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'quotes',
+    invalidCases: ['const foo = "bar"'],
+    validCases: [`const foo = 'bar'`],
+  })
+
+  testRule({
+    ruleId: 'no-else-return',
+    invalidCases: [
+      `
+      function foo() {
+        if (x) {
+            return y
+        } else {
+            return z
+        }
+      }
+      `,
+    ],
+    validCases: [
+      `
+      function foo() {
+        if (x) {
+            return y
+        }
+
+        return z
+      }
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'import/no-extraneous-dependencies',
+    invalidCases: [`import { ESLint } from 'eslint'`],
+    validCases: [`import fs from 'fs'`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/array-type',
+    invalidCases: [`const foo: Array<string> = ['a', 'b']`],
+    validCases: [`const foo: string[] = ['a', 'b']`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/explicit-function-return-type',
+    validCases: [`const foo = (): number => 1`, `const foo = () => 1`],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-use-before-define',
+    invalidCases: [
+      `
+      foo()
+
+      const foo = () => {}
+      `,
+    ],
+    validCases: [
+      `
+      const foo = () => {}
+      
+      foo()
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-unused-vars',
+    invalidCases: ['const foo = 1'],
+    validCases: [
+      `
+      const foo = 1
+      
+      console.log(foo)
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/func-call-spacing',
+    invalidCases: ['foo ()', 'foo<T> ()'],
+    validCases: ['foo()', 'foo<T>()'],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/no-unused-expressions',
+    invalidCases: ['if (0) null'],
+    validCases: ['if (0) return null'],
+  })
+
+  testRule({
+    ruleId: '@typescript-eslint/ban-types',
+    invalidCases: [`const foo: String = 'foo'`, 'const foo: Number = 1'],
+    validCases: [
+      'const foo: Function = () => 1',
+      'const foo: object = {}',
+      'const foo: {} = {}',
+    ],
+  })
+
+  testRule({
+    ruleId: 'func-style',
+    invalidCases: ['function foo() {}'],
+    validCases: ['const foo = function() {}'],
+  })
+
+  testRule({
+    ruleId: 'curly',
+    invalidCases: ['if (foo) foo++'],
+    validCases: ['if (foo) { foo++ }'],
+  })
+
+  testRule({
+    ruleId: 'todo-plz/ticket-ref',
+    invalidCases: [
+      '// TODO:',
+      '// TODO: lorem',
+      '// TODO :',
+      '// TODO: [FX-]',
+      '// TODO: [-000]',
+      '// TODO: [-AAA]',
+      '// TODO [FX-000]',
+      '// TODO:[FX-000]',
+      '// TODO: FX-000',
+      '// TODO: lorem FX-000 ipsum',
+      `/**
+        * TODO:
+        */`,
+      `/**
+        * TODO: lorem
+        */`,
+    ],
+    validCases: [
+      '// TODO: [FX-000]',
+      '// TODO: [SPC-000]',
+      '// TODO: [FX-000] [SPC-000]',
+      '// TODO: [FX-000], [SPC-000]',
+      '// TODO: [FX-000], [SPC-000],',
+      '// TODO: [FX-000] [SPC-000],',
+      '// TODO: lorem [FX-000] [SPC-000],',
+      '// TODO: [FX-000] [SPC-000], lorem',
+      `/**
+        * TODO: [FX-000] lorem
+        */`,
+      `/**
+        * TODO: lorem [FX-000] ipsum
+        */`,
+      `/**
+        * TODO: lorem ipsum
+        * lorem [FX-000]
+        */`,
+      `/**
+        * TODO: lorem ipsum
+        * [FX-000]
+        */`,
+    ],
+  })
+
+  testRule({
+    ruleId: 'unused-imports/no-unused-imports',
+    invalidCases: [
+      `import { unusedImport } from 'something'`,
+      `import { unusedImport1, unusedImport2 } from 'something'`,
+    ],
+    validCases: [
+      `import { something } from 'something'
+      const c = something.usintThis()
+      `,
+    ],
+  })
+
+  testRule({
+    ruleId: 'import/no-duplicates',
+    invalidCases: [
+      `import { component1 } from 'module1';
+       import { component2 } from 'module1';`,
+      `import component1 from 'module1';
+       import { component2 } from 'module1';`,
+    ],
+    validCases: [
+      `import { component1, component2 } from 'module1';
+       import component3 from 'module2';`,
+      `import { component1 } from 'module';
+       import * as component2 from 'module';`,
+      `import { component1 } from 'module';
+       export { component2 } from 'module';`,
+      `import { component1, component2 } from 'module';
+       export * as component3 from 'module';
+       export * from 'module';`,
+      `import component1, * as component2 from './module'
+       import type componentType1 from './module'`,
+    ],
+  })
+})

package/src/__tests__/no-relative-packages.test.js

@@ -0,0 +1,107 @@
+import { RuleTester } from 'eslint'
+import path from 'path'
+import rule from 'eslint-plugin-import/lib/rules/no-relative-packages'
+
+const testFilePath = relativePath =>
+  path.join(__dirname, '/eslint-package-structure', relativePath)
+
+const FILENAME = testFilePath('foo.js')
+
+const testRule = options => ({
+  filename: FILENAME,
+  parserOptions: {
+    sourceType: 'module',
+    ecmaVersion: 9,
+    ...options.parserOptions,
+  },
+  ...options,
+})
+
+const ruleTester = new RuleTester()
+
+ruleTester.run('no-relative-packages', rule, {
+  valid: [
+    testRule({
+      code: 'import foo from "./index.js"',
+      filename: testFilePath('./package/index.js'),
+    }),
+    /**
+     * Unfortunately, this case is considered valid for the rule,
+     * but we cannot influence this. This case should be considered invalid.
+     *
+     * testRule({
+     *  code: 'import bar from "../bar"',
+     *  filename: testFilePath('./package/index.js')
+     * }),
+     */
+    testRule({
+      code: 'import { foo } from "a"',
+      filename: testFilePath('./package-named/index.js'),
+    }),
+    testRule({
+      code: 'const bar = require("../bar.js")',
+      filename: testFilePath('./package/index.js'),
+    }),
+    testRule({
+      code: 'import "package"',
+      filename: testFilePath('./package/index.js'),
+    }),
+    testRule({
+      code: 'require("../bar.js")',
+      filename: testFilePath('./package/index.js'),
+    }),
+  ],
+  invalid: [
+    testRule({
+      code: 'import foo from "./package-named"',
+      filename: testFilePath('./bar.js'),
+      errors: [
+        {
+          message:
+            'Relative import from another package is not allowed. Use `package-named` instead of `./package-named`',
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "package-named"',
+    }),
+    testRule({
+      code: 'import foo from "../package-named"',
+      filename: testFilePath('./package/index.js'),
+      errors: [
+        {
+          message:
+            'Relative import from another package is not allowed. Use `package-named` instead of `../package-named`',
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "package-named"',
+    }),
+    testRule({
+      code: 'import foo from "../package-scoped"',
+      filename: testFilePath('./package/index.js'),
+      errors: [
+        {
+          message: `Relative import from another package is not allowed. Use \`@scope/package-named\` instead of \`../package-scoped\``,
+          line: 1,
+          column: 17,
+        },
+      ],
+      output: 'import foo from "@scope/package-named"',
+    }),
+    testRule({
+      code: 'import bar from "../bar"',
+      filename: testFilePath('./package-named/index.js'),
+      errors: [
+        {
+          message: `Relative import from another package is not allowed. Use \`@toptal/davinci-syntax/src/__tests__/eslint-package-structure/bar\` instead of \`../bar\``,
+          line: 1,
+          column: 17,
+        },
+      ],
+      output:
+        'import bar from "@toptal/davinci-syntax/src/__tests__/eslint-package-structure/bar"',
+    }),
+  ],
+})

package/src/index.js

@@ -1,11 +1,9 @@
-const initCommandCreator = require('./commands/init')
 const lintCodeCommandCreator = require('./commands/lint-code')
 const lintStylesCommandCreator = require('./commands/lint-styles')
 const lintDirsCommandCreator = require('./commands/lint-dirs')
 
 module.exports = {
   commands: [
-    initCommandCreator,
     lintCodeCommandCreator,
     lintStylesCommandCreator,
     lintDirsCommandCreator,

package/src/commands/init.js

@@ -1,183 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const { print, prompt } = require('@toptal/davinci-cli-shared')
-
-const copyConfigFile = async ({
-  copyFromFile,
-  copyToFile,
-  promptName,
-  promptText,
-}) => {
-  if (fs.existsSync(copyToFile)) {
-    const shouldRewrite = await prompt.confirm(promptName, promptText)
-
-    if (!shouldRewrite) {
-      return
-    }
-  }
-
-  fs.copyFileSync(copyFromFile, copyToFile)
-}
-
-const copyLintConfigFile = (rootDir, currentRunningDir) => {
-  return copyConfigFile({
-    copyFromFile: path.join(rootDir, './src/configs/to-copy/root.eslintrc'),
-    copyToFile: path.join(currentRunningDir, './.eslintrc'),
-    promptName: 'eslintrc',
-    promptText: 'Do you want to override your existing .eslintrc file?',
-  })
-}
-
-const copyLintIgnoreFile = (rootDir, currentRunningDir) => {
-  return copyConfigFile({
-    copyFromFile: path.join(rootDir, './src/configs/to-copy/root.eslintignore'),
-    copyToFile: path.join(currentRunningDir, './.eslintignore'),
-    promptName: 'eslintignore',
-    promptText: 'Do you want to override your existing .eslintignore file?',
-  })
-}
-
-const copyPrettierConfigFile = (rootDir, currentRunningDir) => {
-  return copyConfigFile({
-    copyFromFile: path.join(
-      rootDir,
-      './src/configs/to-copy/root.prettierrc.js'
-    ),
-    copyToFile: path.join(currentRunningDir, './.prettierrc.js'),
-    promptName: 'prettierrc',
-    promptText: 'Do you want to override your existing .prettierrc.js file?',
-  })
-}
-
-const copyEditorConfigFile = (rootDir, currentRunningDir) => {
-  return copyConfigFile({
-    copyFromFile: path.join(rootDir, './src/configs/to-copy/root.editorconfig'),
-    copyToFile: path.join(currentRunningDir, './.editorconfig'),
-    promptName: 'editorconfig',
-    promptText: 'Do you want to override your existing .editorconfig file?',
-  })
-}
-
-const copyStylelintConfigFile = (rootDir, currentRunningDir) => {
-  return copyConfigFile({
-    copyFromFile: path.join(rootDir, './src/configs/to-copy/root.stylelintrc'),
-    copyToFile: path.join(currentRunningDir, './.stylelintrc'),
-    promptName: 'stylelintrc',
-    promptText: 'Do you want to override your existing .stylelintrc file?',
-  })
-}
-
-const checkPackageJsonExists = currentRunningDir => {
-  const packageJsonFile = path.join(currentRunningDir, './package.json')
-
-  if (!fs.existsSync(packageJsonFile)) {
-    print.red(
-      'You should run `npm init` in your repo before running davinci-syntax init.'
-    )
-
-    return false
-  }
-
-  return true
-}
-
-const addLintCommands = async currentRunningDir => {
-  const packageJsonFile = path.join(currentRunningDir, './package.json')
-
-  const configData = fs.readFileSync(packageJsonFile)
-  const config = JSON.parse(configData)
-
-  const lintCommand = config.scripts && config.scripts.lint
-
-  if (lintCommand) {
-    const shouldRewrite = await prompt.confirm(
-      'lintCommand',
-      'You have already a lint command in you package.json. Do you want to override it?'
-    )
-
-    if (!shouldRewrite) {
-      return
-    }
-  }
-
-  // add scripts lint command
-  config.scripts.lint =
-    'davinci-syntax lint code . && davinci-syntax lint styles .'
-
-  const modifiedConfigData = JSON.stringify(config, null, 2).concat('\n')
-
-  fs.writeFileSync(packageJsonFile, modifiedConfigData)
-}
-
-const addLintStagedCommands = async currentRunningDir => {
-  const packageJsonFile = path.join(currentRunningDir, './package.json')
-
-  const configData = fs.readFileSync(packageJsonFile)
-  const config = JSON.parse(configData)
-
-  const lintStagedCommand = config.husky || config['lint-staged']
-
-  if (lintStagedCommand) {
-    const shouldRewrite = await prompt.confirm(
-      'lintStagedCommand',
-      'You have already a husky or lint-staged in you package.json. Do you want still to override them?'
-    )
-
-    if (!shouldRewrite) {
-      return
-    }
-  }
-
-  // add lint-staged
-  config['lint-staged'] = {
-    '*.{js,jsx,ts,tsx}': ['davinci-syntax lint code', 'prettier', 'git add'],
-    'styles.{js,jsx,ts,tsx}': [
-      'davinci syntax lint styles',
-      'prettier',
-      'git add',
-    ],
-  }
-  // add husky
-  config.husky = {
-    hooks: {
-      'pre-commit': 'lint-staged',
-    },
-  }
-
-  const modifiedConfigData = JSON.stringify(config, null, 2).concat('\n')
-
-  fs.writeFileSync(packageJsonFile, modifiedConfigData)
-}
-
-const initCommand = async () => {
-  print.green('Initializing syntax package...')
-
-  const currentRunningDir = process.cwd()
-  const rootDir = path.join(__dirname, '../..')
-
-  try {
-    await copyLintConfigFile(rootDir, currentRunningDir)
-    await copyLintIgnoreFile(rootDir, currentRunningDir)
-    await copyPrettierConfigFile(rootDir, currentRunningDir)
-    await copyStylelintConfigFile(rootDir, currentRunningDir)
-    await copyEditorConfigFile(rootDir, currentRunningDir)
-
-    if (checkPackageJsonExists(currentRunningDir)) {
-      await addLintCommands(currentRunningDir)
-      await addLintStagedCommands(currentRunningDir)
-    }
-  } finally {
-    // eslint-disable-next-line
-    console.log('Done.')
-  }
-}
-
-const initCommandCreator = {
-  action: () => {
-    initCommand()
-  },
-  command: 'init',
-  description: 'Init the syntax package',
-}
-
-module.exports = initCommandCreator

package/src/configs/to-copy/root.editorconfig

@@ -1,15 +0,0 @@
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-# Consistent 2 space indentation
-[*]
-indent_style = space
-indent_size = 2
-
-[*.ejs.t]
-insert_final_newline = false

package/src/configs/to-copy/root.eslintignore

@@ -1,2 +0,0 @@
-/build
-/node_modules

package/src/configs/to-copy/root.eslintrc

@@ -1,3 +0,0 @@
-{
-  "extends": "./node_modules/@toptal/davinci-syntax/src/configs/.eslintrc"
-}

package/src/configs/to-copy/root.prettierrc.js

@@ -1,3 +0,0 @@
-module.exports = {
-  ...require('@toptal/davinci-syntax/src/configs/.prettierrc.js'),
-}

package/src/configs/to-copy/root.stylelintrc

@@ -1,3 +0,0 @@
-{
-  "extends": "./node_modules/@toptal/davinci-syntax/src/configs/.stylelintrc"
-}