use 5.008;
use Scalar::Util 'blessed';
-use Carp 'confess';
+use Carp 'carp', 'confess';
+use Class::Load 'is_class_loaded';
use Moose::Deprecated;
use Moose::Exporter;
use Class::MOP;
+BEGIN {
+ die "Class::MOP version $Moose::VERSION required--this is version $Class::MOP::VERSION"
+ if $Moose::VERSION && $Class::MOP::VERSION ne $Moose::VERSION;
+}
+
use Moose::Meta::Class;
use Moose::Meta::TypeConstraint;
use Moose::Meta::TypeCoercion;
Moose->throw_error('Usage: has \'name\' => ( key => value, ... )')
if @_ % 2 == 1;
- my %options = ( definition_context => Moose::Util::_caller_info(), @_ );
+ my %context = Moose::Util::_caller_info;
+ $context{context} = 'has declaration';
+ $context{type} = 'class';
+ my %options = ( definition_context => \%context, @_ );
my $attrs = ( ref($name) eq 'ARRAY' ) ? $name : [ ($name) ];
$meta->add_attribute( $_, %options ) for @$attrs;
}
our @SUPER_ARGS;
sub super {
+ if (@_) {
+ carp 'Arguments passed to super() are ignored';
+ }
+
# This check avoids a recursion loop - see
# t/bugs/super_recursion.t
return if defined $SUPER_PACKAGE && $SUPER_PACKAGE ne caller();
);
sub init_meta {
- # This used to be called as a function. This hack preserves
- # backwards compatibility.
- if ( $_[0] ne __PACKAGE__ ) {
- Moose::Deprecated::deprecated(
- feature => 'Moose::init_meta',
- message => 'Calling Moose::init_meta as a function is deprecated.'
- . ' Doing so will throw an error in Moose 2.0200.'
- );
-
- return __PACKAGE__->init_meta(
- for_class => $_[0],
- base_class => $_[1],
- metaclass => $_[2],
- );
- }
-
shift;
my %args = @_;
my $metaclass = $args{metaclass} || 'Moose::Meta::Class';
my $meta_name = exists $args{meta_name} ? $args{meta_name} : 'meta';
+ Moose->throw_error("The Metaclass $metaclass must be loaded. (Perhaps you forgot to 'use $metaclass'?)")
+ unless is_class_loaded($metaclass);
+
Moose->throw_error("The Metaclass $metaclass must be a subclass of Moose::Meta::Class.")
unless $metaclass->isa('Moose::Meta::Class');
Moose::Meta::TypeCoercion::Union
Moose::Meta::Method
- Moose::Meta::Method::Accessor
Moose::Meta::Method::Constructor
Moose::Meta::Method::Destructor
Moose::Meta::Method::Overridden
Moose::Meta::Role::Application::ToInstance
);
-Moose::Meta::Mixin::AttributeCore->meta->make_immutable(
+$_->make_immutable(
inline_constructor => 0,
constructor_name => undef,
+ # these are Class::MOP accessors, so they need inlining
+ inline_accessors => 1
+ ) for grep { $_->is_mutable }
+ map { $_->meta }
+ qw(
+ Moose::Meta::Method::Accessor
+ Moose::Meta::Method::Delegation
+ Moose::Meta::Mixin::AttributeCore
);
1;
This will attempt to use coercion with the supplied type constraint to change
the value passed into any accessors or constructors. You B<must> supply a type
constraint, and that type constraint B<must> define a coercion. See
-L<Moose::Cookbook::Basics::Recipe5> for an example.
+L<Moose::Cookbook::Basics::HTTP_SubtypesAndCoercion> for an example.
=item I<does =E<gt> $role_name>
See L<Metaclass and Trait Name Resolution> for details on how a trait name is
resolved to a role name.
-Also see L<Moose::Cookbook::Meta::Recipe3> for a metaclass trait
-example.
+Also see L<Moose::Cookbook::Meta::Labeled_AttributeTrait> for a metaclass
+trait example.
=item I<builder> => Str
-The value of this key is the name of the method that will be called to
-obtain the value used to initialize the attribute. See the L<builder
-option docs in Class::MOP::Attribute|Class::MOP::Attribute/builder>
-and/or L<Moose::Cookbook::Basics::Recipe8> for more information.
+The value of this key is the name of the method that will be called to obtain
+the value used to initialize the attribute. See the L<builder option docs in
+Class::MOP::Attribute|Class::MOP::Attribute/builder> and/or
+L<Moose::Cookbook::Basics::BinaryTree_BuilderAndLazyBuild> for more
+information.
=item I<default> => SCALAR | CODE
Aside from where the attributes come from (one from superclass, the other
from a role), this feature works exactly the same. This feature is restricted
-somewhat, so as to try and force at least I<some> sanity into it. You are only
-allowed to change the following attributes:
+somewhat, so as to try and force at least I<some> sanity into it. Most options work the same, but there are some exceptions:
=over 4
-=item I<default>
+=item I<reader>
-Change the default value of an attribute.
+=item I<writer>
-=item I<coerce>
+=item I<accessor>
-Change whether the attribute attempts to coerce a value passed to it.
+=item I<clearer>
-=item I<required>
+=item I<predicate>
-Change if the attribute is required to have a value.
-
-=item I<documentation>
-
-Change the documentation string associated with the attribute.
-
-=item I<lazy>
-
-Change if the attribute lazily initializes the slot.
-
-=item I<isa>
-
-You I<are> allowed to change the type without restriction.
-
-It is recommended that you use this freedom with caution. We used to
-only allow for extension only if the type was a subtype of the parent's
-type, but we felt that was too restrictive and is better left as a
-policy decision.
-
-=item I<handles>
-
-You are allowed to B<add> a new C<handles> definition, but you are B<not>
-allowed to I<change> one.
-
-=item I<builder>
-
-You are allowed to B<add> a new C<builder> definition, but you are B<not>
-allowed to I<change> one.
-
-=item I<metaclass>
-
-You are allowed to B<add> a new C<metaclass> definition, but you are
-B<not> allowed to I<change> one.
+These options can be added, but cannot override a superclass definition.
=item I<traits>
found in L<Moose::Manual::MethodModifiers> and the
L<Class::MOP::Class documentation|Class::MOP::Class/"Method Modifiers">.
-=item B<super>
-
-The keyword C<super> is a no-op when called outside of an C<override> method. In
-the context of an C<override> method, it will call the next most appropriate
-superclass method with the same arguments as the original method.
-
=item B<override ($name, &sub)>
An C<override> method is a way of explicitly saying "I am overriding this
it will work as expected. The same thing I<can> be accomplished with a normal
method call and the C<SUPER::> pseudo-package; it is really your choice.
-=item B<inner>
+=item B<super>
-The keyword C<inner>, much like C<super>, is a no-op outside of the context of
-an C<augment> method. You can think of C<inner> as being the inverse of
-C<super>; the details of how C<inner> and C<augment> work is best described in
-the L<Moose::Cookbook::Basics::Recipe6>.
+The keyword C<super> is a no-op when called outside of an C<override> method. In
+the context of an C<override> method, it will call the next most appropriate
+superclass method with the same arguments as the original method.
=item B<augment ($name, &sub)>
An C<augment> method, is a way of explicitly saying "I am augmenting this
method from my superclass". Once again, the details of how C<inner> and
-C<augment> work is best described in the L<Moose::Cookbook::Basics::Recipe6>.
+C<augment> work is best described in the
+L<Moose::Cookbook::Basics::Document_AugmentAndInner>.
-=item B<confess>
+=item B<inner>
-This is the C<Carp::confess> function, and exported here because I use it
-all the time.
+The keyword C<inner>, much like C<super>, is a no-op outside of the context of
+an C<augment> method. You can think of C<inner> as being the inverse of
+C<super>; the details of how C<inner> and C<augment> work is best described in
+the L<Moose::Cookbook::Basics::Document_AugmentAndInner>.
=item B<blessed>
-This is the C<Scalar::Util::blessed> function. It is exported here because I
-use it all the time. It is highly recommended that this is used instead of
-C<ref> anywhere you need to test for an object's class name.
+This is the C<Scalar::Util::blessed> function. It is highly recommended that
+this is used instead of C<ref> anywhere you need to test for an object's class
+name.
-=back
+=item B<confess>
-=head1 METACLASS
+This is the C<Carp::confess> function, and exported here for historical
+reasons.
-When you use Moose, you can specify which metaclass to use:
+=back
- use Moose -metaclass => 'My::Meta::Class';
+=head1 METACLASS
-You can also specify traits which will be applied to your metaclass:
+When you use Moose, you can specify traits which will be applied to your
+metaclass:
use Moose -traits => 'My::Trait';
for a class matching B<Moose::Meta::$type::Custom::$metaclass_name>.
If all this is confusing, take a look at
-L<Moose::Cookbook::Meta::Recipe3>, which demonstrates how to create an
-attribute trait.
+L<Moose::Cookbook::Meta::Labeled_AttributeTrait>, which demonstrates how to
+create an attribute trait.
=head1 UNIMPORTING FUNCTIONS
To learn more about extending Moose, we recommend checking out the
"Extending" recipes in the L<Moose::Cookbook>, starting with
-L<Moose::Cookbook::Extending::Recipe1>, which provides an overview of
-all the different ways you might extend Moose.
-
-=head2 B<< Moose->init_meta(for_class => $class, base_class => $baseclass, metaclass => $metaclass) >>
-
-The C<init_meta> method sets up the metaclass object for the class
-specified by C<for_class>. This method injects a a C<meta> accessor
-into the class so you can get at this object. It also sets the class's
-superclass to C<base_class>, with L<Moose::Object> as the default.
-
-C<init_meta> returns the metaclass object for C<$class>.
-
-You can specify an alternate metaclass with the C<metaclass> option.
-
-For more detail on this topic, see L<Moose::Cookbook::Extending::Recipe2>.
-
-This method used to be documented as a function which accepted
-positional parameters. This calling style will still work for
-backwards compatibility, but is deprecated.
-
-=head2 B<import>
-
-Moose's C<import> method supports the L<Sub::Exporter> form of C<{into =E<gt> $pkg}>
-and C<{into_level =E<gt> 1}>.
-
-B<NOTE>: Doing this is more or less deprecated. Use L<Moose::Exporter>
-instead, which lets you stack multiple C<Moose.pm>-alike modules
-sanely. It handles getting the exported functions into the right place
-for you.
-
-=head2 B<throw_error>
-
-An alias for C<confess>, used internally by Moose.
+L<Moose::Cookbook::Extending::ExtensionOverview>, which provides an overview of
+all the different ways you might extend Moose. L<Moose::Exporter> and
+L<Moose::Util::MetaRole> are the modules which provide the majority of the
+extension functionality, so reading their documentation should also be helpful.
=head2 The MooseX:: namespace
We offer both a mailing list and a very active IRC channel.
-The mailing list is L<moose@perl.org>. You must be subscribed to send
+The mailing list is L<mailto:moose@perl.org>. You must be subscribed to send
a message. To subscribe, send an empty message to
-L<moose-subscribe@perl.org>
+L<mailto:moose-subscribe@perl.org>
You can also visit us at C<#moose> on L<irc://irc.perl.org/#moose>
This channel is quite active, and questions at all levels (on Moose-related
topics ;) are welcome.
+=head1 WHAT DOES MOOSE STAND FOR?
+
+Moose doesn't stand for one thing in particular, however, if you want, here
+are a few of our favorites. Feel free to contribute more!
+
+=over 4
+
+=item * Make Other Object Systems Envious
+
+=item * Makes Object Orientation So Easy
+
+=item * Makes Object Orientation Spiffy- Er (sorry ingy)
+
+=item * Most Other Object Systems Emasculate
+
+=item * Moose Often Ovulate Sorta Early
+
+=item * Moose Offers Often Super Extensions
+
+=item * Meta Object Obligates Salivary Excitation
+
+=item * Meta Object Orientation Syntax Extensions
+
+=back
+
=head1 ACKNOWLEDGEMENTS
=over 4
=item L<http://www.iinteractive.com/moose>
-This is the official web home of Moose, it contains links to our public git repository
-as well as links to a number of talks and articles on Moose and Moose related
-technologies.
+This is the official web home of Moose. It contains links to our public git
+repository, as well as links to a number of talks and articles on Moose and
+Moose related technologies.
+
+=item the L<Moose manual|Moose::Manual>
+
+This is an introduction to Moose which covers most of the basics.
+
+=item Modern Perl, by chromatic
+
+This is an introduction to modern Perl programming, which includes a section on
+Moose. It is available in print and as a free download from
+L<http://onyxneon.com/books/modern_perl/>.
=item The Moose is flying, a tutorial by Randal Schwartz
See L<http://search.cpan.org/search?query=MooseX::> for extensions.
-=item Moose stats on ohloh.net - L<http://www.ohloh.net/projects/moose>
-
=back
=head2 Books
=head1 CONTRIBUTORS
-Aankhen
+Moose is a community project, and as such, involves the work of many, many
+members of the community beyond just the members in the cabal. In particular:
-Adam (Alias) Kennedy
+Dave (autarch) Rolsky wrote most of the documentation in L<Moose::Manual>.
+
+John (jgoulah) Goulah wrote L<Moose::Cookbook::Snack::Keywords>.
-Anders (Debolaz) Nor Berle
+Jess (castaway) Robinson wrote L<Moose::Cookbook::Snack::Types>.
+
+Aran (bluefeet) Clary Deltac wrote
+L<Moose::Cookbook::Basics::Genome_OverloadingSubtypesAndCoercion>.
+
+Anders (Debolaz) Nor Berle contributed L<Test::Moose> and L<Moose::Util>.
+
+Also, the code in L<Moose::Meta::Attribute::Native> is based on code from the
+L<MooseX::AttributeHelpers> distribution, which had contributions from:
Chris (perigrin) Prather
+Cory (gphat) Watson
+
+Evan Carroll
+
+Florian (rafl) Ragwitz
+
+Jason May
+
+Jay Hannah
+
+Jesse (doy) Luehrs
+
+Paul (frodwith) Driver
+
+Robert (rlb3) Boone
+
+Robert Buels
+
+Robert (phaylon) Sedlacek
+
+Shawn (Sartak) Moore
+
+Stevan Little
+
+Tom (dec) Lanyon
+
+Yuval Kogman
+
+Finally, these people also contributed various tests, bug fixes,
+documentation, and features to the Moose codebase:
+
+Aankhen
+
+Adam (Alias) Kennedy
+
Christian (chansen) Hansen
Cory (gphat) Watson
Evan Carroll
-Florian (rafl) Ragwitz
-
Guillermo (groditi) Roditi
Jason May
Jay Hannah
-Jess (castaway) Robinson
-
Jonathan (jrockway) Rockway
Matt (mst) Trout
Scott (konobi) McWhirter
-Shawn (Sartak) Moore
-
Shlomi (rindolf) Fish
Tom (dec) Lanyon
projects / gitmo/Moose.git / blobdiff