use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use clap::ValueEnum;
use serde::Deserialize;
pub(crate) use telar_project::{DevSection, TelarSection, WindowSection};
use telar_project::{ManifestError, RendererBackend, TelarManifest};
#[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 CargoManifest {
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| {
read_package_manifest_in(member).is_some_and(|package| package.name == package_name)
})
}
pub(crate) fn find_package_dir(args: &[String]) -> PathBuf {
let package_name = args
.windows(2)
.find(|pair| pair[0] == "-p" || pair[0] == "--package")
.map(|pair| pair[1].as_str());
if let Some(name) = package_name {
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<CargoManifest> {
let content = std::fs::read_to_string(dir.join("Cargo.toml")).ok()?;
toml::from_str(&content).ok()
}
pub(crate) fn read_package_manifest_in(dir: &Path) -> Option<CargoPackage> {
read_manifest_in(dir)?.package
}
pub(crate) fn read_package_manifest(args: &[String]) -> Option<CargoPackage> {
read_package_manifest_in(&find_package_dir(args))
}
pub(crate) struct ResolvedPackage {
pub(crate) workspace_root: PathBuf,
pub(crate) package_dir: PathBuf,
pub(crate) package: Option<CargoPackage>,
pub(crate) workspace_package: Option<CargoWorkspacePackage>,
pub(crate) produces_cdylib: bool,
pub(crate) features: BTreeMap<String, toml::Value>,
}
impl ResolvedPackage {
pub(crate) fn name(&self) -> String {
self.package
.as_ref()
.map(|p| p.name.clone())
.unwrap_or_else(|| "app".to_string())
}
pub(crate) fn version(&self) -> String {
self.package
.as_ref()
.and_then(|p| {
p.version
.resolve(|| self.workspace_package.as_ref()?.version.clone())
})
.unwrap_or_else(|| "0.1.0".to_string())
}
pub(crate) fn maintainer(&self) -> Option<String> {
self.package
.as_ref()
.and_then(|p| {
p.authors
.resolve(|| Some(self.workspace_package.as_ref()?.authors.clone()))
})
.and_then(|authors| authors.first().cloned())
.or_else(maintainer_from_env)
}
pub(crate) fn description(&self) -> Option<String> {
self.package.as_ref().and_then(|p| {
p.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_note(package: &str) -> String {
let workshop = telar_project::WORKSHOP_PACKAGE;
format!(
"`{package}` declares no optional `{workshop}` dependency, so previews open in a plain page instead of the workshop. Add it with `cargo add -p {package} {workshop} --optional`."
)
}
struct MovedFeature {
feature: &'static str,
package: &'static str,
groups: &'static [&'static str],
}
const COMPONENTS: &str = "telar-components";
const WATCH: &str = "telar-watch";
const MOVED_FEATURES: [MovedFeature; 7] = [
MovedFeature {
feature: "components",
package: COMPONENTS,
groups: &["overlays", "chrome", "advanced"],
},
MovedFeature {
feature: "components-base",
package: COMPONENTS,
groups: &[],
},
MovedFeature {
feature: "components-overlays",
package: COMPONENTS,
groups: &["overlays"],
},
MovedFeature {
feature: "components-chrome",
package: COMPONENTS,
groups: &["chrome"],
},
MovedFeature {
feature: "components-advanced",
package: COMPONENTS,
groups: &["advanced"],
},
MovedFeature {
feature: "navigate",
package: "telar-navigate",
groups: &[],
},
MovedFeature {
feature: "watch",
package: WATCH,
groups: &[],
},
];
const DEPENDENCY_TABLES: [&str; 3] = ["dependencies", "dev-dependencies", "build-dependencies"];
pub(crate) fn moved_telar_features(
manifest: &toml::Table,
workspace_dependencies: Option<&toml::Table>,
) -> BTreeSet<&'static str> {
let targets = manifest
.get("target")
.and_then(toml::Value::as_table)
.into_iter()
.flat_map(|targets| targets.values())
.filter_map(toml::Value::as_table);
let tables: Vec<&toml::Table> = std::iter::once(manifest)
.chain(targets)
.flat_map(|scope| DEPENDENCY_TABLES.iter().filter_map(|t| scope.get(*t)))
.filter_map(toml::Value::as_table)
.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.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] {
let wanted: Vec<&&MovedFeature> = moved
.iter()
.filter(|m| m.package == crate_package)
.collect();
if wanted.is_empty() {
continue;
}
let groups: BTreeSet<&str> = wanted
.iter()
.flat_map(|m| m.groups.iter().copied())
.collect();
let features = match groups.is_empty() {
true => String::new(),
false => format!(
" --features {}",
groups.into_iter().collect::<Vec<_>>().join(",")
),
};
commands.push(format!("cargo add -p {package} {crate_package}{features}"));
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: toml::Table = std::fs::read_to_string(dir.join("Cargo.toml"))
.ok()?
.parse()
.ok()?;
let workspace: Option<toml::Table> = telar_project::find_workspace_root(dir)
.and_then(|root| std::fs::read_to_string(root.join("Cargo.toml")).ok())
.and_then(|content| content.parse().ok());
let workspace_dependencies = workspace
.as_ref()
.and_then(|root| root.get("workspace"))
.and_then(|workspace| workspace.get("dependencies"))
.and_then(toml::Value::as_table);
let moved = moved_telar_features(&manifest, workspace_dependencies);
let package = manifest
.get("package")
.and_then(|package| package.get("name"))
.and_then(toml::Value::as_str)?;
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<String> {
maintainer_from(
std::env::var("DEBFULLNAME").ok(),
std::env::var("DEBEMAIL").ok(),
)
}
fn maintainer_from(name: Option<String>, email: Option<String>) -> Option<String> {
let email = email?;
let email = email.trim();
if email.is_empty() {
return None;
}
match name {
Some(name) if !name.trim().is_empty() => Some(format!("{} <{email}>", name.trim())),
_ => Some(email.to_string()),
}
}
pub(crate) fn resolve_package(args: &[String]) -> ResolvedPackage {
let dir = find_package_dir(args);
let workspace_root = telar_project::find_workspace_root(&dir).unwrap_or_else(|| dir.clone());
let manifest = read_manifest_in(&dir);
let produces_cdylib = manifest
.as_ref()
.and_then(|m| m.lib.as_ref())
.is_some_and(|lib| lib.crate_type.iter().any(|kind| kind == "cdylib"));
let workspace_package = if workspace_root == dir {
manifest.as_ref()
} else {
None
}
.and_then(|m| m.workspace.as_ref())
.and_then(|w| w.package.clone())
.or_else(|| read_manifest_in(&workspace_root)?.workspace?.package);
let features = manifest
.as_ref()
.map(|m| m.features.clone())
.unwrap_or_default();
ResolvedPackage {
workspace_root,
package_dir: dir,
package: manifest.and_then(|m| m.package),
workspace_package,
produces_cdylib,
features,
}
}
pub(crate) fn default_app_id(name: &str) -> String {
format!("com.example.{name}")
}
#[derive(Deserialize)]
struct ManifestTelarOnly {
package: Option<PackageTelarOnly>,
}
#[derive(Deserialize)]
struct PackageTelarOnly {
metadata: Option<MetadataTelarOnly>,
}
#[derive(Deserialize)]
struct MetadataTelarOnly {
telar: Option<TelarSection>,
}
pub(crate) fn read_manifest_telar(dir: &Path) -> Result<Option<TelarSection>, ManifestError> {
let path = dir.join("Cargo.toml");
let Ok(content) = std::fs::read_to_string(&path) else {
return Ok(None);
};
let parsed =
toml::from_str::<ManifestTelarOnly>(&content).map_err(|e| ManifestError::Invalid {
path,
message: e.to_string(),
})?;
Ok(parsed
.package
.and_then(|p| p.metadata)
.and_then(|m| m.telar))
}
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 {
let Ok(content) = std::fs::read_to_string(workspace_root.join("Cargo.toml")) else {
return false;
};
let Ok(value) = toml::from_str::<toml::Value>(&content) else {
return false;
};
value
.get("profile")
.and_then(|profile| profile.get("web"))
.is_some()
}
pub(crate) fn try_load_config(dir: &Path) -> Result<TelarSection, ManifestError> {
let manifest = read_manifest_telar(dir)?.unwrap_or_default();
Ok(merge_config(manifest, TelarManifest::load(dir)?.telar))
}
pub(crate) fn load_config(args: &[String]) -> TelarSection {
match try_load_config(&find_package_dir(args)) {
Ok(config) => config,
Err(e) => {
eprintln!("[cargo-telar] {e}");
std::process::exit(2);
}
}
}
fn merge_opt<T>(base: Option<T>, over: Option<T>, merge: impl FnOnce(T, T) -> T) -> Option<T> {
match (base, over) {
(Some(b), Some(o)) => Some(merge(b, o)),
(b, o) => o.or(b),
}
}
fn merge_window(base: WindowSection, over: WindowSection) -> WindowSection {
WindowSection {
title: over.title.or(base.title),
width: over.width.or(base.width),
height: over.height.or(base.height),
decorations: over.decorations.or(base.decorations),
resizable: over.resizable.or(base.resizable),
transparent: over.transparent.or(base.transparent),
fullscreen: over.fullscreen.or(base.fullscreen),
position: over.position.or(base.position),
}
}
fn merge_dev(base: DevSection, over: DevSection) -> DevSection {
DevSection {
window: merge_opt(base.window, over.window, merge_window),
devtools: over.devtools.or(base.devtools),
}
}
fn merge_config(base: TelarSection, over: TelarSection) -> TelarSection {
TelarSection {
backend: over.backend.or(base.backend),
dev: merge_dev(base.dev, over.dev),
..over
}
}
pub(crate) fn backend_as_str(backend: RendererBackend) -> &'static str {
match backend {
RendererBackend::Auto => "auto",
RendererBackend::Hardware => "hardware",
RendererBackend::Software => "software",
}
}
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;