Composizione di ruoli in una classe Moose non funzionante

Question

Aloha!

Ho un ruolo che sono impegnato a definire in una classe Moose chiamata Authable che è essenzialmente composta in qualsiasi classe che potrebbe potenzialmente richiedere qualche forma di autenticazione in futuro; è un ruolo piuttosto semplice, ecco l'interezza:

package Trello::API::Roles::Authable; 

use Moose::Role; 

#authentication information 
has key => (
    is => "rw", 
    isa => "Str", 
); 

has token => (
    is => "rw", 
    isa => "Str", 
); 

1; 

Per una qualche ragione, quando tento di comporre in una classe con più istruzioni diverse, vale a dire, con "Trello :: API :: :: ruoli Authable "; o con "Ruoli :: Autable";

ho sempre ottenere questo stesso messaggio di errore: You can only consume roles, Roles::Authable is not a Moose role.

Qualsiasi idea del perché questo potrebbe accadere?

Modifica!

Solo una nota a margine, ho controllato la fonte reale per Moose :: ruolo, e ho visto questo bit:

unless ($meta && $meta->isa('Moose::Meta::Role')) { 
     require Moose; 
     Moose->throw_error("You can only consume roles, " 
       . $role->[0] 
       . " is not a Moose role"); 
    } 

Questo sembra essere dove l'errore è in corso, così sembra quasi che per qualche motivo , il ruolo che sto implementando non sta affermando che è un ruolo nel metaclass. Anche se potrei sbagliarmi! Qualsiasi aiuto sarebbe apprezzato.

Un'altra comoda modifica!

Bonus: contesto di codice in cui viene chiamata la routine con.

package Trello::API::Resource; 

use Moose; 
use URI::Escape; 
use LWP::UserAgent; 


with 'Roles::Authable'; 

che quando faccio questo, si sa in modo intelligente per cercare di consumare Ruoli/Authable.pm ma per qualsiasi motivo, non riesce proprio a funzionare!

Answer 1

Prima di tutto, devo concordare con Piers che tecnicamente dovresti chiamarlo come with 'Trello::API::Roles::Authable'.

Quindi, stai chiedendo qualcosa che non trovo da implementare in Moose di base. Ho già usato le idee dei pool di spazi dei nomi generici. Sono una sorta di namespace universali a cui puoi offrire i tuoi servizi semi-anonimi - senza il lock-in di uno spazio dei nomi fisso. Ho perfezionato la mia idea di base del pool di namespace con il supporto Moose (veramente MOP).

Nei giorni Wild West di Perl, tutto si dovrebbe fare è assegnare una scorta al simbolo per l'altro, in questo modo:

{ no strict 'refs'; 
    *{$short_pkg_name.'::'} = \*{$full_pkg_name.'::'}; 
}; 

E, quei due pacchetti erano esattamente le stesse cose!

Ma ora, proteggiamo i nostri dati con lessici un po 'di più. E poiché Class :: MOP custodisce gelosamente i suoi meta-oggetti in un hash lessicale, si deve aggiungere un'altra cosa:

Class::MOP::store_metaclass_by_name( 
     $short_pkg_name 
    , Class::MOP::get_metaclass_by_name($full_pkg_name) 
    ); 

ora sono la stessa identica cosa a Perl e MOP.

Così puoi creare pacchetti che sono semplicemente un repository di namespace per altri pacchetti - Ora con supporto MOP!

package Namespace::Pool; 
use strict; 
use warnings; 
use Params::Util qw<_POSINT>; 

sub import { 
    shift; # It's just me. 
    my $full_pkg_name = caller(); 
    Carp::croak("'$full_pkg_name' is short enough!") 
     unless my $pool_name 
      = shift // [ split /::/, $full_pkg_name ]->[-2] 
      ; 
    Carp::croak("'::$pool_name\::' not found in '$full_pkg_name'") 
     unless ( _POSINT(my $pos = rindex($full_pkg_name, "::$pool_name\::")) 
       or my $is_short = _POSINT(index($pool_name, '::')) 
       ); 
    my $short_pkg_name 
     = $is_short ? $poll_name 
     :    substr($full_pkg_name, $pos + 2) 
     ; 
    { no strict 'refs'; 
     if (%{$short_pkg_name.'::'}) { 
      Carp::croak("You have already defined $short_pkg_name!"); 
     } 
     *{$short_pkg_name.'::'} = \*{$full_pkg_name.'::'}; 
    }; 

    if (my $meta = Class::MOP::get_metaclass_by_name($full_pkg_name)) { 
     Class::MOP::store_metaclass_by_name($short_pkg_name, $meta); 
    } 
    return; 
} 

Così nel pacchetto di ruolo è possibile effettuare le seguenti operazioni:

package Trello::API::Roles::Authable; 
use strict; 
use warnings; 
use Moose::Role; 
use Namespace::Pool 'Roles'; 
... 

e sapere che sarà disponibile dallo spazio dei nomi dei 'ruoli'.

Answer 2

Nel mio caso ho semplicemente accidentalmente chiamato il mio ruolo "Test", ma sul mio sistema c'era già un modulo chiamato "Test" e quindi Moose pensava che volessi utilizzare quel modulo piuttosto che il nuovo ruolo di Moose I creato. Una volta che ho ribattezzato per ruolo in 'Testable', tutto ha funzionato bene.