Portamos el proyecto Angular en ESLint, con Prettier, Husky y lint-staged

Hola Habr! Mi nombre es Bogdan, trabajo en el equipo de PIC Digital Front-End. Estamos desarrollando la mayoría de los proyectos en Angular, y recientemente decidí revisar nuestras guías de estilo, así como agregar nuevas herramientas para un trabajo más conveniente.

Como intérprete, decidí usar ESLint, ya que planean transferir Angular pronto. Y en este artículo quiero compartir instrucciones sobre cómo cambiar de TSLint a ESLint y, al mismo tiempo, decir cómo ejecutar Prettier desde ESLint, cómo agregar reglas de guía de estilo AirBnB y cómo hacer que el linting sea conveniente e invisible configurando VS Code y Git Hooks.

Más bonita y ESLint


ESLint es una herramienta para el análisis de código estático, las reglas se dividen en dos grupos:

  • Formateo : para llevar el código a una vista: longitudes de línea, comas, punto y coma, etc.
  • Calidad del código : búsqueda de plantillas de código problemáticas: código innecesario, errores.

Prettier es una herramienta automática de formateo de código.

La pregunta que me interesó fue: ¿por qué usar Prettier si ESLint también puede formatear código?

La respuesta es simple: Prettier formatea el código mucho mejor: elimina todo el formato y reescribe completamente el código en un solo estilo. Esto permite a los desarrolladores olvidarse del formato del código y no perder el tiempo discutiendo el estilo del código para su revisión. Por ejemplo, tenemos una larga línea de código:

imagen

si intentamos cambiar el formato a través de ESLint, simplemente nos dará un error:

eslint example.ts --fix

output:
error    This line has a length of 97. Maximum allowed is 80

Tal ejemplo muestra que linter no siempre puede ayudar con el formateo del código, y los desarrolladores pueden formatear este código de diferentes maneras, según sus consideraciones personales.

Si guardamos o formateamos el archivo con Prettier, la línea tomará la forma:

imagen

Prettier proporciona un estilo uniforme en toda la base del código. Por lo tanto, puede y debe usarse junto con ESLint, pero debe configurarlos para que no interfieran entre sí.

Configuración de ESLint


La esencia del linting usando ESLint está en los analizadores que transforman el código en AST (Árbol de sintaxis abstracta) para el procesamiento posterior del software, y complementos que contienen reglas, por ejemplo, reglas recomendadas para el linchado TypeScript o las reglas de guía de códigos AirBnB.

Instalación


Para migrar una aplicación angular a ESLint, necesitamos las siguientes dependencias:


Para instalarlos, simplemente ejecute el comando:

ng add @angular-eslint/schematics

En el momento de la escritura, typecript-eslint y angular-eslint no tienen todos los equivalentes para las reglas en la configuración estándar de Codelyzer para TSLint, pero la mayoría de ellas ya existen. Puede supervisar el estado actual de la transferencia de reglas de TSLint a ESLint en los mono-repositorios Angular ESLint y TypeScript ESLint .

Configuración


Instalamos todo lo que necesitamos para conectar aplicaciones angulares. Ahora pasemos a configurar ESLint. Creemos un archivo .eslintrc.js y agreguemos la configuración recomendada para Angular ESLint:

module.exports = {
  extends: ['plugin:@angular-eslint/recommended'],
  rules: {
    '@angular-eslint/directive-selector': [
      'error',
      { type: 'attribute', prefix: 'app', style: 'camelCase' },
    ],
    '@angular-eslint/component-selector': [
      'error',
      { type: 'element', prefix: 'app', style: 'kebab-case' },
    ],
  },
  overrides: [
    //   ,       *.component.ts
    {
      files: ['*.component.ts'],
      parser: '@typescript-eslint/parser',
      parserOptions: {
        ecmaVersion: 2020,
        sourceType: 'module',
      },
      plugins: ['@angular-eslint/template'],
      processor: '@angular-eslint/template/extract-inline-html',
    },
  ],
};

Las configuraciones se pueden describir en diferentes formatos: JavaScript, JSON o archivo YAML. Puedes dejar comentarios en JavaScript.

"Complemento: @ angular-eslint / recomendado" contiene configuraciones para 3 complementos a la vez: "@ typescript-eslint / eslint-plugin", "@ angular-eslint / eslint-plugin" y "@ angular-eslint / eslint-plugin-template " Puedes leer qué reglas establece aquí .

Actualización del comando ng lint


También en la configuración angular.json, debe actualizar el comando ng lint para ejecutar @ angular-eslint / builder :

"lint": {
  "builder": "@angular-eslint/builder:lint",
  "options": {
    "eslintConfig": ".eslintrc.js",
    "tsConfig": [
      "tsconfig.app.json",
      "tsconfig.spec.json",
      "e2e/tsconfig.json"
    ],
    "exclude": [
      "**/node_modules/**"
    ]
  }
},

La configuración básica de ESLint está lista, ahora puede iniciar ESLint con el comando estándar ng lint .

Instalar complementos adicionales


Para instalar el complemento para ESLint, por ejemplo, para pruebas de unidad de linting en Angular, debe descargar y agregar el complemento Jasmine a la configuración :

npm install eslint-plugin-jasmine --save-dev

Y agregue un nuevo bloque de configuración para archivos con la extensión * .spec.ts a la propiedad "overrides":

overrides: [
  ...,
  {
    files: ['src/**/*.spec.ts', 'src/**/*.d.ts'],
    parserOptions: {
      project: './src/tsconfig.spec.json',
    },
    //   
    extends: ['plugin:jasmine/recommended'],
    //    
    plugins: ['jasmine'],
    env: { jasmine: true },
    //   'no-unused-vars'
    rules: {
      '@typescript-eslint/no-unused-vars': 'off',
    },
  }
],

Por analogía, puede agregar otros complementos para diferentes extensiones de archivo.

Agregar guías de guía de estilo


Para lograr una mayor coherencia de la base del código, puede seleccionar y agregar las reglas de una de las guías de estilo populares a la configuración de ESLint:

  • AirBnB : el más popular y estricto de los tres, comas y puntos y comas finales obligatorios.
  • Google : similar a AirBnB en términos de formato, pero menos estrictos, comentarios obligatorios de JSDoc.
  • StandartJS : prohíbe el uso de comas y punto y coma al final.

Elija una guía de estilo que sea más adecuada para su equipo. Puede turnarse para probar todas las guías de estilo en algún proyecto grande, ver qué errores produce el linter y, en función de esto, tomar una decisión.

Elija una implementación de la guía de estilo TypeScript porque las reglas de JavaScript pueden no funcionar correctamente en TypeScript.

Como ejemplo, agreguemos la guía de estilo AirBnB a nuestra configuración de ESLint. Para hacer esto, instale la configuración con las reglas de AirBnB para TypeScript y el complemento con reglas para trabajar con la sintaxis de importación / exportación:

npm install eslint-plugin-import eslint-config-airbnb-typescript --save-dev

Para no cambiar la configuración de nivel superior, crearemos un nuevo bloque de reglas en la propiedad "anulaciones" con las reglas de la guía de estilo AirBnB y el analizador de TypeScript necesarios para su trabajo:

module.exports = {
  ...,
  overrides: [
    ...,
    {
      files: ['*.ts'],
      extends: [
        'airbnb-typescript/base',
      ],
      parser: '@typescript-eslint/parser',
      parserOptions: {
        ecmaVersion: 2020,
        sourceType: 'module',
      },
    },
  ]
}

Para agregar otra guía de estilo, debe instalar un conjunto de reglas para TypeScript, crear un nuevo bloque de reglas en "anulaciones" con las reglas de la guía de estilo y especificar el analizador necesario para su trabajo.

Reglas de personalización


Si desea deshabilitar o redefinir algunas reglas en el estilo de la guía, puede hacerlo en la propiedad "reglas":

module.exports = {
  ...,
  overrides: [
    ...,
    {
      files: ['*.ts'],
      extends: [
        'airbnb-typescript/base',
      ],
      parser: '@typescript-eslint/parser',
      parserOptions: {
        ecmaVersion: 2020,
        sourceType: 'module',
      },
      //  
      rules: {
        'import/no-unresolved': 'off',
        'import/prefer-default-export': 'off',
        'class-methods-use-this': 'off',
        'lines-between-class-members': 'off',
        '@typescript-eslint/unbound-method': [
          'error',
          {
            ignoreStatic: true,
          },
        ],
      },
    },
  ]
}


Configurar más bonito


Para agregar Prettier a nuestra configuración, necesitamos instalar Prettier, un complemento con reglas de Prettier, así como una configuración que deshabilitará todas las reglas que puedan entrar en conflicto con Prettier:

npm i prettier eslint-config-prettier eslint-plugin-prettier --save-dev

En las "anulaciones" en el bloque con las reglas de los archivos con la extensión * .ts en la propiedad "extiende" en la parte inferior, agregue las reglas y la configuración más bonita:

module.exports = {
  ...,
  overrides: [
    ...,
    {
      files: ['*.ts'],
      extends: [
        //   AirBnB
	'airbnb-typescript/base',
	//   Prettier
	'prettier/@typescript-eslint',
	'plugin:prettier/recommended',
      ],
      ...,
    },
  ]
}

La configuración de Prettier siempre debe estar al final de la lista para sobrescribir cualquier regla que pueda entrar en conflicto con Prettier.

`prettier / @ typescript-eslint` deshabilita las reglas` @ typescript-eslint`, que pueden entrar en conflicto con Prettier, y `plugin: prettier / recomendado` hace tres cosas:

  • incluye eslint-plugin-prettier,
  • imprime errores de regla más bonitos / más bonitos en la consola como "error",
  • Agrega las reglas de formato Prettier eslint-config-prettier.

Configuración para Prettier:


Prettier puede formatear el código sin ninguna configuración, pero para que coincida con la guía de estilo de AirBnB, debe agregar algunas configuraciones. Cree el archivo .prettierrc.js en la raíz de la aplicación:

module.exports = {
  trailingComma: "all",
  tabWidth: 2,
  semi: true,
  singleQuote: true,
  bracketSpacing: true,
  printWidth: 100
};

ESLint y Prettier usarán esta configuración si la usa para formatear archivos en VS Code o con el comando:

prettier "--write ."

Configurar código VS


VS Code puede resaltar y corregir los errores encontrados de ESLint al guardar errores. Para hacer esto, descargue el complemento ESLint para VS Code y cree un archivo dentro del proyecto con la configuración para el espacio de trabajo .vscode / settings.json:

  "eslint.validate": [ "javascript", "typescript", "html"],

  "eslint.options": {
    "extensions": [".js", ".ts", "html"]
  },

  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true,
  },

Aquí configuramos ESLint para enfatizar y corregir errores al guardar archivos con las extensiones .js, .ts y .html.

Y para formatear un documento utilizando las combinaciones de teclas "shift + opción + F" o "shift + alt + F", descargue el complemento Prettier para VS Code y configúrelo como el formateador predeterminado.

Configurar ganchos git


Los ganchos de Git son scripts que Git invoca en ciertos eventos: confirmar, enviar, recibir.

Con la ayuda de ellos, podemos comenzar a alinear el código al crear una confirmación para que se introduzcan menos errores en el grupo de solicitudes. Para el trabajo más cómodo con ganchos de Git, instalar Husky , y para comprobar solamente el código que se añade a la confirmación (esto es útil en grandes proyectos en los que linting lleva mucho tiempo) pelusa-etapas :

npm i husky lint-staged --save-dev

Agregue la configuración de estos complementos a package.json:

"scripts": {
  ...
},
"husky": {
  "hooks": {
    "pre-commit": "lint-staged --relative"
  }
},
"lint-staged": {
  "*.{js,ts}": [
     "eslint --fix"
  ]
},

lint-staged pasa una matriz de archivos modificados al comando llamado. El comando ng lint no sabe cómo aceptar una matriz de archivos, y para usarlo, debe escribir un controlador de script adicional. O simplemente puede llamar a ESLint, como en este ejemplo. Dicha solución se puede utilizar para los compromisos previos, y puede ejecutar ng lint para alinear todo el proyecto, por ejemplo, en la canalización de CI.

recomendaciones


En futuras versiones de Angular, ESLint con reglas básicas estará listo para usar. Ahora el proceso de configuración de ESLint requiere algunos pasos adicionales, ESLint no tiene equivalentes para algunas reglas de TSLint y Angular ESLint todavía está en versión alfa. Por lo tanto, cambiar a ESLint ahora o no depende de usted.

Sin embargo, el código de guía, las reglas adicionales, Prettier, Husky y pelusa tendrán que configurarlo usted mismo. Espero que este artículo te haya ayudado a descubrir cómo funcionan todas estas cosas juntas.

La configuración de linters puede parecer una tarea trivial, pero incluye varios problemas organizativos importantes: elegir guías de estilo, sincronizar diferentes soluciones entre sí.

Pero el tiempo dedicado a configurar el linter en el futuro le ahorrará significativamente tiempo para discutir el estilo y el formato del código en el proceso de revisión del código, reducirá la cantidad de errores que se incluyen en el grupo de solicitudes y garantizará la coherencia de la base del código.

Un ejemplo de implementación se puede encontrar en Github .

Si encuentra un error en la configuración o tiene complementos, ¡escriba!

Referencias



All Articles