lib/Method/Generate/Accessor.pm

   1 package Method::Generate::Accessor;
   2
   3 use strictures 1;
   4 use Class::Tiny::_Utils;
   5 use base qw(Class::Tiny::Object);
   6 use Sub::Quote;
   7 use B 'perlstring';
   8
   9 sub generate_method {
  10   my ($self, $into, $name, $spec, $quote_opts) = @_;
  11   die "Must have an is" unless my $is = $spec->{is};
  12   local $self->{captures} = {};
  13   my $body = do {
  14     if ($is eq 'ro') {
  15       $self->_generate_get($name, $spec)
  16     } elsif ($is eq 'rw') {
  17       $self->_generate_getset($name, $spec)
  18     } else {
  19       die "Unknown is ${is}";
  20     }
  21   };
  22   if (my $pred = $spec->{predicate}) {
  23     quote_sub "${into}::${pred}" =>
  24       '    '.$self->_generate_simple_has('$_[0]', $name)."\n"
  25     ;
  26   }
  27   if (my $cl = $spec->{clearer}) {
  28     quote_sub "${into}::${cl}" =>
  29       "    delete \$_[0]->{${\perlstring $name}}\n"
  30     ;
  31   }
  32   quote_sub
  33     "${into}::${name}" => '    '.$body."\n",
  34     $self->{captures}, $quote_opts||{}
  35   ;
  36 }
  37
  38 sub is_simple_attribute {
  39   my ($self, $name, $spec) = @_;
  40   # clearer doesn't have to be listed because it doesn't
  41   # affect whether defined/exists makes a difference
  42   return !grep $spec->{$_},
  43     qw(lazy default builder isa trigger predicate);
  44 }
  45
  46 sub _generate_get {
  47   my ($self, $name, $spec) = @_;
  48   my $simple = $self->_generate_simple_get('$_[0]', $name);
  49   my ($lazy, $default, $builder) = @{$spec}{qw(lazy default builder)};
  50   return $simple unless $lazy and ($default or $builder);
  51   'do { '.$self->_generate_use_default(
  52     '$_[0]', $name, $spec,
  53     $self->_generate_simple_has('$_[0]', $name),
  54   ).'; '.$simple.' }';
  55 }
  56
  57 sub _generate_simple_has {
  58   my ($self, $me, $name) = @_;
  59   "exists ${me}->{${\perlstring $name}}";
  60 }
  61
  62 sub generate_get_default {
  63   my $self = shift;
  64   local $self->{captures} = {};
  65   my $code = $self->_generate_get_default(@_);
  66   return ($code, $self->{captures});
  67 }
  68
  69 sub _generate_use_default {
  70   my ($self, $me, $name, $spec, $test) = @_;
  71   $self->_generate_simple_set(
  72     $me, $name, $self->_generate_get_default($me, $name, $spec)
  73   ).' unless '.$test;
  74 }
  75
  76 sub _generate_get_default {
  77   my ($self, $me, $name, $spec) = @_;
  78   $spec->{default}
  79     ? $self->_generate_call_code($name, 'default', $me, $spec->{default})
  80     : "${me}->${\$spec->{builder}}"
  81 }
  82
  83 sub generate_simple_get {
  84   shift->_generate_simple_get(@_);
  85 }
  86
  87 sub _generate_simple_get {
  88   my ($self, $me, $name) = @_;
  89   my $name_str = perlstring $name;
  90   "${me}->{${name_str}}";
  91 }
  92
  93 sub _generate_set {
  94   my ($self, $name, $value, $spec) = @_;
  95   my $simple = $self->_generate_simple_set('$_[0]', $name, $value);
  96   my ($trigger, $isa_check) = @{$spec}{qw(trigger isa)};
  97   return $simple unless $trigger or $isa_check;
  98   my $code = 'do {';
  99   if ($isa_check) {
 100     $code .= ' '.$self->_generate_isa_check($name, '$_[1]', $isa_check).';';
 101   }
 102   if ($trigger) {
 103     my $fire = $self->_generate_trigger($name, '$_[0]', '$value', $trigger);
 104     $code .=
 105       ' my $value = '.$simple.'; '.$fire.'; '
 106       .'$value';
 107   } else {
 108     $code .= ' '.$simple;
 109   }
 110   $code .= ' }';
 111   return $code;
 112 }
 113
 114 sub generate_trigger {
 115   my $self = shift;
 116   local $self->{captures} = {};
 117   my $code = $self->_generate_trigger(@_);
 118   return ($code, $self->{captures});
 119 }
 120
 121 sub _generate_trigger {
 122   my ($self, $name, $obj, $value, $trigger) = @_;
 123   $self->_generate_call_code($name, 'trigger', "${obj}, ${value}", $trigger);
 124 }
 125
 126 sub generate_isa_check {
 127   my $self = shift;
 128   local $self->{captures} = {};
 129   my $code = $self->_generate_isa_check(@_);
 130   return ($code, $self->{captures});
 131 }
 132
 133 sub _generate_isa_check {
 134   my ($self, $name, $value, $check) = @_;
 135   $self->_generate_call_code($name, 'isa_check', $value, $check);
 136 }
 137
 138 sub _generate_call_code {
 139   my ($self, $name, $type, $values, $sub) = @_;
 140   if (my $quoted = quoted_from_sub($sub)) {
 141     my $code = $quoted->[1];
 142     my $at_ = 'local @_ = ('.$values.');';
 143     if (my $captures = $quoted->[2]) {
 144       my $cap_name = qq{\$${type}_captures_for_${name}};
 145       $self->{captures}->{$cap_name} = \$captures;
 146       return "do {\n".'      '.$at_."\n"
 147         .Sub::Quote::capture_unroll($cap_name, $captures, 6)
 148         ."     ${code}\n    }";
 149     }
 150     return 'do { local @_ = ('.$values.'); '.$code.' }';
 151   }
 152   my $cap_name = qq{\$${type}_for_${name}};
 153   $self->{captures}->{$cap_name} = \$sub;
 154   return "${cap_name}->(${values})";
 155 }
 156
 157 sub generate_populate_set {
 158   my $self = shift;
 159   local $self->{captures} = {};
 160   my $code = $self->_generate_populate_set(@_);
 161   return ($code, $self->{captures});
 162 }
 163
 164 sub _generate_populate_set {
 165   my ($self, $me, $name, $spec, $source, $test) = @_;
 166   if (!$spec->{lazy} and
 167         ($spec->{default} or $spec->{builder})) {
 168     my $get_indent = ' ' x ($spec->{isa} ? 6 : 4);
 169     my $get_value =
 170       "(\n${get_indent}  ${test}\n${get_indent}   ? ${source}\n${get_indent}   : "
 171         .$self->_generate_get_default(
 172           '$new', $_, $spec
 173         )
 174         ."\n${get_indent})";
 175     ($spec->{isa}
 176       ? "    {\n      my \$value = ".$get_value.";\n      "
 177         .$self->_generate_isa_check(
 178           $name, '$value', $spec->{isa}
 179         ).";\n"
 180         .'      '.$self->_generate_simple_set($me, $name, '$value').";\n"
 181         ."    }\n"
 182       : '    '.$self->_generate_simple_set($me, $name, $get_value).";\n"
 183     )
 184     .($spec->{trigger}
 185       ? '    '
 186         .$self->_generate_trigger(
 187           $name, $me, $self->_generate_simple_get($me, $name),
 188           $spec->{trigger}
 189         )." if ${test};\n"
 190       : ''
 191     );
 192   } else {
 193     "    if (${test}) {\n"
 194       .($spec->{isa}
 195         ? "      "
 196           .$self->_generate_isa_check(
 197             $name, $source, $spec->{isa}
 198           ).";\n"
 199         : ""
 200       )
 201       ."      ".$self->_generate_simple_set($me, $name, $source).";\n"
 202       .($spec->{trigger}
 203         ? "      "
 204           .$self->_generate_trigger(
 205             $name, $me, $self->_generate_simple_get($me, $name),
 206             $spec->{trigger}
 207           ).";\n"
 208         : ""
 209       )
 210       ."    }\n";
 211   }
 212 }
 213
 214 sub generate_multi_set {
 215   my ($self, $me, $to_set, $from) = @_;
 216   "\@{${me}}{qw(${\join ' ', @$to_set})} = $from";
 217 }
 218
 219 sub generate_simple_set {
 220   my $self = shift;
 221   local $self->{captures} = {};
 222   my $code = $self->_generate_simple_set(@_);
 223   return ($code, $self->{captures});
 224 }
 225
 226 sub _generate_simple_set {
 227   my ($self, $me, $name, $value) = @_;
 228   my $name_str = perlstring $name;
 229   "${me}->{${name_str}} = ${value}";
 230 }
 231
 232 sub _generate_getset {
 233   my ($self, $name, $spec) = @_;
 234   q{(@_ > 1 ? }.$self->_generate_set($name, q{$_[1]}, $spec)
 235     .' : '.$self->_generate_get($name).')';
 236 }
 237
 238 1;