in reply to RFC: Alias::Exporter

There just has to be a way to remove that eval. ;-)

Why do you 'use $module ( \@import_list )'? You don't need to import anything into Alias::Exporter's namespace. So you only need to require it instead. That can pull it out of the eval if you do the required modifications: 

  (my $modname = $module . '.pm') =~ s,::,/,g;
  require $modname;

[download]
Next, we want to pull that loop out of the eval. You have the right idea - it pretty much could have been done without the eval already, except that I just removed the importing from the other module. So now we need to point at the code in the desired module explicitly. 
  for my $var (@import_list)
  {
    no strict 'refs';
    *{$package . '::' . $imports{$var}} = *{$module . '::' . $var};
  }

[download]
Of course, having gotten rid of the eval, the die isn't needed anymore, either.

A few more variables could make things a bit easier to read. Also, I would use references a bit more. This gives us: 

sub import {
  my $class = shift;
  my @modules = @_;
  my $package = caller();

  for my $module ( keys %modules ) {
    my $imports = $modules{$module};

    # we need to load the module if it doesn't already exist.
    (my $modname = $module . '.pm') =~ s,::,/,g;
    require $modname;

    for my $var (@import_list)
    {
      no strict 'refs';

      my $from = join '::', $module,  $var;
      my $to   = join '::', $package, $imports->{var};

      *{$to} = *{$from};
    }
  }
}

[download]
Unfortunately, that's completely untested. And still needs more commenting ;-) Good luck,

Replies are listed 'Best First'.
Re^2: RFC: Alias::Exporter
by runrig (Abbot) on Sep 20, 2006 at 20:19 UTC
    Ahh, but what if the module you're importing from has a custom import, where the thing being exported does not actually exist as a symbol in the exporting module, but gets imported to a symbol in the calling module (e.g. exporting a dynamically created anonymous subroutine)? That's why I import to the Alias module first, though I may still be able to get by without the eval. I know, it's a strange arbitrary edge-case, but what the hay.

    Update: Fixed some minor things in your code, and went back to importing to this module first. One thing to fix after that was the glob assignment. If you assign glob to glob, you end up with all functions initially imported with the same name being exported as the same (last exported) function (when you import to this module first). Another thing I might consider is using Tie::IxHash or something to process the lists of modules and symbols in their original order.

    Another update: Another consideration...we're totally polluting the namespace of this module by doing it this way, so maybe we should initially import to Alias::Exporter::Junk or something...

    sub import {
  my $class = shift;
  my %modules = @_;
  my $package = caller();

  for my $module ( keys %modules ) {
    my $imports = $modules{$module};

    # we need to load the module if it doesn't already exist.
    (my $modname = $module . '.pm') =~ s,::,/,g;
    require $modname;
    my @import_list = keys(%$imports);
    $module->import(@import_list);

    for my $var (@import_list)
    {
      no strict 'refs';

      my $from = join '::', __PACKAGE__, $var;
      my $to   = join '::', $package, $imports->{$var};

      *{$to} = \&{$from};
    }
  }
}

    [download]
[reply]
[d/l]

In Section Meditations