use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use clap::ValueEnum;
use serde::Deserialize;
pub(crate) use telar_project::TelarSection;
use telar_project::protocol::RendererBackend;
use telar_project::{CargoManifest, TelarManifest};
use super::cargo_args::selected_package;
#[derive(Clone, Copy, ValueEnum)]
pub(crate) enum BackendArg {
Auto,
Hardware,
Software,
}
impl From<BackendArg> for RendererBackend {
fn from(arg: BackendArg) -> Self {
match arg {
BackendArg::Auto => Self::Auto,
BackendArg::Hardware => Self::Hardware,
BackendArg::Software => Self::Software,
}
}
}
#[derive(Deserialize, Default)]
pub(crate) struct CargoWorkspace {
pub(crate) package: Option<CargoWorkspacePackage>,
}
#[derive(Deserialize, Default, Clone)]
pub(crate) struct CargoWorkspacePackage {
#[serde(default)]
pub(crate) version: Option<String>,
#[serde(default)]
pub(crate) authors: Vec<String>,
#[serde(default)]
pub(crate) description: Option<String>,
}
#[derive(Deserialize, Default)]
pub(crate) struct ManifestView {
pub(crate) workspace: Option<CargoWorkspace>,
pub(crate) package: Option<CargoPackage>,
pub(crate) lib: Option<CargoLib>,
#[serde(default)]
pub(crate) features: BTreeMap<String, toml::Value>,
}
#[derive(Deserialize, Default)]
pub(crate) struct CargoLib {
#[serde(default, rename = "crate-type")]
pub(crate) crate_type: Vec<String>,
}
#[derive(Deserialize, Default)]
pub(crate) struct CargoPackage {
pub(crate) name: String,
#[serde(default)]
pub(crate) version: Inheritable<String>,
#[serde(default)]
pub(crate) authors: Inheritable<Vec<String>>,
#[serde(default)]
pub(crate) description: Inheritable<String>,
pub(crate) metadata: Option<CargoPackageMetadata>,
}
#[derive(Default, Debug, PartialEq)]
pub(crate) enum Inheritable<T> {
#[default]
Absent,
FromWorkspace,
Set(T),
}
impl<'de, T: serde::de::DeserializeOwned> Deserialize<'de> for Inheritable<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = toml::Value::deserialize(deserializer)?;
if value.get("workspace").and_then(toml::Value::as_bool) == Some(true) {
return Ok(Self::FromWorkspace);
}
T::deserialize(value)
.map(Self::Set)
.map_err(serde::de::Error::custom)
}
}
impl<T: Clone> Inheritable<T> {
fn resolve(&self, inherited: impl FnOnce() -> Option<T>) -> Option<T> {
match self {
Self::Set(value) => Some(value.clone()),
Self::FromWorkspace => inherited(),
Self::Absent => None,
}
}
}
#[derive(Deserialize, Default)]
pub(crate) struct CargoPackageMetadata {
pub(crate) android: Option<AndroidMetadata>,
}
#[derive(Deserialize, Default)]
pub(crate) struct AndroidMetadata {
pub(crate) package: Option<String>,
}
fn find_package_dir_in_workspace(workspace_root: &Path, package_name: &str) -> Option<PathBuf> {
telar_project::workspace_member_dirs(workspace_root)
.into_iter()
.find(|member| {
CargoManifest::read(member)
.is_some_and(|manifest| manifest.package_name() == Some(package_name))
})
}
pub(crate) fn find_package_dir(args: &[String]) -> PathBuf {
if let Some(name) = selected_package(args) {
let cwd = std::env::current_dir().unwrap_or_default();
if let Some(root) = telar_project::find_workspace_root(&cwd)
&& let Some(dir) = find_package_dir_in_workspace(&root, name)
{
return dir;
}
}
let mut dir = std::env::current_dir().unwrap_or_default();
loop {
if dir.join("Cargo.toml").exists() {
return dir;
}
match dir.parent() {
Some(parent) => dir = parent.to_path_buf(),
None => return std::env::current_dir().unwrap_or_default(),
}
}
}
fn read_manifest_in(dir: &Path) -> Option<ManifestView> {
CargoManifest::read(dir)?.view().ok()
}
pub(crate) fn read_package_manifest_in(dir: &Path) -> Option<CargoPackage> {
read_manifest_in(dir)?.package
}
pub(crate) struct ResolvedPackage {
pub(crate) workspace_root: PathBuf,
pub(crate) package_dir: PathBuf,
pub(crate) name: String,
pub(crate) version: String,
pub(crate) package: CargoPackage,
pub(crate) workspace_package: Option<CargoWorkspacePackage>,
pub(crate) produces_cdylib: bool,
pub(crate) features: BTreeMap<String, toml::Value>,
pub(crate) default_run: Option<String>,
}
impl ResolvedPackage {
pub(crate) fn maintainer(&self) -> Option<Maintainer> {
self.package
.authors
.resolve(|| Some(self.workspace_package.as_ref()?.authors.clone()))
.and_then(|authors| authors.first().cloned())
.map(|value| Maintainer {
value,
source: MaintainerSource::CargoAuthors,
})
.or_else(maintainer_from_env)
}
pub(crate) fn description(&self) -> Option<String> {
self.package
.description
.resolve(|| self.workspace_package.as_ref()?.description.clone())
}
fn default_names(&self, wanted: &str) -> bool {
let enabled = closure(&self.features, feature_list(self.features.get(DEFAULT)));
enabled.contains(wanted) || enabled.contains(&format!("telar/{wanted}"))
}
pub(crate) fn defaults_to_terminal(&self) -> bool {
self.default_names("tui")
&& !["desktop", "web", "web-dom", "android"]
.iter()
.any(|frontend| self.default_names(frontend))
}
pub(crate) fn targets_web(&self) -> bool {
self.features.contains_key("web")
|| self.features.contains_key("web-dom")
|| self.default_names("web")
|| self.default_names("web-dom")
}
pub(crate) fn frontend_feature(&self, wanted: &str) -> FrontendFeature {
if self.default_names(wanted) {
return FrontendFeature::AlreadyDefault;
}
if !self.features.contains_key(wanted) {
return FrontendFeature::Telar(format!("telar/{wanted}"));
}
let name = &self.name;
let mut named = vec![format!("{name}/{wanted}")];
named.extend(
feature_list(self.features.get(DEFAULT))
.into_iter()
.filter(|feature| !enables_frontend(&self.features, feature))
.map(|feature| match feature.contains('/') {
true => feature,
false => format!("{name}/{feature}"),
}),
);
FrontendFeature::Package(named)
}
}
pub(crate) enum FrontendFeature {
AlreadyDefault,
Package(Vec<String>),
Telar(String),
}
impl FrontendFeature {
pub(crate) fn push_to(&self, args: &mut Vec<String>) {
match self {
Self::AlreadyDefault => {}
Self::Package(features) => {
args.push("--no-default-features".to_string());
args.push("--features".to_string());
args.push(features.join(","));
}
Self::Telar(feature) => {
args.push("--features".to_string());
args.push(feature.clone());
}
}
}
}
const DEFAULT: &str = "default";
const FRONTENDS: [&str; 6] = ["desktop", "tui", "web", "web-dom", "android", "headless"];
fn feature_list(value: Option<&toml::Value>) -> Vec<String> {
value
.and_then(toml::Value::as_array)
.map(|entries| {
entries
.iter()
.filter_map(|entry| entry.as_str().map(str::to_string))
.collect()
})
.unwrap_or_default()
}
fn closure(features: &BTreeMap<String, toml::Value>, roots: Vec<String>) -> BTreeSet<String> {
let mut seen = BTreeSet::new();
let mut queue = roots;
while let Some(feature) = queue.pop() {
if !seen.insert(feature.clone()) {
continue;
}
queue.extend(feature_list(features.get(&feature)));
}
seen
}
fn enables_frontend(features: &BTreeMap<String, toml::Value>, feature: &str) -> bool {
closure(features, vec![feature.to_string()])
.iter()
.any(|enabled| FRONTENDS.contains(&enabled.trim_start_matches("telar/")))
}
pub(crate) const TOOLING_FEATURES: [&str; 6] = [
"telar/dev",
"telar/hot-reload",
"telar/previews",
"telar/preview",
"telar/preview-headless",
"telar/preview-snapshots",
];
pub(crate) fn tooling_feature_entry() -> String {
let features = TOOLING_FEATURES
.map(|feature| format!("\"{feature}\""))
.join(", ");
format!("tooling = [{features}]")
}
fn names_feature(features: &BTreeMap<String, toml::Value>, wanted: &str) -> bool {
let weak = wanted.replacen('/', "?/", 1);
features
.values()
.flat_map(|value| feature_list(Some(value)))
.any(|feature| feature == wanted || feature == weak)
}
pub(crate) fn unlocked_tooling_note(
declared: &[BTreeMap<String, toml::Value>],
injected: &[&str],
) -> Option<String> {
let unlocked: Vec<String> = injected
.iter()
.filter(|feature| {
!declared
.iter()
.any(|features| names_feature(features, feature))
})
.map(|feature| format!("`{feature}`"))
.collect();
if unlocked.is_empty() {
return None;
}
Some(format!(
"[cargo-telar] warning: no `[features]` entry in this workspace names {}, so Cargo.lock does not pin what it brings in and a telar upgrade can fail to resolve it. Add this under the app's `[features]`:\n {}",
unlocked.join(", "),
tooling_feature_entry()
))
}
pub(crate) fn warn_if_tooling_unlocked(args: &[String], injected: &[&str]) {
let dir = find_package_dir(args);
let root = telar_project::find_workspace_root(&dir).unwrap_or(dir);
let declared: Vec<_> = telar_project::workspace_member_dirs(&root)
.iter()
.filter_map(|member| read_manifest_in(member))
.map(|manifest| manifest.features)
.collect();
if let Some(note) = unlocked_tooling_note(&declared, injected) {
eprintln!("{note}");
}
}
pub(crate) fn missing_devtools_note(package: &str) -> String {
let devtools = telar_project::DEVTOOLS_PACKAGE;
format!(
"`{package}` declares no optional `{devtools}` dependency, so no devtools overlay is built in. Add it with `cargo add -p {package} {devtools} --optional`."
)
}
pub(crate) fn missing_workshop(resolved: &ResolvedPackage) -> Option<String> {
let workshop = telar_project::WORKSHOP_PACKAGE;
if telar_project::declares_optional_dependency(&resolved.package_dir, workshop) {
return None;
}
let package = &resolved.name;
Some(format!(
"`{package}` declares no optional `{workshop}` dependency, which `cargo telar preview` shows the previews in. Add it with `cargo add -p {package} {workshop} --optional`."
))
}
struct MovedFeature {
feature: &'static str,
package: &'static str,
}
const COMPONENTS: &str = "telar-components";
const WATCH: &str = "telar-watch";
const MOVED_FEATURES: [MovedFeature; 7] = [
MovedFeature {
feature: "components",
package: COMPONENTS,
},
MovedFeature {
feature: "components-base",
package: COMPONENTS,
},
MovedFeature {
feature: "components-overlays",
package: COMPONENTS,
},
MovedFeature {
feature: "components-chrome",
package: COMPONENTS,
},
MovedFeature {
feature: "components-advanced",
package: COMPONENTS,
},
MovedFeature {
feature: "navigate",
package: "telar-navigate",
},
MovedFeature {
feature: "watch",
package: WATCH,
},
];
const DEPENDENCY_TABLES: [&str; 3] = ["dependencies", "dev-dependencies", "build-dependencies"];
pub(crate) fn moved_telar_features(
manifest: &CargoManifest,
workspace_dependencies: Option<&toml::Table>,
) -> BTreeSet<&'static str> {
let tables: Vec<&toml::Table> = DEPENDENCY_TABLES
.iter()
.flat_map(|kind| manifest.dependency_tables(kind))
.collect();
let mut keys = BTreeSet::from(["telar".to_string()]);
let mut named: Vec<String> = Vec::new();
for (key, dependency) in tables.iter().flat_map(|table| table.iter()) {
let package = dependency.get("package").and_then(toml::Value::as_str);
if package.unwrap_or(key) != "telar" {
continue;
}
keys.insert(key.clone());
named.extend(feature_list(dependency.get("features")));
if dependency.get("workspace").and_then(toml::Value::as_bool) == Some(true) {
named.extend(feature_list(
workspace_dependencies
.and_then(|deps| deps.get(key))
.and_then(|dependency| dependency.get("features")),
));
}
}
let features = manifest
.table()
.get("features")
.and_then(toml::Value::as_table);
for entry in features
.into_iter()
.flat_map(|features| features.values())
.flat_map(|value| feature_list(Some(value)))
{
if let Some((dependency, feature)) = entry.split_once('/')
&& keys.contains(dependency.trim_end_matches('?'))
{
named.push(feature.to_string());
}
}
MOVED_FEATURES
.iter()
.map(|moved| moved.feature)
.filter(|feature| named.iter().any(|name| name == feature))
.collect()
}
pub(crate) fn moved_features_hint(
package: &str,
moved: &BTreeSet<&str>,
prelude: &[telar_project::PreludeEntry],
) -> Option<String> {
if moved.is_empty() {
return None;
}
let moved: Vec<&MovedFeature> = MOVED_FEATURES
.iter()
.filter(|m| moved.contains(m.feature))
.collect();
let mut commands: Vec<String> = Vec::new();
let mut entries: Vec<String> = prelude.iter().map(ToString::to_string).collect();
for crate_package in [COMPONENTS, "telar-navigate", WATCH] {
if !moved.iter().any(|m| m.package == crate_package) {
continue;
}
commands.push(format!("cargo add -p {package} {crate_package}"));
let crate_name = crate_package.replace('-', "_");
if crate_package != WATCH && !entries.contains(&crate_name) {
entries.push(crate_name);
}
}
let features = moved
.iter()
.map(|m| format!("`{}`", m.feature))
.collect::<Vec<_>>()
.join(", ");
let mut hint = format!(
"`{package}` turns on `telar` features that are crates of their own now: {features}. Drop them from its `telar` dependency, then run:\n {}",
commands.join("\n ")
);
if entries.len() > prelude.len() {
let quoted = entries
.iter()
.map(|entry| format!("\"{entry}\""))
.collect::<Vec<_>>()
.join(", ");
hint.push_str(&format!(
"\nand name their tags in its telar.toml:\n [telar]\n prelude = [{quoted}]"
));
}
Some(hint)
}
pub(crate) fn moved_features_hint_for(dir: &Path) -> Option<String> {
let manifest = CargoManifest::read(dir)?;
let workspace =
telar_project::find_workspace_root(dir).and_then(|root| CargoManifest::read(&root));
let workspace_dependencies = workspace
.as_ref()
.and_then(CargoManifest::workspace_dependencies);
let moved = moved_telar_features(&manifest, workspace_dependencies);
let package = manifest.package_name()?;
let prelude = telar_project::resolve_prelude(dir).unwrap_or_default();
moved_features_hint(package, &moved, &prelude)
}
pub(crate) fn warn_if_features_moved(args: &[String]) {
let dir = find_package_dir(args);
let root = telar_project::find_workspace_root(&dir).unwrap_or(dir);
for member in telar_project::workspace_member_dirs(&root) {
if let Some(hint) = moved_features_hint_for(&member) {
eprintln!("[cargo-telar] warning: {hint}");
}
}
}
fn maintainer_from_env() -> Option<Maintainer> {
maintainer_from(
std::env::var("DEBFULLNAME").ok(),
std::env::var("DEBEMAIL").ok(),
)
}
pub(crate) fn maintainer_from(name: Option<String>, email: Option<String>) -> Option<Maintainer> {
let email = email?.trim_matches(' ').to_string();
if email.is_empty() {
return None;
}
let value = match name.map(|name| name.trim_matches(' ').to_string()) {
Some(name) if !name.is_empty() => format!("{name} <{email}>"),
_ => email,
};
Some(Maintainer {
value,
source: MaintainerSource::DebEnv,
})
}
#[derive(Debug, PartialEq)]
pub(crate) enum MaintainerSource {
CargoAuthors,
DebEnv,
}
#[derive(Debug, PartialEq)]
pub(crate) struct Maintainer {
pub(crate) value: String,
pub(crate) source: MaintainerSource,
}
#[derive(Debug)]
pub(crate) enum PackageError {
NoManifest { dir: PathBuf },
Manifest(telar_project::ManifestError),
Invalid { path: PathBuf, message: String },
NoPackage { path: PathBuf },
NoVersion { path: PathBuf, name: String },
}
impl PackageError {
pub(crate) fn exit(self) -> ! {
eprintln!("[cargo-telar] {self}");
std::process::exit(2);
}
}
impl std::fmt::Display for PackageError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NoManifest { dir } => write!(f, "no Cargo.toml in {}", dir.display()),
Self::Manifest(error) => error.fmt(f),
Self::Invalid { path, message } => write!(f, "{}: {message}", path.display()),
Self::NoPackage { path } => write!(f, "{} declares no `[package]`", path.display()),
Self::NoVersion { path, name } => write!(
f,
"{}: package `{name}` has no `version`, and the workspace declares none to inherit",
path.display()
),
}
}
}
impl std::error::Error for PackageError {}
const CARGO_MANIFEST: &str = "Cargo.toml";
pub(crate) fn resolve_package(args: &[String]) -> Result<ResolvedPackage, PackageError> {
resolve_package_in(find_package_dir(args))
}
pub(crate) fn resolve_package_in(dir: PathBuf) -> Result<ResolvedPackage, PackageError> {
let workspace_root = telar_project::find_workspace_root(&dir).unwrap_or_else(|| dir.clone());
let path = dir.join(CARGO_MANIFEST);
let cargo_manifest = CargoManifest::load(&dir)
.map_err(PackageError::Manifest)?
.ok_or_else(|| PackageError::NoManifest { dir: dir.clone() })?;
let default_run = cargo_manifest.default_run().map(str::to_string);
let manifest = cargo_manifest
.view::<ManifestView>()
.map_err(|e| PackageError::Invalid {
path: path.clone(),
message: e.to_string(),
})?;
let produces_cdylib = manifest
.lib
.as_ref()
.is_some_and(|lib| lib.crate_type.iter().any(|kind| kind == "cdylib"));
let workspace_package = if workspace_root == dir {
manifest.workspace.as_ref().and_then(|w| w.package.clone())
} else {
None
}
.or_else(|| read_manifest_in(&workspace_root)?.workspace?.package);
let package = manifest
.package
.ok_or_else(|| PackageError::NoPackage { path: path.clone() })?;
let version = package
.version
.resolve(|| workspace_package.as_ref()?.version.clone())
.ok_or_else(|| PackageError::NoVersion {
path,
name: package.name.clone(),
})?;
Ok(ResolvedPackage {
workspace_root,
package_dir: dir,
name: package.name.clone(),
version,
package,
workspace_package,
produces_cdylib,
features: manifest.features,
default_run,
})
}
pub(crate) fn default_app_id(name: &str) -> String {
format!("com.example.{name}")
}
pub(crate) const WEB_PROFILE_TOML: &str =
"[profile.web]\ninherits = \"release\"\nopt-level = \"z\"\npanic = \"abort\"\n";
pub(crate) fn has_web_profile(workspace_root: &Path) -> bool {
CargoManifest::read(workspace_root).is_some_and(|manifest| manifest.has_profile("web"))
}
pub(crate) fn load_config(args: &[String]) -> TelarSection {
match TelarManifest::load(&find_package_dir(args)) {
Ok(manifest) => manifest.telar,
Err(e) => {
eprintln!("[cargo-telar] {e}");
std::process::exit(2);
}
}
}
pub(crate) fn split_android_flag(args: Vec<String>) -> (bool, Vec<String>) {
let android = args.contains(&"--android".to_string());
let rest = args.into_iter().filter(|a| a != "--android").collect();
(android, rest)
}
pub(crate) fn foreign_version_note(project_telar: &str) -> Option<String> {
let ours = env!("CARGO_PKG_VERSION");
if project_telar == ours {
return None;
}
Some(format!(
"[cargo-telar] note: this project builds telar {project_telar}, and this is cargo-telar {ours}. If a build refuses what was transpiled, the versions are why: cargo install cargo-telar --version {project_telar} --force"
))
}
pub(crate) fn warn_if_foreign_version(project_telar: &str) {
static WARNED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if let Some(note) = foreign_version_note(project_telar)
&& !WARNED.swap(true, std::sync::atomic::Ordering::Relaxed)
{
eprintln!("{note}");
}
}
#[cfg(test)]
#[path = "config.test.rs"]
mod tests;