view release on metacpan or  search on metacpan

lib/PAR/Packer.pm  view on Meta::CPAN

sub set_par_file {
    my ($self, $file) = @_;

    $self->{par_file} = $file;
    $self->_check_write($file);
}

sub pack_manifest_hash {
    my ($self) = @_;

    my @SharedLibs;
    return ($self->{pack_manifest}) if ($self->{pack_manifest});

    $self->{pack_manifest} ||= {};
    $self->{full_manifest} ||= {};
    my $full_manifest = $self->{full_manifest};
    my $dep_manifest  = $self->{pack_manifest};

    my $sn = $self->{script_name};
    my $fe = $self->{frontend};

    my $opt    = $self->{options};
    my $input  = $self->{input};
    my $output = $self->{output};

    my $root = '';
    $root = "$Config{archname}/" if ($opt->{m});
    $self->{pack_attrib}{root} = '';

    my $par_file = $self->{par_file};
    my (@modules, @data, @exclude);

    # Search for scannable code in all -I'd paths
    # NOTE: We need this early, because Module::ScanDeps::_find_in_inc
    # and others refer to @IncludeLibs.
    push @Module::ScanDeps::IncludeLibs, @{$opt->{I}} if $opt->{I};

    foreach my $name (@{ $opt->{M} || [] }) {
        if ($name =~ s/^([\w:]+)::(\*{0,2})$/$1/) {
            my $ns = length $2;        # namespace depth indicator

            if ($ns == 0) {
                # "-MFoo::" shorthand for "-MFoo -MFoo::**"
                $self->_name2moddata($name, \@modules, \@data);
                $ns = 2;
            }

            (my $mod = $name) =~ s/::/\//g;
            my @mods_in_ns = $ns == 1
                ? Module::ScanDeps::_glob_in_inc_1($mod, 1)
                : Module::ScanDeps::_glob_in_inc($mod, 1);
            $self->_name2moddata($_, \@modules, \@data) foreach @mods_in_ns;
        }
        else {
            $self->_name2moddata($name, \@modules, \@data);
        }
    }

    if ($opt->{u}) {
        if ($] lt '5.031006') {
            push @modules, "utf8_heavy.pl";
        }
        else {
            $self->_warn("'-u' is not needed for Perl >= 5.31.6");
        }
    }

    # Skip either
    # a) all files from a .par file or
    # b) A module
    foreach my $name ('PAR', @{ $opt->{X} || [] }) {
        if (-f $name and my $dep_zip = Archive::Zip->new($name)) {
            for ($dep_zip->memberNames()) {
                next if ( /MANIFEST/ or /META.yml/ or /^script\// );
                $dep_zip_files{$_} ||= $name;
            }
        }
        else {
            $self->_name2moddata($name, \@exclude, \@exclude);
        }
    }

    my %map;

    unshift(@INC, @{ $opt->{I} || [] });
    unshift(@SharedLibs, map $self->_find_shlib($_), @{ $opt->{l} || [] });

    # Note: _find_in_inc() may return ()
    my %skip = map { $_ => 1 } grep { defined } map { Module::ScanDeps::_find_in_inc($_) } @exclude;
    if ($^O eq 'MSWin32') {
        %skip = (%skip, map { s{\\}{/}g; lc($_) => 1 } @SharedLibs);
    }
    else {
        %skip = (%skip, map { $_ => 1 } @SharedLibs);
    }

    my $add_deps = $self->_obj_function($fe, 'add_deps');

    if ($opt->{x} && defined $opt->{xargs}) {
        require Text::ParseWords;
        $opt->{x} = [ Text::ParseWords::shellwords($opt->{xargs}) ];
    }

    if (!$opt->{n}) {
        my @files = @$input;

        # apply %Preload to the -M'd modules and add them to the list of files to scan
        foreach my $module (@modules) {
            my $file = Module::ScanDeps::_find_in_inc($module)
              or $self->_die("Cannot find module $module (specified with -M)\n");
            push @files, $file;

            my @preload = Module::ScanDeps::_get_preload($module) or next;

            $add_deps->(
                used_by => $file,
                rv      => \%map,
                modules => \@preload,
                skip    => \%skip,
            );