Alien-Xrepo

 view release on metacpan or  search on metacpan

lib/Alien/Xrepo/Runtime.pm  view on Meta::CPAN

    field $diagnosis           : param = 0;          # forwarded to Alien::Xrepo->diagnosis (xmake -D on installs)
    field $repo                : param //= undef;    # injectable engine
    field $snapshot            : param //= undef;    # path to a snapshot JSON (hermetic mode)
    field $autodetect_snapshot : param //= 1;        # look for dist auto/share snapshots
    field $install_opts        : param = {};         # ambient profile merged under every package def
    field $cache               : param //= 1;        # forward the engine's warm-start cache to Alien::Xrepo

    #
    field $recipe_obj        = undef;                        # resolved Alien::Xrepo::Build::Recipe
    field $infos             = {};                           # package => Alien::Xrepo::PackageInfo
    field $snap              = {};                           # package => raw snapshot data
    field $r                 = undef;                        # resolved Alien::Xrepo engine
    field $snap_install_type = undef;
    field $snap_file   : reader(snapshot_path)   = undef;    # path of the snapshot actually loaded, if any
    field $snap_errors : reader(snapshot_errors) = {};       # package => build error recorded in that snapshot
    field $rdeps   = {};                                     # package => discovered runtime deps (aref)
    field $closure = {};                                     # package => raw fetch --deps closure (aref)
    field $check_runtime_deps : param //= 1;                 # surface the diagnostic through package_info

    #
    ADJUST {
        if ( !defined $pkg_name && !defined $recipe ) {
            if ( $self->can('recipe') ) {
                $recipe = $self->recipe;
            }
            elsif ( $self->can('pkg_name') ) {
                $pkg_name = $self->pkg_name;
            }
        }
        die "pkg_name, recipe, or a subclass recipe() is required" if !defined $pkg_name && !defined $recipe;
        if ( !keys %$install_opts && $self->can('install_opts') ) {
            $install_opts = { $self->install_opts };
        }
        $r = $repo // Alien::Xrepo->new( root => $root, verbose => $verbose, diagnosis => $diagnosis, cache => $cache );
        if ( defined $recipe ) {
            $recipe_obj
                = ref $recipe eq 'HASH' ? Alien::Xrepo::Build::Recipe->new(%$recipe) :
                ref $recipe             ? $recipe :
                Alien::Xrepo::Build::Recipe->new( defined $recipe && -d $recipe ? ( dir => $recipe ) : ( file => $recipe ), );
        }
        else {
            $recipe_obj = Alien::Xrepo::Build::Recipe->new( packages => $pkg_name );
        }
        $self->_load_snapshot;
    }
    #
    method package_names () { $recipe_obj->packages }
    method package_defs ()  { $recipe_obj->package_defs }
    #
    method has_snapshot () { defined $snap_file }
    #
    # Hermetic mode: a snapshot file wins entirely (no xrepo subprocess).
    method _load_snapshot () {
        my $file = $snapshot;
        if ( !defined $file && $autodetect_snapshot ) {
            for my $cand ( __PACKAGE__->_snapshot_candidates_for( ref $self ) ) {
                if ( -e $cand ) { $file = $cand; last; }
            }
        }
        return unless defined $file && -e $file;
        my $data = eval { decode_json( path($file)->slurp_utf8 ) };
        return unless ref $data eq 'HASH';
        $snap              = $data->{packages} // {};
        $snap_install_type = $data->{install_type};
        $snap_file         = "$file";
        $snap_errors       = $data->{errors} // {};
        my $base = path($file)->parent;

        for my $name ( keys %$snap ) {
            my %pkg = %{ $snap->{$name} };
            $self->_rebase_relative( $base, \%pkg );
            $infos->{$name} = Alien::Xrepo::PackageInfo->new(%pkg);
        }
        return;
    }

    method _rebase_relative ( $base, $data ) {
        $data->{$_} = [ map { $self->_snap_abs( $base, $_ ) } @{ $data->{$_} } ] for qw[includedirs libfiles linkdirs bindirs];
        for my $k (qw[libpath installdir]) {
            $data->{$k} = $self->_snap_abs( $base, $data->{$k} ) if defined $data->{$k};
        }
        if ( ref $data->{runtime_deps} eq 'ARRAY' ) {
            for my $dep ( @{ $data->{runtime_deps} } ) {
                next unless ref $dep eq 'HASH';
                for my $k (qw[path dir]) {
                    $dep->{$k} = $self->_snap_abs( $base, $dep->{$k} ) if defined $dep->{$k};
                }
            }
        }
        return;
    }

    method _snap_abs ( $base, $p ) {
        return $p if !defined $p || length $p == 0 || path($p)->is_absolute;
        return $base->child($p)->stringify;
    }

    sub _snapshot_candidates_for ( $class, $instance ) {
        ( my $dist = $instance ) =~ s{::}{-}g;
        my @cand  = path( 'blib', 'lib', 'auto', 'share', 'dist', $dist )->child('xrepo-snapshot.json')->stringify;
        my $share = eval { File::ShareDir::dist_dir($dist) };
        unshift @cand, path($share)->child('xrepo-snapshot.json')->stringify if $share;
        return @cand;
    }

    # Lazy resolution: so long as we are not serving a snapshot, fetch paths for a package the first time it is asked
    # for and remember them. An unresolvable package settles at undef (safe defaults) instead of killing the caller, so
    # a cold checkout (no snapshot, no store) yields safe defaults.
    method _ensure_info ($pkg) {
        return $infos->{$pkg} if exists $infos->{$pkg};
        my $info = $infos->{$pkg};
        return $info if defined $info;
        my $version = $recipe_obj->version_for($pkg);
        my %ambient = ( %{ $recipe_obj->defaults // {} }, %$install_opts );
        my %opts    = $recipe_obj->opts_for( $pkg, %ambient );
        my $resolved;
        try { $resolved = $r->fetch( $pkg, $version, %opts ) }
        catch ($e) {
            warn "[!] could not resolve $pkg: $e\n" if $verbose;
            $resolved = undef;
        }



( run in 0.676 second using v1.01-cache-2.11-cpan-234fa220139 )