perf(config): skip tera render for plain strings

src/backend/external_plugin_cache.rs

@@ -4,7 +4,7 @@ use crate::config::Config;
 use crate::env;
 use crate::env_diff::EnvMap;
 use crate::hash::hash_to_str;
-use crate::tera::{BASE_CONTEXT, get_tera};
+use crate::tera::{BASE_CONTEXT, get_tera, render_str_if_template};
 use crate::toolset::{ToolRequest, ToolVersion};
 use dashmap::DashMap;
 use eyre::{WrapErr, eyre};
@@ -110,13 +110,13 @@ fn parse_template(config: &Config, tv: &ToolVersion, tmpl: &str) -> eyre::Result
     let mut ctx = BASE_CONTEXT.clone();
     ctx.insert("project_root", &config.project_root);
     ctx.insert("opts", &tv.request.options().opts_as_strings());
-    get_tera(
+    let mut tera = get_tera(
         config
             .project_root
             .as_ref()
             .or(env::current_dir().as_ref().ok())
             .map(|p| p.as_path()),
-    )
-    .render_str(tmpl, &ctx)
-    .wrap_err_with(|| eyre!("failed to parse template: {tmpl}"))
+    );
+    render_str_if_template(&mut tera, tmpl, &ctx)
+        .wrap_err_with(|| eyre!("failed to parse template: {tmpl}"))
 }

src/backend/github.rs

@@ -1858,7 +1858,7 @@ fn template_string_for_target(template: &str, tv: &ToolVersion, target: &Platfor
     tera.register_function("os", make_remapping_fn(os.to_string()));
     tera.register_function("arch", make_remapping_fn(arch.to_string()));
 
-    match tera.render_str(template, &ctx) {
+    match crate::tera::render_str_if_template(&mut tera, template, &ctx) {
         Ok(rendered) => rendered,
         Err(e) => {
             warn!("Failed to render template '{}': {}", template, e);

src/backend/mod.rs

@@ -28,7 +28,7 @@ use crate::plugins::core::CORE_PLUGINS;
 use crate::plugins::{PEP440_PRERELEASE_REGEX, PluginType, VERSION_REGEX};
 use crate::registry::{REGISTRY, full_to_url, normalize_remote, tool_enabled};
 use crate::runtime_symlinks::is_runtime_symlink;
-use crate::tera::get_tera;
+use crate::tera::{get_tera, render_str_if_template};
 use crate::toolset::outdated_info::OutdatedInfo;
 use crate::toolset::{
     ResolveOptions, ToolOptionSource, ToolRequest, ToolVersion, Toolset, install_state,
@@ -1823,7 +1823,7 @@ pub trait Backend: Debug + Send + Sync {
         let tera_ctx = ctx.ts.tera_ctx(&ctx.config).await?;
         let dir = tv.request.source().path().and_then(|p| p.parent());
         let mut tera = get_tera(dir);
-        let rendered_script = tera.render_str(script, tera_ctx)?;
+        let rendered_script = render_str_if_template(&mut tera, script, tera_ctx)?;
 
         let mut runner = CmdLineRunner::new(&*env::SHELL)
             .env(&*env::PATH_KEY, path_env.join())

src/backend/static_helpers.rs

@@ -362,7 +362,8 @@ pub fn template_string(template: &str, tv: &ToolVersion) -> String {
     let mut ctx = crate::tera::BASE_CONTEXT.clone();
     ctx.insert("version", &tv.version);
 
-    match crate::tera::get_tera(None).render_str(template, &ctx) {
+    let mut tera = crate::tera::get_tera(None);
+    match crate::tera::render_str_if_template(&mut tera, template, &ctx) {
         Ok(rendered) => rendered,
         Err(e) => {
             warn!("Failed to render template '{}': {}", template, e);

src/cli/tasks/validate.rs

@@ -7,6 +7,7 @@ use crate::duration;
 use crate::file;
 use crate::task::Task;
 use crate::task::task_fetcher::TaskFetcher;
+use crate::tera::contains_template_syntax;
 use crate::ui::style;
 use console::style as console_style;
 use eyre::{Result, eyre};
@@ -414,7 +415,7 @@ impl TasksValidate {
 
         if let Some(ref dir) = task.dir {
             // Try to render the directory template
-            if dir.contains("{{") || dir.contains("{%") {
+            if contains_template_syntax(dir) {
                 // Contains template syntax - try to render it
                 match task.dir(config).await {
                     Ok(rendered_dir) => {

src/cli/test_tool.rs

@@ -3,7 +3,7 @@ use crate::cmd::cmd;
 use crate::config::Config;
 use crate::file::display_path;
 use crate::registry::{REGISTRY, RegistryTool};
-use crate::tera::get_tera;
+use crate::tera::{get_tera, render_str_if_template};
 use crate::toolset::{InstallOptions, ToolsetBuilder};
 use crate::ui::time;
 use crate::{dirs, env, file};
@@ -449,7 +449,7 @@ impl TestTool {
         let mut ctx = config.tera_ctx.clone();
         ctx.insert("version", &tv.version);
         let mut tera = get_tera(dirs::CWD.as_ref().map(|d| d.as_path()));
-        let expected = tera.render_str(expected, &ctx)?;
+        let expected = render_str_if_template(&mut tera, expected, &ctx)?;
         let stdout = String::from_utf8(res.stdout)?;
         let clean_stdout = console::strip_ansi_codes(&stdout);
         if !clean_stdout.contains(&expected) {

src/config/config_file/mise_toml.rs

@@ -31,7 +31,7 @@ use crate::oci::OciConfig;
 use crate::redactions::Redactions;
 use crate::registry::REGISTRY;
 use crate::task::{Task, TaskTemplate};
-use crate::tera::{BASE_CONTEXT, get_tera};
+use crate::tera::{BASE_CONTEXT, contains_template_syntax, get_tera, render_str_if_template};
 use crate::toolset::{ToolRequest, ToolRequestSet, ToolSource, ToolVersionOptions};
 use crate::watch_files::WatchFile;
 use crate::{env, file};
@@ -249,10 +249,6 @@ impl MiseToml {
         }
         Ok(())
     }
-    fn contains_template_syntax(input: &str) -> bool {
-        input.contains("{{") || input.contains("{%") || input.contains("{#")
-    }
-
     pub fn init(path: &Path) -> Self {
         let mut context = BASE_CONTEXT.clone();
         context.insert(
@@ -575,11 +571,12 @@ impl MiseToml {
         context: &TeraContext,
         input: &str,
     ) -> eyre::Result<String> {
-        if !Self::contains_template_syntax(input) {
+        if !contains_template_syntax(input) {
             return Ok(input.to_string());
         }
         let dir = self.path.parent();
-        let output = get_tera(dir).render_str(input, context).wrap_err_with(|| {
+        let mut tera = get_tera(dir);
+        let output = render_str_if_template(&mut tera, input, context).wrap_err_with(|| {
             let p = display_path(&self.path);
             eyre!("failed to parse template {input} in {p}")
         })?;

src/config/config_file/tool_versions.rs

@@ -14,7 +14,7 @@ use crate::cli::args::BackendArg;
 use crate::config::config_file::{ConfigFile, trust_check};
 use crate::file;
 use crate::file::display_path;
-use crate::tera::{BASE_CONTEXT, get_tera};
+use crate::tera::{BASE_CONTEXT, contains_template_syntax, get_tera, render_str_if_template};
 use crate::toolset::{ToolRequest, ToolRequestSet, ToolSource};
 
 use super::ConfigFileType;
@@ -60,9 +60,10 @@ impl ToolVersions {
     pub fn parse_str(s: &str, path: PathBuf) -> Result<Self> {
         let mut cf = Self::init(&path);
         let dir = path.parent();
-        let s = if s.contains("{{") || s.contains("{%") || s.contains("{#") {
+        let s = if contains_template_syntax(s) {
             trust_check(&path)?;
-            get_tera(dir).render_str(s, &cf.context)?
+            let mut tera = get_tera(dir);
+            render_str_if_template(&mut tera, s, &cf.context)?
         } else {
             s.to_string()
         };

src/config/env_directive/mod.rs

@@ -4,7 +4,7 @@ use crate::env;
 use crate::env_diff::EnvMap;
 use crate::file::display_path;
 use crate::path_env::PathEnv;
-use crate::tera::{get_tera, tera_exec};
+use crate::tera::{contains_template_syntax, get_tera, render_str_if_template, tera_exec};
 use eyre::{Context, eyre};
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -680,10 +680,9 @@ impl EnvResults {
         let mut output = input.to_string();
 
         // Step 1: Tera template expansion
-        if input.contains("{{") || input.contains("{%") || input.contains("{#") {
+        if contains_template_syntax(input) {
             trust_check(path)?;
-            output = tera
-                .render_str(input, ctx)
+            output = render_str_if_template(tera, input, ctx)
                 .wrap_err_with(|| eyre!("failed to parse template: '{input}'"))?;
         }
 

src/config/miserc.rs

@@ -16,7 +16,9 @@ use crate::config::settings::MisercSettings;
 use crate::dirs;
 use crate::env;
 use crate::file;
-use crate::tera::{get_miserc_tera, take_tera_accessed_files};
+use crate::tera::{
+    contains_template_syntax, get_miserc_tera, render_str_if_template, take_tera_accessed_files,
+};
 
 static MISERC: OnceLock<MisercSettings> = OnceLock::new();
 
@@ -84,7 +86,7 @@ fn render_miserc_template(
     content: &str,
     config_root: &Path,
 ) -> String {
-    if !content.contains("{{") && !content.contains("{%") && !content.contains("{#") {
+    if !contains_template_syntax(content) {
         return content.to_string();
     }
     // Lazily initialize the Tera instance — only pay the clone cost if at least one file
@@ -103,7 +105,7 @@ fn render_miserc_template(
     context.insert("xdg_config_home", &*env::XDG_CONFIG_HOME);
     context.insert("xdg_data_home", &*env::XDG_DATA_HOME);
     context.insert("xdg_state_home", &*env::XDG_STATE_HOME);
-    match tera.render_str(content, &context) {
+    match render_str_if_template(tera, content, &context) {
         Ok(rendered) => rendered,
         Err(e) => {
             warn!("Failed to render template in miserc: {e}");

src/config/mod.rs

@@ -28,7 +28,7 @@ use crate::file::display_path;
 use crate::shorthands::{Shorthands, get_shorthands};
 use crate::task::task_file_providers::TaskFileProvidersBuilder;
 use crate::task::{Task, TaskTemplate};
-use crate::tera::take_tera_accessed_files;
+use crate::tera::{render_str_if_template, take_tera_accessed_files};
 use crate::toolset::env_cache::{CachedNonToolEnv, compute_settings_hash, get_file_mtime};
 use crate::toolset::{
     ResolvedToolOptions, ToolOptionSource, ToolOptions, ToolRequestSet, ToolRequestSetBuilder,
@@ -2314,7 +2314,7 @@ async fn load_tasks_includes(
             {
                 let mut tera = crate::tera::get_tera(Some(config_root.as_ref()));
                 let tera_ctx = task.tera_ctx(&config).await?;
-                task.dir = Some(tera.render_str(dir, &tera_ctx)?);
+                task.dir = Some(render_str_if_template(&mut tera, dir, &tera_ctx)?);
             }
             tasks.push(task);
         }

src/deps/engine.rs

@@ -9,7 +9,7 @@ use tokio::task::JoinSet;
 use crate::cmd::CmdLineRunner;
 use crate::config::config_file::ConfigFile;
 use crate::config::{Config, Settings};
-use crate::tera::{BASE_CONTEXT, get_tera};
+use crate::tera::{BASE_CONTEXT, contains_template_syntax, get_tera, render_str_if_template};
 use crate::ui::multi_progress_report::MultiProgressReport;
 use crate::ui::progress_report::SingleReport;
 use crate::ui::style;
@@ -791,8 +791,8 @@ impl DepsEngine {
         tera_ctx.insert("env", &env_map);
         let mut tera = get_tera(cmd.cwd.as_deref());
         for (k, v) in &cmd.env {
-            let rendered = if v.contains("{{") || v.contains("{%") || v.contains("{#") {
-                tera.render_str(v, &tera_ctx).unwrap_or_else(|e| {
+            let rendered = if contains_template_syntax(v) {
+                render_str_if_template(&mut tera, v, &tera_ctx).unwrap_or_else(|e| {
                     warn!("failed to render template for deps env {k}: {e}");
                     v.clone()
                 })

src/hooks.rs

@@ -1,7 +1,7 @@
 use crate::cmd::cmd;
 use crate::config::{Config, Settings, config_file};
 use crate::shell::Shell;
-use crate::tera::get_tera;
+use crate::tera::{get_tera, render_str_if_template};
 use crate::toolset::{ToolVersion, Toolset};
 use crate::{dirs, hook_env};
 use eyre::Result;
@@ -443,7 +443,7 @@ async fn execute(
         (ctx, env)
     };
     let mut tera = get_tera(Some(root));
-    let rendered_script = tera.render_str(run, &tera_ctx)?;
+    let rendered_script = render_str_if_template(&mut tera, run, &tera_ctx)?;
 
     let args = shell
         .iter()

src/redactions.rs

@@ -2,6 +2,8 @@ use aho_corasick::AhoCorasick;
 use indexmap::IndexSet;
 use std::sync::Arc;
 
+use crate::tera::render_str_if_template;
+
 #[derive(Default, Clone, Debug, serde::Deserialize)]
 pub struct Redactions(pub IndexSet<String>);
 
@@ -12,7 +14,7 @@ impl Redactions {
 
     pub fn render(&mut self, tera: &mut tera::Tera, ctx: &tera::Context) -> eyre::Result<()> {
         for r in self.0.clone().drain(..) {
-            self.0.insert(tera.render_str(&r, ctx)?);
+            self.0.insert(render_str_if_template(tera, &r, ctx)?);
         }
         Ok(())
     }

src/task/mod.rs

@@ -4,7 +4,7 @@ use crate::config::env_directive::{EnvDirective, EnvResolveOptions, EnvResults,
 use crate::config::{self, Config};
 use crate::path_env::PathEnv;
 use crate::task::task_script_parser::TaskScriptParser;
-use crate::tera::get_tera;
+use crate::tera::{contains_template_syntax, get_tera, render_str_if_template};
 use crate::ui::tree::TreeItem;
 use crate::{dirs, env, file};
 use console::{measure_text_width, truncate_str};
@@ -159,35 +159,36 @@ impl RunEntry {
         match self {
             RunEntry::Script(s) => Ok(RunEntry::Script(s.clone())),
             RunEntry::SingleTask { task, args, env } => {
-                let task = tera.render_str(task, tera_ctx)?;
+                let task = render_str_if_template(tera, task, tera_ctx)?;
                 let args = args
                     .iter()
-                    .map(|a| tera.render_str(a, tera_ctx))
+                    .map(|a| render_str_if_template(tera, a, tera_ctx))
                     .collect::<Result<Vec<_>, _>>()?;
                 let env = env
                     .iter()
-                    .map(|(k, v)| Ok((k.clone(), tera.render_str(v, tera_ctx)?)))
+                    .map(|(k, v)| Ok((k.clone(), render_str_if_template(tera, v, tera_ctx)?)))
                     .collect::<Result<IndexMap<_, _>, tera::Error>>()?;
                 Ok(RunEntry::SingleTask { task, args, env })
             }
             RunEntry::TaskGroup { tasks } => {
                 let tasks = tasks
                     .iter()
-                    .map(|t| tera.render_str(t, tera_ctx))
+                    .map(|t| render_str_if_template(tera, t, tera_ctx))
                     .collect::<Result<Vec<_>, _>>()?;
                 Ok(RunEntry::TaskGroup { tasks })
             }
         }
     }
 
     pub fn has_tera_template(&self) -> bool {
-        let has_ref = |s: &str| s.contains("{{") || s.contains("{%") || s.contains("{#");
         match self {
             RunEntry::Script(_) => false,
             RunEntry::SingleTask { task, args, env } => {
-                has_ref(task) || args.iter().any(|a| has_ref(a)) || env.values().any(|v| has_ref(v))
+                contains_template_syntax(task)
+                    || args.iter().any(|a| contains_template_syntax(a))
+                    || env.values().any(|v| contains_template_syntax(v))
             }
-            RunEntry::TaskGroup { tasks } => tasks.iter().any(|t| has_ref(t)),
+            RunEntry::TaskGroup { tasks } => tasks.iter().any(|t| contains_template_syntax(t)),
         }
     }
 }
@@ -1038,7 +1039,7 @@ impl Task {
             let config_root = self.config_root.clone().unwrap_or_default();
             let mut tera = get_tera(Some(&config_root));
             let tera_ctx = self.tera_ctx(config).await?;
-            let dir = tera.render_str(&dir, &tera_ctx)?;
+            let dir = render_str_if_template(&mut tera, &dir, &tera_ctx)?;
             let dir = file::replace_path(&dir);
             if dir.is_absolute() {
                 Ok(Some(dir.to_path_buf()))
@@ -1058,7 +1059,7 @@ impl Task {
             let config_root = self.config_root.clone().unwrap_or_default();
             let mut tera = get_tera(Some(&config_root));
             let tera_ctx = self.tera_ctx(config).await?;
-            let rendered = tera.render_str(&file_str, &tera_ctx)?;
+            let rendered = render_str_if_template(&mut tera, &file_str, &tera_ctx)?;
             let rendered_path = file::replace_path(&rendered);
             if rendered_path.is_absolute() {
                 Ok(Some(rendered_path))
@@ -1333,12 +1334,12 @@ impl Task {
         let mut tera = get_tera(Some(config_root));
         let tera_ctx = self.tera_ctx(config).await?;
         for a in &mut self.aliases {
-            *a = tera.render_str(a, &tera_ctx)?;
+            *a = render_str_if_template(&mut tera, a, &tera_ctx)?;
         }
 
-        self.description = tera.render_str(&self.description, &tera_ctx)?;
+        self.description = render_str_if_template(&mut tera, &self.description, &tera_ctx)?;
         for s in &mut self.sources {
-            *s = tera.render_str(s, &tera_ctx)?;
+            *s = render_str_if_template(&mut tera, s, &tera_ctx)?;
         }
         if !self.sources.is_empty() && self.outputs.is_empty() {
             self.outputs = TaskOutputs::Auto;
@@ -1368,21 +1369,23 @@ impl Task {
             }
         }
         if let Some(dir) = &mut self.dir {
-            *dir = tera.render_str(dir, &tera_ctx)?;
+            *dir = render_str_if_template(&mut tera, dir, &tera_ctx)?;
         }
         if let Some(shell) = &mut self.shell {
-            *shell = tera.render_str(shell, &tera_ctx)?;
+            *shell = render_str_if_template(&mut tera, shell, &tera_ctx)?;
         }
         for (_, v) in &mut self.tools {
             match v {
                 TaskToolValue::String(s) => {
-                    *v = TaskToolValue::String(tera.render_str(s, &tera_ctx)?);
+                    *v = TaskToolValue::String(render_str_if_template(&mut tera, s, &tera_ctx)?);
                 }
                 TaskToolValue::Map(map) => {
-                    map.version = tera.render_str(&map.version, &tera_ctx)?;
+                    map.version = render_str_if_template(&mut tera, &map.version, &tera_ctx)?;
                     for (_ok, ov) in &mut map.opts {
                         if let toml::Value::String(s) = ov {
-                            *ov = toml::Value::String(tera.render_str(s, &tera_ctx)?);
+                            *ov = toml::Value::String(render_str_if_template(
+                                &mut tera, s, &tera_ctx,
+                            )?);
                         }
                     }
                 }