CODEWITHSUNDEEP
perlmojolicious
simone
simone

Reputation: 5221

Can I inject a perl sub in a package?

I'd like to be able to "inject" methods in a class on the fly, similarly to what happens with Mojolicious helpers. Something like this:

my $s = SomeThing->new;

$s->helper(do_this => sub {
               my $self = shift;
               $foo = shift;
           });

$s->do_this('bar');

I've made it some distance, but I would like the subs that get injected to be operating in the namespace of the class they get injected into, not in the main one. In other words this currently works as follows:

$s->do_this('bar');

print 'in main:      ', $foo;

this prints "bar" - and I'd like it not to, while I'd like this

print 'in SomeThing: ', $SomeThing::foo;

to print "bar" instead

while this works but seems clunky to me

$s->helper(do_this => sub {
               my $self = shift;
               ${(ref $self) . '::foo'} = shift;
           });

$s->do_this('foo');

print 'in SomeThing: ', $SomeThing::foo;  # now this prints "foo"

The package where all this happens looks like this:

package SomeThing {
    use Mojo::Base -base;
    use Carp;

    sub helper {
        my $self = shift;
        my $name = shift || croak "The helper name is required";
        my $sub = shift || sub {};

        my $namespace = __PACKAGE__;
        no strict 'refs';
        { 
            *{"$namespace\::$name"} = $sub
        }
    }
};

Is there a way to do this? I suspect I'd be messing up strictness real bad - but I kind of don't want to give up just yet (and it'd be a nice trick to learn).

Upvotes: 2

Views: 267

Answers (2)

Grinnz
Grinnz

Reputation: 9231

Consider roles.

# role module
package SomeThing::Role::Foo;
use Role::Tiny;
sub foo { 42 }
1;

# user
use strict;
use warnings;
use SomeThing;
use With::Roles;

my $something_with_foo = SomeThing->with::roles('+Foo');
# new subclass of SomeThing, doesn't affect other usage of SomeThing
my $obj = $something_with_foo->new;

# can also dynamically apply to an existing object
my $obj = SomeThing->new->with::roles('+Foo');
print $obj->foo;

Upvotes: 0

ikegami
ikegami

Reputation: 385546

You are asking to change the package associated with an already-compiled anon sub for the purpose of variable lookups. I don't know if that's possible.

Even if it was possible, it's not something you want to do because your code still wouldn't work. You'd have to add use vars qw( foo ); to the file in which the sub { } literal is found. And that's in addition to using our $foo; or use vars qw( $foo ); in Something.pm if you accessed it there.

That's pretty magical and messy. And it's easily avoided by using accessors. Simple replace

$s->helper(
   do_this => sub {
      my $self = shift;
      $foo = shift;
   },
);

with

$s->helper(
   do_this => sub {
      my $self = shift;
      $self->foo(shift);
   },
);

If you also need to add the accessor, you can use the following:

$s->helper(
   foo => sub {
      shift;
      state $foo;
      $foo = shift if @_;
      $foo
   },
   do_this => sub {
      my $self = shift;
      $self->foo(shift);
   },
);

As an aside, monkey_patch from Mojo::Util can be used as a replacement for helper. (Credit to @brian d foy for bringing it up.) It does the same thing, but it has the two added benefits:

  1. You don't need to support it.
  2. It sets the name of the anon sub so that stack traces use a meaningful name instead of __ANON__.

Switching to monkey_patch doesn't address your problem, but I do recommend using it (or similar) in addition to the change of approach I mentioned above.

use Mojo::Util qw(  );
sub helper { shift; Mojo::Util::monkey_patch(__PACKAGE__, @_); }

Upvotes: 2

Related Questions