1use crate::functions;
2use anyhow::{Result, anyhow};
3use mlua::{self, Lua, LuaSerdeExt, Table, Value};
4use std::fs;
5use std::path::Path;
6use tar::Archive;
7use walkdir::WalkDir;
8use zoi_core::{types, utils};
9use zstd::stream::read::Decoder as ZstdDecoder;
10
11pub fn parse_lua_package_from_archive(
12 archive_path: &Path,
13 version_override: Option<&str>,
14 scope: Option<types::Scope>,
15 quiet: bool,
16) -> Result<types::Package> {
17 let platform = utils::get_platform()?;
18 parse_lua_package_from_archive_for_platform(
19 archive_path,
20 &platform,
21 version_override,
22 scope,
23 quiet,
24 )
25}
26
27pub fn parse_lua_package_from_archive_for_platform(
28 archive_path: &Path,
29 platform: &str,
30 version_override: Option<&str>,
31 scope: Option<types::Scope>,
32 quiet: bool,
33) -> Result<types::Package> {
34 let file = fs::File::open(archive_path)?;
35 let decoder = ZstdDecoder::new(file)?;
36 let mut archive = Archive::new(decoder);
37 let temp_dir = tempfile::Builder::new()
38 .prefix("zoi-arch-parse-")
39 .tempdir()?;
40 archive.unpack(temp_dir.path())?;
41
42 let mut pkg_lua = None;
43 for entry in WalkDir::new(temp_dir.path())
44 .into_iter()
45 .filter_map(|e| e.ok())
46 {
47 if entry.file_name().to_string_lossy().ends_with(".pkg.lua") {
48 pkg_lua = Some(entry.path().to_path_buf());
49 break;
50 }
51 }
52
53 let pkg_lua_path = pkg_lua.ok_or_else(|| anyhow!("No .pkg.lua in archive"))?;
54 parse_lua_package_from_file_for_platform(
55 pkg_lua_path
56 .to_str()
57 .ok_or_else(|| anyhow!("Invalid path"))?,
58 platform,
59 version_override,
60 scope,
61 quiet,
62 )
63}
64
65pub fn parse_lua_package_for_platform(
66 file_path: &str,
67 platform: &str,
68 version_override: Option<&str>,
69 scope: Option<types::Scope>,
70 quiet: bool,
71) -> Result<types::Package> {
72 if file_path.ends_with(".zpa") || file_path.ends_with(".zsa") {
73 return parse_lua_package_from_archive_for_platform(
74 Path::new(file_path),
75 platform,
76 version_override,
77 scope,
78 quiet,
79 );
80 }
81 parse_lua_package_from_file_for_platform(file_path, platform, version_override, scope, quiet)
82}
83
84fn parse_lua_package_from_file_for_platform(
85 file_path: &str,
86 platform: &str,
87 version_override: Option<&str>,
88 scope: Option<types::Scope>,
89 quiet: bool,
90) -> Result<types::Package> {
91 let lua_code = fs::read_to_string(file_path)?;
92 let lua = Lua::new();
93
94 functions::setup_lua_environment(
95 &lua,
96 platform,
97 version_override,
98 Some(file_path),
99 None,
100 None,
101 None,
102 None,
103 scope,
104 None,
105 quiet,
106 )
107 .map_err(|e| anyhow!("Failed to setup Lua environment for '{}': {}", file_path, e))?;
108
109 lua.load(&lua_code).exec().map_err(|e| {
110 anyhow!(
111 "Failed to execute Lua package file '{}':
112{}",
113 file_path,
114 e
115 )
116 })?;
117
118 let final_pkg_meta: Table = lua
119 .globals()
120 .get("__ZoiPackageMeta")
121 .map_err(|e| anyhow!(e.to_string()))?;
122 let final_pkg_deps: Table = lua
123 .globals()
124 .get("__ZoiPackageDeps")
125 .map_err(|e| anyhow!(e.to_string()))?;
126 let final_pkg_updates: Table = lua
127 .globals()
128 .get("__ZoiPackageUpdates")
129 .map_err(|e| anyhow!(e.to_string()))?;
130 let final_pkg_hooks: Table = lua
131 .globals()
132 .get("__ZoiPackageHooks")
133 .map_err(|e| anyhow!(e.to_string()))?;
134 let final_pkg_service: Table = lua
135 .globals()
136 .get("__ZoiPackageService")
137 .map_err(|e| anyhow!(e.to_string()))?;
138
139 let mut package: types::Package =
140 lua.from_value(Value::Table(final_pkg_meta)).map_err(|e| {
141 anyhow!(
142 "Failed to parse 'metadata' block in package file '{}':
143{}",
144 file_path,
145 e
146 )
147 })?;
148
149 package.dependencies = if final_pkg_deps.is_empty() {
150 None
151 } else {
152 Some(lua.from_value(Value::Table(final_pkg_deps)).map_err(|e| {
153 anyhow!(
154 "Failed to parse 'dependencies' block in package file '{}':\n{}",
155 file_path,
156 e
157 )
158 })?)
159 };
160
161 package.updates = if final_pkg_updates.is_empty() {
162 None
163 } else {
164 Some(
165 lua.from_value(Value::Table(final_pkg_updates))
166 .map_err(|e| {
167 anyhow!(
168 "Failed to parse 'updates' block in package file '{}':
169{}",
170 file_path,
171 e
172 )
173 })?,
174 )
175 };
176
177 package.hooks = if final_pkg_hooks.is_empty() {
178 None
179 } else {
180 Some(lua.from_value(Value::Table(final_pkg_hooks)).map_err(|e| {
181 anyhow!(
182 "Failed to parse 'hooks' block in package file '{}':
183{}",
184 file_path,
185 e
186 )
187 })?)
188 };
189
190 package.service = if final_pkg_service.is_empty() {
191 None
192 } else {
193 Some(
194 lua.from_value(Value::Table(final_pkg_service))
195 .map_err(|e| {
196 anyhow!(
197 "Failed to parse 'service' block in package file '{}':
198{}",
199 file_path,
200 e
201 )
202 })?,
203 )
204 };
205
206 Ok(package)
207}
208
209pub fn parse_lua_package(
210 file_path: &str,
211 version_override: Option<&str>,
212 scope: Option<types::Scope>,
213 quiet: bool,
214) -> Result<types::Package> {
215 let platform = utils::get_platform()?;
216 parse_lua_package_for_platform(file_path, &platform, version_override, scope, quiet)
217}