pray-cli 1.15.0

Package manager for the language placed before inference — Prayfile CLI (binary: pray)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::project_paths::lockfile_path;
use pray_core::lockfile::read_lockfile;
use pray_core::manifest::Manifest;
use pray_core::resolve::resolve_upstream::{
    apply_path_upstream_latest_constraints, plan_path_upstream_latest_constraints,
    PathUpstreamLatestConstraint,
};
use pray_core::resolve::{apply_path_upstream_refreshes, ResolvedProject};
use pray_core::resolve_context::ResolveOptions;
use pray_core::PrayResult;
use std::path::Path;

pub(super) fn plan_latest_upstream_constraints(
    project: &ResolvedProject,
    selected: Option<&str>,
    options: &ResolveOptions,
) -> PrayResult<Vec<PathUpstreamLatestConstraint>> {
    let previous = read_lockfile(&lockfile_path()).ok();
    plan_path_upstream_latest_constraints(project, previous.as_ref(), selected, options)
}

pub(super) fn print_latest_upstream_constraints(plans: &[PathUpstreamLatestConstraint]) {
    for plan in plans {
        println!(
            "{} upstream {} -> {} (latest {})",
            plan.package_name, plan.current_constraint, plan.new_constraint, plan.latest_version
        );
    }
}

pub(super) fn latest_upstream_constraint_updates_json(
    plans: &[PathUpstreamLatestConstraint],
) -> Vec<serde_json::Value> {
    plans
        .iter()
        .map(|plan| {
            serde_json::json!({
                "name": plan.package_name,
                "from_constraint": plan.current_constraint,
                "to_constraint": plan.new_constraint,
                "latest_version": plan.latest_version,
            })
        })
        .collect()
}

pub(super) fn resolve_after_latest_upstream(
    manifest_path: &Path,
    project_root: &Path,
    manifest: Manifest,
    options: &ResolveOptions,
    selected: Option<&str>,
    plans: &[PathUpstreamLatestConstraint],
    dry_run: bool,
) -> PrayResult<ResolvedProject> {
    if !dry_run {
        apply_path_upstream_latest_constraints(plans)?;
    }
    let mut candidate = pray_core::resolve::resolve_manifest_in_context(
        manifest_path,
        project_root,
        manifest.clone(),
        options,
    )?;
    if dry_run {
        return Ok(candidate);
    }
    let previous = read_lockfile(&lockfile_path()).ok();
    if apply_path_upstream_refreshes(&candidate, previous.as_ref(), selected, options)? {
        candidate = pray_core::resolve::resolve_manifest_in_context(
            manifest_path,
            project_root,
            manifest,
            options,
        )?;
    }
    Ok(candidate)
}