xs-src/MouseAttribute.xs

   1 #include "mouse.h"
   2
   3 static MGVTBL mouse_xa_vtbl; /* identity */
   4
   5 static AV*
   6 mouse_build_xa(pTHX_ SV* const attr) {
   7     AV*    xa;
   8     MAGIC* mg;
   9
  10     SV* slot;
  11     STRLEN len;
  12     const char* pv;
  13     U16 flags = 0x00;
  14
  15     ENTER;
  16     SAVETMPS;
  17
  18     xa = newAV();
  19
  20     mg = sv_magicext(SvRV(attr), (SV*)xa, PERL_MAGIC_ext, &mouse_xa_vtbl, NULL, 0);
  21     SvREFCNT_dec(xa); /* refcnt++ in sv_magicext */
  22
  23     av_extend(xa, MOUSE_XA_last - 1);
  24
  25     slot = mcall0(attr, mouse_name);
  26     pv = SvPV_const(slot, len);
  27     av_store(xa, MOUSE_XA_SLOT, newSVpvn_share(pv, len, 0U));
  28
  29     av_store(xa, MOUSE_XA_ATTRIBUTE, newSVsv(attr));
  30
  31     av_store(xa, MOUSE_XA_INIT_ARG, newSVsv(mcall0s(attr, "init_arg")));
  32
  33     if(predicate_calls(attr, "has_type_constraint")){
  34         SV* tc;
  35         flags |= MOUSEf_ATTR_HAS_TC;
  36
  37         tc = mcall0s(attr, "type_constraint");
  38         av_store(xa, MOUSE_XA_TC, newSVsv(tc));
  39
  40         if(predicate_calls(attr, "should_auto_deref")){
  41             SV* const is_a_type_of = sv_2mortal(newSVpvs_share("is_a_type_of"));
  42
  43             flags |= MOUSEf_ATTR_SHOULD_AUTO_DEREF;
  44             if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("ArrayRef", SVs_TEMP))) ){
  45                 flags |= MOUSEf_TC_IS_ARRAYREF;
  46             }
  47             else if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("HashRef", SVs_TEMP))) ){
  48                 flags |= MOUSEf_TC_IS_HASHREF;
  49             }
  50             else{
  51                 mouse_throw_error(attr, tc,
  52                     "Can not auto de-reference the type constraint '%"SVf"'",
  53                         mcall0(tc, mouse_name));
  54             }
  55         }
  56
  57         if(predicate_calls(attr, "should_coerce") && predicate_calls(tc, "has_coercion")){
  58             flags |= MOUSEf_ATTR_SHOULD_COERCE;
  59         }
  60
  61     }
  62
  63     if(predicate_calls(attr, "has_trigger")){
  64         flags |= MOUSEf_ATTR_HAS_TRIGGER;
  65     }
  66
  67     if(predicate_calls(attr, "is_lazy")){
  68         flags |= MOUSEf_ATTR_IS_LAZY;
  69     }
  70     if(predicate_calls(attr, "has_builder")){
  71         flags |= MOUSEf_ATTR_HAS_BUILDER;
  72     }
  73     else if(predicate_calls(attr, "has_default")){
  74         flags |= MOUSEf_ATTR_HAS_DEFAULT;
  75     }
  76
  77     if(predicate_calls(attr, "is_weak_ref")){
  78         flags |= MOUSEf_ATTR_IS_WEAK_REF;
  79     }
  80
  81     if(predicate_calls(attr, "is_required")){
  82         flags |= MOUSEf_ATTR_IS_REQUIRED;
  83     }
  84
  85     av_store(xa, MOUSE_XA_FLAGS, newSVuv(flags));
  86     MOUSE_mg_flags(mg) = flags;
  87
  88     FREETMPS;
  89     LEAVE;
  90
  91     return xa;
  92 }
  93
  94 AV*
  95 mouse_get_xa(pTHX_ SV* const attr) {
  96     AV*    xa;
  97     MAGIC* mg;
  98
  99     if(!IsObject(attr)){
 100         croak("Not a Mouse meta attribute");
 101     }
 102
 103     mg = mouse_mg_find(aTHX_ SvRV(attr), &mouse_xa_vtbl, 0x00);
 104     if(!mg){
 105         xa = mouse_build_xa(aTHX_ attr);
 106     }
 107     else{
 108         xa = (AV*)MOUSE_mg_obj(mg);
 109
 110         assert(xa);
 111         assert(SvTYPE(xa) == SVt_PVAV);
 112     }
 113
 114     return xa;
 115 }
 116
 117 SV*
 118 mouse_xa_apply_type_constraint(pTHX_ AV* const xa, SV* value, U16 const flags){
 119     SV* const tc = MOUSE_xa_tc(xa);
 120     SV* tc_code;
 121
 122     if(flags & MOUSEf_ATTR_SHOULD_COERCE){
 123           value = mcall1(tc, mouse_coerce, value);
 124     }
 125
 126     if(!SvOK(MOUSE_xa_tc_code(xa))){
 127         tc_code = mcall0s(tc, "_compiled_type_constraint");
 128         av_store(xa, MOUSE_XA_TC_CODE, newSVsv(tc_code));
 129
 130         if(!IsCodeRef(tc_code)){
 131             mouse_throw_error(MOUSE_xa_attribute(xa), tc, "Not a CODE reference");
 132         }
 133     }
 134     else{
 135         tc_code = MOUSE_xa_tc_code(xa);
 136     }
 137
 138     if(!mouse_tc_check(aTHX_ tc_code, value)){
 139         mouse_throw_error(MOUSE_xa_attribute(xa), value,
 140             "Attribute (%"SVf") does not pass the type constraint because: %"SVf,
 141                 mcall0(MOUSE_xa_attribute(xa), mouse_name),
 142                 mcall1s(tc, "get_message", value));
 143     }
 144
 145     return value;
 146 }
 147
 148
 149 SV*
 150 mouse_xa_set_default(pTHX_ AV* const xa, SV* const object) {
 151     U16 const flags = (U16)MOUSE_xa_flags(xa);
 152     SV* value;
 153
 154     ENTER;
 155     SAVETMPS;
 156
 157     /* get default value by $attr->builder or $attr->default */
 158     if(flags & MOUSEf_ATTR_HAS_BUILDER){
 159         SV* const builder = mcall0s(MOUSE_xa_attribute(xa), "builder");
 160         value = mcall0(object, builder); /* $object->$builder() */
 161     }
 162     else {
 163         value = mcall0s(MOUSE_xa_attribute(xa), "default");
 164
 165         if(IsCodeRef(value)){
 166             value = mcall0(object, value);
 167         }
 168     }
 169
 170     /* apply coerce and type constraint */
 171     if(flags & MOUSEf_ATTR_HAS_TC){
 172         value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
 173     }
 174
 175     /* store value to slot */
 176     value = set_slot(object, MOUSE_xa_slot(xa), value);
 177     if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){
 178         weaken_slot(object, MOUSE_xa_slot(xa));
 179     }
 180
 181     FREETMPS;
 182     LEAVE;
 183
 184     return value;
 185 }
 186
 187 /* checks $isa->does($does) */
 188 static void
 189 mouse_check_isa_does_does(pTHX_ SV* const klass, SV* const name, SV* const isa, SV* const does){
 190     STRLEN len;
 191     const char* const pv = SvPV_const(isa, len); /* need strigify */
 192     bool does_ok;
 193     dSP;
 194
 195     ENTER;
 196     SAVETMPS;
 197
 198     SAVESPTR(ERRSV);
 199     ERRSV = sv_newmortal();
 200
 201     PUSHMARK(SP);
 202     EXTEND(SP, 2);
 203     mPUSHp(pv, len);
 204     PUSHs(does);
 205     PUTBACK;
 206
 207     call_method("does", G_EVAL | G_SCALAR);
 208
 209     SPAGAIN;
 210     does_ok = sv_true(POPs);
 211     PUTBACK;
 212
 213     FREETMPS;
 214     LEAVE;
 215
 216     if(!does_ok){
 217         mouse_throw_error(klass, NULL,
 218             "Cannot have both an isa option and a does option"
 219             "because '%"SVf"' does not do '%"SVf"' on attribute (%"SVf")",
 220             isa, does, name
 221         );
 222     }
 223 }
 224
 225 MODULE = Mouse::Meta::Attribute  PACKAGE = Mouse::Meta::Attribute
 226
 227 PROTOTYPES: DISABLE
 228
 229 BOOT:
 230     /* readers */
 231     INSTALL_SIMPLE_READER(Attribute, name);
 232     INSTALL_SIMPLE_READER(Attribute, associated_class);
 233     INSTALL_SIMPLE_READER(Attribute, accessor);
 234     INSTALL_SIMPLE_READER(Attribute, reader);
 235     INSTALL_SIMPLE_READER(Attribute, writer);
 236     INSTALL_SIMPLE_READER(Attribute, predicate);
 237     INSTALL_SIMPLE_READER(Attribute, clearer);
 238     INSTALL_SIMPLE_READER(Attribute, handles);
 239
 240     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, _is_metadata, is);
 241     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_required, required);
 242     INSTALL_SIMPLE_READER(Attribute, default);
 243     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy, lazy);
 244     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy_build, lazy_build);
 245     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_weak_ref, weak_ref);
 246     INSTALL_SIMPLE_READER(Attribute, init_arg);
 247     INSTALL_SIMPLE_READER(Attribute, type_constraint);
 248     INSTALL_SIMPLE_READER(Attribute, trigger);
 249     INSTALL_SIMPLE_READER(Attribute, builder);
 250     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_auto_deref, auto_deref);
 251     INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_coerce, coerce);
 252     INSTALL_SIMPLE_READER(Attribute, documentation);
 253     INSTALL_SIMPLE_READER(Attribute, insertion_order);
 254
 255     /* predicates */
 256     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_accessor, accessor);
 257     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_reader, reader);
 258     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_writer, writer);
 259     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_predicate, predicate);
 260     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_clearer, clearer);
 261     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_handles, handles);
 262
 263     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_default, default);
 264     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_type_constraint, type_constraint);
 265     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_trigger, trigger);
 266     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_builder, builder);
 267     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_documentation, documentation);
 268
 269     INSTALL_CLASS_HOLDER(Attribute, accessor_metaclass, "Mouse::Meta::Method::Accessor::XS");
 270
 271 void
 272 _process_options(SV* klass, SV* name, HV* args)
 273 CODE:
 274 {
 275     /* TODO: initialize 'xa' here */
 276     SV** svp;
 277     SV* tc = NULL;
 278
 279     /* 'required' requires eigher 'init_arg', 'builder', or 'default' */
 280     bool can_be_required = FALSE;
 281     bool has_default     = FALSE;
 282     bool has_builder     = FALSE;
 283
 284     /* taken from Class::MOP::Attribute::new */
 285
 286     must_defined(name, "an attribute name");
 287
 288     svp = hv_fetchs(args, "init_arg", FALSE);
 289     if(!svp){
 290         (void)hv_stores(args, "init_arg", newSVsv(name));
 291         can_be_required = TRUE;
 292     }
 293     else{
 294         can_be_required = SvOK(*svp) ? TRUE : FALSE;
 295     }
 296
 297     svp = hv_fetchs(args, "builder", FALSE);
 298     if(svp){
 299         if(!SvOK(*svp)){
 300             mouse_throw_error(klass, *svp,
 301                 "builder must be a defined scalar value which is a method name");
 302         }
 303         can_be_required = TRUE;
 304         has_builder     = TRUE;
 305     }
 306     else if((svp = hv_fetchs(args, "default", FALSE))){
 307         if(SvROK(*svp) && SvTYPE(SvRV(*svp)) != SVt_PVCV) {
 308             mouse_throw_error(klass, *svp,
 309                "References are not allowed as default values, you must "
 310                 "wrap the default of '%"SVf"' in a CODE reference "
 311                 "(ex: sub { [] } and not [])", name);
 312         }
 313         can_be_required = TRUE;
 314         has_default     = TRUE;
 315     }
 316
 317     svp = hv_fetchs(args, "required", FALSE);
 318     if( (svp && sv_true(*svp)) && !can_be_required){
 319         mouse_throw_error(klass, NULL,
 320             "You cannot have a required attribute (%"SVf") "
 321             "without a default, builder, or an init_arg", name);
 322     }
 323
 324     /* taken from Mouse::Meta::Attribute->new and ->_process_args */
 325
 326     svp = hv_fetchs(args, "is", FALSE);
 327     if(svp){
 328         const char* const is = SvOK(*svp) ? SvPV_nolen_const(*svp) : "undef";
 329         if(strEQ(is, "ro")){
 330             svp = hv_fetchs(args, "reader", TRUE);
 331             if(!sv_true(*svp)){
 332                 sv_setsv(*svp, name);
 333             }
 334         }
 335         else if(strEQ(is, "rw")){
 336             if(hv_fetchs(args, "writer", FALSE)){
 337                 svp = hv_fetchs(args, "reader", TRUE);
 338             }
 339             else{
 340                 svp = hv_fetchs(args, "accessor", TRUE);
 341             }
 342             if(!SvOK(*svp)) {
 343                 sv_setsv(*svp, name);
 344             }
 345         }
 346         else if(strEQ(is, "bare")){
 347             /* do nothing, but might complain later about missing methods */
 348         }
 349         else{
 350             mouse_throw_error(klass, NULL,
 351                 "I do not understand this option (is => %s) on attribute (%"SVf")",
 352                 is, name);
 353         }
 354     }
 355
 356     svp = hv_fetchs(args, "isa", FALSE);
 357     if(svp){
 358         SPAGAIN;
 359         PUSHMARK(SP);
 360         XPUSHs(*svp);
 361         PUTBACK;
 362
 363         call_pv("Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint",
 364             G_SCALAR);
 365         SPAGAIN;
 366         tc = newSVsv(POPs);
 367         PUTBACK;
 368     }
 369
 370     if((svp = hv_fetchs(args, "does", FALSE))){
 371         /* check 'isa' does 'does' */
 372         if(tc){
 373             mouse_check_isa_does_does(aTHX_ klass, name, tc, *svp);
 374             /* nothing to do */
 375         }
 376         else{
 377             SPAGAIN;
 378             PUSHMARK(SP);
 379             XPUSHs(*svp);
 380             PUTBACK;
 381
 382             call_pv("Mouse::Util::TypeConstraints::find_or_create_does_type_constraint",
 383                 G_SCALAR);
 384             SPAGAIN;
 385             tc = newSVsv(POPs);
 386             PUTBACK;
 387         }
 388     }
 389     if(tc){
 390         (void)hv_stores(args, "type_constraint", tc);
 391     }
 392
 393     svp = hv_fetchs(args, "coerce", FALSE);
 394     if(svp){
 395         if(!tc){
 396             mouse_throw_error(klass, NULL,
 397                 "You cannot have coercion without specifying a type constraint "
 398                 "on attribute (%"SVf")", name);
 399         }
 400         svp = hv_fetchs(args, "weak_ref", FALSE);
 401         if(svp && sv_true(*svp)){
 402             mouse_throw_error(klass, NULL,
 403                 "You cannot have a weak reference to a coerced value on "
 404                 "attribute (%"SVf")", name);
 405         }
 406     }
 407
 408     svp = hv_fetchs(args, "lazy_build", FALSE);
 409     if(svp){
 410         SV* clearer;
 411         SV* predicate;
 412         if(has_default){
 413             mouse_throw_error(klass, NULL,
 414                 "You can not use lazy_build and default for the same "
 415                 "attribute (%"SVf")", name);
 416         }
 417
 418         svp = hv_fetchs(args, "lazy", TRUE);
 419         sv_setiv(*svp, TRUE);
 420
 421         svp = hv_fetchs(args, "builder", TRUE);
 422         if(!sv_true(*svp)){
 423             sv_setpvf(*svp, "_build_%"SVf, name);
 424         }
 425         has_builder = TRUE;
 426
 427         clearer   = *hv_fetchs(args, "clearer",   TRUE);
 428         predicate = *hv_fetchs(args, "predicate", TRUE);
 429
 430         if(SvPV_nolen_const(name)[0] == '_'){
 431             if(!sv_true(clearer)){
 432                 sv_setpvf(clearer, "_clear%"SVf, name);
 433             }
 434             if(!sv_true(predicate)){
 435                 sv_setpvf(predicate, "_has%"SVf, name);
 436             }
 437         }
 438         else{
 439             if(!sv_true(clearer)){
 440                 sv_setpvf(clearer, "clear_%"SVf, name);
 441             }
 442             if(!sv_true(predicate)){
 443                 sv_setpvf(predicate, "has_%"SVf, name);
 444             }
 445         }
 446     }
 447
 448     svp = hv_fetchs(args, "auto_deref", FALSE);
 449     if(svp && sv_true(*svp)){
 450         SV* const meth = sv_2mortal(newSVpvs_share("is_a_type_of"));
 451         if(!tc){
 452             mouse_throw_error(klass, NULL,
 453                 "You cannot auto-dereference without specifying a type "
 454                 "constraint on attribute (%"SVf")", name);
 455         }
 456
 457         if(!(sv_true(mcall1(tc, meth, newSVpvs_flags("ArrayRef", SVs_TEMP)))
 458             || sv_true(mcall1(tc, meth, newSVpvs_flags("HashRef", SVs_TEMP))) )){
 459             mouse_throw_error(klass, NULL,
 460                 "You cannot auto-dereference anything other than a ArrayRef "
 461                 "or HashRef on attribute (%"SVf")", name);
 462         }
 463     }
 464
 465     svp = hv_fetchs(args, "trigger", FALSE);
 466     if(svp){
 467         if(!IsCodeRef(*svp)){
 468             mouse_throw_error(klass, NULL,
 469                 "Trigger must be a CODE ref on attribute (%"SVf")",
 470                 name);
 471         }
 472     }
 473
 474
 475     svp = hv_fetchs(args, "lazy", FALSE);
 476     if(svp && sv_true(*svp)){
 477         if(!(has_default || has_builder)){
 478             mouse_throw_error(klass, NULL,
 479                 "You cannot have a lazy attribute (%"SVf") without specifying "
 480                 "a default value for it", name);
 481         }
 482     }
 483 }