9  Développement de Package R dans VSCode

Mots clés

Développement de packages R, VSCode pour R packages, Roxygen2 dans VSCode, devtools pour les packages R

9.1 Introduction

Le développement de packages R est un aspect clé du partage de code R réutilisable et de l’amélioration de vos compétences en programmation. Visual Studio Code (VSCode) fournit un environnement rationalisé qui rend le développement de packages efficace et intuitif. Avec les bonnes extensions et les bons configurateurs, VSCode peut supporter tous les aspects de la création d’un package R, de l’écriture de fonctions à la documentation et aux tests. Dans ce chapitre, nous allons explorer comment utiliser VSCode pour développer des packages R.



9.2 Prérequis

  • Installer les outils essentiels pour la programmation R dans VSCode comme indiqué dans les chapitres précédents (Chapitre 2 et Chapitre 3).

  • Assurez-vous d’avoir les paquets devtools et roxygen2 installés dans R pour le développement du package. Sinon, installez-les en utilisant:

    install.packages("devtools")
install.packages("roxygen2")
Note

Notez que devtools est un package de développement qui simplifie la création, la documentation et le test des packages, tandis que roxygen2 est utilisé pour documenter les fonctions.

9.3 Créer un nouveau package R

Suivez les étapes suivantes:

  1. Créez un répertoire de package : Utilisez la fonction create() de devtools pour configurer une nouvelle structure de package. Exécutez ce qui suit dans un terminal R:

    devtools::create("path/to/your/package")

    Cette fonction créera un répertoire avec la structure nécessaire pour un package R, incluant des dossiers comme R/ pour les fonctions et man/ pour la documentation.

  2. Ouvrir le répertoire dans VSCode : Dans VSCode, cliquez sur File > Open Folder... et sélectionnez le répertoire du package. Cela vous permet d’éditer les fichiers de votre package, d’ajouter des fonctions et d’écrire de la documentation.

9.4 Écrire des fonctions et de la documentation

Une fois que la structure de votre package est prête, vous pouvez commencer à écrire des fonctions dans le dossier R/. VSCode rend ce processus efficace grâce à des fonctionnalités telles que IntelliSense et linting.

  • Développement de fonctions : Créez un nouveau fichier .R dans le dossier R/. Ecrivez vos fonctions comme vous le feriez dans n’importe quel script R. L’IntelliSense de VSCode fournira des suggestions pour les noms de fonctions et les arguments, ce qui vous aidera à éviter les erreurs.

  • Documentation avec Roxygen2 : Documentez vos fonctions en utilisant les commentaires roxygen2. Ajoutez des commentaires commençant par « # » au-dessus de chaque fonction pour décrire son but, ses paramètres et ses valeurs de retour. Par exemple:

    #' Calculate the Mean of a Vector
#'
#' This function calculates the arithmetic mean of a given numeric vector.
#'
#' @param x A numeric vector.
#' @return The mean of the vector.
#' @export
calculate_mean <- function(x) {
  mean(x, na.rm = TRUE)
}

    Après avoir documenté, exécutez devtools::document() pour générer des fichiers .Rd dans le dossier man/.

9.5 Test de votre package

Les tests sont essentiels pour s’assurer que votre package fonctionne comme prévu. VSCode et R fournissent des outils pour faciliter les tests unitaires:

  • Testthat Package : Utilisez le package testthat pour écrire des tests unitaires. Installez-le avec:

    install.packages("testthat")

    Créez un dossier tests/ dans votre package et ajoutez des fichiers de test en utilisant la structure suivante:

    test_that("calculate_mean works correctly", {
  expect_equal(calculate_mean(c(1, 2, 3)), 2)
  expect_equal(calculate_mean(c(NA, 2, 3)), 2.5)
})

  • Exécuter des tests : Exécuter les tests en utilisant devtools::test(). Le terminal intégré de VSCode rend facile l’exécution de commandes sans quitter l’éditeur.

9.6 Construire et installer le package

Pour construire votre package et créer un fichier compressé (.tar.gz), exécutez:

devtools::build()

Ce fichier peut être partagé et installé par d’autres personnes qui utilisent VSCode et R install.packages("yourpackage.tar.gz", repos = NULL, type = "source").

Pour installer et tester votre package localement:

devtools::install()

Cette commande installera votre package, le rendant disponible pour être utilisé sur votre système.

9.7 Débogage et dépannage

VSCode fournit plusieurs fonctionnalités qui rendent le débogage de votre package R plus facile:

  • Intégration du terminal R : Vous pouvez tester les fonctions interactivement dans le terminal R en chargeant votre package avec devtools::install() devtools::load_all(). Cela charge votre package dans l’environnement R sans qu’il soit nécessaire de le réinstaller, ce qui rend les changements plus faciles à tester.

  • Points de rupture et débogage : En utilisant les outils de débogage de R, vous pouvez utiliser les fonctions de débogage natives de R (browser(), trace(), etc.) pour enquêter sur les problèmes dans votre code.

9.8 Contrôle de version avec Git

Utiliser Git pour le contrôle de version est une partie essentielle du développement de logiciels modernes. VSCode a un support Git intégré, vous permettant de:

  • Suivre les changements : Suivez les changements dans les fichiers de votre package R directement dans l’onglet Source Control de VSCode.
  • Commit et Push : Validez vos changements et poussez-les vers un dépôt distant (par exemple, GitHub) pour la collaboration ou la sauvegarde.
  • Branchements : Créez et passez d’une branche à l’autre pour travailler indépendamment sur différentes fonctionnalités ou corrections.

9.9 Exemple de flux de travail pour le développement de packages

  1. Créez la structure du package : Utilisez devtools::create() pour créer un nouveau dossier de package.
  2. Écrire des fonctions : Ajouter vos scripts R à la base de données R/ directory and document them using roxygen2.
  3. Tester votre code : Écrivez des tests unitaires en utilisant VSCode testthat and store them in tests/testthat/.
  4. Documentation et construction : Exécutez devtools::document() pour créer la documentation, et devtools::build() pour construire le package.
  5. Installez et testez localement : Installez votre package avec devtools::install(), puis testez les fonctions de manière interactive.

Pour en savoir plus sur le développement de packages R, consultez la documentation officielle.

9.10 Conclusion

Développer des packages R dans VSCode est une expérience fluide et gratifiante avec les bons outils. En tirant parti d’extensions comme vscode-R et de packages comme devtools et roxygen2, vous pouvez créer des packages R bien documentés et testés en profondeur qui sont faciles à partager et à maintenir. Le terminal intégré de VSCode, le contrôle de version et les riches fonctionnalités d’édition en font un excellent environnement pour les développeurs R, qu’ils soient novices ou expérimentés.

Prêt à aller plus loin dans vos compétences en programmation R ? Dans le prochain chapitre, nous explorerons l’utilisation de Git pour un contrôle de version efficace, garantissant que votre base de code reste organisée et collaborative.