lib/Moose/Meta/Attribute/Native.pm

   1 package Moose::Meta::Attribute::Native;
   2
   3 use Class::Load qw(load_class);
   4
   5 my @trait_names = qw(Bool Counter Number String Array Hash Code);
   6
   7 for my $trait_name (@trait_names) {
   8     my $trait_class = "Moose::Meta::Attribute::Native::Trait::$trait_name";
   9     my $meta = Class::MOP::Class->initialize(
  10         "Moose::Meta::Attribute::Custom::Trait::$trait_name"
  11     );
  12     if ($meta->find_method_by_name('register_implementation')) {
  13         my $class = $meta->name->register_implementation;
  14         Moose->throw_error(
  15             "An implementation for $trait_name already exists " .
  16             "(found '$class' when trying to register '$trait_class')"
  17         );
  18     }
  19     $meta->add_method(register_implementation => sub {
  20         # resolve_metatrait_alias will load classes anyway, but throws away
  21         # their error message; we WANT to die if there's a problem
  22         load_class($trait_class);
  23         return $trait_class;
  24     });
  25 }
  26
  27 1;
  28
  29 # ABSTRACT: Delegate to native Perl types
  30
  31 __END__
  32
  33 =pod
  34
  35 =head1 SYNOPSIS
  36
  37   package MyClass;
  38   use Moose;
  39
  40   has 'mapping' => (
  41       traits  => ['Hash'],
  42       is      => 'rw',
  43       isa     => 'HashRef[Str]',
  44       default => sub { {} },
  45       handles => {
  46           exists_in_mapping => 'exists',
  47           ids_in_mapping    => 'keys',
  48           get_mapping       => 'get',
  49           set_mapping       => 'set',
  50           set_quantity      => [ set => 'quantity' ],
  51       },
  52   );
  53
  54   my $obj = MyClass->new;
  55   $obj->set_quantity(10);      # quantity => 10
  56   $obj->set_mapping('foo', 4); # foo => 4
  57   $obj->set_mapping('bar', 5); # bar => 5
  58   $obj->set_mapping('baz', 6); # baz => 6
  59
  60   # prints 5
  61   print $obj->get_mapping('bar') if $obj->exists_in_mapping('bar');
  62
  63   # prints 'quantity, foo, bar, baz'
  64   print join ', ', $obj->ids_in_mapping;
  65
  66 =head1 DESCRIPTION
  67
  68 Native delegations allow you to delegate to native Perl data
  69 structures as if they were objects. For example, in the L</SYNOPSIS> you can
  70 see a hash reference being treated as if it has methods named C<exists()>,
  71 C<keys()>, C<get()>, and C<set()>.
  72
  73 The delegation methods (mostly) map to Perl builtins and operators. The return
  74 values of these delegations should be the same as the corresponding Perl
  75 operation. Any deviations will be explicitly documented.
  76
  77 =head1 API
  78
  79 Native delegations are enabled by passing certain options to C<has> when
  80 creating an attribute.
  81
  82 =head2 traits
  83
  84 To enable this feature, pass the appropriate name in the C<traits> array
  85 reference for the attribute. For example, to enable this feature for hash
  86 reference, we include C<'Hash'> in the list of traits.
  87
  88 =head2 isa
  89
  90 You will need to make sure that the attribute has an appropriate type. For
  91 example, to use this with a Hash you must specify that your attribute is some
  92 sort of C<HashRef>.
  93
  94 =head2 handles
  95
  96 This is just like any other delegation, but only a hash reference is allowed
  97 when defining native delegations. The keys are the methods to be created in
  98 the class which contains the attribute. The values are the methods provided by
  99 the associated trait. Currying works the same way as it does with any other
 100 delegation.
 101
 102 See the docs for each native trait for details on what methods are available.
 103
 104 =head2 is
 105
 106 Some traits provide a default C<is> for historical reasons. This behavior is
 107 deprecated, and you are strongly encouraged to provide a value. If you don't
 108 plan to read and write the attribute value directly, not passing the C<is>
 109 option will prevent standard accessor generation.
 110
 111 =head2 default or builder
 112
 113 Some traits provide a default C<default> for historical reasons. This behavior
 114 is deprecated, and you are strongly encouraged to provide a default value or
 115 make the attribute required.
 116
 117 =head1 TRAITS FOR NATIVE DELEGATIONS
 118
 119 =over
 120
 121 =item L<Array|Moose::Meta::Attribute::Native::Trait::Array>
 122
 123     has 'queue' => (
 124         traits  => ['Array'],
 125         is      => 'ro',
 126         isa     => 'ArrayRef[Str]',
 127         default => sub { [] },
 128         handles => {
 129             add_item  => 'push',
 130             next_item => 'shift',
 131             # ...
 132         }
 133     );
 134
 135 =item L<Bool|Moose::Meta::Attribute::Native::Trait::Bool>
 136
 137     has 'is_lit' => (
 138         traits  => ['Bool'],
 139         is      => 'ro',
 140         isa     => 'Bool',
 141         default => 0,
 142         handles => {
 143             illuminate  => 'set',
 144             darken      => 'unset',
 145             flip_switch => 'toggle',
 146             is_dark     => 'not',
 147             # ...
 148         }
 149     );
 150
 151 =item L<Code|Moose::Meta::Attribute::Native::Trait::Code>
 152
 153     has 'callback' => (
 154         traits  => ['Code'],
 155         is      => 'ro',
 156         isa     => 'CodeRef',
 157         default => sub {
 158             sub {'called'}
 159         },
 160         handles => {
 161             call => 'execute',
 162             # ...
 163         }
 164     );
 165
 166 =item L<Counter|Moose::Meta::Attribute::Native::Trait::Counter>
 167
 168     has 'counter' => (
 169         traits  => ['Counter'],
 170         is      => 'ro',
 171         isa     => 'Num',
 172         default => 0,
 173         handles => {
 174             inc_counter   => 'inc',
 175             dec_counter   => 'dec',
 176             reset_counter => 'reset',
 177             # ...
 178         }
 179     );
 180
 181 =item L<Hash|Moose::Meta::Attribute::Native::Trait::Hash>
 182
 183     has 'options' => (
 184         traits  => ['Hash'],
 185         is      => 'ro',
 186         isa     => 'HashRef[Str]',
 187         default => sub { {} },
 188         handles => {
 189             set_option => 'set',
 190             get_option => 'get',
 191             has_option => 'exists',
 192             # ...
 193         }
 194     );
 195
 196 =item L<Number|Moose::Meta::Attribute::Native::Trait::Number>
 197
 198     has 'integer' => (
 199         traits  => ['Number'],
 200         is      => 'ro',
 201         isa     => 'Int',
 202         default => 5,
 203         handles => {
 204             set => 'set',
 205             add => 'add',
 206             sub => 'sub',
 207             mul => 'mul',
 208             div => 'div',
 209             mod => 'mod',
 210             abs => 'abs',
 211             # ...
 212         }
 213     );
 214
 215 =item L<String|Moose::Meta::Attribute::Native::Trait::String>
 216
 217     has 'text' => (
 218         traits  => ['String'],
 219         is      => 'ro',
 220         isa     => 'Str',
 221         default => q{},
 222         handles => {
 223             add_text     => 'append',
 224             replace_text => 'replace',
 225             # ...
 226         }
 227     );
 228
 229 =back
 230
 231 =head1 COMPATIBILITY WITH MooseX::AttributeHelpers
 232
 233 This feature used to be a separated CPAN distribution called
 234 L<MooseX::AttributeHelpers>.
 235
 236 When the feature was incorporated into the Moose core, some of the API details
 237 were changed. The underlying capabilities are the same, but some details of
 238 the API were changed.
 239
 240 =head1 BUGS
 241
 242 See L<Moose/BUGS> for details on reporting bugs.
 243
 244 =cut