use crate::{
config::{ConfigEntry, DefaultSource, PresetName},
context::InvocationContext,
jinja::{Expr, Typed, context_from_answers, is_global, is_reserved},
template::{FlowAction, Id, Node, Question, QuestionKind, SkipScope, Template},
};
use indexmap::IndexMap;
use serde_json::Value;
use std::{collections::HashSet, fmt};
#[derive(Debug, Clone, PartialEq)]
pub enum Answer {
Text(String),
Bool(bool),
List(Vec<String>),
None,
Value(Value),
}
impl Answer {
pub fn to_json(&self) -> Value {
match self {
Self::Text(v) => Value::String(v.clone()),
Self::Bool(v) => Value::Bool(*v),
Self::List(v) => serde_json::json!(v),
Self::None => Value::Null,
Self::Value(v) => v.clone(),
}
}
}
pub type Answers = IndexMap<Id, Answer>;
#[derive(Debug, Clone)]
pub struct RawAnswer(pub Value);
pub type RawAnswers = IndexMap<Id, RawAnswer>;
#[derive(Debug, Clone)]
pub struct Seed {
pub now: jiff::ZonedDateTime,
pub defaults: IndexMap<Id, RawAnswer>,
pub context: InvocationContext,
}
#[derive(Debug, Clone)]
struct InterviewSeed {
now: jiff::ZonedDateTime,
defaults: IndexMap<Id, DefaultBankEntry>,
part_selection: crate::parts::Selection,
context: Option<InvocationContext>,
}
#[derive(Debug, Clone)]
enum DefaultBankEntry {
Seed(RawAnswer),
Configured(ResolvedDefault),
Application {
raw: RawAnswer,
from: String,
},
}
#[derive(Debug, Clone)]
pub struct ApplicationSeed {
pub defaults: IndexMap<Id, RawAnswer>,
pub from: String,
}
#[derive(Debug)]
#[allow(clippy::large_enum_variant)]
pub enum Interview<'a> {
Asking(Pending<'a>),
Complete(Completed),
Ended(Ended),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Disposition {
#[default]
Proceed,
DryRun,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EndKind {
Stop,
Abort,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Step {
Plan { apply: bool },
}
#[derive(Debug, Clone)]
pub struct Ended {
pub kind: EndKind,
pub messages: Vec<String>,
pub last_messages: Vec<String>,
pub label: Option<String>,
}
impl Ended {
pub fn kind(&self) -> EndKind {
self.kind
}
pub fn messages(&self) -> &[String] {
&self.messages
}
pub fn label(&self) -> Option<&str> {
self.label.as_deref()
}
}
#[derive(Debug)]
pub struct Pending<'a> {
template: &'a Template,
seed: InterviewSeed,
answers: Answers,
accepted_raw: IndexMap<Id, RawAnswer>,
held: RawAnswers,
skipped: Skipped,
messages: Vec<String>,
hooks: Vec<RenderedHook>,
visited: HashSet<String>,
batch: Batch,
}
#[derive(Debug)]
pub struct Completed {
pub answers: Answers,
accepted_raw: IndexMap<Id, RawAnswer>,
pub messages: Vec<String>,
pub last_messages: Vec<String>,
pub hooks: Vec<RenderedHook>,
pub now: jiff::ZonedDateTime,
pub disposition: Disposition,
context: Option<InvocationContext>,
skipped: Skipped,
step_start: usize,
}
type Skipped = IndexMap<Id, usize>;
impl Completed {
pub fn accepted_raw(&self) -> &IndexMap<Id, RawAnswer> {
&self.accepted_raw
}
pub fn disposition(&self) -> Disposition {
self.disposition
}
pub fn context(&self) -> Option<&InvocationContext> {
self.context.as_ref()
}
pub fn step(&self) -> Step {
match self.disposition {
Disposition::Proceed => Step::Plan { apply: true },
Disposition::DryRun => Step::Plan { apply: false },
}
}
pub fn was_skipped(&self, id: &Id) -> bool {
self.skipped.contains_key(id)
}
pub(crate) fn warn_unused(&mut self, unused: &RawAnswers) {
let mut added = 0;
for (id, position) in &self.skipped {
if unused.contains_key(id) {
self.messages.insert(position + added, skipped_warning(id));
added += 1;
}
}
self.last_messages = self.messages[self.step_start..].to_vec();
}
}
pub fn skipped_warning(id: &Id) -> String {
format!("warning: answer for \"{id}\" was not used: the question was skipped")
}
#[derive(Debug, Clone)]
pub struct RenderedHook {
pub program: RenderedProgram,
pub cwd: Option<String>,
pub id: Option<crate::template::Id>,
pub capture: crate::template::Capture,
pub allow_failure: bool,
pub parse_json: bool,
pub status_id: Option<crate::template::Id>,
}
#[derive(Debug, Clone)]
pub enum RenderedProgram {
Run(Vec<String>),
Script {
path: std::path::PathBuf,
args: Vec<String>,
},
}
#[derive(Debug)]
pub(crate) struct HookFault {
pub field: &'static str,
pub source: String,
pub message: String,
}
fn render_hook(
hook: &crate::template::HookNode,
ctx: &impl serde::Serialize,
) -> Result<RenderedHook, HookFault> {
use crate::template::HookProgram;
let render = |field: &'static str| {
move |t: &crate::jinja::Tmpl| {
t.render(ctx).map_err(|e| HookFault {
field,
source: t.source().into(),
message: e.to_string(),
})
}
};
let program = match &hook.command.program {
HookProgram::Run(args) => {
RenderedProgram::Run(args.iter().map(render("run")).collect::<Result<_, _>>()?)
}
HookProgram::Script { path, args } => RenderedProgram::Script {
path: path.clone(),
args: args.iter().map(render("args")).collect::<Result<_, _>>()?,
},
};
Ok(RenderedHook {
program,
cwd: hook.command.cwd.as_ref().map(render("cwd")).transpose()?,
id: hook.id.clone(),
capture: hook.capture,
allow_failure: hook.allow_failure,
parse_json: hook.parse_json,
status_id: hook.status_id.clone(),
})
}
pub(crate) fn render_hooks(
hook: &crate::template::HookNode,
ctx: &std::collections::BTreeMap<String, Value>,
) -> Result<Vec<RenderedHook>, HookFault> {
match &hook.each {
None => Ok(vec![render_hook(hook, ctx)?]),
Some(each) => each
.contexts(ctx)
.map_err(|message| HookFault {
field: "each",
source: each.expr.source().into(),
message,
})?
.iter()
.map(|local| render_hook(hook, local))
.collect(),
}
}
#[derive(Debug, Default)]
pub struct Batch {
pub items: Vec<Item>,
pub errors: Rejections,
default_sources: IndexMap<Id, PreparedDefaultSource>,
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug)]
pub enum Item {
Prompt(Prompt),
Message(String),
}
#[derive(Debug)]
pub struct Prompt {
pub id: Id,
pub kind: PromptKind,
pub title: String,
pub description: Option<String>,
pub placeholder: Option<String>,
pub default: Option<Answer>,
pub options: Vec<String>,
pub constraints: Constraints,
pub document: Option<Box<DocumentPrompt>>,
}
#[derive(Debug, Clone)]
pub struct DocumentPrompt {
pub target: Option<std::path::PathBuf>,
pub schemas: Vec<String>,
pub input: std::path::PathBuf,
}
#[derive(Debug)]
struct PreparedPrompt {
prompt: Prompt,
default_source: Option<PreparedDefaultSource>,
configured_rejection: Option<Rejection>,
}
#[derive(Debug, Clone)]
struct PreparedDefault {
answer: Answer,
source: PreparedDefaultSource,
}
#[derive(Debug, Clone)]
enum PreparedDefaultSource {
Template {
expression: Option<String>,
},
Configured(ConfiguredDefaultOrigin),
Seed,
Application {
from: String,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PromptKind {
Document,
Text,
Multiline,
Git,
Confirm,
Select,
MultiSelect,
TextLoop,
}
#[derive(Debug, Default)]
pub struct Constraints {
pub required: bool,
pub min: Option<u32>,
pub max: Option<u32>,
pub regex: Option<String>,
pub loop_min: Option<u32>,
pub loop_max: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Rejection {
pub id: Id,
pub message: String,
pub kind: RejectionKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RejectionKind {
Invalid,
Answered,
}
pub type Rejections = Vec<Rejection>;
#[derive(Debug)]
pub struct EvalError {
pub id: Id,
pub field: &'static str,
pub message: String,
pub expression: Option<String>,
pub config_key: Option<String>,
}
pub const CONFIGURED_DEFAULT: &str = "configured default";
fn configured_default_source(id: &Id) -> String {
format!("configured default for question \"{id}\"")
}
impl fmt::Display for EvalError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.field == CONFIGURED_DEFAULT {
let key = self
.config_key
.clone()
.unwrap_or_else(|| configured_default_source(&self.id));
return write!(f, "{key}: {}", self.message);
}
match (&self.expression, self.field) {
(Some(source), _) => write!(
f,
"template error in {}.{} `{}`: {}",
self.id, self.field, source, self.message
),
(None, "default") => {
write!(f, "template error in {}.default: {}", self.id, self.message)
}
(None, _) => write!(f, "{}.{}: {}", self.id, self.field, self.message),
}
}
}
impl std::error::Error for EvalError {}
#[derive(Debug)]
#[allow(clippy::large_enum_variant)]
pub enum AnswerError<'a> {
Rejected {
pending: Pending<'a>,
rejections: Rejections,
},
Eval(EvalError),
}
impl fmt::Display for Rejection {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {}", self.id, self.message)
}
}
fn eval_error(id: &Id, field: &'static str, error: impl ToString) -> EvalError {
EvalError {
id: id.clone(),
field,
message: error.to_string(),
expression: None,
config_key: None,
}
}
fn fault(id: &Id, field: &'static str, source: Option<&str>, error: impl ToString) -> EvalError {
EvalError {
expression: source.map(str::to_owned),
..eval_error(id, field, error)
}
}
fn context(
template: &Template,
answers: &Answers,
seed: &InterviewSeed,
) -> std::collections::BTreeMap<String, Value> {
let mut values = context_from_answers(answers, &template.data, &seed.now);
if let Some(context) = &seed.context {
context.project(&mut values);
}
values
}
fn has_refs(refs: &HashSet<String>, answers: &Answers, template: &Template) -> bool {
refs.iter().all(|r| {
template.data.keys().any(|id| id.as_str() == r)
|| answers.keys().any(|id| id.as_str() == r)
|| is_global(r)
|| (template.reserves_context() && is_reserved(r))
})
}
fn typed_ready<T: Clone + serde::de::DeserializeOwned>(
v: &Typed<T>,
a: &Answers,
t: &Template,
) -> bool {
has_refs(&v.references(), a, t)
}
fn tmpl_ready(v: &crate::jinja::Tmpl, a: &Answers, t: &Template) -> bool {
has_refs(v.references(), a, t)
}
fn expr_ready(v: &Expr, a: &Answers, t: &Template) -> bool {
has_refs(v.references(), a, t)
}
fn hook_ready(h: &crate::template::HookNode, a: &Answers, t: &Template) -> bool {
use crate::template::HookProgram;
let binding = h.each.as_ref().map(|e| e.binding.as_str());
let ready = |v: &crate::jinja::Tmpl| {
v.references()
.iter()
.filter(|name| Some(name.as_str()) != binding)
.all(|name| has_refs(&HashSet::from([name.clone()]), a, t))
};
h.each.as_ref().is_none_or(|e| expr_ready(&e.expr, a, t))
&& h.command.cwd.as_ref().is_none_or(ready)
&& match &h.command.program {
HookProgram::Run(v) => v.iter().all(ready),
HookProgram::Script { args, .. } => args.iter().all(ready),
}
}
fn question_ready(q: &Question, a: &Answers, t: &Template, seed: &InterviewSeed) -> bool {
let base = tmpl_ready(&q.prompt, a, t)
&& q.description.as_ref().is_none_or(|v| tmpl_ready(v, a, t))
&& q.placeholder.as_ref().is_none_or(|v| tmpl_ready(v, a, t))
&& typed_ready(&q.required, a, t)
&& q.when.as_ref().is_none_or(|v| expr_ready(v, a, t))
&& q.validate.min.as_ref().is_none_or(|v| typed_ready(v, a, t))
&& q.validate.max.as_ref().is_none_or(|v| typed_ready(v, a, t))
&& q.format.as_ref().is_none_or(|v| {
v.references()
.iter()
.filter(|name| name.as_str() != "value")
.all(|name| has_refs(&HashSet::from([name.clone()]), a, t))
});
if !base {
return false;
}
let override_default = seed.defaults.contains_key(&q.id);
match &q.kind {
QuestionKind::Document { .. } => true,
QuestionKind::Text { default }
| QuestionKind::Multiline { default }
| QuestionKind::Git { default } => {
override_default || default.as_ref().is_none_or(|v| tmpl_ready(v, a, t))
}
QuestionKind::Confirm { default } => {
override_default || default.as_ref().is_none_or(|v| typed_ready(v, a, t))
}
QuestionKind::Select { options, default } => {
typed_ready(options, a, t)
&& (override_default || default.as_ref().is_none_or(|v| tmpl_ready(v, a, t)))
}
QuestionKind::MultiSelect { options, default } => {
typed_ready(options, a, t)
&& (override_default || default.as_ref().is_none_or(|v| typed_ready(v, a, t)))
}
QuestionKind::TextLoop { default, min, max } => {
(override_default || default.as_ref().is_none_or(|v| typed_ready(v, a, t)))
&& min.as_ref().is_none_or(|v| typed_ready(v, a, t))
&& max.as_ref().is_none_or(|v| typed_ready(v, a, t))
}
}
}
fn eval_typed<T: Clone + serde::de::DeserializeOwned>(
v: &Typed<T>,
ctx: &impl serde::Serialize,
id: &Id,
field: &'static str,
) -> Result<T, EvalError> {
v.eval(ctx).map_err(|e| fault(id, field, v.source(), e))
}
fn default_ready(q: &Question, a: &Answers, t: &Template, seed: &InterviewSeed) -> bool {
if seed.defaults.contains_key(&q.id) {
return true;
}
match &q.kind {
QuestionKind::Document { .. } => true,
QuestionKind::Text { default }
| QuestionKind::Multiline { default }
| QuestionKind::Git { default }
| QuestionKind::Select { default, .. } => {
default.as_ref().is_none_or(|v| tmpl_ready(v, a, t))
}
QuestionKind::Confirm { default } => default.as_ref().is_none_or(|v| typed_ready(v, a, t)),
QuestionKind::MultiSelect { default, .. } | QuestionKind::TextLoop { default, .. } => {
default.as_ref().is_none_or(|v| typed_ready(v, a, t))
}
}
}
fn render_default(
q: &Question,
t: &Template,
a: &Answers,
seed: &InterviewSeed,
) -> Result<Option<PreparedDefault>, EvalError> {
let id = &q.id;
if matches!(q.kind, QuestionKind::Document { .. }) {
return Ok(None);
}
let kind = prompt_kind(q);
if q.parts
&& let Some(parts) = &seed.part_selection.base
{
return Ok(Some(PreparedDefault {
answer: Answer::List(parts.clone()),
source: PreparedDefaultSource::Seed,
}));
}
if let Some(entry) = seed.defaults.get(id) {
let (raw, source) = match entry {
DefaultBankEntry::Seed(raw) => (raw, PreparedDefaultSource::Seed),
DefaultBankEntry::Configured(value) => (
&value.raw,
PreparedDefaultSource::Configured(value.origin.clone()),
),
DefaultBankEntry::Application { raw, from } => (
raw,
PreparedDefaultSource::Application { from: from.clone() },
),
};
let answer = if raw.0.is_null() && matches!(source, PreparedDefaultSource::Seed) {
Ok(empty_answer(kind))
} else {
parse_kind(id, kind, raw.0.clone())
};
return answer
.map(|answer| Some(PreparedDefault { answer, source }))
.map_err(|e| eval_error(id, CONFIGURED_DEFAULT, e.message));
}
let ctx = context(t, a, seed);
match &q.kind {
QuestionKind::Document { .. } => Ok(None),
QuestionKind::Text { default }
| QuestionKind::Multiline { default }
| QuestionKind::Git { default }
| QuestionKind::Select { default, .. } => default
.as_ref()
.map(|v| {
v.render(&ctx)
.map(|answer| PreparedDefault {
answer: Answer::Text(answer),
source: PreparedDefaultSource::Template {
expression: Some(v.source().into()),
},
})
.map_err(|e| fault(id, "default", Some(v.source()), e))
})
.transpose(),
QuestionKind::Confirm { default } => default
.as_ref()
.map(|v| {
eval_typed(v, &ctx, id, "default").map(|answer| PreparedDefault {
answer: Answer::Bool(answer),
source: PreparedDefaultSource::Template {
expression: v.source().map(str::to_owned),
},
})
})
.transpose(),
QuestionKind::MultiSelect { default, .. } | QuestionKind::TextLoop { default, .. } => {
default
.as_ref()
.map(|v| {
eval_typed(v, &ctx, id, "default").map(|answer| PreparedDefault {
answer: Answer::List(answer),
source: PreparedDefaultSource::Template {
expression: v.source().map(str::to_owned),
},
})
})
.transpose()
}
}
}
fn make_prompt(
q: &Question,
t: &Template,
a: &Answers,
seed: &InterviewSeed,
) -> Result<PreparedPrompt, EvalError> {
let ctx = context(t, a, seed);
let id = &q.id;
let title = q
.prompt
.render(&ctx)
.map_err(|e| fault(id, "prompt", Some(q.prompt.source()), e))?;
let description = q
.description
.as_ref()
.map(|v| {
v.render(&ctx)
.map_err(|e| fault(id, "description", Some(v.source()), e))
})
.transpose()?;
let placeholder = q
.placeholder
.as_ref()
.map(|v| {
v.render(&ctx)
.map_err(|e| fault(id, "placeholder", Some(v.source()), e))
})
.transpose()?;
let required = matches!(q.kind, QuestionKind::Document { .. })
|| eval_typed(&q.required, &ctx, id, "required")?;
let min = q
.validate
.min
.as_ref()
.map(|v| eval_typed(v, &ctx, id, "validate.min"))
.transpose()?;
let max = q
.validate
.max
.as_ref()
.map(|v| eval_typed(v, &ctx, id, "validate.max"))
.transpose()?;
let mut options = vec![];
let mut loop_min = None;
let mut loop_max = None;
let kind = match &q.kind {
QuestionKind::Document { .. } => PromptKind::Document,
QuestionKind::Text { .. } => PromptKind::Text,
QuestionKind::Multiline { .. } => PromptKind::Multiline,
QuestionKind::Git { .. } => PromptKind::Git,
QuestionKind::Confirm { .. } => PromptKind::Confirm,
QuestionKind::Select { options: o, .. } => {
options = eval_typed(o, &ctx, id, "options")?;
PromptKind::Select
}
QuestionKind::MultiSelect { options: o, .. } => {
options = eval_typed(o, &ctx, id, "options")?;
PromptKind::MultiSelect
}
QuestionKind::TextLoop { min, max, .. } => {
loop_min = min
.as_ref()
.map(|v| eval_typed(v, &ctx, id, "loop.min"))
.transpose()?;
loop_max = max
.as_ref()
.map(|v| eval_typed(v, &ctx, id, "loop.max"))
.transpose()?;
PromptKind::TextLoop
}
};
let prepared = render_default(q, t, a, seed)?;
let document = match &q.kind {
QuestionKind::Document { contract } => Some(Box::new(DocumentPrompt {
target: contract.target.clone(),
schemas: contract.schemas.clone(),
input: contract.input.clone(),
})),
_ => None,
};
let mut prompt = Prompt {
document,
id: id.clone(),
kind,
title,
description,
placeholder,
default: prepared.as_ref().map(|value| value.answer.clone()),
options,
constraints: Constraints {
required,
min,
max,
regex: q.validate.regex.as_ref().map(|r| r.as_str().into()),
loop_min,
loop_max,
},
};
let default_source = prepared.as_ref().map(|value| value.source.clone());
let mut configured_rejection = None;
if let Some(prepared) = prepared
&& let Err(rejected) =
validate(id, &Rules::of_prompt(&prompt, q), prepared.answer.to_json())
{
match prepared.source {
PreparedDefaultSource::Template { expression } => {
return Err(EvalError {
id: id.clone(),
field: "default",
message: format!(
"default {} is not allowed: {}",
prepared.answer.to_json(),
rejected.message
),
expression,
config_key: None,
});
}
PreparedDefaultSource::Configured(origin) => {
prompt.default = None;
configured_rejection = Some(rejection(
id,
format!(
"default {} from {} is not allowed: {}",
prepared.answer.to_json(),
origin.description(),
rejected.message
),
));
}
PreparedDefaultSource::Seed | PreparedDefaultSource::Application { .. } => {}
}
}
Ok(PreparedPrompt {
prompt,
default_source,
configured_rejection,
})
}
fn parse_kind(id: &Id, kind: PromptKind, value: Value) -> Result<Answer, Rejection> {
let fail = |msg: &str| rejection(id, msg);
match kind {
PromptKind::Document => {
if value.is_object() {
Ok(Answer::Value(value))
} else {
Err(fail("must be a JSON object"))
}
}
PromptKind::Git if value.as_str().is_some_and(crate::source::has_password) => {
Err(fail(crate::source::PASSWORD_REFUSED))
}
PromptKind::Text | PromptKind::Multiline | PromptKind::Git | PromptKind::Select => value
.as_str()
.map(|v| Answer::Text(v.into()))
.ok_or_else(|| fail("must be a string")),
PromptKind::Confirm => value
.as_bool()
.map(Answer::Bool)
.ok_or_else(|| fail("must be true or false")),
PromptKind::MultiSelect | PromptKind::TextLoop => value
.as_array()
.and_then(|v| {
v.iter()
.map(|x| x.as_str().map(str::to_owned))
.collect::<Option<Vec<_>>>()
})
.map(Answer::List)
.ok_or_else(|| fail("must be an array of strings")),
}
}
fn empty_answer(kind: PromptKind) -> Answer {
match kind {
PromptKind::MultiSelect | PromptKind::TextLoop => Answer::List(vec![]),
_ => Answer::None,
}
}
fn count(n: u32, one: &str, many: &str) -> String {
format!("{n} {}", if n == 1 { one } else { many })
}
struct Rules<'q> {
kind: PromptKind,
document: Option<&'q crate::document::DocumentQuestion>,
required: Option<bool>,
min: Option<u32>,
max: Option<u32>,
loop_min: Option<u32>,
loop_max: Option<u32>,
options: Option<Vec<String>>,
regex: Option<&'q regex::Regex>,
}
impl<'q> Rules<'q> {
fn of_prompt(prompt: &Prompt, q: &'q Question) -> Self {
let c = &prompt.constraints;
Self {
kind: prompt.kind,
document: match &q.kind {
QuestionKind::Document { contract } => Some(contract),
_ => None,
},
required: Some(c.required),
min: c.min,
max: c.max,
loop_min: c.loop_min,
loop_max: c.loop_max,
options: matches!(prompt.kind, PromptKind::Select | PromptKind::MultiSelect)
.then(|| prompt.options.clone()),
regex: q.validate.regex.as_ref(),
}
}
}
impl<'q> Rules<'q> {
fn of_question(q: &'q Question) -> Self {
let literal = |v: &Option<Typed<u32>>| v.as_ref().and_then(|v| v.literal().copied());
let (options, loop_min, loop_max) = match &q.kind {
QuestionKind::Select { options, .. } | QuestionKind::MultiSelect { options, .. } => {
(options.literal().cloned(), None, None)
}
QuestionKind::TextLoop { min, max, .. } => (None, literal(min), literal(max)),
_ => (None, None, None),
};
Self {
kind: prompt_kind(q),
document: match &q.kind {
QuestionKind::Document { contract } => Some(contract),
_ => None,
},
required: if matches!(q.kind, QuestionKind::Document { .. }) {
Some(true)
} else {
q.required.literal().copied()
},
min: literal(&q.validate.min),
max: literal(&q.validate.max),
loop_min,
loop_max,
options,
regex: q.validate.regex.as_ref(),
}
}
fn ready(
q: &'q Question,
answers: &Answers,
template: &Template,
seed: &InterviewSeed,
) -> Result<Self, EvalError> {
let ctx = context(template, answers, seed);
let number = |field: &'static str,
value: &'q Option<Typed<u32>>|
-> Result<Option<u32>, EvalError> {
value
.as_ref()
.filter(|value| typed_ready(value, answers, template))
.map(|value| eval_typed(value, &ctx, &q.id, field))
.transpose()
};
let required = typed_ready(&q.required, answers, template)
.then(|| eval_typed(&q.required, &ctx, &q.id, "required"))
.transpose()?;
let (options, loop_min, loop_max) = match &q.kind {
QuestionKind::Select { options, .. } | QuestionKind::MultiSelect { options, .. } => {
let options = typed_ready(options, answers, template)
.then(|| eval_typed(options, &ctx, &q.id, "options"))
.transpose()?;
(options, None, None)
}
QuestionKind::TextLoop { min, max, .. } => {
(None, number("loop.min", min)?, number("loop.max", max)?)
}
_ => (None, None, None),
};
Ok(Self {
kind: prompt_kind(q),
document: match &q.kind {
QuestionKind::Document { contract } => Some(contract),
_ => None,
},
required,
min: number("validate.min", &q.validate.min)?,
max: number("validate.max", &q.validate.max)?,
loop_min,
loop_max,
options,
regex: q.validate.regex.as_ref(),
})
}
}
fn skipped_default(
q: &Question,
prepared: Option<PreparedDefault>,
answers: &Answers,
template: &Template,
seed: &InterviewSeed,
) -> Result<Option<Answer>, EvalError> {
let Some(prepared) = prepared else {
return Ok(None);
};
if let PreparedDefaultSource::Template { expression } = &prepared.source
&& let Err(rejected) = validate(
&q.id,
&Rules::ready(q, answers, template, seed)?,
prepared.answer.to_json(),
)
{
return Err(EvalError {
id: q.id.clone(),
field: "default",
message: format!(
"default {} is not allowed: {}",
prepared.answer.to_json(),
rejected.message
),
expression: expression.clone(),
config_key: None,
});
}
Ok(Some(prepared.answer))
}
fn prompt_kind(q: &Question) -> PromptKind {
match q.kind {
QuestionKind::Document { .. } => PromptKind::Document,
QuestionKind::Text { .. } => PromptKind::Text,
QuestionKind::Multiline { .. } => PromptKind::Multiline,
QuestionKind::Git { .. } => PromptKind::Git,
QuestionKind::Confirm { .. } => PromptKind::Confirm,
QuestionKind::Select { .. } => PromptKind::Select,
QuestionKind::MultiSelect { .. } => PromptKind::MultiSelect,
QuestionKind::TextLoop { .. } => PromptKind::TextLoop,
}
}
fn validate(id: &Id, rules: &Rules, value: Value) -> Result<Answer, Rejection> {
let fail = |msg: String| Err(rejection(id, msg));
if value.is_null() {
if rules.required == Some(true) {
return fail("is required".into());
}
return Ok(empty_answer(rules.kind));
}
if let Some(contract) = rules.document {
contract.validate(&value).map_err(|e| rejection(id, e))?;
}
let answer = parse_kind(id, rules.kind, value)?;
if rules.required == Some(true)
&& match &answer {
Answer::Text(v) => v.is_empty(),
Answer::List(v) => v.is_empty(),
_ => false,
}
{
return fail("is required".into());
}
let (strings, prefix): (Vec<&str>, &str) = match &answer {
Answer::Text(v) => (vec![v], ""),
Answer::List(v) if rules.kind == PromptKind::TextLoop => {
(v.iter().map(String::as_str).collect(), "each item ")
}
_ => (vec![], ""),
};
for s in strings {
let len = s.chars().count() as u32;
if let Some(n) = rules.min.filter(|n| len < *n) {
return fail(format!(
"{prefix}must be at least {}",
count(n, "character", "characters")
));
}
if let Some(n) = rules.max.filter(|n| len > *n) {
return fail(format!(
"{prefix}must be at most {}",
count(n, "character", "characters")
));
}
if let Some(r) = rules.regex.filter(|r| !r.is_match(s)) {
return fail(format!("{prefix}must match {}", r.as_str()));
}
}
let (at_least, at_most) = match rules.kind {
PromptKind::MultiSelect => (rules.min, rules.max),
_ => (rules.loop_min, rules.loop_max),
};
if let Answer::List(v) = &answer {
let len = v.len() as u32;
if let Some(n) = at_least.filter(|n| len < *n) {
return fail(format!("must have at least {}", count(n, "item", "items")));
}
if let Some(n) = at_most.filter(|n| len > *n) {
return fail(format!("must have at most {}", count(n, "item", "items")));
}
if rules.kind == PromptKind::MultiSelect {
if let Some(options) = &rules.options
&& v.iter().any(|s| !options.contains(s))
{
return fail(format!("each item must be one of: {}", options.join(", ")));
}
let mut seen = HashSet::new();
if !v.iter().all(|s| seen.insert(s)) {
return fail("must not repeat an item".into());
}
}
}
if let (Answer::Text(v), PromptKind::Select, Some(options)) =
(&answer, rules.kind, &rules.options)
&& !options.contains(v)
{
return fail(format!("must be one of: {}", options.join(", ")));
}
Ok(answer)
}
#[derive(Debug)]
pub struct Resolution {
defaults: IndexMap<Id, ResolvedDefault>,
warnings: Vec<String>,
}
#[derive(Debug, Clone)]
struct ResolvedDefault {
raw: RawAnswer,
origin: ConfiguredDefaultOrigin,
}
#[derive(Debug, Clone)]
struct ConfiguredDefaultOrigin {
mapping: MappingSite,
preset: Option<PresetSite>,
}
#[derive(Debug, Clone)]
struct MappingSite {
origin: crate::config::ConfigOrigin,
formal_name: String,
id: Id,
}
#[derive(Debug, Clone)]
struct PresetSite {
origin: crate::config::ConfigOrigin,
name: PresetName,
value: Value,
}
impl ConfiguredDefaultOrigin {
fn description(&self) -> String {
let identity =
serde_json::to_string(&self.mapping.formal_name).expect("string is a JSON value");
let mapping = format!(
"{}: template-defaults.{}.{id}",
self.mapping.origin.path.display(),
identity,
id = self.mapping.id
);
match &self.preset {
Some(preset) => format!(
"{mapping} → {}: presets.\"{}\" ({})",
preset.origin.path.display(),
preset.name,
preset.value
),
None => mapping,
}
}
}
impl Resolution {
pub fn warnings(&self) -> &[String] {
&self.warnings
}
pub fn start<'a>(
self,
template: &'a Template,
now: jiff::ZonedDateTime,
) -> Result<Interview<'a>, EvalError> {
Interview::start_with_bank(
template,
InterviewSeed {
part_selection: template.part_selection.clone(),
now,
defaults: self
.defaults
.into_iter()
.map(|(id, value)| (id, DefaultBankEntry::Configured(value)))
.collect(),
context: None,
},
)
}
pub fn start_with_context<'a>(
self,
template: &'a Template,
now: jiff::ZonedDateTime,
context: InvocationContext,
) -> Result<Interview<'a>, EvalError> {
Interview::start_with_bank(
template,
InterviewSeed {
part_selection: template.part_selection.clone(),
now,
defaults: self
.defaults
.into_iter()
.map(|(id, value)| (id, DefaultBankEntry::Configured(value)))
.collect(),
context: Some(context),
},
)
}
pub fn start_with_seed<'a>(
self,
template: &'a Template,
now: jiff::ZonedDateTime,
context: InvocationContext,
seed: Option<ApplicationSeed>,
) -> Result<(Interview<'a>, Vec<String>), EvalError> {
self.start_with_selection(
template,
now,
context,
seed,
template.part_selection.clone(),
)
}
pub(crate) fn start_with_selection<'a>(
self,
template: &'a Template,
now: jiff::ZonedDateTime,
context: InvocationContext,
seed: Option<ApplicationSeed>,
part_selection: crate::parts::Selection,
) -> Result<(Interview<'a>, Vec<String>), EvalError> {
let Some(seed) = seed else {
let defaults = self
.defaults
.into_iter()
.map(|(id, value)| (id, DefaultBankEntry::Configured(value)))
.collect();
return Interview::start_with_bank(
template,
InterviewSeed {
now,
defaults,
context: Some(context),
part_selection,
},
)
.map(|interview| (interview, Vec::new()));
};
let mut defaults: IndexMap<Id, DefaultBankEntry> = self
.defaults
.into_iter()
.map(|(id, value)| (id, DefaultBankEntry::Configured(value)))
.collect();
let mut warnings = Vec::new();
for (id, raw) in seed.defaults {
let Some(question) = question_by_id(&template.interview, &id) else {
continue;
};
if parse_kind(&id, prompt_kind(question), raw.0.clone()).is_ok() {
defaults.insert(
id,
DefaultBankEntry::Application {
raw,
from: seed.from.clone(),
},
);
} else {
warnings.push(format!(
"application {} default for \"{id}\" does not match the question's type; ignored",
seed.from
));
}
}
Interview::start_with_bank(
template,
InterviewSeed {
part_selection,
now,
defaults,
context: Some(context),
},
)
.map(|interview| (interview, warnings))
}
pub fn into_flat_defaults(self) -> (IndexMap<Id, RawAnswer>, Vec<String>) {
(
self.defaults
.into_iter()
.map(|(id, value)| (id, value.raw))
.collect(),
self.warnings,
)
}
}
pub fn configured_defaults(
formal_name: &str,
template: &Template,
presets: &IndexMap<PresetName, ConfigEntry<Value>>,
mappings: &IndexMap<String, IndexMap<Id, ConfigEntry<DefaultSource>>>,
) -> Result<Resolution, EvalError> {
let mut defaults = IndexMap::new();
let mut warnings = Vec::new();
let Some(values) = mappings.get(formal_name) else {
return Ok(Resolution { defaults, warnings });
};
for (id, entry) in values {
let identity = serde_json::to_string(formal_name).expect("string is a JSON value");
let mapping = MappingSite {
origin: entry.origin.clone(),
formal_name: formal_name.into(),
id: id.clone(),
};
let mapping_key = format!(
"{}: template-defaults.{}.{id}",
mapping.origin.path.display(),
identity
);
let Some(question) = question_by_id(&template.interview, id) else {
warnings.push(format!(
"{mapping_key}: question is not defined by the selected template; ignored"
));
continue;
};
let (value, preset) = match &entry.value {
DefaultSource::Literal(value) => (value, None),
DefaultSource::Ref(name) => {
let Some(preset) = presets.get(name) else {
return Err(EvalError {
id: id.clone(),
field: CONFIGURED_DEFAULT,
message: format!("no preset named \"{name}\""),
expression: None,
config_key: Some(mapping_key),
});
};
(
&preset.value,
Some(PresetSite {
origin: preset.origin.clone(),
name: name.clone(),
value: preset.value.clone(),
}),
)
}
};
let origin = ConfiguredDefaultOrigin { mapping, preset };
let refused = value.as_str().is_some_and(crate::source::has_password);
parse_kind(id, prompt_kind(question), value.clone()).map_err(|error| EvalError {
id: id.clone(),
field: CONFIGURED_DEFAULT,
message: error.message,
expression: None,
config_key: Some(if refused {
mapping_key.clone()
} else {
origin.description()
}),
})?;
defaults.insert(
id.clone(),
ResolvedDefault {
raw: RawAnswer(value.clone()),
origin,
},
);
}
Ok(Resolution { defaults, warnings })
}
fn question_by_id<'a>(nodes: &'a [Node], id: &Id) -> Option<&'a Question> {
for n in nodes {
match n {
Node::Question(q) if &q.id == id => return Some(q),
Node::Group(g) => {
if let Some(q) = question_by_id(&g.nodes, id) {
return Some(q);
}
}
_ => {}
}
}
None
}
fn skipped_descendants_ready(
nodes: &[Node],
answers: &Answers,
template: &Template,
seed: &InterviewSeed,
) -> bool {
let mut available = answers.clone();
fn visit(
nodes: &[Node],
available: &mut Answers,
template: &Template,
seed: &InterviewSeed,
) -> bool {
for node in nodes {
match node {
Node::Question(q) => {
if !default_ready(q, available, template, seed) {
return false;
}
available.insert(q.id.clone(), Answer::None);
}
Node::Computed(c) => {
available.insert(c.id.clone(), Answer::None);
}
Node::Group(g) => {
if !visit(&g.nodes, available, template, seed) {
return false;
}
}
Node::Message(_) | Node::Hook(_) | Node::Flow(_) => {}
}
}
true
}
visit(nodes, &mut available, template, seed)
}
fn check_answer(
template: &Template,
answers: &Answers,
seed: &InterviewSeed,
prompt: &Prompt,
raw: RawAnswer,
) -> Result<Answer, CheckError> {
let id = &prompt.id;
let q = question_by_id(&template.interview, id).expect("prompt has question");
let empty = raw.0.is_null();
let answer = validate(id, &Rules::of_prompt(prompt, q), raw.0)?;
if empty {
return Ok(answer);
}
let answer =
format_answer(template, answers, seed, q, prompt.kind, answer).map_err(CheckError::Eval)?;
if q.parts {
let Answer::List(parts) = validate(id, &Rules::of_prompt(prompt, q), answer.to_json())?
else {
unreachable!("parts is multiselect")
};
return Ok(Answer::List(
crate::parts::options(q)
.iter()
.filter(|p| parts.contains(p))
.cloned()
.collect(),
));
}
Ok(answer)
}
fn format_answer(
template: &Template,
answers: &Answers,
seed: &InterviewSeed,
q: &Question,
kind: PromptKind,
answer: Answer,
) -> Result<Answer, EvalError> {
let id = &q.id;
let Some(expr) = &q.format else {
return Ok(answer);
};
let ctx = context(template, answers, seed);
let fail = |e: &dyn fmt::Display| fault(id, "format", Some(expr.source()), e);
let apply = |value: Value| -> Result<Value, EvalError> {
let mut c = ctx.clone();
c.insert("value".into(), value);
expr.eval(c)
.and_then(|v| {
serde_json::to_value(v).map_err(|e| {
minijinja::Error::new(minijinja::ErrorKind::InvalidOperation, e.to_string())
})
})
.map_err(|e| fail(&e))
};
Ok(match answer {
Answer::Text(v) => {
Answer::Text(serde_json::from_value(apply(Value::String(v))?).map_err(|e| fail(&e))?)
}
Answer::Bool(v) => {
Answer::Bool(serde_json::from_value(apply(Value::Bool(v))?).map_err(|e| fail(&e))?)
}
Answer::List(v) if kind == PromptKind::MultiSelect => Answer::List(
serde_json::from_value(apply(serde_json::json!(v))?).map_err(|e| fail(&e))?,
),
Answer::List(v) => Answer::List(
v.into_iter()
.map(|s| serde_json::from_value(apply(Value::String(s))?).map_err(|e| fail(&e)))
.collect::<Result<Vec<_>, EvalError>>()?,
),
a => a,
})
}
fn same_answer(
template: &Template,
answers: &Answers,
seed: &InterviewSeed,
q: &Question,
raw: &Value,
recorded: &Answer,
) -> Result<bool, EvalError> {
let kind = prompt_kind(q);
if raw.is_null() {
return Ok(empty_answer(kind) == *recorded);
}
let Ok(answer) = parse_kind(&q.id, kind, raw.clone()) else {
return Ok(false);
};
Ok(format_answer(template, answers, seed, q, kind, answer)? == *recorded)
}
type Expression<'n> = (&'static str, &'n str, HashSet<String>);
fn expressions(node: &Node) -> (Id, Vec<Expression<'_>>) {
use crate::template::HookProgram;
fn tmpl<'n>(field: &'static str, v: &'n crate::jinja::Tmpl) -> Expression<'n> {
(field, v.source(), v.references().clone())
}
fn expr<'n>(field: &'static str, v: &'n Expr) -> Expression<'n> {
(field, v.source(), v.references().clone())
}
fn typed<'n, T: Clone + serde::de::DeserializeOwned>(
field: &'static str,
v: &'n Typed<T>,
) -> Option<Expression<'n>> {
v.source().map(|source| (field, source, v.references()))
}
let mut out = Vec::new();
let id = match node {
Node::Question(q) => {
out.push(tmpl("prompt", &q.prompt));
out.extend(q.description.as_ref().map(|v| tmpl("description", v)));
out.extend(q.placeholder.as_ref().map(|v| tmpl("placeholder", v)));
out.extend(typed("required", &q.required));
out.extend(q.when.as_ref().map(|v| expr("when", v)));
out.extend(
q.validate
.min
.as_ref()
.and_then(|v| typed("validate.min", v)),
);
out.extend(
q.validate
.max
.as_ref()
.and_then(|v| typed("validate.max", v)),
);
if let Some(v) = &q.format {
let (field, source, mut refs) = expr("format", v);
refs.remove("value");
out.push((field, source, refs));
}
match &q.kind {
QuestionKind::Document { .. } => {}
QuestionKind::Text { default }
| QuestionKind::Multiline { default }
| QuestionKind::Git { default } => {
out.extend(default.as_ref().map(|v| tmpl("default", v)));
}
QuestionKind::Confirm { default } => {
out.extend(default.as_ref().and_then(|v| typed("default", v)));
}
QuestionKind::Select { options, default } => {
out.extend(typed("options", options));
out.extend(default.as_ref().map(|v| tmpl("default", v)));
}
QuestionKind::MultiSelect { options, default } => {
out.extend(typed("options", options));
out.extend(default.as_ref().and_then(|v| typed("default", v)));
}
QuestionKind::TextLoop { default, min, max } => {
out.extend(default.as_ref().and_then(|v| typed("default", v)));
out.extend(min.as_ref().and_then(|v| typed("loop.min", v)));
out.extend(max.as_ref().and_then(|v| typed("loop.max", v)));
}
}
q.id.clone()
}
Node::Computed(c) => {
out.extend(c.when.as_ref().map(|v| expr("when", v)));
out.push(expr("computed", &c.expr));
c.id.clone()
}
Node::Group(g) => {
out.extend(g.when.as_ref().map(|v| expr("when", v)));
g.name.clone()
}
Node::Hook(h) => {
out.extend(h.when.as_ref().map(|v| expr("when", v)));
out.extend(h.each.as_ref().map(|e| expr("each", &e.expr)));
let binding = h.each.as_ref().map(|e| e.binding.as_str());
let mut command = match &h.command.program {
HookProgram::Run(v) => v.iter().map(|v| tmpl("run", v)).collect::<Vec<_>>(),
HookProgram::Script { args, .. } => args.iter().map(|v| tmpl("args", v)).collect(),
};
command.extend(h.command.cwd.as_ref().map(|v| tmpl("cwd", v)));
for (field, source, mut refs) in command {
if let Some(binding) = binding {
refs.remove(binding);
}
out.push((field, source, refs));
}
Id::parse("hook").unwrap()
}
Node::Message(m) => {
out.extend(m.when.as_ref().map(|v| expr("when", v)));
out.push(tmpl("message", &m.text));
Id::parse("message").unwrap()
}
Node::Flow(f) => {
out.extend(f.when.as_ref().map(|v| expr("when", v)));
Id::parse("flow").unwrap()
}
};
(id, out)
}
fn unresolved(nodes: &[Node], available: &mut HashSet<String>, t: &Template) -> Option<EvalError> {
for node in nodes {
let (id, fields) = expressions(node);
for (field, source, refs) in fields {
let mut missing: Vec<_> = refs
.iter()
.filter(|r| {
!available.contains(*r)
&& !t.data.keys().any(|d| d.as_str() == r.as_str())
&& !is_global(r)
&& !(t.reserves_context() && is_reserved(r))
})
.collect();
missing.sort();
if let Some(name) = missing.first() {
return Some(fault(
&id,
field,
Some(source),
format!("{name} has no answer when this node is reached"),
));
}
}
if let Node::Group(g) = node
&& let Some(error) = unresolved(&g.nodes, available, t)
{
return Some(error);
}
if let Node::Question(Question { id, .. })
| Node::Computed(crate::template::Computed { id, .. }) = node
{
available.insert(id.to_string());
}
}
None
}
enum Walk {
Complete,
Blocked,
Ended(EndKind),
SkipRest,
}
struct Advance<'a> {
template: &'a Template,
seed: InterviewSeed,
answers: Answers,
accepted_raw: IndexMap<Id, RawAnswer>,
held: RawAnswers,
skipped: Skipped,
messages: Vec<String>,
step_start: usize,
hooks: Vec<RenderedHook>,
visited: HashSet<String>,
batch: Batch,
blocked: Option<&'a Node>,
disposition: Disposition,
ended: Option<(EndKind, Option<String>)>,
skip_rest: bool,
}
impl<'a> Advance<'a> {
fn block(&mut self, node: &'a Node) -> Result<Walk, EvalError> {
self.blocked = Some(node);
Ok(Walk::Blocked)
}
fn message(&mut self, message: String) {
self.batch.items.push(Item::Message(message.clone()));
self.messages.push(message);
}
fn skip(&mut self, q: &Question, default: Option<Answer>) {
self.answers.insert(
q.id.clone(),
default.unwrap_or_else(|| empty_answer(prompt_kind(q))),
);
self.skipped.insert(q.id.clone(), self.messages.len());
self.warn_if_held(&q.id);
}
fn warn_if_held(&mut self, id: &Id) {
if self.held.shift_remove(id).is_some() {
self.message(skipped_warning(id));
}
}
fn walk(
&mut self,
nodes: &'a [Node],
prefix: &str,
ancestor_skip: bool,
) -> Result<Walk, EvalError> {
let mut skip = ancestor_skip;
for (i, node) in nodes.iter().enumerate() {
if self.skip_rest {
skip = true;
}
let key = format!("{prefix}/{i}");
match node {
Node::Question(q) => {
if self.answers.contains_key(&q.id) {
if self.skipped.contains_key(&q.id) {
self.warn_if_held(&q.id);
}
continue;
}
if skip {
if !default_ready(q, &self.answers, self.template, &self.seed) {
return self.block(node);
}
let default = skipped_default(
q,
render_default(q, self.template, &self.answers, &self.seed)?,
&self.answers,
self.template,
&self.seed,
)?;
self.skip(q, default);
continue;
}
if !question_ready(q, &self.answers, self.template, &self.seed) {
return self.block(node);
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = !skip
&& q.when
.as_ref()
.map(|w| {
w.eval(&ctx)
.map(|v| v.is_true())
.map_err(|e| fault(&q.id, "when", Some(w.source()), e))
})
.transpose()?
.unwrap_or(true);
if active {
let prepared = make_prompt(q, self.template, &self.answers, &self.seed)?;
let prompt = prepared.prompt;
let selected = if q.parts && self.seed.part_selection.is_present() {
let default = match &prompt.default {
Some(Answer::List(parts)) => parts.clone(),
_ => vec![],
};
Some(RawAnswer(serde_json::json!(
self.seed.part_selection.settle(default)
)))
} else {
None
};
if let Some(raw) = selected.or_else(|| self.held.shift_remove(&q.id)) {
match check_answer(
self.template,
&self.answers,
&self.seed,
&prompt,
raw.clone(),
) {
Ok(answer) => {
self.accepted_raw.insert(q.id.clone(), raw);
self.answers.insert(q.id.clone(), answer);
continue;
}
Err(CheckError::Rejected(r)) => {
self.batch.errors.push(rejection(
&q.id,
format!(
"value recorded earlier is not allowed: {}",
r.message
),
));
}
Err(CheckError::Eval(e)) => return Err(e),
}
}
if let Some(error) = prepared.configured_rejection {
self.batch.errors.push(error);
}
if let Some(source) = prepared.default_source {
self.batch.default_sources.insert(q.id.clone(), source);
}
self.batch.items.push(Item::Prompt(prompt));
} else {
if !default_ready(q, &self.answers, self.template, &self.seed) {
return self.block(node);
}
let default = skipped_default(
q,
render_default(q, self.template, &self.answers, &self.seed)?,
&self.answers,
self.template,
&self.seed,
)?;
self.skip(q, default);
}
}
Node::Computed(c) => {
if self.answers.contains_key(&c.id) {
continue;
}
if !skip
&& (!expr_ready(&c.expr, &self.answers, self.template)
|| c.when
.as_ref()
.is_some_and(|w| !expr_ready(w, &self.answers, self.template)))
{
return self.block(node);
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = !skip
&& c.when
.as_ref()
.map(|w| {
w.eval(&ctx)
.map(|v| v.is_true())
.map_err(|e| fault(&c.id, "when", Some(w.source()), e))
})
.transpose()?
.unwrap_or(true);
let value = if active {
let value = c
.expr
.eval(&ctx)
.map_err(|e| fault(&c.id, "computed", Some(c.expr.source()), e))?;
serde_json::to_value(value)
.map(Answer::Value)
.map_err(|e| fault(&c.id, "computed", Some(c.expr.source()), e))?
} else {
Answer::None
};
self.answers.insert(c.id.clone(), value);
}
Node::Group(g) => {
if !skip
&& g.when
.as_ref()
.is_some_and(|w| !expr_ready(w, &self.answers, self.template))
{
return self.block(node);
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = !skip
&& g.when
.as_ref()
.map(|w| {
w.eval(&ctx)
.map(|v| v.is_true())
.map_err(|e| fault(&g.name, "when", Some(w.source()), e))
})
.transpose()?
.unwrap_or(true);
if !active
&& !skipped_descendants_ready(
&g.nodes,
&self.answers,
self.template,
&self.seed,
)
{
return self.block(node);
}
match self.walk(&g.nodes, &key, !active)? {
Walk::Blocked => return Ok(Walk::Blocked),
Walk::Ended(kind) => return Ok(Walk::Ended(kind)),
Walk::Complete | Walk::SkipRest => {}
}
}
Node::Hook(h) => {
if self.visited.contains(&key) {
continue;
}
if !skip
&& (h
.when
.as_ref()
.is_some_and(|w| !expr_ready(w, &self.answers, self.template))
|| !hook_ready(h, &self.answers, self.template))
{
return self.block(node);
}
self.visited.insert(key);
if skip {
continue;
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = h
.when
.as_ref()
.map(|w| {
w.eval(&ctx).map(|v| v.is_true()).map_err(|e| {
fault(&Id::parse("hook").unwrap(), "when", Some(w.source()), e)
})
})
.transpose()?
.unwrap_or(true);
if active {
self.hooks.extend(render_hooks(h, &ctx).map_err(|f| {
fault(
&Id::parse("hook").unwrap(),
f.field,
Some(&f.source),
f.message,
)
})?);
}
}
Node::Message(m) => {
if self.visited.contains(&key) {
continue;
}
if !skip
&& (!tmpl_ready(&m.text, &self.answers, self.template)
|| m.when
.as_ref()
.is_some_and(|w| !expr_ready(w, &self.answers, self.template)))
{
return self.block(node);
}
self.visited.insert(key);
if skip {
continue;
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = m
.when
.as_ref()
.map(|w| {
w.eval(&ctx).map(|v| v.is_true()).map_err(|e| {
fault(&Id::parse("message").unwrap(), "when", Some(w.source()), e)
})
})
.transpose()?
.unwrap_or(true);
if active {
let text = m.text.render(&ctx).map_err(|e| {
fault(
&Id::parse("message").unwrap(),
"message",
Some(m.text.source()),
e,
)
})?;
if !text.trim().is_empty() {
self.message(text);
}
}
}
Node::Flow(f) => {
if !skip
&& f.when
.as_ref()
.is_some_and(|w| !expr_ready(w, &self.answers, self.template))
{
return self.block(node);
}
if skip {
continue;
}
let ctx = context(self.template, &self.answers, &self.seed);
let active = f
.when
.as_ref()
.map(|w| {
w.eval(&ctx).map(|v| v.is_true()).map_err(|e| {
fault(&Id::parse("flow").unwrap(), "when", Some(w.source()), e)
})
})
.transpose()?
.unwrap_or(true);
if active {
match f.action {
FlowAction::Stop => {
self.ended = Some((EndKind::Stop, f.label.clone()));
return Ok(Walk::Ended(EndKind::Stop));
}
FlowAction::Abort => {
self.ended = Some((EndKind::Abort, f.label.clone()));
return Ok(Walk::Ended(EndKind::Abort));
}
FlowAction::DryRun => self.disposition = Disposition::DryRun,
FlowAction::Skip(SkipScope::Group) => skip = true,
FlowAction::Skip(SkipScope::Rest) => {
self.skip_rest = true;
skip = true;
}
}
}
}
}
}
Ok(if self.skip_rest {
Walk::SkipRest
} else {
Walk::Complete
})
}
}
fn advance(mut state: Advance<'_>) -> Result<Interview<'_>, EvalError> {
let template = state.template;
let outcome = state.walk(&template.interview, "", false)?;
if let Walk::Ended(kind) = outcome {
let label = state.ended.take().and_then(|(_, label)| label);
return Ok(Interview::Ended(Ended {
kind,
last_messages: state.messages[state.step_start..].to_vec(),
messages: state.messages,
label,
}));
}
let complete = matches!(outcome, Walk::Complete | Walk::SkipRest);
let has_prompt = state
.batch
.items
.iter()
.any(|i| matches!(i, Item::Prompt(_)));
if !complete && !has_prompt {
let mut available = state.answers.keys().map(Id::to_string).collect();
return Err(state
.blocked
.and_then(|node| unresolved(std::slice::from_ref(node), &mut available, template))
.unwrap_or_else(|| {
eval_error(
&Id::parse("interview").unwrap(),
"batch",
"unresolved question dependencies",
)
}));
}
if complete && !has_prompt {
Ok(Interview::Complete(Completed {
answers: state.answers,
accepted_raw: state.accepted_raw,
last_messages: state.messages[state.step_start..].to_vec(),
messages: state.messages,
hooks: state.hooks,
now: state.seed.now,
disposition: state.disposition,
context: state.seed.context,
skipped: state.skipped,
step_start: state.step_start,
}))
} else {
Ok(Interview::Asking(Pending {
template,
seed: state.seed,
answers: state.answers,
accepted_raw: state.accepted_raw,
held: state.held,
skipped: state.skipped,
messages: state.messages,
hooks: state.hooks,
visited: state.visited,
batch: state.batch,
}))
}
}
fn probe_skips(mut state: Advance<'_>) -> (Skipped, bool) {
let template = state.template;
let ended = matches!(
state.walk(&template.interview, "", false),
Ok(Walk::Ended(_))
);
(state.skipped, ended)
}
impl<'a> Interview<'a> {
pub fn start(template: &'a Template, seed: Seed) -> Result<Self, EvalError> {
Self::start_with_selection(template, seed, template.part_selection.clone())
}
pub(crate) fn start_with_selection(
template: &'a Template,
seed: Seed,
part_selection: crate::parts::Selection,
) -> Result<Self, EvalError> {
Self::start_with_bank(
template,
InterviewSeed {
part_selection,
now: seed.now,
defaults: seed
.defaults
.into_iter()
.map(|(id, value)| (id, DefaultBankEntry::Seed(value)))
.collect(),
context: Some(seed.context),
},
)
}
fn start_with_bank(template: &'a Template, seed: InterviewSeed) -> Result<Self, EvalError> {
advance(Advance {
template,
seed,
answers: Answers::new(),
accepted_raw: IndexMap::new(),
held: crate::document::admitted(template),
skipped: Skipped::new(),
messages: vec![],
step_start: 0,
hooks: vec![],
visited: HashSet::new(),
batch: Batch::default(),
blocked: None,
disposition: Disposition::default(),
ended: None,
skip_rest: false,
})
}
}
fn rejection(id: &Id, message: impl Into<String>) -> Rejection {
Rejection {
id: id.clone(),
message: message.into(),
kind: RejectionKind::Invalid,
}
}
impl Pending<'_> {
pub fn batch(&self) -> &Batch {
&self.batch
}
pub fn messages_reached(&self) -> usize {
self.messages.len()
}
pub fn accepts_id(&self, id: &Id) -> bool {
self.template.has_question_id(id)
}
fn check_inner(&self, id: &Id, raw: RawAnswer) -> Result<Answer, CheckError> {
let prompt = self
.batch
.items
.iter()
.find_map(|i| match i {
Item::Prompt(p) if &p.id == id => Some(p),
_ => None,
})
.ok_or_else(|| rejection(id, "is not in the current batch"))?;
check_answer(self.template, &self.answers, &self.seed, prompt, raw)
}
pub fn holds(&self, id: &Id) -> bool {
self.held.contains_key(id)
}
pub fn check(&self, id: &Id, raw: RawAnswer) -> Result<Answer, CheckError> {
self.check_inner(id, raw)
}
}
#[derive(Debug)]
pub enum CheckError {
Rejected(Rejection),
Eval(EvalError),
}
impl From<Rejection> for CheckError {
fn from(v: Rejection) -> Self {
Self::Rejected(v)
}
}
impl From<EvalError> for CheckError {
fn from(v: EvalError) -> Self {
Self::Eval(v)
}
}
impl<'a> Pending<'a> {
#[allow(clippy::result_large_err)]
pub fn answer(self, incoming: RawAnswers) -> Result<Interview<'a>, AnswerError<'a>> {
let mut held = self.held.clone();
let mut rejections = vec![];
let mut unless_skipped = vec![];
for (id, raw) in incoming {
let Some(q) = question_by_id(&self.template.interview, &id) else {
rejections.push(rejection(&id, "is not a question in this template"));
continue;
};
if prompt_kind(q) == PromptKind::Git
&& raw.0.as_str().is_some_and(crate::source::has_password)
{
rejections.push(rejection(&id, crate::source::PASSWORD_REFUSED));
continue;
}
if self.skipped.contains_key(&id) {
held.insert(id, raw);
continue;
}
if let Some(recorded) = self.answers.get(&id) {
let same = same_answer(
self.template,
&self.answers,
&self.seed,
q,
&raw.0,
recorded,
)
.map_err(AnswerError::Eval)?;
if !same {
rejections.push(Rejection {
kind: RejectionKind::Answered,
..rejection(
&id,
format!("is already answered with {}", recorded.to_json()),
)
});
}
continue;
}
let early = !self.answers.contains_key(&id)
&& !self
.batch
.items
.iter()
.any(|i| matches!(i, Item::Prompt(p) if p.id == id));
if early {
if let Err(r) = validate(&id, &Rules::of_question(q), raw.0.clone()) {
rejections.push(r);
unless_skipped.push(id.clone());
}
}
held.insert(id, raw);
}
let mut next = Answers::new();
let mut raw_next: IndexMap<Id, RawAnswer> = IndexMap::new();
for item in &self.batch.items {
let Item::Prompt(p) = item else { continue };
let raw = held.get(&p.id).cloned();
let carried = self.batch.errors.iter().find(|e| e.id == p.id);
let raw_captured: Option<Value> = raw.as_ref().map(|r| r.0.clone());
let checked = match (raw, carried) {
(Some(raw), _) => self.check_inner(&p.id, raw),
(None, Some(error)) => Err(error.clone().into()),
(None, None) => match &p.default {
Some(v)
if matches!(
self.batch.default_sources.get(&p.id),
Some(PreparedDefaultSource::Seed)
) =>
{
self.check_inner(&p.id, RawAnswer(v.to_json()))
.map_err(|e| match e {
CheckError::Rejected(r) => rejection(
&p.id,
format!(
"default {} from {} is not allowed: {}",
v.to_json(),
configured_default_source(&p.id),
r.message
),
)
.into(),
e => e,
})
}
Some(v)
if matches!(
self.batch.default_sources.get(&p.id),
Some(PreparedDefaultSource::Application { .. })
) =>
{
let from = match self.batch.default_sources.get(&p.id) {
Some(PreparedDefaultSource::Application { from }) => from.clone(),
_ => unreachable!("matched an application default source"),
};
self.check_inner(&p.id, RawAnswer(v.to_json()))
.map_err(|e| match e {
CheckError::Rejected(r) => rejection(
&p.id,
format!(
"default {} from application {from} is not allowed: {}",
v.to_json(),
r.message
),
)
.into(),
e => e,
})
}
Some(v) => self.check_inner(&p.id, RawAnswer(v.to_json())),
None if !p.constraints.required => Ok(empty_answer(p.kind)),
None => Err(rejection(&p.id, "is required").into()),
},
};
match checked {
Ok(v) => {
let raw_value = raw_captured
.or_else(|| p.default.as_ref().map(|d| d.to_json()))
.unwrap_or_else(|| v.to_json());
raw_next.insert(p.id.clone(), RawAnswer(raw_value));
next.insert(p.id.clone(), v);
}
Err(CheckError::Rejected(r)) => rejections.push(r),
Err(CheckError::Eval(e)) => return Err(AnswerError::Eval(e)),
}
}
let rejected = |pending, rejections| {
Err(AnswerError::Rejected {
pending,
rejections,
})
};
if unless_skipped.is_empty() && !rejections.is_empty() {
return rejected(self, rejections);
}
for id in next.keys() {
held.shift_remove(id);
}
let mut answers = self.answers.clone();
answers.extend(next);
let mut accepted_raw = self.accepted_raw.clone();
accepted_raw.extend(raw_next);
let (probe_skipped, probe_ended) = probe_skips(Advance {
template: self.template,
seed: self.seed.clone(),
answers: answers.clone(),
accepted_raw: accepted_raw.clone(),
held: held.clone(),
skipped: self.skipped.clone(),
step_start: self.messages.len(),
messages: self.messages.clone(),
hooks: self.hooks.clone(),
visited: self.visited.clone(),
batch: Batch::default(),
blocked: None,
disposition: Disposition::default(),
ended: None,
skip_rest: false,
});
let stands = |id: &Id| !probe_ended && !probe_skipped.contains_key(id);
let dropped: Vec<Id> = unless_skipped
.into_iter()
.filter(|id| !stands(id))
.collect();
rejections.retain(|r| !dropped.contains(&r.id));
if !rejections.is_empty() {
return rejected(self, rejections);
}
advance(Advance {
template: self.template,
seed: self.seed,
answers,
accepted_raw,
held,
skipped: self.skipped,
step_start: self.messages.len(),
messages: self.messages,
hooks: self.hooks,
visited: self.visited,
batch: Batch::default(),
blocked: None,
disposition: Disposition::default(),
ended: None,
skip_rest: false,
})
.map_err(AnswerError::Eval)
}
}