rustible/src/modules/package/builder.rs

use super::{PackageArgs, IntoPackageList, PackageList, PackageState, PackageModule, PackageStatus, PackageError, SpecificPackageManager};
use super::apt::DebianPackageManager;
use super::pacman::ArchlinuxPackageManager;
use std::boxed::Box;

use crate::Module;

pub struct PackageArgsBuilder<Packages, State, Manager> {
    name: Packages,
    state: State,
    manager: Manager,
}

pub struct NoPackage;
pub struct NoState;
pub struct NoManager;

impl PackageArgsBuilder<NoPackage, NoState, NoManager> {
    pub fn new() -> PackageArgsBuilder<NoPackage, NoState, NoManager> {
        PackageArgsBuilder {
            name: NoPackage,
            state: NoState,
            manager: NoManager,
        }
    }
}

impl<State, Manager> PackageArgsBuilder<NoPackage, State, Manager> {
    pub fn name<T: IntoPackageList>(self, list: T) -> PackageArgsBuilder<PackageList, State, Manager> {
        let Self { state, manager, .. } = self;

        PackageArgsBuilder {
            name: list.into_package_list(),
            state,
            manager,
        }
    }
}

impl<Packages, Manager> PackageArgsBuilder<Packages, NoState, Manager> {
    pub fn state(self, state: PackageState) -> PackageArgsBuilder<Packages, PackageState, Manager> {
        let Self { name, manager, .. } = self;

        PackageArgsBuilder {
            name,
            state,
            manager,
        }
    }
}

impl<Packages, State> PackageArgsBuilder<Packages, State, NoManager> {
    pub fn with(self, manager: impl SpecificPackageManager + 'static) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
        let Self { name, state, .. } = self;

        PackageArgsBuilder {
            name,
            state,
            manager: Box::new(manager),
        }
    }

    pub fn with_apt(self) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
        let Self { name, state, .. } = self;
        PackageArgsBuilder {
            name,
            state,
            manager: Box::new(DebianPackageManager),
        }
    }

    pub fn with_pacman(self) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
        let Self { name, state, .. } = self;
        PackageArgsBuilder {
            name,
            state,
            manager: Box::new(ArchlinuxPackageManager),
        }
    }
}
    

// We can only RUN the args when a package manager has been set. Alternatively,
// when called inside a playbook, the package manager can be populated automatically from facts.
impl PackageArgsBuilder<PackageList, PackageState, Box<dyn SpecificPackageManager>> {
    pub fn run(self) -> Result<PackageStatus, PackageError> {
        self.build().run()
    }
}

impl PackageArgsBuilder<PackageList, PackageState, Box<dyn SpecificPackageManager>> {
    pub fn build(self) -> PackageModule<Box<dyn SpecificPackageManager>> {
        let Self { name, state, manager, .. } = self;

        PackageModule {
            args: PackageArgs {
                name,
                state,
            },
            manager,
        }
    }
}

impl PackageArgsBuilder<PackageList, PackageState, NoManager> {
    pub fn build(self) -> PackageModule<NoManager> {
        let Self { name, state, .. } = self;

        PackageModule {
            args: PackageArgs {
                name,
                state,
            },
            manager: NoManager,
        }
    }
}