Configuration d'outils pour la qualité du code

Lors du développement de ReadmeGenie, mon objectif était d'assurer une qualité de code cohérente avec une configuration automatisée pour le peluchage et le formatage. Après avoir envisagé plusieurs outils, j'ai sélectionné Ruff comme linter et Black comme formateur de code. Bien que Ruff puisse également gérer à la fois le peluchage et le formatage, j'ai décidé de configurer Black en tant que formateur distinct pour acquérir de l'expérience avec la configuration des deux outils. Ci-dessous, je vais partager pourquoi j'ai choisi ces outils, comment je les ai configurés pour mon projet, les défis que j'ai rencontrés et les leçons que j'ai apprises en cours de route.

---

1. Sélection des outils

Pourquoi Ruff ?

Ruff est un linter rapide pour Python qui prend en charge diverses règles de linting d'autres linters (comme Flake8 et Pyflakes) et offre des améliorations de performances significatives. Il est hautement personnalisable, ce qui m'a permis de spécifier un mélange de règles tout en assurant la compatibilité avec Black pour le formatage. La conception de Ruff en matière de rapidité et d'extensibilité est idéale pour les projets qui privilégient l'efficacité sans sacrifier la qualité.

• Documentation Ruff : https://github.com/charliermarsh/ruff

Pourquoi Noir ?

Black est un formateur Python qui applique strictement un style de formatage, contribuant ainsi à réduire les discussions et les incohérences sur le style du code. Bien que Ruff offre des capacités de formatage de base, l'approche dédiée de Black offre quelques avantages :

• Cohérence : Black applique un style strict et standard qui minimise les débats sur le formatage du code.

• Large adoption : Le noir est largement utilisé, ce qui facilite son intégration dans la plupart des flux de travail de développement, en particulier dans les projets collaboratifs.

• Documentation noire : https://github.com/psf/black

2. Configuration du projet

Pour m'assurer que Ruff et Black fonctionnent parfaitement dans ReadmeGenie, je les ai configurés à la fois dans pyproject.toml et
.pre-commit-config.yaml, permettant aux développeurs de formater et de lint automatiquement le code lors des validations.

Configuration pour Ruff et Black dans pyproject.toml

Cette configuration garantit que Ruff est utilisé uniquement pour le peluchage et Black pour le formatage :

# pyproject.toml
# Set up black as formatter
[tool.black]
line-length = 88
target-version = ["py311"]

# Set up ruff as linter only
[tool.ruff]
# Exclude directories that don’t need linting (e.g., virtual environments)
exclude = [
    "venv/",
    "__pycache__/"
]
fix = true


# Enable specific linting rules
select = ["F", "E", "W", "B", "I", "S"]  # Example codes: F=flake8, E=errors, W=warnings, B=bugbear, I=import, S=safety
# Exclude Black-compatible rules to avoid conflicts with Black's formatting.
ignore = ["E501", "E203", "E231"]  # Exclude Black-incompatible style issues

• ignorer : le noir gère un style spécifique, nous avons donc exclu ces règles dans Ruff.
• correctif : permet à Ruff de résoudre les problèmes lorsque cela est possible, en laissant le formatage à Black.

Ajout d'un crochet de pré-commit pour Ruff et Black

À l'aide de hooks de pré-commit, j'ai configuré .pre-commit-config.yaml pour appliquer le peluchage et le formatage à chaque commit :

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/psf/black
    rev: 23.1.0
    hooks:
      - id: black
  - repo: https://github.com/charliermarsh/ruff-pre-commit
    rev: v0.7.1
    hooks:
      - id: ruff

3. Exécuter Ruff et Black depuis la ligne de commande

Avec la configuration ci-dessus, vous pouvez utiliser les commandes suivantes :

• Exécuter Ruff :

# pyproject.toml
# Set up black as formatter
[tool.black]
line-length = 88
target-version = ["py311"]

# Set up ruff as linter only
[tool.ruff]
# Exclude directories that don’t need linting (e.g., virtual environments)
exclude = [
    "venv/",
    "__pycache__/"
]
fix = true


# Enable specific linting rules
select = ["F", "E", "W", "B", "I", "S"]  # Example codes: F=flake8, E=errors, W=warnings, B=bugbear, I=import, S=safety
# Exclude Black-compatible rules to avoid conflicts with Black's formatting.
ignore = ["E501", "E203", "E231"]  # Exclude Black-incompatible style issues

• Exécuter Noir :

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/psf/black
    rev: 23.1.0
    hooks:
      - id: black
  - repo: https://github.com/charliermarsh/ruff-pre-commit
    rev: v0.7.1
    hooks:
      - id: ruff

Ces commandes appliquent des correctifs à tous les fichiers Python, garantissant un style et des contrôles de qualité cohérents.

4. Intégration du code VS

Pour automatiser Ruff et Black lors de la sauvegarde, j'ai ajouté la configuration suivante dans .vscode/settings.json :

  ruff check . --fix

Cette configuration fait de Black le formateur par défaut et de Ruff le seul linter actif dans VS Code, permettant aux deux de s'exécuter
automatiquement lors de l'enregistrement.

5. Résultats et correctifs

Une fois configuré, Ruff et Black ont ​​identifié plusieurs problèmes :

• Longueur de la ligne (E501) : Ruff a initialement signalé les longues lignes, que Black a automatiquement formatées.
• Importations et variables inutilisées : Ruff a détecté plusieurs importations et variables inutilisées.
• Cohérence de l'indentation et du style : le noir applique un espacement et une indentation cohérents, améliorant ainsi la lisibilité.

6. Défis

Un défi notable consistait à comprendre que certains styles sont incompatibles entre Ruff et Black. Par exemple :

• Longueur de ligne (E501) : Ruff a initialement signalé de longues lignes dépassant 88 caractères, que Black gère en les enveloppant. lignes. Pour éviter les conflits, j'ai ajouté E501 à la liste des ignorés de Ruff. Malgré cela, Ruff signalait parfois des erreurs E501. si les Noirs n’appliquaient pas les points d’arrêt attendus. Ces écarts ont souligné l’importance d’ajuster les performances de chaque outil. configuration et compréhension des endroits où ils peuvent se chevaucher.

7. Leçons apprises

Utiliser Ruff et Black ensemble a été un excellent moyen d'améliorer la qualité du code. Voici ce que j'ai appris :

• Cohérence : le style opiniâtre de Black réduit l'ambiguïté dans le style du code.
• Automation : les hooks de pré-validation permettent de gagner du temps et garantissent un formatage cohérent.
• Intégration de l'éditeur : configuration de Ruff et Black pour qu'ils s'exécutent lors de la sauvegarde dans le développement rationalisé de VS Code.
• Compatibilité : Apprendre à résoudre des conflits comme E501 m'a appris les configurations des outils et m'a aidé affiner les flux de travail du projet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!