libxinux 1.0.2

Collection of API & ABI for Xinux
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 crate::{utils::misc::get_pname_version_from_storepath, Package, PackageAttr, NIXARCH};
use anyhow::{Context, Result};
use log::debug;
use serde::Deserialize;
use std::collections::HashMap;

#[derive(Debug, Deserialize)]
struct ProfilePkgsRoot {
    elements: HashMap<String, ProfilePkgOut>,
}

#[derive(Debug, Deserialize)]
struct ProfilePkgOut {
    #[serde(rename = "attrPath")]
    attrpath: Option<String>,
    #[serde(rename = "originalUrl")]
    originalurl: Option<String>,
    #[serde(rename = "storePaths")]
    storepaths: Vec<String>,
}

pub fn list() -> Result<Vec<Package>> {
    let profileroot: ProfilePkgsRoot = serde_json::from_reader(
        std::process::Command::new("nix")
            .arg("profile")
            .arg("list")
            .arg("--json")
            .output()?
            .stdout
            .as_slice(),
    )?;

    let mut pkgs = Vec::new();
    for (profile_name, pkg) in profileroot.elements {
        if let (Some(attrpath), Some(originalurl)) = (pkg.attrpath, pkg.originalurl) {
            let storepath = pkg.storepaths[0].clone();

            debug!(
                "Listing package: {} {} {}",
                attrpath, originalurl, storepath
            );
            // let derivation = get_drv(&storepath)?;

            let (pname, version) = get_pname_version_from_storepath(&storepath)?;

            if let Some(pkgattr) =
                attrpath.strip_prefix(&format!("legacyPackages.{}.", NIXARCH.as_str()))
            {
                pkgs.push(Package {
                    version,
                    attr: PackageAttr::NixPkgs {
                        attr: pkgattr.to_string(),
                    },
                    pname: Some(pname),
                    profile_name: Some(profile_name),
                });
            } else {
                pkgs.push(Package {
                    version,
                    attr: PackageAttr::External {
                        url: originalurl,
                        attr: attrpath,
                    },
                    pname: Some(pname),
                    profile_name: Some(profile_name),
                });
            };
        }
    }

    Ok(pkgs)
}

pub fn name_from_attr(attr: &str) -> Result<String> {
    let list = list()?;
    for pkg in list {
        match pkg.attr {
            PackageAttr::NixPkgs { attr: x } => {
                if x == attr {
                    return pkg.profile_name.context("Profile name not found");
                }
            }
            PackageAttr::External {
                url,
                attr: ext_attr,
            } => {
                if attr == format!("{}#{}", url, ext_attr)
                    || (ext_attr.ends_with(".default") && url == attr)
                {
                    return pkg.profile_name.context("Profile name not found");
                }
            }
        }
    }
    Err(anyhow::anyhow!("Package not found"))
}