nixy-rs 0.2.2

Homebrew-style wrapper for Nix using flake.nix
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

use std::collections::HashSet;

use crate::config::Config;
use crate::error::Result;
use crate::flake::parser::collect_local_packages;
use crate::profile::get_flake_dir;
use crate::state::{get_state_path, PackageState};

use super::info;

/// Package entry with source information
struct PackageEntry {
    name: String,
    source: PackageSource,
    /// Platform restrictions (None means all platforms)
    platforms: Option<Vec<String>>,
}

/// Source of a package
enum PackageSource {
    /// Standard nixpkgs package (legacy, no version info)
    Nixpkgs,
    /// Resolved nixpkgs package with version
    NixpkgsVersioned { version: String },
    /// Custom package from an external flake
    Custom { url: String },
    /// Local package from packages/ directory
    Local,
}

impl PackageSource {
    fn display(&self) -> String {
        match self {
            PackageSource::Nixpkgs | PackageSource::NixpkgsVersioned { .. } => {
                "nixpkgs".to_string()
            }
            PackageSource::Custom { url } => url.clone(),
            PackageSource::Local => "local".to_string(),
        }
    }
}

/// Format package name with version if available
fn format_package_name(entry: &PackageEntry) -> String {
    match &entry.source {
        PackageSource::NixpkgsVersioned { version } => {
            format!("{}@{}", entry.name, version)
        }
        _ => entry.name.clone(),
    }
}

/// Format platform restrictions for display
fn format_platforms(platforms: &Option<Vec<String>>) -> String {
    match platforms {
        None => String::new(),
        Some(p) if p.is_empty() => String::new(),
        Some(p) => {
            // Simplify platform display: if all darwin or all linux, show the alias
            let all_darwin = p.iter().all(|s| s.ends_with("-darwin"));
            let all_linux = p.iter().all(|s| s.ends_with("-linux"));
            if all_darwin && p.len() == 2 {
                " [darwin]".to_string()
            } else if all_linux && p.len() == 2 {
                " [linux]".to_string()
            } else {
                format!(" [{}]", p.join(", "))
            }
        }
    }
}

pub fn run(config: &Config) -> Result<()> {
    info("Installed packages:");

    // Get the flake directory
    let flake_dir = get_flake_dir(config)?;
    let state_path = get_state_path(&flake_dir);

    // Load state from packages.json
    let state = PackageState::load(&state_path)?;

    // Collect all packages with their sources
    let mut entries: Vec<PackageEntry> = Vec::new();
    let mut seen: HashSet<String> = HashSet::new();

    // Add legacy nixpkgs packages (no version info)
    for name in &state.packages {
        entries.push(PackageEntry {
            name: name.clone(),
            source: PackageSource::Nixpkgs,
            platforms: None,
        });
        seen.insert(name.clone());
    }

    // Add resolved nixpkgs packages (with version info)
    for pkg in &state.resolved_packages {
        entries.push(PackageEntry {
            name: pkg.name.clone(),
            source: PackageSource::NixpkgsVersioned {
                version: pkg.resolved_version.clone(),
            },
            platforms: pkg.platforms.clone(),
        });
        seen.insert(pkg.name.clone());
    }

    // Add custom packages
    for pkg in &state.custom_packages {
        entries.push(PackageEntry {
            name: pkg.name.clone(),
            source: PackageSource::Custom {
                url: pkg.input_url.clone(),
            },
            platforms: pkg.platforms.clone(),
        });
        seen.insert(pkg.name.clone());
    }

    // Add local packages from packages/ directory
    let packages_dir = flake_dir.join("packages");
    if packages_dir.exists() {
        let (local_packages, local_flakes) = collect_local_packages(&packages_dir);
        for pkg in local_packages {
            if !seen.contains(&pkg.name) {
                entries.push(PackageEntry {
                    name: pkg.name.clone(),
                    source: PackageSource::Local,
                    platforms: None,
                });
                seen.insert(pkg.name);
            }
        }
        for flake in local_flakes {
            if !seen.contains(&flake.name) {
                entries.push(PackageEntry {
                    name: flake.name.clone(),
                    source: PackageSource::Local,
                    platforms: None,
                });
                seen.insert(flake.name);
            }
        }
    }

    // Sort by name
    entries.sort_by(|a, b| a.name.cmp(&b.name));

    if entries.is_empty() {
        println!("  (none)");
    } else {
        // Calculate column width for alignment (using formatted name with version)
        let max_name_len = entries
            .iter()
            .map(|e| format_package_name(e).len())
            .max()
            .unwrap_or(0);

        for entry in entries {
            let formatted_name = format_package_name(&entry);
            let platform_str = format_platforms(&entry.platforms);
            println!(
                "  {:<width$}  ({}){}",
                formatted_name,
                entry.source.display(),
                platform_str,
                width = max_name_len
            );
        }
    }

    Ok(())
}