Ottieni tutte le funzioni di provenienza

In R, sto usando source()per caricare alcune funzioni:

source("functions.R")

È possibile ottenere l'elenco di tutte le funzioni definite in questo file? Come nomi di funzioni. (Forse lo source()stesso può in qualche modo restituirlo?).

PS: L'ultima risorsa sarebbe quella di chiamare la source()seconda volta local({ source(); })e poi fare ls()funzioni interne e di filtro, ma è troppo complicato: esiste una soluzione più semplice e meno goffa?

Penso che il modo migliore sarebbe quello di trovare il file in un ambiente temporaneo. Interroga quell'ambiente per tutte le funzioni, quindi copia quei valori nell'ambiente padre.

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")

È un po 'goffo ma potresti guardare i cambiamenti negli oggetti prima e dopo la sourcechiamata in questo modo.

    # 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"

Penso che questo regex rilevi quasi ogni tipo valido di funzione (operatore binario, funzioni di assegnazione) e ogni carattere valido in un nome di funzione, ma potrei aver perso un caso limite.

# 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<-`"

Se questo è il tuo script in modo da avere il controllo su come è formattato, sarebbe sufficiente una semplice convenzione. Assicurati solo che il nome di ogni funzione inizi dal primo carattere sulla sua riga e che la parola functionappaia anche su quella riga. Qualsiasi altro uso della parola functiondovrebbe apparire su una riga che inizia con uno spazio o una scheda. Quindi una soluzione a una riga è:

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

I vantaggi di questo approccio sono quelli

• è molto semplice . Le regole sono semplicemente dichiarate e c'è solo una semplice riga di codice R necessaria per estrarre i nomi delle funzioni. Regex è anche semplice e per un file esistente è molto facile controllare - basta greppare la parola functione controllare se ogni occorrenza visualizzata segue la regola.

• non è necessario eseguire la fonte. È completamente statico .

• in molti casi non sarà necessario modificare affatto il file sorgente e in altri ci saranno cambiamenti minimi. Se stai scrivendo la sceneggiatura da zero con questo in mente, è ancora più facile da organizzare.

Ci sono molte altre alternative all'idea delle convenzioni. potresti avere una regex più sofisticata o potresti aggiungere # FUNCTIONalla fine della prima riga di qualsiasi definizione di funzione se stai scrivendo lo script da zero e quindi estrai quella frase ed estrai la prima parola sulla riga ma il suggerimento principale qui sembra particolarmente attraente per la sua semplicità e gli altri vantaggi elencati.

Test

# 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"

Questo adatta il codice utilizzato nel post dal mio commento per cercare una sequenza di token (simbolo, operatore di assegnazione, quindi funzione) e dovrebbe prendere qualsiasi funzione definita. Non sono sicuro che sia affidabile come la risposta di MrFlick, ma è un'altra opzione:

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"]]
}