Obtenez toutes les fonctions d'origine

Dans R, j'utilise source()pour charger certaines fonctions:

source("functions.R")

Est-il possible d'obtenir la liste de toutes les fonctions définies dans ce fichier? En tant que noms de fonction. (Peut source()- être que lui - même peut le rendre en quelque sorte?).

PS: Le dernier recours serait d'appeler une source()deuxième fois comme local({ source(); })et ensuite de faire des fonctions ls()internes et de filtrage, mais c'est trop compliqué - y a-t-il une solution plus facile et moins maladroite?

Je pense que la meilleure façon serait de placer le fichier dans un environnement temporaire. Recherchez cet environnement pour toutes les fonctions, puis copiez ces valeurs dans l'environnement parent.

my_source <- function(..., local=NULL) {
  tmp <- new.env(parent=parent.frame())
  source(..., local = tmp)
  funs <- names(tmp)[unlist(eapply(tmp, is.function))]
  for(x in names(tmp)) {
    assign(x, tmp[[x]], envir = parent.frame())
  }
  list(functions=funs)
}

my_source("script.R")

C'est un peu maladroit mais vous pouvez regarder les changements dans les objets avant et après l' sourceappel comme ça.

    # optionally delete all variables
    #rm(list=ls())

    before <- ls()
    cat("f1 <- function(){}\nf2 <- function(){}\n", file = 'define_function.R')
    # defines these
    #f1 <- function() {}
    #f2 <- function() {}
    source('define_function.R')
    after <- ls()

    changed <- setdiff(after, before)
    changed_objects <- mget(changed, inherits = T)
    changed_function <- do.call(rbind, lapply(changed_objects, is.function))
    new_functions <- changed[changed_function]

    new_functions
    # [1] "f1" "f2"

Je pense que cette expression régulière capture presque tous les types de fonctions valides (opérateur binaire, fonctions d'affectation) et tous les caractères valides dans un nom de fonction, mais j'ai peut-être manqué un cas de bord.

# lines <- readLines("functions.R")

lines <- c(
  "`%in%` <- function",
  "foo <- function",
  "foo2bar <- function",
  "`%in%`<-function",
  "foo<-function",
  ".foo <-function",
  "foo2bar<-function",
  "`foo2bar<-`<-function",
  "`foo3bar<-`=function",
  "`foo4bar<-` = function",
  "` d d` <- function", 
  "lapply(x, function)"
)
grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines)
#>  [1]  1  2  3  4  5  6  7  8  9 10
funs <- grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines, value = TRUE)
gsub("^(`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?).*", "\\1", funs)
#>  [1] "`%in%`"      "foo "        "foo2bar "    "`%in%`"      "foo"        
#>  [6] ".foo "       "foo2bar"     "`foo2bar<-`" "`foo3bar<-`" "`foo4bar<-`"

S'il s'agit de votre propre script afin que vous ayez le contrôle sur la façon dont il est formaté, une simple convention serait suffisante. Assurez-vous simplement que chaque nom de fonction commence au premier caractère de sa ligne et que le mot functionapparaît également sur cette ligne. Toute autre utilisation du mot functiondoit apparaître sur une ligne commençant par un espace ou une tabulation. Ensuite, une solution en ligne est:

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))

Les avantages de cette approche sont que

• c'est très simple . Les règles sont simplement énoncées et il n'y a qu'une seule ligne simple de code R nécessaire pour extraire les noms de fonction. Regex est également simple et pour un fichier existant, il est très facile à vérifier - il suffit de grep le mot functionet de vérifier si chaque occurrence affichée suit la règle.

• pas besoin d'exécuter la source. C'est entièrement statique .

• dans de nombreux cas, vous n'aurez pas du tout besoin de modifier le fichier source et dans d'autres, les modifications seront minimes. Si vous écrivez le script à partir de zéro dans cet esprit, il est encore plus facile à organiser.

Il existe de nombreuses autres alternatives à l'idée de conventions. vous pouvez avoir une expression rationnelle plus sophistiquée ou vous pouvez ajouter # FUNCTIONà la fin de la première ligne de toute définition de fonction si vous écrivez le script à partir de zéro, puis repérez cette phrase et extrayez le premier mot de la ligne, mais la principale suggestion semble ici particulièrement attrayant en raison de sa simplicité et des autres avantages énumérés.

Tester

# generate test file
cat("f <- function(x) x\nf(23)\n", file = "myscript.R") 

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))
## [1] "f"

Cela adapte le code utilisé dans la publication de mon commentaire pour rechercher une séquence de jetons (symbole, opérateur d'affectation, puis fonction), et il devrait saisir toutes les fonctions définies. Je ne sais pas si c'est robuste comme réponse de MrFlick, mais c'est une autre option:

source2 <- function(file, ...) {
  source(file, ...)
  t_t <- subset(getParseData(parse(file)), terminal == TRUE)
  subset(t_t, token == "SYMBOL" & 
           grepl("ASSIGN", c(tail(token, -1), NA), fixed = TRUE) & 
           c(tail(token, -2), NA, NA) == "FUNCTION")[["text"]]
}