lux_lib/project/
mod.rs

1use itertools::Itertools;
2use lets_find_up::{find_up_with, FindUpKind, FindUpOptions};
3use path_slash::PathBufExt;
4use project_toml::{
5    LocalProjectTomlValidationError, PartialProjectToml, RemoteProjectTomlValidationError,
6};
7use std::{
8    io,
9    ops::Deref,
10    path::{Path, PathBuf},
11    str::FromStr,
12};
13use thiserror::Error;
14use toml_edit::{DocumentMut, Item};
15
16use crate::{
17    build,
18    config::{Config, LuaVersion},
19    git::{
20        self,
21        shorthand::RemoteGitUrlShorthand,
22        url::RemoteGitUrl,
23        utils::{GitError, SemVerTagOrSha},
24    },
25    lockfile::{LockfileError, ProjectLockfile, ReadOnly},
26    lua_rockspec::{
27        LocalLuaRockspec, LuaRockspecError, LuaVersionError, PartialLuaRockspec,
28        PartialRockspecError, RemoteLuaRockspec,
29    },
30    package::SpecRev,
31    remote_package_db::RemotePackageDB,
32    rockspec::{
33        lua_dependency::{DependencyType, LuaDependencySpec, LuaDependencyType},
34        LuaVersionCompatibility,
35    },
36    tree::{Tree, TreeError},
37};
38use crate::{
39    lockfile::PinnedState,
40    package::{PackageName, PackageReq},
41};
42
43pub(crate) mod gen;
44pub mod project_toml;
45
46pub use project_toml::PROJECT_TOML;
47
48pub const EXTRA_ROCKSPEC: &str = "extra.rockspec";
49pub(crate) const LUX_DIR_NAME: &str = ".lux";
50const LUARC: &str = ".luarc.json";
51const EMMYRC: &str = ".emmyrc.json";
52
53#[derive(Error, Debug)]
54#[error(transparent)]
55pub enum ProjectError {
56    #[error("cannot get current directory: {0}")]
57    GetCwd(io::Error),
58    #[error("error reading project TOML at {0}:\n{1}")]
59    ReadProjectTOML(String, io::Error),
60    #[error("error creating project root at {0}:\n{1}")]
61    CreateProjectRoot(String, io::Error),
62    Lockfile(#[from] LockfileError),
63    Project(#[from] LocalProjectTomlValidationError),
64    Toml(#[from] toml::de::Error),
65    #[error("error when parsing `extra.rockspec`: {0}")]
66    Rockspec(#[from] PartialRockspecError),
67    #[error("not in a lux project directory")]
68    NotAProjectDir,
69}
70
71#[derive(Error, Debug)]
72#[error(transparent)]
73pub enum IntoLocalRockspecError {
74    LocalProjectTomlValidationError(#[from] LocalProjectTomlValidationError),
75    RockspecError(#[from] LuaRockspecError),
76}
77
78#[derive(Error, Debug)]
79#[error(transparent)]
80pub enum IntoRemoteRockspecError {
81    RocksTomlValidationError(#[from] RemoteProjectTomlValidationError),
82    RockspecError(#[from] LuaRockspecError),
83}
84
85#[derive(Error, Debug)]
86pub enum ProjectEditError {
87    #[error(transparent)]
88    Io(#[from] tokio::io::Error),
89    #[error(transparent)]
90    Toml(#[from] toml_edit::TomlError),
91    #[error("error parsing lux.toml after edit. This is probably a bug.")]
92    TomlDe(#[from] toml::de::Error),
93    #[error(transparent)]
94    Git(#[from] GitError),
95    #[error("unable to query latest version for {0}")]
96    LatestVersionNotFound(PackageName),
97    #[error("expected field to be a value, but got {0}")]
98    ExpectedValue(toml_edit::Item),
99    #[error("expected string, but got {0}")]
100    ExpectedString(toml_edit::Value),
101    #[error(transparent)]
102    GitUrlShorthandParse(#[from] git::shorthand::ParseError),
103}
104
105#[derive(Error, Debug)]
106#[error(transparent)]
107pub enum ProjectTreeError {
108    Tree(#[from] TreeError),
109    LuaVersionError(#[from] LuaVersionError),
110}
111
112#[derive(Error, Debug)]
113pub enum PinError {
114    #[error("package {0} not found in dependencies")]
115    PackageNotFound(PackageName),
116    #[error("dependency {dep} is already {}pinned!", if *.pin_state == PinnedState::Unpinned { "un" } else { "" })]
117    PinStateUnchanged {
118        pin_state: PinnedState,
119        dep: PackageName,
120    },
121    #[error(transparent)]
122    Toml(#[from] toml_edit::TomlError),
123    #[error("error parsing lux.toml after edit. This is probably a bug.")]
124    TomlDe(#[from] toml::de::Error),
125    #[error(transparent)]
126    Io(#[from] tokio::io::Error),
127}
128
129/// A newtype for the project root directory.
130/// This is used to ensure that the project root is a valid project directory.
131#[derive(Clone, Debug)]
132#[cfg_attr(test, derive(Default))]
133pub struct ProjectRoot(PathBuf);
134
135impl ProjectRoot {
136    pub(crate) fn new() -> Self {
137        Self(PathBuf::new())
138    }
139}
140
141impl AsRef<Path> for ProjectRoot {
142    fn as_ref(&self) -> &Path {
143        self.0.as_ref()
144    }
145}
146
147impl Deref for ProjectRoot {
148    type Target = PathBuf;
149
150    fn deref(&self) -> &Self::Target {
151        &self.0
152    }
153}
154
155#[derive(Clone, Debug)]
156pub struct Project {
157    /// The path where the `lux.toml` resides.
158    root: ProjectRoot,
159    /// The parsed lux.toml.
160    toml: PartialProjectToml,
161}
162
163impl Project {
164    pub fn current() -> Result<Option<Self>, ProjectError> {
165        let cwd = std::env::current_dir().map_err(ProjectError::GetCwd)?;
166        Self::from(&cwd)
167    }
168
169    pub fn current_or_err() -> Result<Self, ProjectError> {
170        Self::current()?.ok_or(ProjectError::NotAProjectDir)
171    }
172
173    pub fn from_exact(start: impl AsRef<Path>) -> Result<Option<Self>, ProjectError> {
174        if !start.as_ref().exists() {
175            return Ok(None);
176        }
177
178        if start.as_ref().join(PROJECT_TOML).exists() {
179            let project_toml_path = start.as_ref().join(PROJECT_TOML);
180            let toml_content = std::fs::read_to_string(&project_toml_path).map_err(|err| {
181                ProjectError::ReadProjectTOML(project_toml_path.to_string_lossy().to_string(), err)
182            })?;
183            let root = start.as_ref();
184
185            let mut project = Project {
186                root: ProjectRoot(root.to_path_buf()),
187                toml: PartialProjectToml::new(&toml_content, ProjectRoot(root.to_path_buf()))?,
188            };
189
190            if let Some(extra_rockspec) = project.extra_rockspec()? {
191                project.toml = project.toml.merge(extra_rockspec);
192            }
193
194            Ok(Some(project))
195        } else {
196            Ok(None)
197        }
198    }
199
200    pub fn from(start: impl AsRef<Path>) -> Result<Option<Self>, ProjectError> {
201        if !start.as_ref().exists() {
202            return Ok(None);
203        }
204
205        match find_up_with(
206            PROJECT_TOML,
207            FindUpOptions {
208                cwd: start.as_ref(),
209                kind: FindUpKind::File,
210            },
211        ) {
212            Ok(Some(path)) => {
213                if let Some(root) = path.parent() {
214                    let toml_content = std::fs::read_to_string(&path).map_err(|err| {
215                        ProjectError::ReadProjectTOML(path.to_string_lossy().to_string(), err)
216                    })?;
217
218                    let mut project = Project {
219                        root: ProjectRoot(root.to_path_buf()),
220                        toml: PartialProjectToml::new(
221                            &toml_content,
222                            ProjectRoot(root.to_path_buf()),
223                        )?,
224                    };
225
226                    if let Some(extra_rockspec) = project.extra_rockspec()? {
227                        project.toml = project.toml.merge(extra_rockspec);
228                    }
229
230                    std::fs::create_dir_all(root).map_err(|err| {
231                        ProjectError::CreateProjectRoot(root.to_string_lossy().to_string(), err)
232                    })?;
233
234                    Ok(Some(project))
235                } else {
236                    Ok(None)
237                }
238            }
239            // NOTE: If we hit a read error, it could be because we haven't found a PROJECT_TOML
240            // and have started searching too far upwards.
241            // See for example https://github.com/lumen-oss/lux/issues/532
242            _ => Ok(None),
243        }
244    }
245
246    /// Get the `lux.toml` path.
247    pub fn toml_path(&self) -> PathBuf {
248        self.root.join(PROJECT_TOML)
249    }
250
251    /// Get the `.luarc.json` or `.emmyrc.json` path.
252    pub fn luarc_path(&self) -> PathBuf {
253        let luarc_path = self.root.join(LUARC);
254        if luarc_path.is_file() {
255            luarc_path
256        } else {
257            let emmy_path = self.root.join(EMMYRC);
258            if emmy_path.is_file() {
259                emmy_path
260            } else {
261                luarc_path
262            }
263        }
264    }
265
266    /// Get the `extra.rockspec` path.
267    pub fn extra_rockspec_path(&self) -> PathBuf {
268        self.root.join(EXTRA_ROCKSPEC)
269    }
270
271    /// Get the `lux.lock` lockfile path.
272    pub fn lockfile_path(&self) -> PathBuf {
273        self.root.join("lux.lock")
274    }
275
276    /// Get the `lux.lock` lockfile in the project root.
277    pub fn lockfile(&self) -> Result<ProjectLockfile<ReadOnly>, ProjectError> {
278        Ok(ProjectLockfile::new(self.lockfile_path())?)
279    }
280
281    /// Get the `lux.lock` lockfile in the project root, if present.
282    pub fn try_lockfile(&self) -> Result<Option<ProjectLockfile<ReadOnly>>, ProjectError> {
283        let path = self.lockfile_path();
284        if path.is_file() {
285            Ok(Some(ProjectLockfile::load(path)?))
286        } else {
287            Ok(None)
288        }
289    }
290
291    pub fn root(&self) -> &ProjectRoot {
292        &self.root
293    }
294
295    pub fn toml(&self) -> &PartialProjectToml {
296        &self.toml
297    }
298
299    pub fn local_rockspec(&self) -> Result<LocalLuaRockspec, IntoLocalRockspecError> {
300        Ok(self.toml().into_local()?.to_lua_rockspec()?)
301    }
302
303    pub fn remote_rockspec(
304        &self,
305        specrev: Option<SpecRev>,
306    ) -> Result<RemoteLuaRockspec, IntoRemoteRockspecError> {
307        Ok(self.toml().into_remote(specrev)?.to_lua_rockspec()?)
308    }
309
310    pub fn extra_rockspec(&self) -> Result<Option<PartialLuaRockspec>, PartialRockspecError> {
311        if self.extra_rockspec_path().exists() {
312            Ok(Some(PartialLuaRockspec::new(&std::fs::read_to_string(
313                self.extra_rockspec_path(),
314            )?)?))
315        } else {
316            Ok(None)
317        }
318    }
319
320    pub(crate) fn default_tree_root_dir(&self) -> PathBuf {
321        self.root.join(LUX_DIR_NAME)
322    }
323
324    pub fn tree(&self, config: &Config) -> Result<Tree, ProjectTreeError> {
325        self.lua_version_tree(self.lua_version(config)?, config)
326    }
327
328    pub(crate) fn lua_version_tree(
329        &self,
330        lua_version: LuaVersion,
331        config: &Config,
332    ) -> Result<Tree, ProjectTreeError> {
333        Ok(Tree::new(
334            self.default_tree_root_dir(),
335            lua_version,
336            config,
337        )?)
338    }
339
340    pub fn test_tree(&self, config: &Config) -> Result<Tree, ProjectTreeError> {
341        Ok(self.tree(config)?.test_tree(config)?)
342    }
343
344    pub fn build_tree(&self, config: &Config) -> Result<Tree, ProjectTreeError> {
345        Ok(self.tree(config)?.build_tree(config)?)
346    }
347
348    pub fn lua_version(&self, config: &Config) -> Result<LuaVersion, LuaVersionError> {
349        self.toml().lua_version_matches(config)
350    }
351
352    pub async fn add(
353        &mut self,
354        dependencies: DependencyType<PackageReq>,
355        package_db: &RemotePackageDB,
356    ) -> Result<(), ProjectEditError> {
357        let mut project_toml =
358            toml_edit::DocumentMut::from_str(&tokio::fs::read_to_string(self.toml_path()).await?)?;
359
360        prepare_dependency_tables(&mut project_toml);
361        let table = match dependencies {
362            DependencyType::Regular(_) => &mut project_toml["dependencies"],
363            DependencyType::Build(_) => &mut project_toml["build_dependencies"],
364            DependencyType::Test(_) => &mut project_toml["test_dependencies"],
365            DependencyType::External(_) => &mut project_toml["external_dependencies"],
366        };
367
368        match dependencies {
369            DependencyType::Regular(ref deps)
370            | DependencyType::Build(ref deps)
371            | DependencyType::Test(ref deps) => {
372                for dep in deps {
373                    let dep_version_str = if dep.version_req().is_any() {
374                        package_db
375                            .latest_version(dep.name())
376                            .map(|latest_version| latest_version.to_string())
377                            .unwrap_or_else(|| dep.version_req().to_string())
378                    } else {
379                        dep.version_req().to_string()
380                    };
381                    table[dep.name().to_string()] = toml_edit::value(dep_version_str);
382                }
383            }
384            DependencyType::External(ref deps) => {
385                for (name, dep) in deps {
386                    if let Some(path) = &dep.header {
387                        table[name]["header"] = toml_edit::value(path.to_slash_lossy().to_string());
388                    }
389                    if let Some(path) = &dep.library {
390                        table[name]["library"] =
391                            toml_edit::value(path.to_slash_lossy().to_string());
392                    }
393                }
394            }
395        };
396
397        let toml_content = project_toml.to_string();
398        tokio::fs::write(self.toml_path(), &toml_content).await?;
399        self.toml = PartialProjectToml::new(&toml_content, self.root.clone())?;
400
401        Ok(())
402    }
403
404    pub async fn add_git(
405        &mut self,
406        dependencies: LuaDependencyType<RemoteGitUrlShorthand>,
407    ) -> Result<(), ProjectEditError> {
408        let mut project_toml =
409            toml_edit::DocumentMut::from_str(&tokio::fs::read_to_string(self.toml_path()).await?)?;
410
411        prepare_dependency_tables(&mut project_toml);
412        let table = match dependencies {
413            LuaDependencyType::Regular(_) => &mut project_toml["dependencies"],
414            LuaDependencyType::Build(_) => &mut project_toml["build_dependencies"],
415            LuaDependencyType::Test(_) => &mut project_toml["test_dependencies"],
416        };
417
418        match dependencies {
419            LuaDependencyType::Regular(ref urls)
420            | LuaDependencyType::Build(ref urls)
421            | LuaDependencyType::Test(ref urls) => {
422                for url in urls {
423                    let git_url: RemoteGitUrl = url.clone().into();
424                    let mut dep_entry = toml_edit::table();
425                    match git::utils::latest_semver_tag_or_commit_sha(&git_url)? {
426                        SemVerTagOrSha::SemVerTag(tag) => {
427                            dep_entry["git"] = Item::Value(url.to_string().into());
428                            dep_entry["version"] = Item::Value(tag.clone().into());
429                            if tag.contains("-") {
430                                // Tag contains a specrev.
431                                dep_entry["rev"] = Item::Value(tag.into());
432                            }
433                        }
434                        SemVerTagOrSha::CommitSha(sha) => {
435                            dep_entry["git"] = Item::Value(url.to_string().into());
436                            dep_entry["version"] = Item::Value(sha.into());
437                        }
438                    }
439                    table[git_url.repo.clone()] = dep_entry;
440                }
441            }
442        }
443
444        let toml_content = project_toml.to_string();
445        tokio::fs::write(self.toml_path(), &toml_content).await?;
446        self.toml = PartialProjectToml::new(&toml_content, self.root.clone())?;
447
448        Ok(())
449    }
450
451    pub async fn remove(
452        &mut self,
453        dependencies: DependencyType<PackageName>,
454    ) -> Result<(), ProjectEditError> {
455        let mut project_toml =
456            toml_edit::DocumentMut::from_str(&tokio::fs::read_to_string(self.toml_path()).await?)?;
457
458        prepare_dependency_tables(&mut project_toml);
459        let table = match dependencies {
460            DependencyType::Regular(_) => &mut project_toml["dependencies"],
461            DependencyType::Build(_) => &mut project_toml["build_dependencies"],
462            DependencyType::Test(_) => &mut project_toml["test_dependencies"],
463            DependencyType::External(_) => &mut project_toml["external_dependencies"],
464        };
465
466        match dependencies {
467            DependencyType::Regular(ref deps)
468            | DependencyType::Build(ref deps)
469            | DependencyType::Test(ref deps) => {
470                for dep in deps {
471                    table[dep.to_string()] = Item::None;
472                }
473            }
474            DependencyType::External(ref deps) => {
475                for (name, dep) in deps {
476                    if dep.header.is_some() {
477                        table[name]["header"] = Item::None;
478                    }
479                    if dep.library.is_some() {
480                        table[name]["library"] = Item::None;
481                    }
482                }
483            }
484        };
485
486        let toml_content = project_toml.to_string();
487        tokio::fs::write(self.toml_path(), &toml_content).await?;
488        self.toml = PartialProjectToml::new(&toml_content, self.root.clone())?;
489
490        Ok(())
491    }
492
493    pub async fn upgrade(
494        &mut self,
495        dependencies: LuaDependencyType<PackageName>,
496        package_db: &RemotePackageDB,
497    ) -> Result<(), ProjectEditError> {
498        let mut project_toml =
499            toml_edit::DocumentMut::from_str(&tokio::fs::read_to_string(self.toml_path()).await?)?;
500
501        prepare_dependency_tables(&mut project_toml);
502        let table = match dependencies {
503            LuaDependencyType::Regular(_) => &mut project_toml["dependencies"],
504            LuaDependencyType::Build(_) => &mut project_toml["build_dependencies"],
505            LuaDependencyType::Test(_) => &mut project_toml["test_dependencies"],
506        };
507
508        match dependencies {
509            LuaDependencyType::Regular(ref deps)
510            | LuaDependencyType::Build(ref deps)
511            | LuaDependencyType::Test(ref deps) => {
512                let latest_rock_version_str =
513                    |dep: &PackageName| -> Result<String, ProjectEditError> {
514                        Ok(package_db
515                            .latest_version(dep)
516                            .ok_or(ProjectEditError::LatestVersionNotFound(dep.clone()))?
517                            .to_string())
518                    };
519                for dep in deps {
520                    let mut dep_item = table[dep.to_string()].clone();
521                    match &dep_item {
522                        Item::Value(_) => {
523                            let dep_version_str = latest_rock_version_str(dep)?;
524                            table[dep.to_string()] = toml_edit::value(dep_version_str);
525                        }
526                        Item::Table(tbl) => {
527                            match tbl.get("git") {
528                                Some(git_item) => {
529                                    let git_value = git_item
530                                        .clone()
531                                        .into_value()
532                                        .map_err(ProjectEditError::ExpectedValue)?;
533                                    let git_url_str = git_value.as_str().ok_or(
534                                        ProjectEditError::ExpectedString(git_value.clone()),
535                                    )?;
536                                    let shorthand: RemoteGitUrlShorthand = git_url_str.parse()?;
537                                    match git::utils::latest_semver_tag_or_commit_sha(
538                                        &shorthand.into(),
539                                    )? {
540                                        SemVerTagOrSha::SemVerTag(latest_tag) => {
541                                            table[dep.to_string()]["version"] =
542                                                Item::Value(latest_tag.clone().into());
543                                            if latest_tag.contains("-") {
544                                                // Tag contains a specrev.
545                                                table[dep.to_string()]["rev"] =
546                                                    Item::Value(latest_tag.into());
547                                            }
548                                        }
549                                        SemVerTagOrSha::CommitSha(latest_sha) => {
550                                            table[dep.to_string()]["version"] =
551                                                Item::Value(latest_sha.into());
552                                        }
553                                    }
554                                    table[dep.to_string()] = dep_item;
555                                }
556                                None => {
557                                    let dep_version_str = latest_rock_version_str(dep)?;
558                                    dep_item["version".to_string()] =
559                                        toml_edit::value(dep_version_str);
560                                    table[dep.to_string()] = dep_item;
561                                }
562                            }
563                        }
564                        _ => {}
565                    }
566                }
567            }
568        }
569
570        let toml_content = project_toml.to_string();
571        tokio::fs::write(self.toml_path(), &toml_content).await?;
572        self.toml = PartialProjectToml::new(&toml_content, self.root.clone())?;
573
574        Ok(())
575    }
576
577    pub async fn upgrade_all(
578        &mut self,
579        package_db: &RemotePackageDB,
580    ) -> Result<(), ProjectEditError> {
581        if let Some(dependencies) = &self.toml().dependencies {
582            let packages = dependencies
583                .iter()
584                .map(|dep| dep.name())
585                .cloned()
586                .collect_vec();
587            self.upgrade(LuaDependencyType::Regular(packages), package_db)
588                .await?;
589        }
590        if let Some(dependencies) = &self.toml().build_dependencies {
591            let packages = dependencies
592                .iter()
593                .map(|dep| dep.name())
594                .cloned()
595                .collect_vec();
596            self.upgrade(LuaDependencyType::Build(packages), package_db)
597                .await?;
598        }
599        if let Some(dependencies) = &self.toml().test_dependencies {
600            let packages = dependencies
601                .iter()
602                .map(|dep| dep.name())
603                .cloned()
604                .collect_vec();
605            self.upgrade(LuaDependencyType::Test(packages), package_db)
606                .await?;
607        }
608        Ok(())
609    }
610
611    pub async fn set_pinned_state(
612        &mut self,
613        dependencies: LuaDependencyType<PackageName>,
614        pin: PinnedState,
615    ) -> Result<(), PinError> {
616        let mut project_toml =
617            toml_edit::DocumentMut::from_str(&tokio::fs::read_to_string(self.toml_path()).await?)?;
618
619        prepare_dependency_tables(&mut project_toml);
620        let table = match dependencies {
621            LuaDependencyType::Regular(_) => &mut project_toml["dependencies"],
622            LuaDependencyType::Build(_) => &mut project_toml["build_dependencies"],
623            LuaDependencyType::Test(_) => &mut project_toml["test_dependencies"],
624        };
625
626        match dependencies {
627            LuaDependencyType::Regular(ref _deps) => {
628                self.toml.dependencies = Some(
629                    self.toml
630                        .dependencies
631                        .take()
632                        .unwrap_or_default()
633                        .into_iter()
634                        .map(|dep| LuaDependencySpec { pin, ..dep })
635                        .collect(),
636                )
637            }
638            LuaDependencyType::Build(ref _deps) => {
639                self.toml.build_dependencies = Some(
640                    self.toml
641                        .build_dependencies
642                        .take()
643                        .unwrap_or_default()
644                        .into_iter()
645                        .map(|dep| LuaDependencySpec { pin, ..dep })
646                        .collect(),
647                )
648            }
649            LuaDependencyType::Test(ref _deps) => {
650                self.toml.test_dependencies = Some(
651                    self.toml
652                        .test_dependencies
653                        .take()
654                        .unwrap_or_default()
655                        .into_iter()
656                        .map(|dep| LuaDependencySpec { pin, ..dep })
657                        .collect(),
658                )
659            }
660        }
661
662        match dependencies {
663            LuaDependencyType::Regular(ref deps)
664            | LuaDependencyType::Build(ref deps)
665            | LuaDependencyType::Test(ref deps) => {
666                for dep in deps {
667                    let mut dep_item = table[dep.to_string()].clone();
668                    match dep_item {
669                        version @ Item::Value(_) => match &pin {
670                            PinnedState::Unpinned => {}
671                            PinnedState::Pinned => {
672                                if let Ok(mut dep_entry) = toml_edit::table().into_table() {
673                                    dep_entry.set_implicit(true);
674                                    dep_entry["version"] = version;
675                                    dep_entry["pin"] = toml_edit::value(true);
676                                    table[dep.to_string()] = toml_edit::Item::Table(dep_entry);
677                                }
678                            }
679                        },
680                        Item::Table(_) => {
681                            dep_item["pin".to_string()] = toml_edit::value(pin.as_bool());
682                            table[dep.to_string()] = dep_item;
683                        }
684                        _ => {}
685                    }
686                }
687            }
688        }
689
690        let toml_content = project_toml.to_string();
691        tokio::fs::write(self.toml_path(), &toml_content).await?;
692        self.toml = PartialProjectToml::new(&toml_content, self.root.clone())?;
693
694        Ok(())
695    }
696
697    pub fn project_files(&self) -> Vec<PathBuf> {
698        build::utils::project_files(&self.root().0)
699    }
700}
701
702fn prepare_dependency_tables(project_toml: &mut DocumentMut) {
703    if !project_toml.contains_table("dependencies") {
704        if let Ok(mut table) = toml_edit::table().into_table() {
705            table.set_implicit(true);
706            project_toml["dependencies"] = toml_edit::Item::Table(table);
707        }
708    }
709    if !project_toml.contains_table("build_dependencies") {
710        if let Ok(mut table) = toml_edit::table().into_table() {
711            table.set_implicit(true);
712            project_toml["build_dependencies"] = toml_edit::Item::Table(table);
713        }
714    }
715    if !project_toml.contains_table("test_dependencies") {
716        if let Ok(mut table) = toml_edit::table().into_table() {
717            table.set_implicit(true);
718            project_toml["test_dependencies"] = toml_edit::Item::Table(table);
719        }
720    }
721    if !project_toml.contains_table("external_dependencies") {
722        if let Ok(mut table) = toml_edit::table().into_table() {
723            table.set_implicit(true);
724            project_toml["external_dependencies"] = toml_edit::Item::Table(table);
725        }
726    }
727}
728
729// TODO: More project-based test
730#[cfg(test)]
731mod tests {
732    use std::collections::HashMap;
733
734    use assert_fs::prelude::PathCopy;
735    use url::Url;
736
737    use super::*;
738    use crate::{
739        lua_rockspec::ExternalDependencySpec,
740        manifest::{Manifest, ManifestMetadata},
741        package::PackageReq,
742        rockspec::Rockspec,
743    };
744
745    #[tokio::test]
746    async fn test_add_various_dependencies() {
747        let sample_project: PathBuf = "resources/test/sample-projects/no-build-spec/".into();
748        let project_root = assert_fs::TempDir::new().unwrap();
749        project_root.copy_from(&sample_project, &["**"]).unwrap();
750        let project_root: PathBuf = project_root.path().into();
751        let mut project = Project::from(&project_root).unwrap().unwrap();
752        let add_dependencies =
753            vec![PackageReq::new("busted".into(), Some(">= 1.0.0".into())).unwrap()];
754        let expected_dependencies = vec![PackageReq::new("busted".into(), Some(">= 1.0.0".into()))
755            .unwrap()
756            .into()];
757
758        let test_manifest_path =
759            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/manifest-5.1");
760        let content = String::from_utf8(std::fs::read(&test_manifest_path).unwrap()).unwrap();
761        let metadata = ManifestMetadata::new(&content).unwrap();
762        let package_db = Manifest::new(Url::parse("https://example.com").unwrap(), metadata).into();
763
764        project
765            .add(
766                DependencyType::Regular(add_dependencies.clone()),
767                &package_db,
768            )
769            .await
770            .unwrap();
771
772        project
773            .add(DependencyType::Build(add_dependencies.clone()), &package_db)
774            .await
775            .unwrap();
776        project
777            .add(DependencyType::Test(add_dependencies.clone()), &package_db)
778            .await
779            .unwrap();
780
781        project
782            .add(
783                DependencyType::External(HashMap::from([(
784                    "lib".into(),
785                    ExternalDependencySpec {
786                        library: Some("path.so".into()),
787                        header: None,
788                    },
789                )])),
790                &package_db,
791            )
792            .await
793            .unwrap();
794
795        // Reparse the lux.toml (not usually necessary, but we want to test that the file was
796        // written correctly)
797        let project = Project::from(&project_root).unwrap().unwrap();
798        let validated_toml = project.toml().into_remote(None).unwrap();
799
800        assert_eq!(
801            validated_toml.dependencies().current_platform(),
802            &expected_dependencies
803        );
804        assert_eq!(
805            validated_toml.build_dependencies().current_platform(),
806            &expected_dependencies
807        );
808        assert_eq!(
809            validated_toml.test_dependencies().current_platform(),
810            &expected_dependencies
811        );
812        assert_eq!(
813            validated_toml
814                .external_dependencies()
815                .current_platform()
816                .get("lib")
817                .unwrap(),
818            &ExternalDependencySpec {
819                library: Some("path.so".into()),
820                header: None
821            }
822        );
823    }
824
825    #[tokio::test]
826    async fn test_remove_dependencies() {
827        let sample_project: PathBuf = "resources/test/sample-projects/dependencies/".into();
828        let project_root = assert_fs::TempDir::new().unwrap();
829        project_root.copy_from(&sample_project, &["**"]).unwrap();
830        let project_root: PathBuf = project_root.path().into();
831        let mut project = Project::from(&project_root).unwrap().unwrap();
832        let remove_dependencies = vec!["lua-cjson".into(), "plenary.nvim".into()];
833        project
834            .remove(DependencyType::Regular(remove_dependencies.clone()))
835            .await
836            .unwrap();
837        let check = |project: &Project| {
838            for name in &remove_dependencies {
839                assert!(!project
840                    .toml()
841                    .dependencies
842                    .clone()
843                    .unwrap_or_default()
844                    .iter()
845                    .any(|dep| dep.name() == name));
846            }
847        };
848        check(&project);
849        // check again after reloading lux.toml
850        let reloaded_project = Project::from(&project_root).unwrap().unwrap();
851        check(&reloaded_project);
852    }
853
854    #[tokio::test]
855    async fn test_extra_rockspec_parsing() {
856        let sample_project: PathBuf = "resources/test/sample-projects/extra-rockspec/".into();
857        let project_root = assert_fs::TempDir::new().unwrap();
858        project_root.copy_from(&sample_project, &["**"]).unwrap();
859        let project_root: PathBuf = project_root.path().into();
860        let project = Project::from(project_root).unwrap().unwrap();
861
862        let extra_rockspec = project.extra_rockspec().unwrap();
863
864        assert!(extra_rockspec.is_some());
865
866        let rocks = project.toml().into_remote(None).unwrap();
867
868        assert_eq!(rocks.package().to_string(), "custom-package");
869    }
870
871    #[tokio::test]
872    async fn test_pin_dependencies() {
873        test_pin_unpin_dependencies(PinnedState::Pinned).await
874    }
875
876    #[tokio::test]
877    async fn test_unpin_dependencies() {
878        test_pin_unpin_dependencies(PinnedState::Unpinned).await
879    }
880
881    async fn test_pin_unpin_dependencies(pin: PinnedState) {
882        let sample_project: PathBuf = "resources/test/sample-projects/dependencies/".into();
883        let project_root = assert_fs::TempDir::new().unwrap();
884        project_root.copy_from(&sample_project, &["**"]).unwrap();
885        let project_root: PathBuf = project_root.path().into();
886        let mut project = Project::from(&project_root).unwrap().unwrap();
887        let pin_dependencies = vec!["lua-cjson".into(), "plenary.nvim".into()];
888        project
889            .set_pinned_state(LuaDependencyType::Regular(pin_dependencies.clone()), pin)
890            .await
891            .unwrap();
892        let check = |project: &Project| {
893            for name in &pin_dependencies {
894                assert!(project
895                    .toml()
896                    .dependencies
897                    .clone()
898                    .unwrap_or_default()
899                    .iter()
900                    .any(|dep| dep.name() == name && dep.pin == pin));
901            }
902        };
903        check(&project);
904        // check again after reloading lux.toml
905        let reloaded_project = Project::from(&project_root).unwrap().unwrap();
906        check(&reloaded_project);
907    }
908}
lux_lib/project/mod.rs

lux_lib/project/
mod.rs
