use strict;
use warnings;
-our $VERSION = '0.03_01';
+our $VERSION = '0.05';
use Scalar::Util 'blessed', 'reftype';
use Carp 'confess';
use Sub::Name 'subname';
use UNIVERSAL::require;
+use Sub::Exporter;
use Class::MOP;
use Moose::Object;
use Moose::Util::TypeConstraints;
-sub import {
- shift;
- my $pkg = caller();
-
- # we should never export to main
- return if $pkg eq 'main';
-
- Moose::Util::TypeConstraints->import($pkg);
-
- # make a subtype for each Moose class
- subtype $pkg
- => as 'Object'
- => where { $_->isa($pkg) };
-
- my $meta;
- if ($pkg->can('meta')) {
- $meta = $pkg->meta();
- (blessed($meta) && $meta->isa('Class::MOP::Class'))
- || confess "Whoops, not møøsey enough";
- }
- else {
- $meta = Moose::Meta::Class->initialize($pkg => (
- ':attribute_metaclass' => 'Moose::Meta::Attribute'
- ));
- $meta->add_method('meta' => sub {
- # re-initialize so it inherits properly
- Moose::Meta::Class->initialize($pkg => (
- ':attribute_metaclass' => 'Moose::Meta::Attribute'
- ));
- })
- }
-
- # NOTE:
- # &alias_method will install the method, but it
- # will not name it with
-
- # handle superclasses
- $meta->alias_method('extends' => subname 'Moose::extends' => sub {
- _load_all_classes(@_);
- $meta->superclasses(@_)
- });
-
- # handle roles
- $meta->alias_method('with' => subname 'Moose::with' => sub {
- my ($role) = @_;
- _load_all_classes($role);
- $role->meta->apply($meta);
- });
-
- # handle attributes
- $meta->alias_method('has' => subname 'Moose::has' => sub {
- my ($name, %options) = @_;
- $meta->add_attribute($name, %options)
- });
-
- # handle method modifers
- $meta->alias_method('before' => subname 'Moose::before' => sub {
- my $code = pop @_;
- $meta->add_before_method_modifier($_, $code) for @_;
- });
- $meta->alias_method('after' => subname 'Moose::after' => sub {
- my $code = pop @_;
- $meta->add_after_method_modifier($_, $code) for @_;
- });
- $meta->alias_method('around' => subname 'Moose::around' => sub {
- my $code = pop @_;
- $meta->add_around_method_modifier($_, $code) for @_;
- });
-
- $meta->alias_method('super' => subname 'Moose::super' => sub {});
- $meta->alias_method('override' => subname 'Moose::override' => sub {
- my ($name, $method) = @_;
- $meta->add_override_method_modifier($name => $method);
- });
-
- $meta->alias_method('inner' => subname 'Moose::inner' => sub {});
- $meta->alias_method('augment' => subname 'Moose::augment' => sub {
- my ($name, $method) = @_;
- $meta->add_augment_method_modifier($name => $method);
- });
-
- # make sure they inherit from Moose::Object
- $meta->superclasses('Moose::Object')
- unless $meta->superclasses();
-
- # we recommend using these things
- # so export them for them
- $meta->alias_method('confess' => \&Carp::confess);
- $meta->alias_method('blessed' => \&Scalar::Util::blessed);
+{
+ my ( $CALLER, %METAS );
+
+ sub _find_meta {
+ my $class = $CALLER;
+
+ return $METAS{$class} if exists $METAS{$class};
+
+ # make a subtype for each Moose class
+ subtype $class
+ => as 'Object'
+ => where { $_->isa($class) }
+ unless find_type_constraint($class);
+
+ my $meta;
+ if ($class->can('meta')) {
+ $meta = $class->meta();
+ (blessed($meta) && $meta->isa('Moose::Meta::Class'))
+ || confess "Whoops, not møøsey enough";
+ }
+ else {
+ $meta = Moose::Meta::Class->initialize($class);
+ $meta->add_method('meta' => sub {
+ # re-initialize so it inherits properly
+ Moose::Meta::Class->initialize($class);
+ })
+ }
+
+ # make sure they inherit from Moose::Object
+ $meta->superclasses('Moose::Object')
+ unless $meta->superclasses();
+
+ return $METAS{$class} = $meta;
+ }
+
+ my %exports = (
+ extends => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::extends' => sub {
+ _load_all_classes(@_);
+ $meta->superclasses(@_)
+ };
+ },
+ with => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::with' => sub {
+ my ($role) = @_;
+ _load_all_classes($role);
+ $role->meta->apply($meta);
+ };
+ },
+ has => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::has' => sub {
+ my ($name, %options) = @_;
+ if ($options{metaclass}) {
+ _load_all_classes($options{metaclass});
+ $meta->add_attribute($options{metaclass}->new($name, %options));
+ }
+ else {
+ $meta->add_attribute($name, %options);
+ }
+ };
+ },
+ before => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::before' => sub {
+ my $code = pop @_;
+ $meta->add_before_method_modifier($_, $code) for @_;
+ };
+ },
+ after => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::after' => sub {
+ my $code = pop @_;
+ $meta->add_after_method_modifier($_, $code) for @_;
+ };
+ },
+ around => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::around' => sub {
+ my $code = pop @_;
+ $meta->add_around_method_modifier($_, $code) for @_;
+ };
+ },
+ super => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::super' => sub {};
+ },
+ override => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::override' => sub {
+ my ($name, $method) = @_;
+ $meta->add_override_method_modifier($name => $method);
+ };
+ },
+ inner => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::inner' => sub {};
+ },
+ augment => sub {
+ my $meta = _find_meta();
+ return subname 'Moose::augment' => sub {
+ my ($name, $method) = @_;
+ $meta->add_augment_method_modifier($name => $method);
+ };
+ },
+ confess => sub {
+ return \&Carp::confess;
+ },
+ blessed => sub {
+ return \&Scalar::Util::blessed;
+ }
+ );
+
+ my $exporter = Sub::Exporter::build_exporter({
+ exports => \%exports,
+ groups => {
+ default => [':all']
+ }
+ });
+
+ sub import {
+ $CALLER = caller();
+
+ # we should never export to main
+ return if $CALLER eq 'main';
+
+ goto $exporter;
+ };
}
## Utility functions
=item Moose Offers Often Super Extensions
+=item Meta Object Orientation Syntax Extensions
+
=back
=head1 BUILDING CLASSES WITH MOOSE
=back
+=head1 CAVEATS
+
+=over 4
+
+=item *
+
+It should be noted that C<super> and C<inner> can B<not> be used in the same
+method. However, they can be combined together with the same class hierarchy,
+see F<t/014_override_augment_inner_super.t> for an example.
+
+The reason that this is so is because C<super> is only valid within a method
+with the C<override> modifier, and C<inner> will never be valid within an
+C<override> method. In fact, C<augment> will skip over any C<override> methods
+when searching for it's appropriate C<inner>.
+
+This might seem like a restriction, but I am of the opinion that keeping these
+two features seperate (but interoperable) actually makes them easy to use since
+their behavior is then easier to predict. Time will tell if I am right or not.
+
+=back
+
=head1 ACKNOWLEDGEMENTS
=over 4
projects / gitmo/Moose.git / blobdiff