Skip to main content

zenquirer_core/
answer.rs

1//! Answer types and value storage.
2//!
3//! This module provides types for representing questionnaire answers.
4//! Answers support multiple value types (text, numbers, booleans) and can be
5//! serialized to/from JSON and YAML.
6//!
7//! # Answer types
8//!
9//! - [`Answer`] - Enum representing different answer value types
10//! - [`Value<T>`] - Single or multiple values of type T
11//! - [`Answers`] - Collection of named answers from a questionnaire
12//! - [`QuestionAnswer`] - A single question-answer pair
13//!
14//! # Example
15//!
16//! ```rust,ignore
17//! use zenquirer::{Answer, answer::Value};
18//!
19//! let answer = Answer::Text(Value::Single("Alice".to_string()));
20//! match answer {
21//!     Answer::Text(Value::Single(s)) => println!("Name: {}", s),
22//!     _ => {}
23//! }
24//! ```
25
26use indexmap::IndexMap;
27use serde::{Deserialize, Serialize};
28use std::collections::HashMap;
29use std::path::{Path, PathBuf};
30
31#[cfg(feature = "datetime-tz")]
32use chrono::{DateTime, FixedOffset};
33#[cfg(feature = "datetime")]
34use chrono::{NaiveDate, NaiveDateTime};
35
36/// A single question-answer pair.
37///
38/// Contains the question name and its corresponding answer value.
39#[derive(Debug)]
40pub struct QuestionAnswer {
41    pub question_name: String,
42    pub value: Answer,
43}
44
45use std::sync::Arc;
46
47/// Type alias for answer formatter functions.
48///
49/// Formatters are cloneable (via Arc) but cannot be serialized due to containing closures.
50/// When serializing questions, formatters are skipped and must be re-attached programmatically.
51pub type AnswerFormatter = Arc<dyn Fn(&Answer) -> String + Send + Sync>;
52
53/// Single or multiple values of type T.
54///
55/// Used to represent answers that can be either a single value (like a text input)
56/// or multiple values (like a multi-select question).
57#[derive(Debug, Clone, PartialEq)]
58pub enum Value<T> {
59    /// A single value
60    Single(T),
61    /// Multiple values (from multi-select questions)
62    Multiple(Vec<T>),
63}
64
65/// Answer value from a questionnaire question.
66///
67/// Supports text, numeric, boolean, and key-value answer types, plus null for optional questions.
68/// Runtime-only typed variants such as integers, dates, and paths serialize as plain JSON/YAML
69/// values; deserialization is shape-based unless questionnaire normalization is applied.
70///
71/// # Examples
72///
73/// ```rust,ignore
74/// use zenquirer::{Answer, answer::Value};
75/// use std::collections::HashMap;
76///
77/// // Text answer
78/// let name = Answer::Text(Value::Single("Alice".to_string()));
79///
80/// // Multiple choice answer
81/// let tools = Answer::Text(Value::Multiple(vec!["Git".to_string(), "Docker".to_string()]));
82///
83/// // Number answer
84/// let age = Answer::Number(Value::Single(25.0));
85///
86/// // Boolean answer
87/// let subscribed = Answer::Boolean(true);
88///
89/// // Key-value answer
90/// let config = Answer::KeyValue(HashMap::from([
91///     ("host".to_string(), Answer::text("localhost")),
92///     ("port".to_string(), Answer::number(5432.0)),
93/// ]));
94///
95/// // Null (no answer)
96/// let optional = Answer::Null;
97/// ```
98#[derive(Debug, Clone, PartialEq)]
99pub enum Answer {
100    /// Text value (single or multiple strings)
101    Text(Value<String>),
102    /// Numeric value (single or multiple floats)
103    Number(Value<f64>),
104    /// Boolean value (single or multiple yes/no, true/false)
105    Boolean(Value<bool>),
106    /// Key-value pairs (hashmap of string keys to answer values)
107    KeyValue(HashMap<String, Answer>),
108    /// Null value (unanswered or optional question)
109    Null,
110    /// Calendar date (requires `datetime` feature)
111    #[cfg(feature = "datetime")]
112    Date(NaiveDate),
113    /// Naive (timezone-less) date and time (requires `datetime` feature)
114    #[cfg(feature = "datetime")]
115    DateTime(NaiveDateTime),
116    /// Date and time with a fixed-offset timezone (requires `datetime-tz` feature)
117    #[cfg(feature = "datetime-tz")]
118    DateTimeTz(DateTime<FixedOffset>),
119    /// Single filesystem path
120    Path(PathBuf),
121    /// Multiple filesystem paths
122    Paths(Vec<PathBuf>),
123    /// 64-bit signed integer value
124    Integer(i64),
125}
126
127impl serde::Serialize for Answer {
128    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
129    where
130        S: serde::Serializer,
131    {
132        match self {
133            Answer::Text(Value::Single(value)) => value.serialize(serializer),
134            Answer::Text(Value::Multiple(values)) => values.serialize(serializer),
135            Answer::Number(Value::Single(value)) => value.serialize(serializer),
136            Answer::Number(Value::Multiple(values)) => values.serialize(serializer),
137            Answer::Boolean(Value::Single(value)) => value.serialize(serializer),
138            Answer::Boolean(Value::Multiple(values)) => values.serialize(serializer),
139            Answer::KeyValue(map) => map.serialize(serializer),
140            Answer::Null => serializer.serialize_none(),
141            #[cfg(feature = "datetime")]
142            Answer::Date(d) => d.format("%Y-%m-%d").to_string().serialize(serializer),
143            #[cfg(feature = "datetime")]
144            Answer::DateTime(dt) => dt
145                .format("%Y-%m-%dT%H:%M:%S")
146                .to_string()
147                .serialize(serializer),
148            #[cfg(feature = "datetime-tz")]
149            Answer::DateTimeTz(dt) => dt.to_rfc3339().serialize(serializer),
150            Answer::Path(p) => p.to_string_lossy().into_owned().serialize(serializer),
151            Answer::Paths(paths) => {
152                let strs: Vec<String> = paths
153                    .iter()
154                    .map(|p| p.to_string_lossy().into_owned())
155                    .collect();
156                strs.serialize(serializer)
157            }
158            Answer::Integer(n) => n.serialize(serializer),
159        }
160    }
161}
162
163impl<'de> serde::Deserialize<'de> for Answer {
164    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
165    where
166        D: serde::Deserializer<'de>,
167    {
168        use serde::de::Error;
169        let value = serde_json::Value::deserialize(deserializer)?;
170
171        match value {
172            serde_json::Value::String(s) => Ok(Answer::Text(Value::Single(s))),
173            serde_json::Value::Number(n) => match n.as_f64() {
174                Some(f) => Ok(Answer::Number(Value::Single(f))),
175                None => Err(D::Error::custom("Invalid number format")),
176            },
177            serde_json::Value::Array(arr) => {
178                // Try to parse as array of numbers, strings, or booleans
179                let mut numbers = Vec::new();
180                let mut strings = Vec::new();
181                let mut bools = Vec::new();
182                let mut has_numbers = false;
183                let mut has_strings = false;
184                let mut has_bools = false;
185
186                for v in arr {
187                    match v {
188                        serde_json::Value::Number(n) => {
189                            if let Some(f) = n.as_f64() {
190                                numbers.push(f);
191                                has_numbers = true;
192                            } else {
193                                return Err(D::Error::custom("Invalid number in array"));
194                            }
195                        }
196                        serde_json::Value::String(s) => {
197                            strings.push(s);
198                            has_strings = true;
199                        }
200                        serde_json::Value::Bool(b) => {
201                            bools.push(b);
202                            has_bools = true;
203                        }
204                        _ => {
205                            return Err(D::Error::custom(
206                                "Array must contain only strings, numbers, or booleans",
207                            ));
208                        }
209                    }
210                }
211
212                // Now we can properly handle numeric, string, and boolean arrays
213                match (has_numbers, has_strings, has_bools) {
214                    (true, false, false) => Ok(Answer::Number(Value::Multiple(numbers))),
215                    (false, true, false) => Ok(Answer::Text(Value::Multiple(strings))),
216                    (false, false, true) => Ok(Answer::Boolean(Value::Multiple(bools))),
217                    (false, false, false) => Ok(Answer::Text(Value::Multiple(Vec::new()))), // Empty array defaults to strings
218                    _ => Err(D::Error::custom("Array cannot contain mixed types")),
219                }
220            }
221            serde_json::Value::Bool(b) => Ok(Answer::Boolean(Value::Single(b))),
222            serde_json::Value::Null => Ok(Answer::Null),
223            serde_json::Value::Object(obj) => {
224                let mut map = HashMap::new();
225                for (key, value) in obj {
226                    let answer = Answer::deserialize(value).map_err(D::Error::custom)?;
227                    map.insert(key, answer);
228                }
229                Ok(Answer::KeyValue(map))
230            }
231        }
232    }
233}
234
235/// Collection of named answers from a questionnaire.
236///
237/// Maps question names to their corresponding answer values. Preserves insertion
238/// order and supports serialization to/from JSON and YAML.
239///
240/// # Examples
241///
242/// ```rust,ignore
243/// use zenquirer::{Answers, Answer};
244///
245/// let answers = Answers::new()
246///     .with_answer("name", Answer::from("Alice"))
247///     .with_answer("age", Answer::Number(zenquirer::answer::Value::Single(25.0)))
248///     .with_answer("subscribed", Answer::from(true));
249///
250/// // Access answers
251/// if let Some(name) = answers.get("name") {
252///     println!("Name answer: {:?}", name);
253/// }
254/// ```
255#[derive(Serialize, Deserialize, Clone, Debug, Default)]
256#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
257pub struct Answers(IndexMap<String, Answer>);
258
259impl Answers {
260    /// Create an empty answer collection.
261    pub fn new() -> Self {
262        Self(IndexMap::new())
263    }
264
265    /// Add an answer and return the updated collection.
266    pub fn with_answer(mut self, name: impl Into<String>, value: Answer) -> Self {
267        self.insert(name, value);
268        self
269    }
270
271    /// Insert or replace an answer for the given question name.
272    pub fn insert(&mut self, name: impl Into<String>, value: Answer) -> Option<Answer> {
273        self.0.insert(name.into(), value)
274    }
275
276    /// Return the answer for the given question name, if present.
277    pub fn get(&self, name: &str) -> Option<&Answer> {
278        self.0.get(name)
279    }
280
281    /// Return true when an answer exists for the given question name.
282    pub fn contains_key(&self, name: &str) -> bool {
283        self.0.contains_key(name)
284    }
285
286    /// Iterate over answers in questionnaire order.
287    pub fn iter(&self) -> indexmap::map::Iter<'_, String, Answer> {
288        self.0.iter()
289    }
290
291    /// Return the number of stored answers.
292    pub fn len(&self) -> usize {
293        self.0.len()
294    }
295
296    /// Return true when no answers are stored.
297    pub fn is_empty(&self) -> bool {
298        self.0.is_empty()
299    }
300
301    /// Borrow the underlying map.
302    pub fn as_inner(&self) -> &IndexMap<String, Answer> {
303        &self.0
304    }
305
306    /// Convert this collection into its underlying map.
307    pub fn into_inner(self) -> IndexMap<String, Answer> {
308        self.0
309    }
310
311    fn lookup(&self, name: &str) -> Result<&Answer, crate::Error> {
312        self.0
313            .get(name)
314            .ok_or_else(|| crate::Error::Validation(format!("Question '{name}' not found")))
315    }
316
317    /// Extract an answer as the requested Rust type.
318    ///
319    /// This uses [`TryFrom`] implementations for the target type. Borrowed
320    /// targets such as `&str`, `&[String]`, and `&Path` avoid cloning; owned targets
321    /// such as `String`, `Vec<String>`, and `PathBuf` clone from the stored answer.
322    ///
323    /// # Errors
324    ///
325    /// Returns an error if the question does not exist or the answer cannot be
326    /// extracted as the requested type.
327    ///
328    /// # Examples
329    ///
330    /// ```
331    /// use zenquirer_core::{Answers, Answer};
332    ///
333    /// let answers = Answers::new()
334    ///     .with_answer("name", Answer::from("Alice"))
335    ///     .with_answer("subscribe", Answer::from(true));
336    ///
337    /// let name: &str = answers.get_as("name").unwrap();
338    /// let subscribed = answers.get_as::<bool>("subscribe").unwrap();
339    ///
340    /// assert_eq!(name, "Alice");
341    /// assert!(subscribed);
342    /// ```
343    pub fn get_as<'a, T>(&'a self, name: &str) -> Result<T, crate::Error>
344    where
345        T: TryFrom<&'a Answer, Error = crate::Error>,
346    {
347        T::try_from(self.lookup(name)?)
348    }
349
350    /// Check if a question answer is null
351    ///
352    /// Returns `false` if the question doesn't exist
353    ///
354    /// # Examples
355    ///
356    /// ```
357    /// use zenquirer_core::{Answers, Answer};
358    ///
359    /// let answers = Answers::new()
360    ///     .with_answer("optional", Answer::Null);
361    ///
362    /// assert!(answers.is_null("optional"));
363    /// assert!(!answers.is_null("nonexistent"));
364    /// ```
365    pub fn is_null(&self, name: &str) -> bool {
366        self.0.get(name).is_some_and(|a| a.is_null())
367    }
368}
369
370impl From<IndexMap<String, Answer>> for Answers {
371    fn from(value: IndexMap<String, Answer>) -> Self {
372        Answers(value)
373    }
374}
375
376impl From<Answers> for IndexMap<String, Answer> {
377    fn from(value: Answers) -> Self {
378        value.into_inner()
379    }
380}
381
382impl IntoIterator for Answers {
383    type Item = (String, Answer);
384    type IntoIter = indexmap::map::IntoIter<String, Answer>;
385
386    fn into_iter(self) -> Self::IntoIter {
387        self.0.into_iter()
388    }
389}
390
391impl<'a> IntoIterator for &'a Answers {
392    type Item = (&'a String, &'a Answer);
393    type IntoIter = indexmap::map::Iter<'a, String, Answer>;
394
395    fn into_iter(self) -> Self::IntoIter {
396        self.iter()
397    }
398}
399
400impl<'a> TryFrom<&'a Answer> for &'a str {
401    type Error = crate::Error;
402
403    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
404        value.as_string()
405    }
406}
407
408impl TryFrom<&Answer> for String {
409    type Error = crate::Error;
410
411    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
412        value.as_string().map(ToOwned::to_owned)
413    }
414}
415
416impl<'a> TryFrom<&'a Answer> for &'a [String] {
417    type Error = crate::Error;
418
419    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
420        value.as_strings()
421    }
422}
423
424impl TryFrom<&Answer> for Vec<String> {
425    type Error = crate::Error;
426
427    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
428        value.as_strings().map(ToOwned::to_owned)
429    }
430}
431
432impl TryFrom<&Answer> for f64 {
433    type Error = crate::Error;
434
435    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
436        value.as_number()
437    }
438}
439
440impl<'a> TryFrom<&'a Answer> for &'a [f64] {
441    type Error = crate::Error;
442
443    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
444        value.as_numbers()
445    }
446}
447
448impl TryFrom<&Answer> for Vec<f64> {
449    type Error = crate::Error;
450
451    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
452        value.as_numbers().map(ToOwned::to_owned)
453    }
454}
455
456impl TryFrom<&Answer> for bool {
457    type Error = crate::Error;
458
459    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
460        value.as_bool()
461    }
462}
463
464impl<'a> TryFrom<&'a Answer> for &'a [bool] {
465    type Error = crate::Error;
466
467    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
468        value.as_bools()
469    }
470}
471
472impl TryFrom<&Answer> for Vec<bool> {
473    type Error = crate::Error;
474
475    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
476        value.as_bools().map(ToOwned::to_owned)
477    }
478}
479
480impl<'a> TryFrom<&'a Answer> for &'a HashMap<String, Answer> {
481    type Error = crate::Error;
482
483    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
484        value.as_keyvalue()
485    }
486}
487
488impl TryFrom<&Answer> for HashMap<String, Answer> {
489    type Error = crate::Error;
490
491    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
492        value.as_keyvalue().cloned()
493    }
494}
495
496#[cfg(feature = "datetime")]
497impl TryFrom<&Answer> for NaiveDate {
498    type Error = crate::Error;
499
500    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
501        value.as_date()
502    }
503}
504
505#[cfg(feature = "datetime")]
506impl TryFrom<&Answer> for NaiveDateTime {
507    type Error = crate::Error;
508
509    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
510        value.as_datetime()
511    }
512}
513
514#[cfg(feature = "datetime-tz")]
515impl TryFrom<&Answer> for DateTime<FixedOffset> {
516    type Error = crate::Error;
517
518    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
519        value.as_datetime_tz()
520    }
521}
522
523impl<'a> TryFrom<&'a Answer> for &'a Path {
524    type Error = crate::Error;
525
526    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
527        value.as_path()
528    }
529}
530
531impl TryFrom<&Answer> for PathBuf {
532    type Error = crate::Error;
533
534    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
535        value.as_path().map(Path::to_path_buf)
536    }
537}
538
539impl<'a> TryFrom<&'a Answer> for &'a [PathBuf] {
540    type Error = crate::Error;
541
542    fn try_from(value: &'a Answer) -> Result<Self, Self::Error> {
543        value.as_paths()
544    }
545}
546
547impl TryFrom<&Answer> for Vec<PathBuf> {
548    type Error = crate::Error;
549
550    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
551        value.as_paths().map(ToOwned::to_owned)
552    }
553}
554
555impl TryFrom<&Answer> for i64 {
556    type Error = crate::Error;
557
558    fn try_from(value: &Answer) -> Result<Self, Self::Error> {
559        value.as_integer()
560    }
561}
562
563// Implementations for converting common types to Answer
564impl From<&str> for Answer {
565    fn from(value: &str) -> Self {
566        Answer::Text(Value::Single(value.to_string()))
567    }
568}
569
570impl From<String> for Answer {
571    fn from(value: String) -> Self {
572        Answer::Text(Value::Single(value))
573    }
574}
575
576impl From<bool> for Answer {
577    fn from(value: bool) -> Self {
578        Answer::Boolean(Value::Single(value))
579    }
580}
581
582impl From<Vec<&str>> for Answer {
583    fn from(value: Vec<&str>) -> Self {
584        Answer::Text(Value::Multiple(
585            value.iter().map(|s| s.to_string()).collect(),
586        ))
587    }
588}
589
590impl From<Vec<String>> for Answer {
591    fn from(value: Vec<String>) -> Self {
592        Answer::Text(Value::Multiple(value))
593    }
594}
595
596impl From<&[&str]> for Answer {
597    fn from(value: &[&str]) -> Self {
598        Answer::Text(Value::Multiple(
599            value.iter().map(|s| s.to_string()).collect(),
600        ))
601    }
602}
603
604// Macro for generating integer type implementations (signed and unsigned widths < i64)
605macro_rules! impl_integer_from {
606    ($($t:ty),*) => {
607        $(
608            impl From<$t> for Answer {
609                fn from(value: $t) -> Self {
610                    Answer::Integer(value as i64)
611                }
612            }
613        )*
614    };
615}
616
617// Macro for generating float type implementations
618macro_rules! impl_float_from {
619    ($($t:ty),*) => {
620        $(
621            impl From<$t> for Answer {
622                fn from(value: $t) -> Self {
623                    Answer::Number(Value::Single(value as f64))
624                }
625            }
626        )*
627    };
628}
629
630// Special case for f64 to avoid unnecessary casting
631impl From<f64> for Answer {
632    fn from(value: f64) -> Self {
633        Answer::Number(Value::Single(value))
634    }
635}
636
637// Integer types map to Answer::Integer for end-to-end integer-typed extraction
638impl_integer_from!(i8, i16, i32, i64, u8, u16, u32);
639// Float types map to Answer::Number
640impl_float_from!(f32);
641
642// Option type implementations for null handling - use individual implementations for clarity
643impl From<Option<String>> for Answer {
644    fn from(value: Option<String>) -> Self {
645        match value {
646            Some(s) => Answer::Text(Value::Single(s)),
647            None => Answer::Null,
648        }
649    }
650}
651
652impl From<Option<&str>> for Answer {
653    fn from(value: Option<&str>) -> Self {
654        match value {
655            Some(s) => Answer::Text(Value::Single(s.to_string())),
656            None => Answer::Null,
657        }
658    }
659}
660
661impl From<Option<bool>> for Answer {
662    fn from(value: Option<bool>) -> Self {
663        match value {
664            Some(b) => Answer::Boolean(Value::Single(b)),
665            None => Answer::Null,
666        }
667    }
668}
669
670// Boolean vector implementations - new functionality for consistency
671impl From<Vec<bool>> for Answer {
672    fn from(value: Vec<bool>) -> Self {
673        Answer::Boolean(Value::Multiple(value))
674    }
675}
676
677impl From<&[bool]> for Answer {
678    fn from(value: &[bool]) -> Self {
679        Answer::Boolean(Value::Multiple(value.to_vec()))
680    }
681}
682
683impl From<Option<Vec<bool>>> for Answer {
684    fn from(value: Option<Vec<bool>>) -> Self {
685        match value {
686            Some(v) => Answer::Boolean(Value::Multiple(v)),
687            None => Answer::Null,
688        }
689    }
690}
691
692impl From<Option<Vec<String>>> for Answer {
693    fn from(value: Option<Vec<String>>) -> Self {
694        match value {
695            Some(v) => Answer::Text(Value::Multiple(v)),
696            None => Answer::Null,
697        }
698    }
699}
700
701// Numeric vector implementations - new functionality that was missing
702impl From<Vec<f64>> for Answer {
703    fn from(value: Vec<f64>) -> Self {
704        Answer::Number(Value::Multiple(value))
705    }
706}
707
708impl From<Vec<f32>> for Answer {
709    fn from(value: Vec<f32>) -> Self {
710        Answer::Number(Value::Multiple(
711            value.into_iter().map(|x| x as f64).collect(),
712        ))
713    }
714}
715
716impl From<Vec<i32>> for Answer {
717    fn from(value: Vec<i32>) -> Self {
718        Answer::Number(Value::Multiple(
719            value.into_iter().map(|x| x as f64).collect(),
720        ))
721    }
722}
723
724impl From<Vec<i64>> for Answer {
725    fn from(value: Vec<i64>) -> Self {
726        Answer::Number(Value::Multiple(
727            value.into_iter().map(|x| x as f64).collect(),
728        ))
729    }
730}
731
732impl From<&[f64]> for Answer {
733    fn from(value: &[f64]) -> Self {
734        Answer::Number(Value::Multiple(value.to_vec()))
735    }
736}
737
738impl From<Option<Vec<f64>>> for Answer {
739    fn from(value: Option<Vec<f64>>) -> Self {
740        match value {
741            Some(v) => Answer::Number(Value::Multiple(v)),
742            None => Answer::Null,
743        }
744    }
745}
746
747#[cfg(feature = "datetime")]
748impl From<NaiveDate> for Answer {
749    fn from(value: NaiveDate) -> Self {
750        Answer::Date(value)
751    }
752}
753
754#[cfg(feature = "datetime")]
755impl From<NaiveDateTime> for Answer {
756    fn from(value: NaiveDateTime) -> Self {
757        Answer::DateTime(value)
758    }
759}
760
761#[cfg(feature = "datetime-tz")]
762impl From<DateTime<FixedOffset>> for Answer {
763    fn from(value: DateTime<FixedOffset>) -> Self {
764        Answer::DateTimeTz(value)
765    }
766}
767
768impl From<PathBuf> for Answer {
769    fn from(value: PathBuf) -> Self {
770        Answer::Path(value)
771    }
772}
773
774impl From<&Path> for Answer {
775    fn from(value: &Path) -> Self {
776        Answer::Path(value.to_path_buf())
777    }
778}
779
780impl From<Vec<PathBuf>> for Answer {
781    fn from(value: Vec<PathBuf>) -> Self {
782        Answer::Paths(value)
783    }
784}
785
786#[cfg(feature = "schema")]
787impl schemars::JsonSchema for Answer {
788    fn schema_name() -> String {
789        "Answer".to_string()
790    }
791
792    fn json_schema(_generator: &mut schemars::r#gen::SchemaGenerator) -> schemars::schema::Schema {
793        use schemars::schema::{InstanceType, Schema, SchemaObject, SingleOrVec};
794
795        // Answer serializes as one of: string, number, boolean, null, array, or object
796        Schema::Object(SchemaObject {
797            subschemas: Some(Box::new(schemars::schema::SubschemaValidation {
798                one_of: Some(vec![
799                    Schema::Object(SchemaObject {
800                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
801                        ..Default::default()
802                    }),
803                    Schema::Object(SchemaObject {
804                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Number))),
805                        ..Default::default()
806                    }),
807                    Schema::Object(SchemaObject {
808                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Boolean))),
809                        ..Default::default()
810                    }),
811                    Schema::Object(SchemaObject {
812                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Null))),
813                        ..Default::default()
814                    }),
815                    Schema::Object(SchemaObject {
816                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Array))),
817                        ..Default::default()
818                    }),
819                    Schema::Object(SchemaObject {
820                        instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
821                        ..Default::default()
822                    }),
823                ]),
824                ..Default::default()
825            })),
826            ..Default::default()
827        })
828    }
829}
830
831impl Answer {
832    /// Format this answer value using the provided formatter, or use default formatting
833    pub fn format_with(&self, formatter: Option<&AnswerFormatter>) -> String {
834        match formatter {
835            Some(f) => f(self),
836            None => self.default_format(),
837        }
838    }
839
840    /// Default formatting for answer values
841    pub fn default_format(&self) -> String {
842        match self {
843            Answer::Text(Value::Single(s)) => s.clone(),
844            Answer::Text(Value::Multiple(v)) => v.join(", "),
845            Answer::Number(Value::Single(n)) => n.to_string(),
846            Answer::Number(Value::Multiple(v)) => v
847                .iter()
848                .map(|n| n.to_string())
849                .collect::<Vec<_>>()
850                .join(", "),
851            Answer::Boolean(Value::Single(b)) => b.to_string(),
852            Answer::Boolean(Value::Multiple(v)) => v
853                .iter()
854                .map(|b| b.to_string())
855                .collect::<Vec<_>>()
856                .join(", "),
857            Answer::KeyValue(map) => map
858                .iter()
859                .map(|(k, v)| format!("{}: {}", k, v.default_format()))
860                .collect::<Vec<_>>()
861                .join(", "),
862            Answer::Null => "null".to_string(),
863            #[cfg(feature = "datetime")]
864            Answer::Date(d) => d.format("%Y-%m-%d").to_string(),
865            #[cfg(feature = "datetime")]
866            Answer::DateTime(dt) => dt.format("%Y-%m-%dT%H:%M:%S").to_string(),
867            #[cfg(feature = "datetime-tz")]
868            Answer::DateTimeTz(dt) => dt.to_rfc3339(),
869            Answer::Path(p) => p.to_string_lossy().into_owned(),
870            Answer::Paths(paths) => paths
871                .iter()
872                .map(|p| p.to_string_lossy().into_owned())
873                .collect::<Vec<_>>()
874                .join(", "),
875            Answer::Integer(n) => n.to_string(),
876        }
877    }
878
879    /// Helper method to create a text answer
880    pub fn text(s: impl Into<String>) -> Self {
881        Answer::Text(Value::Single(s.into()))
882    }
883
884    /// Helper method to create a number answer
885    pub fn number(n: f64) -> Self {
886        Answer::Number(Value::Single(n))
887    }
888
889    /// Helper method to create a boolean answer
890    pub fn boolean(b: bool) -> Self {
891        Answer::Boolean(Value::Single(b))
892    }
893
894    /// Helper method to create an integer answer
895    pub fn integer(n: i64) -> Self {
896        Answer::Integer(n)
897    }
898
899    /// Convert a date prompt result into the appropriate answer type.
900    ///
901    /// With the `datetime` feature enabled this returns [`Answer::Date`].
902    /// Without it, date prompts keep their historical string representation.
903    pub fn from_date_input(s: String) -> Result<Self, crate::Error> {
904        #[cfg(feature = "datetime")]
905        {
906            let d = NaiveDate::parse_from_str(&s, "%Y-%m-%d")
907                .map_err(|e| crate::Error::Validation(format!("invalid date '{s}': {e}")))?;
908            Ok(Answer::Date(d))
909        }
910        #[cfg(not(feature = "datetime"))]
911        {
912            Ok(Answer::Text(Value::Single(s)))
913        }
914    }
915
916    /// Convert a datetime prompt result into the appropriate answer type.
917    ///
918    /// With the `datetime` feature enabled this returns [`Answer::DateTime`].
919    /// Without it, datetime prompts keep their historical string representation.
920    pub fn from_datetime_input(s: String) -> Result<Self, crate::Error> {
921        #[cfg(feature = "datetime")]
922        {
923            let dt = NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S")
924                .or_else(|_| NaiveDateTime::parse_from_str(&s, "%Y-%m-%dT%H:%M:%S"))
925                .map_err(|e| crate::Error::Validation(format!("invalid datetime '{s}': {e}")))?;
926            Ok(Answer::DateTime(dt))
927        }
928        #[cfg(not(feature = "datetime"))]
929        {
930            Ok(Answer::Text(Value::Single(s)))
931        }
932    }
933
934    /// Convert a timezone-aware datetime prompt result into a typed answer.
935    #[cfg(feature = "datetime-tz")]
936    pub fn from_datetimetz_input(s: String) -> Result<Self, crate::Error> {
937        let dt = DateTime::parse_from_rfc3339(&s)
938            .map_err(|e| crate::Error::Validation(format!("invalid datetimetz '{s}': {e}")))?;
939        Ok(Answer::DateTimeTz(dt))
940    }
941
942    /// Convert file picker results into a path answer matching picker mode.
943    pub fn from_file_picker_results(results: Vec<String>, multi_select: bool) -> Self {
944        if multi_select {
945            Answer::Paths(results.into_iter().map(PathBuf::from).collect())
946        } else {
947            Answer::Path(
948                results
949                    .into_iter()
950                    .next()
951                    .map(PathBuf::from)
952                    .unwrap_or_default(),
953            )
954        }
955    }
956
957    /// Extract a single string value from this answer
958    ///
959    /// # Errors
960    ///
961    /// Returns an error if the answer is not a Text variant with a Single value
962    ///
963    /// # Examples
964    ///
965    /// ```
966    /// use zenquirer_core::Answer;
967    ///
968    /// let answer = Answer::from("Rust");
969    /// assert_eq!(answer.as_string().unwrap(), "Rust");
970    /// ```
971    pub fn as_string(&self) -> Result<&str, crate::Error> {
972        match self {
973            Answer::Text(Value::Single(s)) => Ok(s.as_str()),
974            Answer::Text(Value::Multiple(_)) => Err(crate::Error::Validation(
975                "Expected single string, got multiple strings".to_string(),
976            )),
977            _ => Err(crate::Error::Validation(format!(
978                "Expected string, got {}",
979                self.type_name()
980            ))),
981        }
982    }
983
984    /// Extract multiple string values from this answer
985    ///
986    /// # Errors
987    ///
988    /// Returns an error if the answer is not a Text variant with Multiple values
989    ///
990    /// # Examples
991    ///
992    /// ```
993    /// use zenquirer_core::Answer;
994    ///
995    /// let answer = Answer::from(vec!["Git", "Docker"]);
996    /// assert_eq!(answer.as_strings().unwrap(), &["Git", "Docker"]);
997    /// ```
998    pub fn as_strings(&self) -> Result<&[String], crate::Error> {
999        match self {
1000            Answer::Text(Value::Multiple(v)) => Ok(v.as_slice()),
1001            Answer::Text(Value::Single(_)) => Err(crate::Error::Validation(
1002                "Expected multiple strings, got single string".to_string(),
1003            )),
1004            _ => Err(crate::Error::Validation(format!(
1005                "Expected strings, got {}",
1006                self.type_name()
1007            ))),
1008        }
1009    }
1010
1011    /// Extract a single number value from this answer
1012    ///
1013    /// # Errors
1014    ///
1015    /// Returns an error if the answer is not a Number variant with a Single value
1016    ///
1017    /// # Examples
1018    ///
1019    /// ```
1020    /// use zenquirer_core::Answer;
1021    ///
1022    /// let answer = Answer::from(42.0_f64);
1023    /// assert_eq!(answer.as_number().unwrap(), 42.0);
1024    /// ```
1025    pub fn as_number(&self) -> Result<f64, crate::Error> {
1026        match self {
1027            Answer::Number(Value::Single(n)) => Ok(*n),
1028            Answer::Number(Value::Multiple(_)) => Err(crate::Error::Validation(
1029                "Expected single number, got multiple numbers".to_string(),
1030            )),
1031            _ => Err(crate::Error::Validation(format!(
1032                "Expected number, got {}",
1033                self.type_name()
1034            ))),
1035        }
1036    }
1037
1038    /// Extract multiple number values from this answer
1039    ///
1040    /// # Errors
1041    ///
1042    /// Returns an error if the answer is not a Number variant with Multiple values
1043    ///
1044    /// # Examples
1045    ///
1046    /// ```
1047    /// use zenquirer_core::Answer;
1048    ///
1049    /// let answer = Answer::from(vec![1.0, 2.0, 3.0]);
1050    /// assert_eq!(answer.as_numbers().unwrap(), &[1.0, 2.0, 3.0]);
1051    /// ```
1052    pub fn as_numbers(&self) -> Result<&[f64], crate::Error> {
1053        match self {
1054            Answer::Number(Value::Multiple(v)) => Ok(v.as_slice()),
1055            Answer::Number(Value::Single(_)) => Err(crate::Error::Validation(
1056                "Expected multiple numbers, got single number".to_string(),
1057            )),
1058            _ => Err(crate::Error::Validation(format!(
1059                "Expected numbers, got {}",
1060                self.type_name()
1061            ))),
1062        }
1063    }
1064
1065    /// Extract a single boolean value from this answer
1066    ///
1067    /// # Errors
1068    ///
1069    /// Returns an error if the answer is not a Boolean variant with a Single value
1070    ///
1071    /// # Examples
1072    ///
1073    /// ```
1074    /// use zenquirer_core::Answer;
1075    ///
1076    /// let answer = Answer::from(true);
1077    /// assert_eq!(answer.as_bool().unwrap(), true);
1078    /// ```
1079    pub fn as_bool(&self) -> Result<bool, crate::Error> {
1080        match self {
1081            Answer::Boolean(Value::Single(b)) => Ok(*b),
1082            Answer::Boolean(Value::Multiple(_)) => Err(crate::Error::Validation(
1083                "Expected single boolean, got multiple booleans".to_string(),
1084            )),
1085            _ => Err(crate::Error::Validation(format!(
1086                "Expected boolean, got {}",
1087                self.type_name()
1088            ))),
1089        }
1090    }
1091
1092    /// Extract multiple boolean values from this answer
1093    ///
1094    /// # Errors
1095    ///
1096    /// Returns an error if the answer is not a Boolean variant with Multiple values
1097    ///
1098    /// # Examples
1099    ///
1100    /// ```
1101    /// use zenquirer_core::Answer;
1102    ///
1103    /// let answer = Answer::from(vec![true, false, true]);
1104    /// assert_eq!(answer.as_bools().unwrap(), &[true, false, true]);
1105    /// ```
1106    pub fn as_bools(&self) -> Result<&[bool], crate::Error> {
1107        match self {
1108            Answer::Boolean(Value::Multiple(v)) => Ok(v.as_slice()),
1109            Answer::Boolean(Value::Single(_)) => Err(crate::Error::Validation(
1110                "Expected multiple booleans, got single boolean".to_string(),
1111            )),
1112            _ => Err(crate::Error::Validation(format!(
1113                "Expected booleans, got {}",
1114                self.type_name()
1115            ))),
1116        }
1117    }
1118
1119    /// Extract a key-value map from this answer
1120    ///
1121    /// # Errors
1122    ///
1123    /// Returns an error if the answer is not a KeyValue variant
1124    ///
1125    /// # Examples
1126    ///
1127    /// ```
1128    /// use zenquirer_core::Answer;
1129    /// use std::collections::HashMap;
1130    ///
1131    /// let mut map = HashMap::new();
1132    /// map.insert("host".to_string(), Answer::from("localhost"));
1133    /// let answer = Answer::KeyValue(map);
1134    /// assert!(answer.as_keyvalue().is_ok());
1135    /// ```
1136    pub fn as_keyvalue(&self) -> Result<&HashMap<String, Answer>, crate::Error> {
1137        match self {
1138            Answer::KeyValue(map) => Ok(map),
1139            _ => Err(crate::Error::Validation(format!(
1140                "Expected key-value, got {}",
1141                self.type_name()
1142            ))),
1143        }
1144    }
1145
1146    /// Check if this answer is null
1147    ///
1148    /// # Examples
1149    ///
1150    /// ```
1151    /// use zenquirer_core::Answer;
1152    ///
1153    /// let answer = Answer::Null;
1154    /// assert!(answer.is_null());
1155    ///
1156    /// let answer = Answer::from("test");
1157    /// assert!(!answer.is_null());
1158    /// ```
1159    pub fn is_null(&self) -> bool {
1160        matches!(self, Answer::Null)
1161    }
1162
1163    /// Extract a calendar date from this answer (requires `datetime` feature)
1164    #[cfg(feature = "datetime")]
1165    pub fn as_date(&self) -> Result<NaiveDate, crate::Error> {
1166        match self {
1167            Answer::Date(d) => Ok(*d),
1168            _ => Err(crate::Error::Validation(format!(
1169                "Expected date, got {}",
1170                self.type_name()
1171            ))),
1172        }
1173    }
1174
1175    /// Extract a naive (timezone-less) datetime from this answer (requires `datetime` feature)
1176    #[cfg(feature = "datetime")]
1177    pub fn as_datetime(&self) -> Result<NaiveDateTime, crate::Error> {
1178        match self {
1179            Answer::DateTime(dt) => Ok(*dt),
1180            _ => Err(crate::Error::Validation(format!(
1181                "Expected datetime, got {}",
1182                self.type_name()
1183            ))),
1184        }
1185    }
1186
1187    /// Extract a fixed-offset datetime from this answer (requires `datetime-tz` feature)
1188    #[cfg(feature = "datetime-tz")]
1189    pub fn as_datetime_tz(&self) -> Result<DateTime<FixedOffset>, crate::Error> {
1190        match self {
1191            Answer::DateTimeTz(dt) => Ok(*dt),
1192            _ => Err(crate::Error::Validation(format!(
1193                "Expected datetimetz, got {}",
1194                self.type_name()
1195            ))),
1196        }
1197    }
1198
1199    /// Extract a single filesystem path from this answer
1200    pub fn as_path(&self) -> Result<&Path, crate::Error> {
1201        match self {
1202            Answer::Path(p) => Ok(p.as_path()),
1203            _ => Err(crate::Error::Validation(format!(
1204                "Expected path, got {}",
1205                self.type_name()
1206            ))),
1207        }
1208    }
1209
1210    /// Extract multiple filesystem paths from this answer
1211    pub fn as_paths(&self) -> Result<&[PathBuf], crate::Error> {
1212        match self {
1213            Answer::Paths(paths) => Ok(paths.as_slice()),
1214            _ => Err(crate::Error::Validation(format!(
1215                "Expected paths, got {}",
1216                self.type_name()
1217            ))),
1218        }
1219    }
1220
1221    /// Extract a 64-bit signed integer from this answer
1222    pub fn as_integer(&self) -> Result<i64, crate::Error> {
1223        match self {
1224            Answer::Integer(n) => Ok(*n),
1225            _ => Err(crate::Error::Validation(format!(
1226                "Expected integer, got {}",
1227                self.type_name()
1228            ))),
1229        }
1230    }
1231
1232    /// Get a human-readable type name for this answer
1233    pub(crate) fn type_name(&self) -> &'static str {
1234        match self {
1235            Answer::Text(Value::Single(_)) => "single string",
1236            Answer::Text(Value::Multiple(_)) => "multiple strings",
1237            Answer::Number(Value::Single(_)) => "single number",
1238            Answer::Number(Value::Multiple(_)) => "multiple numbers",
1239            Answer::Boolean(Value::Single(_)) => "single boolean",
1240            Answer::Boolean(Value::Multiple(_)) => "multiple booleans",
1241            Answer::KeyValue(_) => "key-value",
1242            Answer::Null => "null",
1243            #[cfg(feature = "datetime")]
1244            Answer::Date(_) => "date",
1245            #[cfg(feature = "datetime")]
1246            Answer::DateTime(_) => "datetime",
1247            #[cfg(feature = "datetime-tz")]
1248            Answer::DateTimeTz(_) => "datetimetz",
1249            Answer::Path(_) => "path",
1250            Answer::Paths(_) => "paths",
1251            Answer::Integer(_) => "integer",
1252        }
1253    }
1254}
1255
1256#[cfg(test)]
1257mod plain_serde_tests {
1258    use super::*;
1259
1260    fn roundtrip(answer: &Answer) -> Answer {
1261        let json = serde_json::to_string(answer).expect("serialize");
1262        serde_json::from_str(&json).expect("deserialize")
1263    }
1264
1265    #[test]
1266    fn primitives_serialize_bare() {
1267        assert_eq!(
1268            serde_json::to_string(&Answer::from("hi")).unwrap(),
1269            r#""hi""#
1270        );
1271        assert_eq!(serde_json::to_string(&Answer::from(42.0)).unwrap(), "42.0");
1272        assert_eq!(serde_json::to_string(&Answer::from(true)).unwrap(), "true");
1273        assert_eq!(serde_json::to_string(&Answer::Null).unwrap(), "null");
1274    }
1275
1276    #[test]
1277    fn typed_variants_serialize_as_plain_values() {
1278        assert_eq!(serde_json::to_string(&Answer::Integer(42)).unwrap(), "42");
1279        assert_eq!(
1280            serde_json::to_string(&Answer::Path(PathBuf::from("/usr/local/bin/zenq"))).unwrap(),
1281            r#""/usr/local/bin/zenq""#
1282        );
1283        assert_eq!(
1284            serde_json::to_string(&Answer::Paths(vec![
1285                PathBuf::from("/a"),
1286                PathBuf::from("/b/c")
1287            ]))
1288            .unwrap(),
1289            r#"["/a","/b/c"]"#
1290        );
1291    }
1292
1293    #[test]
1294    fn plain_serialized_path_deserializes_as_text() {
1295        let a = Answer::Path(PathBuf::from("/usr/local/bin/zenq"));
1296        let json = serde_json::to_string(&a).unwrap();
1297        assert_eq!(json, r#""/usr/local/bin/zenq""#);
1298        assert_eq!(
1299            roundtrip(&a),
1300            Answer::Text(Value::Single("/usr/local/bin/zenq".to_string()))
1301        );
1302    }
1303
1304    #[test]
1305    fn plain_serialized_paths_deserialize_as_text_array() {
1306        let a = Answer::Paths(vec![PathBuf::from("/a"), PathBuf::from("/b/c")]);
1307        let json = serde_json::to_string(&a).unwrap();
1308        assert_eq!(json, r#"["/a","/b/c"]"#);
1309        assert_eq!(
1310            roundtrip(&a),
1311            Answer::Text(Value::Multiple(vec!["/a".to_string(), "/b/c".to_string()]))
1312        );
1313    }
1314
1315    #[cfg(feature = "datetime")]
1316    #[test]
1317    fn date_serializes_as_plain_string() {
1318        let d = NaiveDate::from_ymd_opt(2025, 12, 31).unwrap();
1319        let a = Answer::Date(d);
1320        let json = serde_json::to_string(&a).unwrap();
1321        assert_eq!(json, r#""2025-12-31""#);
1322        assert_eq!(
1323            roundtrip(&a),
1324            Answer::Text(Value::Single("2025-12-31".to_string()))
1325        );
1326    }
1327
1328    #[cfg(feature = "datetime")]
1329    #[test]
1330    fn datetime_serializes_as_plain_string() {
1331        let dt = NaiveDate::from_ymd_opt(2025, 12, 31)
1332            .unwrap()
1333            .and_hms_opt(23, 59, 59)
1334            .unwrap();
1335        let a = Answer::DateTime(dt);
1336        let json = serde_json::to_string(&a).unwrap();
1337        assert_eq!(json, r#""2025-12-31T23:59:59""#);
1338        assert_eq!(
1339            roundtrip(&a),
1340            Answer::Text(Value::Single("2025-12-31T23:59:59".to_string()))
1341        );
1342    }
1343
1344    #[cfg(feature = "datetime-tz")]
1345    #[test]
1346    fn datetimetz_serializes_as_plain_string() {
1347        let dt = DateTime::parse_from_rfc3339("2025-12-31T23:59:59-05:00").unwrap();
1348        let a = Answer::DateTimeTz(dt);
1349        let json = serde_json::to_string(&a).unwrap();
1350        assert!(json.starts_with(r#""2025-12-31T23:59:59"#));
1351        assert!(matches!(roundtrip(&a), Answer::Text(Value::Single(_))));
1352    }
1353
1354    #[test]
1355    fn keyvalue_with_type_and_value_keys_stays_keyvalue() {
1356        let mut map = HashMap::new();
1357        map.insert("type".to_string(), Answer::from("integer"));
1358        map.insert("value".to_string(), Answer::from(42.0));
1359        let a = Answer::KeyValue(map);
1360        let rt = roundtrip(&a);
1361        match rt {
1362            Answer::KeyValue(m) => {
1363                assert_eq!(m.get("type").unwrap().as_string().unwrap(), "integer");
1364                assert_eq!(m.get("value").unwrap().as_number().unwrap(), 42.0);
1365            }
1366            other => panic!("expected KeyValue, got {other:?}"),
1367        }
1368    }
1369
1370    #[test]
1371    fn answers_collection_serializes_plain_values() {
1372        let answers = Answers::new()
1373            .with_answer("name", Answer::from("Alice"))
1374            .with_answer("score", Answer::from(95.0))
1375            .with_answer("opt_in", Answer::from(true))
1376            .with_answer("config_file", Answer::Path(PathBuf::from("/etc/app.conf")));
1377
1378        let json = serde_json::to_string(&answers).unwrap();
1379        let restored: Answers = serde_json::from_str(&json).unwrap();
1380        assert_eq!(restored.get_as::<&str>("name").unwrap(), "Alice");
1381        assert_eq!(restored.get_as::<f64>("score").unwrap(), 95.0);
1382        assert!(restored.get_as::<bool>("opt_in").unwrap());
1383        assert_eq!(
1384            restored.get_as::<&str>("config_file").unwrap(),
1385            "/etc/app.conf"
1386        );
1387    }
1388
1389    #[cfg(feature = "datetime-tz")]
1390    #[test]
1391    fn datetimetz_extraction_requires_typed_runtime_answer() {
1392        let dt = DateTime::parse_from_rfc3339("2025-12-31T23:59:59-05:00").unwrap();
1393        let answers = Answers::new().with_answer("deadline", Answer::DateTimeTz(dt));
1394        assert_eq!(
1395            answers.get_as::<DateTime<FixedOffset>>("deadline").unwrap(),
1396            dt
1397        );
1398    }
1399
1400    #[test]
1401    fn integer_serializes_as_plain_number() {
1402        let a = Answer::Integer(42);
1403        let json = serde_json::to_string(&a).unwrap();
1404        assert_eq!(json, "42");
1405        assert_eq!(roundtrip(&a), Answer::Number(Value::Single(42.0)));
1406    }
1407
1408    #[test]
1409    fn integer_negative_and_extreme_values_serialize_as_numbers() {
1410        for n in [-1i64, 0, i64::MIN, i64::MAX] {
1411            let a = Answer::Integer(n);
1412            let json = serde_json::to_string(&a).unwrap();
1413            assert_eq!(json, n.to_string());
1414        }
1415    }
1416
1417    #[test]
1418    fn integer_extraction_requires_typed_runtime_answer() {
1419        let answers = Answers::new().with_answer("port", Answer::Integer(8080));
1420        let port: i64 = answers.get_as("port").unwrap();
1421        assert_eq!(port, 8080);
1422    }
1423
1424    #[test]
1425    fn get_as_supports_turbofish_and_inferred_types() {
1426        let answers = Answers::new()
1427            .with_answer("name", Answer::from("Alice"))
1428            .with_answer("enabled", Answer::from(true))
1429            .with_answer("tools", Answer::from(vec!["Git", "Docker"]));
1430
1431        let name: &str = answers.get_as("name").unwrap();
1432        let enabled = answers.get_as::<bool>("enabled").unwrap();
1433        let tools = answers.get_as::<&[String]>("tools").unwrap();
1434
1435        assert_eq!(name, "Alice");
1436        assert!(enabled);
1437        assert_eq!(tools, &["Git", "Docker"]);
1438    }
1439
1440    #[test]
1441    fn integer_from_int_literals() {
1442        // Integer types map to Answer::Integer; floats map to Answer::Number.
1443        assert!(matches!(Answer::from(42i32), Answer::Integer(42)));
1444        assert!(matches!(Answer::from(42i64), Answer::Integer(42)));
1445        assert!(matches!(Answer::from(42u32), Answer::Integer(42)));
1446        match Answer::from(42.0_f64) {
1447            Answer::Number(Value::Single(n)) => assert_eq!(n, 42.0),
1448            other => panic!("expected Number, got {other:?}"),
1449        }
1450    }
1451}