Modificatori del metodo Perl Moose: chiama "intorno" prima di "prima" e "dopo"

Question

Sto usando Moose e ho bisogno di racchiudere le chiamate di metodo nel mio progetto. È importante che il mio codice di wrapping sia il modificatore più esterno. Quello che ho fatto fino ad ora è messo il mio metodo modificatori in un ruolo di Moose e poi applicato quel ruolo alla fine della mia classe in questo modo:

use Moose::Util; 
Moose::Util::apply_all_roles(__PACKAGE__->meta, ('App:Roles::CustomRole')); 
__PACKAGE__->meta->make_immutable; 

Questo mi permette di essere ragionevolmente sicuri che i modificatori di mio mio ruolo sono definito per ultimo, quindi dandomi il comportamento corretto per "prima" e "dopo". (Il "prima" e "dopo" nel ruolo sono chiamati molto prima e molto ultimo.)

Originariamente pensavo che sarebbe stato sufficiente, ma ora ho davvero bisogno di avvolgere i metodi in modo simile con "intorno". Class :: MOP, su cui Moose è costruito, applica i modificatori "intorno" molto prima, quindi vengono chiamati dopo "prima" e prima "dopo".

Per maggiori dettagli, qui è l'ordine di chiamata corrente dei miei modificatori:

CUSTOM ROLE before 
    before 2 
     before 1 
      CUSTOM ROLE around 
       around 
        method 
       around 
      CUSTOM ROLE around 
     after 1 
    after 2 
CUSTOM ROLE AFTER 

ho davvero bisogno di qualcosa di simile:

CUSTOM ROLE before 
    CUSTOM ROLE around 
     before 2 
      before 1 
       around 
        method 
       around 
      after 1 
     after 2 
    CUSTOM ROLE around 
CUSTOM ROLE AFTER 

Tutte le idee su come ottenere il mio modificatore "giro" da applicare/chiamato dove lo voglio? So che potrei fare un po 'di hacking sui tavoli dei simboli (come già accade in Class :: MOP), ma preferirei non farlo.

Answer 1

La soluzione più semplice consiste nell'avere che CUSTOM ROLE definisca un metodo che chiama il metodo principale e quindi lo avvolge.

role MyRole { 
    required 'wrapped_method'; 
    method custom_role_base_wrapper { $self->wrapped_method(@_) } 

    around custom_role_base_wrapper { ... } 
    before custom_role_base_wrapper { ... } 
} 

Il problema che stai avendo è che si sta cercando di avere il ruolo personalizzato intorno involucro di qualcosa altro di un metodo. Quale non è quello che è stato progettato per fare. Oltre a scrivere hackery simile a una tabella di simboli come suggerito (probabilmente potresti obiettare a una delle persone di Moose di esporre un'API in Class :: MOP per ottenere l'accesso), l'unica altra soluzione che riesco a pensare è quella sopra.

Se non si desidera che il telaio in più stack di chiamate che custom_role_base_wrapper aggiungeranno, si dovrebbe guardare a Yuval del Sub::Call::Tail o utilizzando goto per manipolare lo stack di chiamate.

Answer 2

Sono abbastanza nuovo per Moose, ma perché lo fai:

use Moose::Util; 
Moose::Util::apply_all_roles(__PACKAGE__->meta, ('App:Roles::CustomRole')); 

piuttosto che semplicemente questo?

with 'App:Roles::CustomRole'; 

quanto riguarda la tua domanda, è un po 'di un hack, ma potrebbe dividere il metodo di around in before e after metodi e applicare il ruolo alla fine della definizione di classe (quindi è applicata nel vostro ordine desiderato)? È possibile utilizzare attributi privati ​​per salvare lo stato tra i due metodi se assolutamente necessario.