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::{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 {
#[serde(default)]
pub(crate) members: Vec<String>,
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>,
pub(crate) telar: Option<TelarSection>,
}
#[derive(Deserialize, Default)]
pub(crate) struct AndroidMetadata {
pub(crate) package: Option<String>,
}
pub(crate) fn expand_member(workspace_root: &Path, pattern: &str) -> Vec<PathBuf> {
let mut paths = vec![workspace_root.to_path_buf()];
for segment in pattern.split('/') {
paths = if segment == "*" {
paths
.iter()
.filter_map(|path| std::fs::read_dir(path).ok())
.flatten()
.filter_map(|entry| entry.ok())
.map(|entry| entry.path())
.filter(|path| path.is_dir())
.collect()
} else {
paths.into_iter().map(|path| path.join(segment)).collect()
};
}
paths
}
fn find_package_dir_in_workspace(workspace_root: &Path, package_name: &str) -> Option<PathBuf> {
let workspace_manifest = std::fs::read_to_string(workspace_root.join("Cargo.toml")).ok()?;
let manifest: CargoManifest = toml::from_str(&workspace_manifest).ok()?;
let members = manifest.workspace?.members;
for member_glob in members {
for member_path in expand_member(workspace_root, &member_glob) {
let cargo_toml = member_path.join("Cargo.toml");
if let Ok(content) = std::fs::read_to_string(&cargo_toml)
&& let Ok(m) = toml::from_str::<CargoManifest>(&content)
&& m.package.map(|p| p.name == package_name).unwrap_or(false)
{
return Some(member_path);
}
}
}
None
}
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()
}
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: 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 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/")))
}
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: manifest.and_then(|m| m.package),
workspace_package,
produces_cdylib,
features,
}
}
pub(crate) fn default_app_id(name: &str) -> String {
format!("com.example.{name}")
}
fn read_manifest_config(dir: &Path) -> TelarSection {
let Ok(content) = std::fs::read_to_string(dir.join("Cargo.toml")) else {
return TelarSection::default();
};
toml::from_str::<CargoManifest>(&content)
.ok()
.and_then(|m| m.package)
.and_then(|p| p.metadata)
.and_then(|m| m.telar)
.unwrap_or_default()
}
pub(crate) fn manifest_has_telar(dir: &Path) -> bool {
std::fs::read_to_string(dir.join("Cargo.toml"))
.ok()
.and_then(|c| toml::from_str::<CargoManifest>(&c).ok())
.and_then(|m| m.package)
.and_then(|p| p.metadata)
.and_then(|m| m.telar)
.is_some()
}
fn read_toml_config(dir: &Path) -> TelarSection {
match TelarManifest::load(dir) {
Ok(manifest) => manifest.telar,
Err(e) => {
eprintln!("[cargo-telar] {e}");
std::process::exit(2);
}
}
}
pub(crate) fn load_config(args: &[String]) -> TelarSection {
let dir = find_package_dir(args);
merge_config(read_manifest_config(&dir), read_toml_config(&dir))
}
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;