NAME¶
MooseX::AttributeShortcuts - Shorthand for common attribute options
VERSION¶
This document describes version 0.024 of MooseX::AttributeShortcuts - released
May 02, 2014 as part of MooseX-AttributeShortcuts.
SYNOPSIS¶
package Some::Class;
use Moose;
use MooseX::AttributeShortcuts;
# same as:
# is => 'ro', lazy => 1, builder => '_build_foo'
has foo => (is => 'lazy');
# same as: is => 'ro', writer => '_set_foo'
has foo => (is => 'rwp');
# same as: is => 'ro', builder => '_build_bar'
has bar => (is => 'ro', builder => 1);
# same as: is => 'ro', clearer => 'clear_bar'
has bar => (is => 'ro', clearer => 1);
# same as: is => 'ro', predicate => 'has_bar'
has bar => (is => 'ro', predicate => 1);
# works as you'd expect for "private": predicate => '_has_bar'
has _bar => (is => 'ro', predicate => 1);
# extending? Use the "Shortcuts" trait alias
extends 'Some::OtherClass';
has '+bar' => (traits => [Shortcuts], builder => 1, ...);
# or...
package Some::Other::Class;
use Moose;
use MooseX::AttributeShortcuts -writer_prefix => '_';
# same as: is => 'ro', writer => '_foo'
has foo => (is => 'rwp');
DESCRIPTION¶
Ever find yourself repeatedly specifying writers and builders, because there's
no good shortcut to specifying them? Sometimes you want an attribute to have a
read-only public interface, but a private writer. And wouldn't it be easier to
just say "builder => 1" and have the attribute construct the
canonical "_build_$name" builder name for you?
This package causes an attribute trait to be applied to all attributes defined
to the using class. This trait extends the attribute option processing to
handle the above variations.
USAGE¶
This package automatically applies an attribute metaclass trait. Unless you want
to change the defaults, you can ignore the talk about "prefixes"
below.
EXTENDING A CLASS¶
If you're extending a class and trying to extend its attributes as well, you'll
find out that the trait is only applied to attributes defined locally in the
class. This package exports a trait shortcut function "Shortcuts"
that will help you apply this to the extended attribute:
has '+something' => (traits => [Shortcuts], ...);
PREFIXES¶
We accept two parameters on the use of this module; they impact how builders and
writers are named.
-writer_prefix¶
use MooseX::::AttributeShortcuts -writer_prefix => 'prefix';
The default writer prefix is '_set_'. If you'd prefer it to be something else
(say, '_'), this is where you'd do that.
-builder_prefix¶
use MooseX::::AttributeShortcuts -builder_prefix => 'prefix';
The default builder prefix is '_build_', as this is what lazy_build does, and
what people in general recognize as build methods.
NEW ATTRIBUTE OPTIONS¶
Unless specified here, all options defined by Moose::Meta::Attribute and
Class::MOP::Attribute remain unchanged.
Want to see additional options? Ask, or better yet, fork on GitHub and send a
pull request. If the shortcuts you're asking for already exist in Moo or Mouse
or elsewhere, please note that as it will carry significant weight.
For the following, "$name" should be read as the attribute name; and
the various prefixes should be read using the defaults.
is => 'rwp'¶
Specifying "is => 'rwp'" will cause the following options to be
set:
is => 'ro'
writer => "_set_$name"
is => 'lazy'¶
Specifying "is => 'lazy'" will cause the following options to be
set:
is => 'ro'
builder => "_build_$name"
lazy => 1
NOTE: Since 0.009 we no longer set "init_arg => undef" if no
"init_arg" is explicitly provided. This is a change made in parallel
with Moo, based on a large number of people surprised that lazy also made
one's "init_def" undefined.
is => 'lazy', default => ...¶
Specifying "is => 'lazy'" and a default will cause the following
options to be set:
is => 'ro'
lazy => 1
default => ... # as provided
That is, if you specify "is => 'lazy'" and also provide a
"default", then we won't try to set a builder, as well.
builder => 1¶
Specifying "builder => 1" will cause the following options to be
set:
builder => "_build_$name"
clearer => 1¶
Specifying "clearer => 1" will cause the following options to be
set:
clearer => "clear_$name"
or, if your attribute name begins with an underscore:
clearer => "_clear$name"
(that is, an attribute named "_foo" would get "_clear_foo")
predicate => 1¶
Specifying "predicate => 1" will cause the following options to be
set:
predicate => "has_$name"
or, if your attribute name begins with an underscore:
predicate => "_has$name"
(that is, an attribute named "_foo" would get "_has_foo")
trigger => 1¶
Specifying "trigger => 1" will cause the attribute to be created
with a trigger that calls a named method in the class with the options passed
to the trigger. By default, the method name the trigger calls is the name of
the attribute prefixed with "_trigger_".
e.g., for an attribute named "foo" this would be equivalent to:
trigger => sub { shift->_trigger_foo(@_) }
For an attribute named "_foo":
trigger => sub { shift->_trigger__foo(@_) }
This naming scheme, in which the trigger is always private, is the same as the
builder naming scheme (just with a different prefix).
builder => sub { ... }¶
Passing a coderef to builder will cause that coderef to be installed in the
class this attribute is associated with the name you'd expect, and
"builder => 1" to be set.
e.g., in your class,
has foo => (is => 'ro', builder => sub { 'bar!' });
...is effectively the same as...
has foo => (is => 'ro', builder => '_build_foo');
sub _build_foo { 'bar!' }
isa_instance_of => ...¶
Given a package name, this option will create an "isa" type constraint
that requires the value of the attribute be an instance of the class (or a
descendant class) given. That is,
has foo => (is => 'ro', isa_instance_of => 'SomeThing');
...is effectively the same as:
use Moose::TypeConstraints 'class_type';
has foo => (
is => 'ro',
isa => class_type('SomeThing'),
);
...but a touch less awkward.
isa => ..., constraint => sub { ... }¶
Specifying the constraint option with a coderef will cause a new subtype
constraint to be created, with the parent type being the type specified in the
"isa" option and the constraint being the coderef supplied here.
For example, only integers greater than 10 will pass this attribute's type
constraint:
# value must be an integer greater than 10 to pass the constraint
has thinger => (
isa => 'Int',
constraint => sub { $_ > 10 },
# ...
);
Note that if you supply a constraint, you must also provide an "isa".
isa => ..., constraint => sub { ... }, coerce => 1¶
Supplying a constraint and asking for coercion will "Just Work", that
is, any coercions that the "isa" type has will still work.
For example, let's say that you're using the "File" type constraint
from MooseX::Types::Path::Class, and you want an additional constraint that
the file must exist:
has thinger => (
is => 'ro',
isa => File,
constraint => sub { !! $_->stat },
coerce => 1,
);
"thinger" will correctly coerce the string "/etc/passwd" to
a "Path::Class:File", and will only accept the coerced result as a
value if the file exists.
coerce => [ Type => sub { ...coerce... }, ... ]¶
Specifying the coerce option with a hashref will cause a new subtype to be
created and used (just as with the constraint option, above), with the
specified coercions added to the list. In the passed hashref, the keys are
Moose types (well, strings resolvable to Moose types), and the values are
coderefs that will coerce a given type to our type.
has bar => (
is => 'ro',
isa => 'Str',
coerce => [
Int => sub { "$_" },
Object => sub { 'An instance of ' . ref $_ },
],
);
ANONYMOUS SUBTYPING AND COERCION¶
"Abusus non tollit usum."
Note that we create new, anonymous subtypes whenever the constraint or coercion
options are specified in such a way that the Shortcuts trait (this one) is
invoked. It's fully supported to use both constraint and coerce options at the
same time.
This facility is intended to assist with the creation of one-off type
constraints and coercions. It is not possible to deliberately reuse the
subtypes we create, and if you find yourself using a particular isa /
constraint / coerce option triplet in more than one place you should really
think about creating a type that you can reuse. MooseX::Types provides the
facilities to easily do this, or even a simple constant definition at the
package level with an anonymous type stashed away for local use.
SEE ALSO¶
Please see those modules/websites for more information related to this module.
- •
- MooseX::Types
SOURCE¶
The development version is on github at
<
http://https://github.com/RsrchBoy/moosex-attributeshortcuts> and may
be cloned from
<
git://https://github.com/RsrchBoy/moosex-attributeshortcuts.git>
BUGS¶
Please report any bugs or feature requests on the bugtracker website
https://github.com/RsrchBoy/moosex-attributeshortcuts/issues
When submitting a bug or request, please include a test-file or a patch to an
existing test-file that illustrates the bug or desired feature.
AUTHOR¶
Chris Weyl <cweyl@alumni.drew.edu>
SAYING THANKS IN A MATERIALISTIC WAY¶
Please note
I do not expect to be gittip'ed or flattr'ed for this work,
rather
it is simply a very pleasant surprise. I largely create and
release works like this because I need them or I find it enjoyable; however,
don't let that stop you giving me money if you feel like it ;)
flattr this!
<
https://flattr.com/submit/auto?user_id=RsrchBoy&url=https%3A%2F%2Fgithub.com%2FRsrchBoy%2Fmoosex-attributeshortcuts&title=RsrchBoy's%20CPAN%20MooseX-AttributeShortcuts&tags=%22RsrchBoy's%20MooseX-AttributeShortcuts%20in%20the%20CPAN%22>
gittip me! <
https://www.gittip.com/RsrchBoy/> Amazon Wishlist
<
http://www.amazon.com/gp/registry/wishlist/3G2DQFPBA57L6>
CONTRIBUTOR¶
David Steinbrunner <dsteinbrunner@pobox.com>
COPYRIGHT AND LICENSE¶
This software is Copyright (c) 2011 by Chris Weyl.
This is free software, licensed under:
The GNU Lesser General Public License, Version 2.1, February 1999