1 package Method::Generate::Accessor;
5 use base qw(Moo::Object);
8 use Scalar::Util 'blessed';
14 _maybe_load_module('Class::XSAccessor')
16 (eval { Class::XSAccessor->VERSION('1.07') })
21 my ($self, $into, $name, $spec, $quote_opts) = @_;
23 die "Must have an is" unless my $is = $spec->{is};
25 $spec->{reader} = $name unless exists $spec->{reader};
26 } elsif ($is eq 'rw') {
27 $spec->{accessor} = $name unless exists $spec->{accessor}
28 or ( $spec->{reader} and $spec->{writer} );
29 } elsif ($is eq 'lazy') {
30 $spec->{reader} = $name unless exists $spec->{reader};
32 $spec->{builder} ||= '_build_'.$name unless $spec->{default};
33 } elsif ($is eq 'rwp') {
34 $spec->{reader} = $name unless exists $spec->{reader};
35 $spec->{writer} = "_set_${name}" unless exists $spec->{writer};
36 } elsif ($is ne 'bare') {
37 die "Unknown is ${is}";
39 if (exists $spec->{builder}) {
40 if(ref $spec->{builder}) {
41 die "Invalid builder for $into->$name - not a method name, coderef or"
42 . " code-convertible object"
43 unless ref $spec->{builder} eq 'CODE'
44 or (blessed($spec->{builder}) and eval { \&{$spec->{builder}} });
45 $spec->{builder_sub} = $spec->{builder};
48 $spec->{builder} = '_build_'.$name if ($spec->{builder}||0) eq 1;
49 die "Invalid builder for $into->$name - not a valid method name"
50 if $spec->{builder} !~ /\A[A-Za-z_][A-Za-z0-9_]*(?:::[A-Za-z_][A-Za-z0-9_]*)*\z/;
52 if (($spec->{predicate}||0) eq 1) {
53 $spec->{predicate} = $name =~ /^_/ ? "_has${name}" : "has_${name}";
55 if (($spec->{clearer}||0) eq 1) {
56 $spec->{clearer} = $name =~ /^_/ ? "_clear${name}" : "clear_${name}";
58 if (($spec->{trigger}||0) eq 1) {
59 $spec->{trigger} = quote_sub('shift->_trigger_'.$name.'(@_)');
62 for my $setting (qw( default coerce )) {
63 next if !exists $spec->{$setting};
64 my $value = $spec->{$setting};
65 my $invalid = "Invalid $setting '" . overload::StrVal($value)
66 . "' for $into->$name - not a coderef";
67 die "$invalid or code-convertible object"
68 unless ref $value and (ref $value eq 'CODE' or blessed($value));
69 die "$invalid and could not be converted to a coderef: $@"
70 if !eval { \&$value };
74 if (my $reader = $spec->{reader}) {
75 if (our $CAN_HAZ_XS && $self->is_simple_get($name, $spec)) {
76 $methods{$reader} = $self->_generate_xs(
77 getters => $into, $reader, $name, $spec
80 $self->{captures} = {};
82 quote_sub "${into}::${reader}"
83 => ' die "'.$reader.' is a read-only accessor" if @_ > 1;'."\n"
84 .$self->_generate_get($name, $spec)
85 => delete $self->{captures}
89 if (my $accessor = $spec->{accessor}) {
92 && $self->is_simple_get($name, $spec)
93 && $self->is_simple_set($name, $spec)
95 $methods{$accessor} = $self->_generate_xs(
96 accessors => $into, $accessor, $name, $spec
99 $self->{captures} = {};
100 $methods{$accessor} =
101 quote_sub "${into}::${accessor}"
102 => $self->_generate_getset($name, $spec)
103 => delete $self->{captures}
107 if (my $writer = $spec->{writer}) {
110 && $self->is_simple_set($name, $spec)
112 $methods{$writer} = $self->_generate_xs(
113 setters => $into, $writer, $name, $spec
116 $self->{captures} = {};
118 quote_sub "${into}::${writer}"
119 => $self->_generate_set($name, $spec)
120 => delete $self->{captures}
124 if (my $pred = $spec->{predicate}) {
126 quote_sub "${into}::${pred}" =>
127 ' '.$self->_generate_simple_has('$_[0]', $name, $spec)."\n"
130 if (my $pred = $spec->{builder_sub}) {
131 _install_coderef( "${into}::$spec->{builder}" => $spec->{builder_sub} );
133 if (my $cl = $spec->{clearer}) {
135 quote_sub "${into}::${cl}" =>
136 $self->_generate_simple_clear('$_[0]', $name, $spec)."\n"
139 if (my $hspec = $spec->{handles}) {
140 my $asserter = $spec->{asserter} ||= '_assert_'.$name;
142 if (ref($hspec) eq 'ARRAY') {
143 map [ $_ => $_ ], @$hspec;
144 } elsif (ref($hspec) eq 'HASH') {
145 map [ $_ => ref($hspec->{$_}) ? @{$hspec->{$_}} : $hspec->{$_} ],
147 } elsif (!ref($hspec)) {
148 map [ $_ => $_ ], Role::Tiny->methods_provided_by($hspec);
150 die "You gave me a handles of ${hspec} and I have no idea why";
153 foreach my $spec (@specs) {
154 my ($proxy, $target, @args) = @$spec;
155 $self->{captures} = {};
157 quote_sub "${into}::${proxy}" =>
158 $self->_generate_delegation($asserter, $target, \@args),
159 delete $self->{captures}
163 if (my $asserter = $spec->{asserter}) {
164 $self->{captures} = {};
165 $methods{$asserter} =
166 quote_sub "${into}::${asserter}" =>
167 'do { '.$self->_generate_get($name, $spec).qq! }||die "Attempted to access '${name}' but it is not set"!,
168 delete $self->{captures}
174 sub is_simple_attribute {
175 my ($self, $name, $spec) = @_;
176 # clearer doesn't have to be listed because it doesn't
177 # affect whether defined/exists makes a difference
179 qw(lazy default builder coerce isa trigger predicate weak_ref);
183 my ($self, $name, $spec) = @_;
184 !($spec->{lazy} and ($spec->{default} or $spec->{builder}));
188 my ($self, $name, $spec) = @_;
189 !grep $spec->{$_}, qw(coerce isa trigger weak_ref);
192 sub has_eager_default {
193 my ($self, $name, $spec) = @_;
194 (!$spec->{lazy} and ($spec->{default} or $spec->{builder}));
198 my ($self, $name, $spec) = @_;
199 my $simple = $self->_generate_simple_get('$_[0]', $name, $spec);
200 if ($self->is_simple_get($name, $spec)) {
203 'do { '.$self->_generate_use_default(
204 '$_[0]', $name, $spec,
205 $self->_generate_simple_has('$_[0]', $name, $spec),
208 ?($self->_generate_isa_check($name, $simple, $spec->{isa}).'; ')
215 sub _generate_simple_has {
216 my ($self, $me, $name) = @_;
217 "exists ${me}->{${\perlstring $name}}";
220 sub _generate_simple_clear {
221 my ($self, $me, $name) = @_;
222 " delete ${me}->{${\perlstring $name}}\n"
225 sub generate_get_default {
227 $self->{captures} = {};
228 my $code = $self->_generate_get_default(@_);
229 ($code, delete $self->{captures});
232 sub _generate_use_default {
233 my ($self, $me, $name, $spec, $test) = @_;
234 my $get_value = $self->_generate_get_default($me, $name, $spec);
235 if ($spec->{coerce}) {
236 $get_value = $self->_generate_coerce(
241 $self->_generate_simple_set(
242 $me, $name, $spec, $get_value
246 sub _generate_get_default {
247 my ($self, $me, $name, $spec) = @_;
249 ? $self->_generate_call_code($name, 'default', $me, $spec->{default})
250 : "${me}->${\$spec->{builder}}"
253 sub generate_simple_get {
254 my ($self, @args) = @_;
255 $self->_generate_simple_get(@args);
258 sub _generate_simple_get {
259 my ($self, $me, $name) = @_;
260 my $name_str = perlstring $name;
261 "${me}->{${name_str}}";
265 my ($self, $name, $spec) = @_;
266 if ($self->is_simple_set($name, $spec)) {
267 $self->_generate_simple_set('$_[0]', $name, $spec, '$_[1]');
269 my ($coerce, $trigger, $isa_check) = @{$spec}{qw(coerce trigger isa)};
270 my $simple = $self->_generate_simple_set('$self', $name, $spec, '$value');
271 my $code = "do { my (\$self, \$value) = \@_;\n";
275 .$self->_generate_coerce($name, '$value', $coerce).";\n";
279 " ".$self->_generate_isa_check($name, '$value', $isa_check).";\n";
282 my $fire = $self->_generate_trigger($name, '$self', '$value', $trigger);
284 " ".$simple.";\n ".$fire.";\n"
287 $code .= " ".$simple.";\n";
294 sub generate_coerce {
296 $self->{captures} = {};
297 my $code = $self->_generate_coerce(@_);
298 ($code, delete $self->{captures});
302 my ($name, $init_arg) = @_;
303 return perlstring($name) if !defined($init_arg) or $init_arg eq $name;
304 return perlstring($name).' (constructor argument: '.perlstring($init_arg).')';
307 sub _generate_coerce {
308 my ($self, $name, $value, $coerce, $init_arg) = @_;
309 $self->_generate_die_prefix(
310 "coercion for ${\_attr_desc($name, $init_arg)} failed: ",
311 $self->_generate_call_code($name, 'coerce', "${value}", $coerce)
315 sub generate_trigger {
317 $self->{captures} = {};
318 my $code = $self->_generate_trigger(@_);
319 ($code, delete $self->{captures});
322 sub _generate_trigger {
323 my ($self, $name, $obj, $value, $trigger) = @_;
324 $self->_generate_call_code($name, 'trigger', "${obj}, ${value}", $trigger);
327 sub generate_isa_check {
328 my ($self, @args) = @_;
329 $self->{captures} = {};
330 my $code = $self->_generate_isa_check(@args);
331 ($code, delete $self->{captures});
334 sub _generate_die_prefix {
335 my ($self, $prefix, $inside) = @_;
337 .' my $sig_die = $SIG{__DIE__} || sub { die $_[0] };'."\n"
338 .' local $SIG{__DIE__} = sub {'."\n"
339 .' $sig_die->(ref($_[0]) ? $_[0] : '.perlstring($prefix).'.$_[0]);'."\n"
345 sub _generate_isa_check {
346 my ($self, $name, $value, $check, $init_arg) = @_;
347 $self->_generate_die_prefix(
348 "isa check for ${\_attr_desc($name, $init_arg)} failed: ",
349 $self->_generate_call_code($name, 'isa_check', $value, $check)
353 sub _generate_call_code {
354 my ($self, $name, $type, $values, $sub) = @_;
355 if (my $quoted = quoted_from_sub($sub)) {
356 my $code = $quoted->[1];
357 if (my $captures = $quoted->[2]) {
358 my $cap_name = qq{\$${type}_captures_for_${name}};
359 $self->{captures}->{$cap_name} = \$captures;
360 Sub::Quote::inlinify(
361 $code, $values, Sub::Quote::capture_unroll($cap_name, $captures, 6), 1
364 Sub::Quote::inlinify($code, $values, undef, 1);
367 my $cap_name = qq{\$${type}_for_${name}};
368 $self->{captures}->{$cap_name} = \$sub;
369 "${cap_name}->(${values})";
373 sub generate_populate_set {
375 $self->{captures} = {};
376 my $code = $self->_generate_populate_set(@_);
377 ($code, delete $self->{captures});
380 sub _generate_populate_set {
381 my ($self, $me, $name, $spec, $source, $test, $init_arg) = @_;
382 if ($self->has_eager_default($name, $spec)) {
383 my $get_indent = ' ' x ($spec->{isa} ? 6 : 4);
384 my $get_default = $self->_generate_get_default(
388 defined($spec->{init_arg})
389 ? "(\n${get_indent} ${test}\n${get_indent} ? ${source}\n${get_indent} : "
393 if ($spec->{coerce}) {
394 $get_value = $self->_generate_coerce(
396 $spec->{coerce}, $init_arg
400 ? " {\n my \$value = ".$get_value.";\n "
401 .$self->_generate_isa_check(
402 $name, '$value', $spec->{isa}, $init_arg
404 .' '.$self->_generate_simple_set($me, $name, $spec, '$value').";\n"
406 : ' '.$self->_generate_simple_set($me, $name, $spec, $get_value).";\n"
410 .$self->_generate_trigger(
411 $name, $me, $self->_generate_simple_get($me, $name, $spec),
420 .$self->_generate_coerce(
422 $spec->{coerce}, $init_arg
428 .$self->_generate_isa_check(
429 $name, $source, $spec->{isa}, $init_arg
433 ." ".$self->_generate_simple_set($me, $name, $spec, $source).";\n"
436 .$self->_generate_trigger(
437 $name, $me, $self->_generate_simple_get($me, $name, $spec),
446 sub _generate_core_set {
447 my ($self, $me, $name, $spec, $value) = @_;
448 my $name_str = perlstring $name;
449 "${me}->{${name_str}} = ${value}";
452 sub _generate_simple_set {
453 my ($self, $me, $name, $spec, $value) = @_;
454 my $name_str = perlstring $name;
456 if ($spec->{weak_ref}) {
457 $value = '$preserve = '.$value;
458 my $simple = $self->_generate_core_set($me, $name, $spec, $value);
459 require Scalar::Util;
461 # Perl < 5.8.3 can't weaken refs to readonly vars
462 # (e.g. string constants). This *can* be solved by:
464 #Internals::SetReadWrite($foo);
465 #Scalar::Util::weaken ($foo);
466 #Internals::SetReadOnly($foo);
468 # but requires XS and is just too damn crazy
469 # so simply throw a better exception
470 my $weak_simple = "my \$preserve; Scalar::Util::weaken(${simple}); no warnings 'void'; \$preserve";
471 Moo::_Utils::lt_5_8_3() ? <<"EOC" : $weak_simple;
474 eval { Scalar::Util::weaken($simple); 1 }
475 ? do { no warnings 'void'; \$preserve; }
477 if( \$@ =~ /Modification of a read-only value attempted/) {
479 Carp::croak( sprintf (
480 'Reference to readonly value in "%s" can not be weakened on Perl < 5.8.3',
489 $self->_generate_core_set($me, $name, $spec, $value);
493 sub _generate_getset {
494 my ($self, $name, $spec) = @_;
495 q{(@_ > 1}."\n ? ".$self->_generate_set($name, $spec)
496 ."\n : ".$self->_generate_get($name, $spec)."\n )";
499 sub _generate_delegation {
500 my ($self, $asserter, $target, $args) = @_;
501 my $arg_string = do {
503 # I could, I reckon, linearise out non-refs here using perlstring
504 # plus something to check for numbers but I'm unsure if it's worth it
505 $self->{captures}{'@curries'} = $args;
511 "shift->${asserter}->${target}(${arg_string});";
515 my ($self, $type, $into, $name, $slot) = @_;
516 Class::XSAccessor->import(
518 $type => { $name => $slot },
524 sub default_construction_string { '{}' }