Re^7: Beyond Inside-Out

[xdg]

By name and purpose, a "plug-in" can't make assumptions about the makeup of the objects it will work with.

See, for example, CGI::Application and how its plugins work. It's just Exporter bringing in things as requested.

There's no reason that plugins couldn't be written to work with Alter in some way, but many existing plugins violate the assumption you stated.

[clinton]

I think I must be missing something. I can't see what the problem is.

Surely, the only thing that matters is that the property that method X deals with, is protected against being overwritten by any other method? As long as all other methods that want to access that property do so through the defined interface, rather than trying to access it directly, it shouldn't be a problem.

Am I missing something?

thanks

clint

[xdg]

The defined interface decides which property to access based on the caller() function. Importing a method into a namespace (e.g. via Exporter) only creates an alias to the original, so any functions called from the method see the original namespace as the result of caller().

Example: $obj is of class MyClass. Depending on whether ego() is called from a native subroutine of MyClass (bar)or an imported subroutine from Plugin (foo), ego() finds a different calling package -- and thus returns a different storage hash. In the example below, foo() and bar both serve as accessors to the name field -- but they store/access different underlying hashes for the same object.

use strict;
use warnings;
no warnings qw/once/;

package Alter;

my %data;

sub ego {
    return( $data{scalar caller(0)} ||= {} );
}

package Plugin;

sub foo {
    $_[0]->ego()->{name} = $_[1] if @_ >  1;
    return $_[0]->ego()->{name};
}

package MyClass;

*ego = \&Alter::ego;
*foo = \&Plugin::foo;

sub bar {
    $_[0]->ego()->{name} = $_[1] if @_ >  1;
    return $_[0]->ego()->{name};
}

package main;

my $obj = bless( \my $scalar, "MyClass" );

$obj->bar( "Larry" );
$obj->foo( "Damian" );

for my $m ( qw/bar foo/ ) {
    print "$m: ", $obj->$m, "\n";
}

Prints:

bar: Larry
foo: Damian

This would be reasonable behavior if MyClass was a subclass of Plugin and both classes defined a name field, but that isn't what's happening here.

[clinton]

But that's my point - by asking for foo() or bar() you're not asking for the same thing - the fact that they both use the key name to store their values internally is irrelevant.

foo is trying to violate bar's encapsulation by accessing the value directly. Instead it should be using the provided API.

clint

[Anno]

See, for example, CGI::Application and how its plugins work

I will, thanks. It's on Alter's to-do list.

Anno