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 )