X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMouse.pm;h=67c1e7744d00993d774dd3133853b468061b18bb;hb=60f6eba91f12d48fa30a8e16abe2db8c95b4d878;hp=cb8fcd0c4f66b9afd3c1b64bc56867dd310c711e;hpb=07d18a6b15d6d937a78ecd2dd24f5375f0096766;p=gitmo%2FMouse.git

diff --git a/lib/Mouse.pm b/lib/Mouse.pm
index cb8fcd0..67c1e77 100644
--- a/lib/Mouse.pm
+++ b/lib/Mouse.pm
@@ -4,8 +4,7 @@ use warnings;
 use 5.006;
 use base 'Exporter';
 
-our $VERSION = '0.13';
-use 5.006;
+our $VERSION = '0.18';
 
 BEGIN {
     if ($ENV{MOUSE_DEBUG}) {
@@ -22,26 +21,15 @@ use Mouse::Util;
 use Mouse::Meta::Attribute;
 use Mouse::Meta::Class;
 use Mouse::Object;
-use Mouse::TypeRegistry;
+use Mouse::Util::TypeConstraints;
 
-our @EXPORT = qw(extends has before after around blessed confess with);
+our @EXPORT = qw(extends has before after around override super blessed confess with);
 
 sub extends { Mouse::Meta::Class->initialize(caller)->superclasses(@_) }
 
 sub has {
     my $meta = Mouse::Meta::Class->initialize(caller);
-
-    my $names = shift;
-    $names = [$names] if !ref($names);
-
-    for my $name (@$names) {
-        if ($name =~ s/^\+//) {
-            Mouse::Meta::Attribute->clone_parent($meta, $name, @_);
-        }
-        else {
-            Mouse::Meta::Attribute->create($meta, $name, @_);
-        }
-    }
+    $meta->add_attribute(@_);
 }
 
 sub before {
@@ -78,13 +66,58 @@ sub with {
     Mouse::Util::apply_all_roles((caller)[0], @_);
 }
 
+our $SUPER_PACKAGE;
+our $SUPER_BODY;
+our @SUPER_ARGS;
+
+sub super {
+    # This check avoids a recursion loop - see
+    # t/100_bugs/020_super_recursion.t
+    return if defined $SUPER_PACKAGE && $SUPER_PACKAGE ne caller();
+    return unless $SUPER_BODY; $SUPER_BODY->(@SUPER_ARGS);
+}
+
+sub override {
+    my $meta = Mouse::Meta::Class->initialize(caller);
+    my $pkg = $meta->name;
+
+    my $name = shift;
+    my $code = shift;
+
+    my $body = $pkg->can($name)
+        or confess "You cannot override '$name' because it has no super method";
+
+    $meta->add_method($name => sub {
+        local $SUPER_PACKAGE = $pkg;
+        local @SUPER_ARGS = @_;
+        local $SUPER_BODY = $body;
+
+        $code->(@_);
+    });
+}
+
 sub import {
     my $class = shift;
 
     strict->import;
     warnings->import;
 
-    my $caller = caller;
+    my $opts = do {
+        if (ref($_[0]) && ref($_[0]) eq 'HASH') {
+            shift @_;
+        } else {
+            +{ };
+        }
+    };
+    my $level = delete $opts->{into_level};
+       $level = 0 unless defined $level;
+    my $caller = caller($level);
+
+    # we should never export to main
+    if ($caller eq 'main') {
+        warn qq{$class does not export its sugar to the 'main' package.\n};
+        return;
+    }
 
     my $meta = Mouse::Meta::Class->initialize($caller);
     $meta->superclasses('Mouse::Object')
@@ -95,7 +128,7 @@ sub import {
     *{$caller.'::meta'} = sub { $meta };
 
     if (@_) {
-        __PACKAGE__->export_to_level( 1, $class, @_);
+        __PACKAGE__->export_to_level( $level+1, $class, @_);
     } else {
         # shortcut for the common case of no type character
         no strict 'refs';
@@ -209,11 +242,9 @@ Mouse aims to alleviate this by providing a subset of Moose's
 functionality, faster. In particular, L<Moose/has> is missing only a few
 expert-level features.
 
-We're also going as light on dependencies as possible. Most functions we use
-from L<Scalar::Util> are copied into this dist. L<Scalar::Util> is required if
-you'd like weak references; there's simply no way to do it from pure Perl.
-L<Class::Method::Modifiers> is required if you want support for L</before>,
-L</after>, and L</around>.
+We're also going as light on dependencies as possible.
+L<Class::Method::Modifiers> or L<Data::Util> is required if you want support
+for L</before>, L</after>, and L</around>.
 
 =head2 MOOSE COMPAT
 
@@ -226,35 +257,15 @@ The idea is that, if you need the extra power, you should be able to run
 C<s/Mouse/Moose/g> on your codebase and have nothing break. To that end,
 nothingmuch has written L<Squirrel> (part of this distribution) which will act
 as Mouse unless Moose is loaded, in which case it will act as Moose.
+L<Any::Moose> is a more high-tech L<Squirrel>.
 
-Mouse also has the blessings of Moose's author, stevan.
-
-=head2 MISSING FEATURES
-
-=head3 Roles
-
-We're working on fixing this one! stevan has suggested an implementation
-strategy. Mouse currently ignores methods, so that needs to be fixed next.
-Roles that consist entirely of attributes may be usable in this very version.
-
-=head3 Complex types
+=head2 MouseX
 
-User-defined type constraints and parameterized types may be implemented. Type
-coercions probably not (patches welcome).
+Please don't copy MooseX code to MouseX. If you need extensions, you really
+should upgrade to Moose. We don't need two parallel sets of extensions!
 
-=head3 Bootstrapped meta world
-
-Very handy for extensions to the MOP. Not pressing, but would be nice to have.
-
-=head3 Modification of attribute metaclass
-
-When you declare an attribute with L</has>, you get the inlined accessors
-installed immediately. Modifying the attribute metaclass, even if possible,
-does nothing.
-
-=head3 Lots more..
-
-MouseX?
+If you really must write a Mouse extension, please contact the Moose mailing
+list or #moose on IRC beforehand.
 
 =head1 KEYWORDS
 
@@ -414,12 +425,16 @@ Returns whether this class is actually loaded or not. It uses a heuristic which
 involves checking for the existence of C<$VERSION>, C<@ISA>, and any
 locally-defined method.
 
-=head1 AUTHOR
+=head1 AUTHORS
 
 Shawn M Moore, C<< <sartak at gmail.com> >>
 
 Yuval Kogman, C<< <nothingmuch at woobling.org> >>
 
+tokuhirom
+
+Yappo
+
 with plenty of code borrowed from L<Class::MOP> and L<Moose>
 
 =head1 BUGS