lib/Moose/Meta/Attribute.pm

   1
   2 package Moose::Meta::Attribute;
   3
   4 use strict;
   5 use warnings;
   6
   7 use Scalar::Util 'blessed', 'weaken', 'reftype';
   8 use Carp         'confess';
   9 use Sub::Name    'subname';
  10 use overload     ();
  11
  12 our $VERSION   = '0.18';
  13 our $AUTHORITY = 'cpan:STEVAN';
  14
  15 use Moose::Meta::Method::Accessor;
  16 use Moose::Util::TypeConstraints ();
  17
  18 use base 'Class::MOP::Attribute';
  19
  20 # options which are not directly used
  21 # but we store them for metadata purposes
  22 __PACKAGE__->meta->add_attribute('isa'  => (reader    => '_isa_metadata'));
  23 __PACKAGE__->meta->add_attribute('does' => (reader    => '_does_metadata'));
  24 __PACKAGE__->meta->add_attribute('is'   => (reader    => '_is_metadata'));
  25
  26 # these are actual options for the attrs
  27 __PACKAGE__->meta->add_attribute('required'   => (reader => 'is_required'      ));
  28 __PACKAGE__->meta->add_attribute('lazy'       => (reader => 'is_lazy'          ));
  29 __PACKAGE__->meta->add_attribute('lazy_build' => (reader => 'is_lazy_build'    ));
  30 __PACKAGE__->meta->add_attribute('coerce'     => (reader => 'should_coerce'    ));
  31 __PACKAGE__->meta->add_attribute('weak_ref'   => (reader => 'is_weak_ref'      ));
  32 __PACKAGE__->meta->add_attribute('auto_deref' => (reader => 'should_auto_deref'));
  33 __PACKAGE__->meta->add_attribute('type_constraint' => (
  34     reader    => 'type_constraint',
  35     predicate => 'has_type_constraint',
  36 ));
  37 __PACKAGE__->meta->add_attribute('trigger' => (
  38     reader    => 'trigger',
  39     predicate => 'has_trigger',
  40 ));
  41 __PACKAGE__->meta->add_attribute('handles' => (
  42     reader    => 'handles',
  43     predicate => 'has_handles',
  44 ));
  45 __PACKAGE__->meta->add_attribute('documentation' => (
  46     reader    => 'documentation',
  47     predicate => 'has_documentation',
  48 ));
  49
  50 sub new {
  51     my ($class, $name, %options) = @_;
  52     $class->_process_options($name, \%options);
  53     return $class->SUPER::new($name, %options);
  54 }
  55
  56 sub clone_and_inherit_options {
  57     my ($self, %options) = @_;
  58     # you can change default, required, coerce, documentation and lazy
  59     my %actual_options;
  60     foreach my $legal_option (qw(default coerce required documentation lazy)) {
  61         if (exists $options{$legal_option}) {
  62             $actual_options{$legal_option} = $options{$legal_option};
  63             delete $options{$legal_option};
  64         }
  65     }
  66
  67     # handles can only be added, not changed
  68     if ($options{handles}) {
  69         confess "You can only add the 'handles' option, you cannot change it"
  70             if $self->has_handles;
  71         $actual_options{handles} = $options{handles};
  72         delete $options{handles};
  73     }
  74
  75     # isa can be changed, but only if the
  76     # new type is a subtype
  77     if ($options{isa}) {
  78         my $type_constraint;
  79         if (blessed($options{isa}) && $options{isa}->isa('Moose::Meta::TypeConstraint')) {
  80             $type_constraint = $options{isa};
  81         }
  82         else {
  83             $type_constraint = Moose::Util::TypeConstraints::find_or_create_type_constraint(
  84                 $options{isa}
  85             );
  86             (defined $type_constraint)
  87                 || confess "Could not find the type constraint '" . $options{isa} . "'";
  88         }
  89         # NOTE:
  90         # check here to see if the new type
  91         # is a subtype of the old one
  92         ($type_constraint->is_subtype_of($self->type_constraint->name))
  93             || confess "New type constraint setting must be a subtype of inherited one"
  94                 # iff we have a type constraint that is ...
  95                 if $self->has_type_constraint;
  96         # then we use it :)
  97         $actual_options{type_constraint} = $type_constraint;
  98         delete $options{isa};
  99     }
 100     (scalar keys %options == 0)
 101         || confess "Illegal inherited options => (" . (join ', ' => keys %options) . ")";
 102     $self->clone(%actual_options);
 103 }
 104
 105 sub _process_options {
 106     my ($class, $name, $options) = @_;
 107
 108     if (exists $options->{is}) {
 109         if ($options->{is} eq 'ro') {
 110             $options->{reader} ||= $name;
 111             (!exists $options->{trigger})
 112                 || confess "Cannot have a trigger on a read-only attribute";
 113         }
 114         elsif ($options->{is} eq 'rw') {
 115             $options->{accessor} = $name;
 116             ((reftype($options->{trigger}) || '') eq 'CODE')
 117                 || confess "Trigger must be a CODE ref"
 118                     if exists $options->{trigger};
 119         }
 120         else {
 121             confess "I do not understand this option (is => " . $options->{is} . ")"
 122         }
 123     }
 124
 125     if (exists $options->{isa}) {
 126         if (exists $options->{does}) {
 127             if (eval { $options->{isa}->can('does') }) {
 128                 ($options->{isa}->does($options->{does}))
 129                     || confess "Cannot have an isa option and a does option if the isa does not do the does";
 130             }
 131             else {
 132                 confess "Cannot have an isa option which cannot ->does()";
 133             }
 134         }
 135
 136         # allow for anon-subtypes here ...
 137         if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) {
 138             $options->{type_constraint} = $options->{isa};
 139         }
 140         else {
 141             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_type_constraint(
 142                 $options->{isa} => {
 143                     parent     => Moose::Util::TypeConstraints::find_type_constraint('Object'),
 144                     constraint => sub { $_[0]->isa($options->{isa}) }
 145                 }
 146             );
 147         }
 148     }
 149     elsif (exists $options->{does}) {
 150         # allow for anon-subtypes here ...
 151         if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
 152                 $options->{type_constraint} = $options->{does};
 153         }
 154         else {
 155             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_type_constraint(
 156                 $options->{does} => {
 157                     parent     => Moose::Util::TypeConstraints::find_type_constraint('Role'),
 158                     constraint => sub {
 159                         Moose::Util::does_role($_[0], $options->{does})
 160                     }
 161                 }
 162             );
 163         }
 164     }
 165
 166     if (exists $options->{coerce} && $options->{coerce}) {
 167         (exists $options->{type_constraint})
 168             || confess "You cannot have coercion without specifying a type constraint";
 169         confess "You cannot have a weak reference to a coerced value"
 170             if $options->{weak_ref};
 171     }
 172
 173     if (exists $options->{auto_deref} && $options->{auto_deref}) {
 174         (exists $options->{type_constraint})
 175             || confess "You cannot auto-dereference without specifying a type constraint";
 176         ($options->{type_constraint}->is_a_type_of('ArrayRef') ||
 177          $options->{type_constraint}->is_a_type_of('HashRef'))
 178             || confess "You cannot auto-dereference anything other than a ArrayRef or HashRef";
 179     }
 180
 181     if (exists $options->{lazy_build} && $options->{lazy_build} == 1) {
 182         confess("You can not use lazy_build and default for the same attribute")
 183             if exists $options->{default};
 184         $options->{lazy}      = 1;
 185         $options->{required}  = 1;
 186         $options->{builder} ||= "_build_${name}";
 187         if ($name =~ /^_/) {
 188             $options->{clearer}   ||= "_clear${name}";
 189             $options->{predicate} ||= "_has${name}";
 190         }
 191         else {
 192             $options->{clearer}   ||= "clear_${name}";
 193             $options->{predicate} ||= "has_${name}";
 194         }
 195     }
 196
 197     if (exists $options->{lazy} && $options->{lazy}) {
 198         (exists $options->{default} || defined $options->{builder} )
 199             || confess "You cannot have lazy attribute without specifying a default value for it";
 200     }
 201
 202     if ( $options->{required} && !( ( !exists $options->{init_arg} || defined $options->{init_arg} ) || exists $options->{default} || defined $options->{builder} ) ) {
 203         confess "You cannot have a required attribute without a default, builder, or an init_arg";
 204     }
 205
 206 }
 207
 208 sub initialize_instance_slot {
 209     my ($self, $meta_instance, $instance, $params) = @_;
 210     my $init_arg = $self->init_arg();
 211     # try to fetch the init arg from the %params ...
 212
 213     my $val;
 214     my $value_is_set;
 215     if ( defined($init_arg) and exists $params->{$init_arg}) {
 216         $val = $params->{$init_arg};
 217         $value_is_set = 1;
 218     }
 219     else {
 220         # skip it if it's lazy
 221         return if $self->is_lazy;
 222         # and die if it's required and doesn't have a default value
 223         confess "Attribute (" . $self->name . ") is required"
 224             if $self->is_required && !$self->has_default && !$self->has_builder;
 225
 226         # if nothing was in the %params, we can use the
 227         # attribute's default value (if it has one)
 228         if ($self->has_default) {
 229             $val = $self->default($instance);
 230             $value_is_set = 1;
 231         }
 232         elsif ($self->has_builder) {
 233             if (my $builder = $instance->can($self->builder)){
 234                 $val = $instance->$builder;
 235                 $value_is_set = 1;
 236             }
 237             else {
 238                 confess(blessed($instance)." does not support builder method '".$self->builder."' for attribute '" . $self->name . "'");
 239             }
 240         }
 241     }
 242
 243     return unless $value_is_set;
 244
 245     if ($self->has_type_constraint) {
 246         my $type_constraint = $self->type_constraint;
 247         if ($self->should_coerce && $type_constraint->has_coercion) {
 248             $val = $type_constraint->coerce($val);
 249         }
 250         (defined($type_constraint->check($val)))
 251             || confess "Attribute (" .
 252                        $self->name .
 253                        ") does not pass the type constraint (" .
 254                        $type_constraint->name .
 255                        ") with '" .
 256                        (defined $val
 257                            ? overload::StrVal($val)
 258                            : 'undef') .
 259                        "'";
 260     }
 261
 262     $meta_instance->set_slot_value($instance, $self->name, $val);
 263     $meta_instance->weaken_slot_value($instance, $self->name)
 264         if ref $val && $self->is_weak_ref;
 265 }
 266
 267 ## Slot management
 268
 269 sub set_value {
 270     my ($self, $instance, $value) = @_;
 271
 272     my $attr_name = $self->name;
 273
 274     if ($self->is_required) {
 275         defined($value)
 276             || confess "Attribute ($attr_name) is required, so cannot be set to undef";
 277     }
 278
 279     if ($self->has_type_constraint) {
 280
 281         my $type_constraint = $self->type_constraint;
 282
 283         if ($self->should_coerce) {
 284             $value = $type_constraint->coerce($value);
 285         }
 286         $type_constraint->_compiled_type_constraint->($value)
 287                 || confess "Attribute ($attr_name) does not pass the type constraint ("
 288                . $type_constraint->name
 289                . ") with "
 290                . (defined($value)
 291                     ? ("'" . overload::StrVal($value) . "'")
 292                     : "undef")
 293           if defined($value);
 294     }
 295
 296     my $meta_instance = Class::MOP::Class->initialize(blessed($instance))
 297                                          ->get_meta_instance;
 298
 299     $meta_instance->set_slot_value($instance, $attr_name, $value);
 300
 301     if (ref $value && $self->is_weak_ref) {
 302         $meta_instance->weaken_slot_value($instance, $attr_name);
 303     }
 304
 305     if ($self->has_trigger) {
 306         $self->trigger->($instance, $value, $self);
 307     }
 308 }
 309
 310 sub get_value {
 311     my ($self, $instance) = @_;
 312
 313     if ($self->is_lazy) {
 314         unless ($self->has_value($instance)) {
 315             if ($self->has_default) {
 316                 my $default = $self->default($instance);
 317                 $self->set_value($instance, $default);
 318             }
 319             if ( $self->has_builder ){
 320                 if (my $builder = $instance->can($self->builder)){
 321                     $self->set_value($instance, $instance->$builder);
 322                 }
 323                 else {
 324                     confess(blessed($instance)
 325                           . " does not support builder method '"
 326                           . $self->builder
 327                           . "' for attribute '"
 328                           . $self->name
 329                           . "'");
 330                 }
 331             }
 332             else {
 333                 $self->set_value($instance, undef);
 334             }
 335         }
 336     }
 337
 338     if ($self->should_auto_deref) {
 339
 340         my $type_constraint = $self->type_constraint;
 341
 342         if ($type_constraint->is_a_type_of('ArrayRef')) {
 343             my $rv = $self->SUPER::get_value($instance);
 344             return unless defined $rv;
 345             return wantarray ? @{ $rv } : $rv;
 346         }
 347         elsif ($type_constraint->is_a_type_of('HashRef')) {
 348             my $rv = $self->SUPER::get_value($instance);
 349             return unless defined $rv;
 350             return wantarray ? %{ $rv } : $rv;
 351         }
 352         else {
 353             confess "Can not auto de-reference the type constraint '" . $type_constraint->name . "'";
 354         }
 355
 356     }
 357     else {
 358
 359         return $self->SUPER::get_value($instance);
 360     }
 361 }
 362
 363 ## installing accessors
 364
 365 sub accessor_metaclass { 'Moose::Meta::Method::Accessor' }
 366
 367 sub install_accessors {
 368     my $self = shift;
 369     $self->SUPER::install_accessors(@_);
 370
 371     if ($self->has_handles) {
 372
 373         # NOTE:
 374         # Here we canonicalize the 'handles' option
 375         # this will sort out any details and always
 376         # return an hash of methods which we want
 377         # to delagate to, see that method for details
 378         my %handles = $self->_canonicalize_handles();
 379
 380         # find the accessor method for this attribute
 381         my $accessor = $self->get_read_method_ref;
 382         # then unpack it if we need too ...
 383         $accessor = $accessor->body if blessed $accessor;
 384
 385         # install the delegation ...
 386         my $associated_class = $self->associated_class;
 387         foreach my $handle (keys %handles) {
 388             my $method_to_call = $handles{$handle};
 389             my $class_name = $associated_class->name;
 390             my $name = "${class_name}::${handle}";
 391
 392             (!$associated_class->has_method($handle))
 393                 || confess "You cannot overwrite a locally defined method ($handle) with a delegation";
 394
 395             # NOTE:
 396             # handles is not allowed to delegate
 397             # any of these methods, as they will
 398             # override the ones in your class, which
 399             # is almost certainly not what you want.
 400
 401             # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something
 402             #cluck("Not delegating method '$handle' because it is a core method") and
 403             next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
 404
 405             if ((reftype($method_to_call) || '') eq 'CODE') {
 406                 $associated_class->add_method($handle => subname $name, $method_to_call);
 407             }
 408             else {
 409                 $associated_class->add_method($handle => subname $name, sub {
 410                     my $proxy = (shift)->$accessor();
 411                     @_ = ($proxy, @_);
 412                     (defined $proxy)
 413                         || confess "Cannot delegate $handle to $method_to_call because " .
 414                                    "the value of " . $self->name . " is not defined";
 415                     goto &{ $proxy->can($method_to_call) || return };
 416                 });
 417             }
 418         }
 419     }
 420
 421     return;
 422 }
 423
 424 # private methods to help delegation ...
 425
 426 sub _canonicalize_handles {
 427     my $self    = shift;
 428     my $handles = $self->handles;
 429     if (my $handle_type = ref($handles)) {
 430         if ($handle_type eq 'HASH') {
 431             return %{$handles};
 432         }
 433         elsif ($handle_type eq 'ARRAY') {
 434             return map { $_ => $_ } @{$handles};
 435         }
 436         elsif ($handle_type eq 'Regexp') {
 437             ($self->has_type_constraint)
 438                 || confess "Cannot delegate methods based on a RegExpr without a type constraint (isa)";
 439             return map  { ($_ => $_) }
 440                    grep { /$handles/ } $self->_get_delegate_method_list;
 441         }
 442         elsif ($handle_type eq 'CODE') {
 443             return $handles->($self, $self->_find_delegate_metaclass);
 444         }
 445         else {
 446             confess "Unable to canonicalize the 'handles' option with $handles";
 447         }
 448     }
 449     else {
 450         my $role_meta = eval { $handles->meta };
 451         if ($@) {
 452             confess "Unable to canonicalize the 'handles' option with $handles because : $@";
 453         }
 454
 455         (blessed $role_meta && $role_meta->isa('Moose::Meta::Role'))
 456             || confess "Unable to canonicalize the 'handles' option with $handles because ->meta is not a Moose::Meta::Role";
 457
 458         return map { $_ => $_ } (
 459             $role_meta->get_method_list,
 460             $role_meta->get_required_method_list
 461         );
 462     }
 463 }
 464
 465 sub _find_delegate_metaclass {
 466     my $self = shift;
 467     if (my $class = $self->_isa_metadata) {
 468         # if the class does have
 469         # a meta method, use it
 470         return $class->meta if $class->can('meta');
 471         # otherwise we might be
 472         # dealing with a non-Moose
 473         # class, and need to make
 474         # our own metaclass
 475         return Moose::Meta::Class->initialize($class);
 476     }
 477     elsif (my $role = $self->_does_metadata) {
 478         # our role will always have
 479         # a meta method
 480         return $role->meta;
 481     }
 482     else {
 483         confess "Cannot find delegate metaclass for attribute " . $self->name;
 484     }
 485 }
 486
 487 sub _get_delegate_method_list {
 488     my $self = shift;
 489     my $meta = $self->_find_delegate_metaclass;
 490     if ($meta->isa('Class::MOP::Class')) {
 491         return map  { $_->{name}                     }  # NOTE: !never! delegate &meta
 492                grep { $_->{class} ne 'Moose::Object' && $_->{name} ne 'meta' }
 493                     $meta->compute_all_applicable_methods;
 494     }
 495     elsif ($meta->isa('Moose::Meta::Role')) {
 496         return $meta->get_method_list;
 497     }
 498     else {
 499         confess "Unable to recognize the delegate metaclass '$meta'";
 500     }
 501 }
 502
 503 1;
 504
 505 __END__
 506
 507 =pod
 508
 509 =head1 NAME
 510
 511 Moose::Meta::Attribute - The Moose attribute metaclass
 512
 513 =head1 DESCRIPTION
 514
 515 This is a subclass of L<Class::MOP::Attribute> with Moose specific
 516 extensions.
 517
 518 For the most part, the only time you will ever encounter an
 519 instance of this class is if you are doing some serious deep
 520 introspection. To really understand this class, you need to refer
 521 to the L<Class::MOP::Attribute> documentation.
 522
 523 =head1 METHODS
 524
 525 =head2 Overridden methods
 526
 527 These methods override methods in L<Class::MOP::Attribute> and add
 528 Moose specific features. You can safely assume though that they
 529 will behave just as L<Class::MOP::Attribute> does.
 530
 531 =over 4
 532
 533 =item B<new>
 534
 535 =item B<initialize_instance_slot>
 536
 537 =item B<install_accessors>
 538
 539 =item B<accessor_metaclass>
 540
 541 =item B<get_value>
 542
 543 =item B<set_value>
 544
 545   eval { $point->meta->get_attribute('x')->set_value($point, 'fourty-two') };
 546   if($@) {
 547     print "Oops: $@\n";
 548   }
 549
 550 I<Attribute (x) does not pass the type constraint (Int) with 'fourty-two'>
 551
 552 Before setting the value, a check is made on the type constraint of
 553 the attribute, if it has one, to see if the value passes it. If the
 554 value fails to pass, the set operation dies with a L<Carp/confess>.
 555
 556 Any coercion to convert values is done before checking the type constraint.
 557
 558 To check a value against a type constraint before setting it, fetch the
 559 attribute instance using L<Class::MOP::Class/find_attribute_by_name>,
 560 fetch the type_constraint from the attribute using L<Moose::Meta::Attribute/type_constraint>
 561 and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::RecipeX>
 562 for an example.
 563
 564 =back
 565
 566 =head2 Additional Moose features
 567
 568 Moose attributes support type-constraint checking, weak reference
 569 creation and type coercion.
 570
 571 =over 4
 572
 573 =item B<clone_and_inherit_options>
 574
 575 This is to support the C<has '+foo'> feature, it clones an attribute
 576 from a superclass and allows a very specific set of changes to be made
 577 to the attribute.
 578
 579 =item B<has_type_constraint>
 580
 581 Returns true if this meta-attribute has a type constraint.
 582
 583 =item B<type_constraint>
 584
 585 A read-only accessor for this meta-attribute's type constraint. For
 586 more information on what you can do with this, see the documentation
 587 for L<Moose::Meta::TypeConstraint>.
 588
 589 =item B<has_handles>
 590
 591 Returns true if this meta-attribute performs delegation.
 592
 593 =item B<handles>
 594
 595 This returns the value which was passed into the handles option.
 596
 597 =item B<is_weak_ref>
 598
 599 Returns true if this meta-attribute produces a weak reference.
 600
 601 =item B<is_required>
 602
 603 Returns true if this meta-attribute is required to have a value.
 604
 605 =item B<is_lazy>
 606
 607 Returns true if this meta-attribute should be initialized lazily.
 608
 609 NOTE: lazy attributes, B<must> have a C<default> or C<builder> field set.
 610
 611 =item B<is_lazy_build>
 612
 613 Returns true if this meta-attribute should be initialized lazily through
 614 the builder generated by lazy_build. Using C<lazy_build =E<gt> 1> will
 615 make your attribute required and lazy. In addition it will set the builder, clearer
 616 and predicate options for you using the following convention.
 617
 618    #If your attribute name starts with an underscore:
 619    has '_foo' => (lazy_build => 1);
 620    #is the same as
 621    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', builder => '_build__foo);
 622    # or
 623    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', default => sub{shift->_build__foo});
 624
 625    #If your attribute name does not start with an underscore:
 626    has 'foo' => (lazy_build => 1);
 627    #is the same as
 628    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', builder => '_build_foo);
 629    # or
 630    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', default => sub{shift->_build_foo});
 631
 632 The reason for the different naming of the C<builder> is that the C<builder>
 633 method is a private method while the C<clearer> and C<predicate> methods
 634 are public methods.
 635
 636 NOTE: This means your class should provide a method whose name matches the value
 637 of the builder part, in this case _build__foo or _build_foo.
 638
 639 =item B<should_coerce>
 640
 641 Returns true if this meta-attribute should perform type coercion.
 642
 643 =item B<should_auto_deref>
 644
 645 Returns true if this meta-attribute should perform automatic
 646 auto-dereferencing.
 647
 648 NOTE: This can only be done for attributes whose type constraint is
 649 either I<ArrayRef> or I<HashRef>.
 650
 651 =item B<has_trigger>
 652
 653 Returns true if this meta-attribute has a trigger set.
 654
 655 =item B<trigger>
 656
 657 This is a CODE reference which will be executed every time the
 658 value of an attribute is assigned. The CODE ref will get two values,
 659 the invocant and the new value. This can be used to handle I<basic>
 660 bi-directional relations.
 661
 662 =item B<documentation>
 663
 664 This is a string which contains the documentation for this attribute.
 665 It serves no direct purpose right now, but it might in the future
 666 in some kind of automated documentation system perhaps.
 667
 668 =item B<has_documentation>
 669
 670 Returns true if this meta-attribute has any documentation.
 671
 672 =back
 673
 674 =head1 BUGS
 675
 676 All complex software has bugs lurking in it, and this module is no
 677 exception. If you find a bug please either email me, or add the bug
 678 to cpan-RT.
 679
 680 =head1 AUTHOR
 681
 682 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 683
 684 Yuval Kogman E<lt>nothingmuch@woobling.comE<gt>
 685
 686 =head1 COPYRIGHT AND LICENSE
 687
 688 Copyright 2006-2008 by Infinity Interactive, Inc.
 689
 690 L<http://www.iinteractive.com>
 691
 692 This library is free software; you can redistribute it and/or modify
 693 it under the same terms as Perl itself.
 694
 695 =cut