relative - Load modules with relative names

    package BigApp::Report;

    use relative qw(Create Publish);
    # loads BigApp::Report::Create, BigApp::Report::Publish

    use relative qw(..::Utils);
    # loads BigApp::Utils

    use relative -to => "Enterprise::Framework" => qw(Base Factory);
    # loads Enterprise::Framework::Base, Enterprise::Framework::Factory

    use relative;

    my ($Maker, $Publisher) = import relative qw(Create Publish);
    my $report    = $Maker->new;
    my $publisher = $Publisher->new;

    my ($Base, $Factory) = import relative -to => "Enterprise::Framework"
                                => qw(Base Factory);
    my $thing = $Factory->new;

    use relative -aliased => qw(Create Publish);
    my $report    = Create->new;
    my $publisher = Publisher->new;

    use relative -to => "Enterprise::Framework", -aliased => qw(Base Factory);
    my $thing = Factory->new;

    # options as a hashref
    import relative { param => value, ... },  qw(Name ...);

    # options as an arrayref
    import relative [ param => value, ... ],  qw(Name ...);

    import relative -param => value, qw(name ...);

    perldoc relative

package relative;
use strict;
use Carp;
use UNIVERSAL::require;

{
    no strict "vars";
    $VERSION = '0.04';
}

sub import {
    return if @_ <= 1;  # called with no args
    my ($package, @args) = @_;
    my ($caller) = caller();
    my @loaded = ();

    # read the optional parameters
    my %param = ();

    if (ref $args[0] eq 'HASH') {
        %param = %{shift @args}
    }
    elsif (ref $args[0] eq 'ARRAY') {
        %param = @{shift @args}
    }

    # go through the args list, looking to parameters with the dash syntax,
    # and module names and optional arguments
    my %args_for = ();  # modules arguments
    my @modules  = ();  # will be filled with only the module names
    my $prev     = "";

    for my $item (@args) {
        # if $prev is true, the previous thing (parameter or module name)
        # is expecting a value
        if ($prev) {
            # this is a parameter
            if (index($prev, "-") == 0) {
                $param{substr($prev, 1)} = $item;
                $prev = "";
            }
            # this is a module name
            else {
                push @modules, $prev;

                # this isn't a ref, so the previous module is just stored
                # and the current item becomes the new $prev
                if (not ref $item) {
                    $prev = $item;
                }
                # this is an arrayref, which will be used as the import list
                # for the module name in $prev
                elsif (ref $item eq "ARRAY") {
                    $args_for{$prev} = $item;
                    $prev = "";
                }
                else {
                    my $that = "a ".lc(ref $item)."ref";
                    croak "error: Don't know how to deal with $that (after '$prev')";
                }
            }
        }
        else {
            if ($item eq "-aliased") {
                # -aliased is a flag, so it doesn't expect a value
                $param{aliased} = 1
            }
            else {
                $prev = $item
            }
        }
    }

    push @modules, $prev if $prev;

    # determine the base name
    my $base = exists $param{to} ? $param{to} : $caller;

    # load the modules
    for my $relname (@modules) {
        # resolve the module relative name to absolute name
        my $module = "$base\::$relname";
        1 while $module =~ s/::\w+::(?:\.\.)?::/::/g;
        $module =~ s/^:://;

        # load the module, die if it failed
        $module->require or croak _clean($@);

        # import the symbols from the loaded module into the caller module
        if (exists $args_for{$relname}) {
            my $args = $args_for{$relname};

            # an arguments list has been defined, but only call import if 
            # there are some arguments
            if (@$args) {
                my $args_str = join ", ", map {"q/\Q$_\E/"} @$args;
                eval qq{ package $caller; $module->import($args_str); 1 }
                    or croak _clean($@);
            }
        }
        else {
            # use the default import method
            eval qq{ package $caller; $module->import; 1 } or croak _clean($@);
        }

        # define alias if asked to
        if ($param{aliased}) {
            my ($alias) = $module =~ /\b(\w+)$/;
            eval qq{ package $caller; sub $alias () { q/$module/ } };
        }

        # keep a list of the loaded modules
        push @loaded, $module;
    }

    return wantarray ? @loaded : $loaded[-1]
}


sub _clean {
    my ($msg) = @_;
    $msg =~ s/ at .*relative.pm line \d+\.\s*$//s;
    return $msg
}

"evitaler fo dnE" # "End of relative"