lux-lib 0.67.3

Library for the lux package manager for Lua
Documentation 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use bon::Builder;
use miette::Diagnostic;
use thiserror::Error;

use crate::{
    config::Config,
    drivers::sync::{gather_dependencies, DependencyKind, SyncError},
    package_db::{PackageDB, PackageDBError},
    pipeline::{
        emit_lockfile::LockfileHandle,
        materialise::{Error as MaterialiseError, Materialise},
        resolve::{ResolveError, ResolvePackageDependencies},
    },
    workspace::{Workspace, WorkspaceError},
};

/// Generates a workspace's lockfile without installing anything.
#[derive(Builder)]
#[builder(start_fn = new, finish_fn(name = _build, vis = ""))]
pub struct GenerateLockfile<'a> {
    #[builder(start_fn)]
    config: &'a Config,
    #[builder(start_fn)]
    workspace: &'a Workspace,
}

impl<State> GenerateLockfileBuilder<'_, State>
where
    State: generate_lockfile_builder::State + generate_lockfile_builder::IsComplete,
{
    pub async fn generate(self) -> Result<(), GenerateLockfileError> {
        generate_lockfile(self._build()).await
    }
}

async fn generate_lockfile(args: GenerateLockfile<'_>) -> Result<(), GenerateLockfileError> {
    let GenerateLockfile { config, workspace } = args;

    let members = workspace.member_names()?;
    let package_db = PackageDB::open(config, workspace).await?;

    let resolve = ResolvePackageDependencies::new(package_db, config)
        .packages(gather_dependencies(
            workspace,
            DependencyKind::Regular,
            &members,
        )?)
        .build_packages(gather_dependencies(
            workspace,
            DependencyKind::Build,
            &members,
        )?)
        .test_packages(gather_dependencies(
            workspace,
            DependencyKind::Test,
            &members,
        )?);

    let resolved = resolve.resolve().await?;
    let artifacts = Materialise::new(config)
        .resolved(resolved)
        .materialise()
        .await?;

    let handle = LockfileHandle::from_artifacts(&artifacts);

    let mut lockfile = workspace.lockfile()?.write_guard();
    handle.commit(&mut lockfile);

    Ok(())
}

#[derive(Error, Debug, Diagnostic)]
pub enum GenerateLockfileError {
    #[error(transparent)]
    #[diagnostic(transparent)]
    PackageDB(#[from] PackageDBError),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Workspace(#[from] WorkspaceError),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Sync(Box<SyncError>),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Resolve(#[from] ResolveError),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Materialise(#[from] MaterialiseError),
}

impl From<SyncError> for GenerateLockfileError {
    fn from(source: SyncError) -> Self {
        Self::Sync(Box::new(source))
    }
}