1use 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#[derive(Debug)]
40pub struct QuestionAnswer {
41 pub question_name: String,
42 pub value: Answer,
43}
44
45use std::sync::Arc;
46
47pub type AnswerFormatter = Arc<dyn Fn(&Answer) -> String + Send + Sync>;
52
53#[derive(Debug, Clone, PartialEq)]
58pub enum Value<T> {
59 Single(T),
61 Multiple(Vec<T>),
63}
64
65#[derive(Debug, Clone, PartialEq)]
99pub enum Answer {
100 Text(Value<String>),
102 Number(Value<f64>),
104 Boolean(Value<bool>),
106 KeyValue(HashMap<String, Answer>),
108 Null,
110 #[cfg(feature = "datetime")]
112 Date(NaiveDate),
113 #[cfg(feature = "datetime")]
115 DateTime(NaiveDateTime),
116 #[cfg(feature = "datetime-tz")]
118 DateTimeTz(DateTime<FixedOffset>),
119 Path(PathBuf),
121 Paths(Vec<PathBuf>),
123 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 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 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()))), _ => 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#[derive(Serialize, Deserialize, Clone, Debug, Default)]
256#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
257pub struct Answers(IndexMap<String, Answer>);
258
259impl Answers {
260 pub fn new() -> Self {
262 Self(IndexMap::new())
263 }
264
265 pub fn with_answer(mut self, name: impl Into<String>, value: Answer) -> Self {
267 self.insert(name, value);
268 self
269 }
270
271 pub fn insert(&mut self, name: impl Into<String>, value: Answer) -> Option<Answer> {
273 self.0.insert(name.into(), value)
274 }
275
276 pub fn get(&self, name: &str) -> Option<&Answer> {
278 self.0.get(name)
279 }
280
281 pub fn contains_key(&self, name: &str) -> bool {
283 self.0.contains_key(name)
284 }
285
286 pub fn iter(&self) -> indexmap::map::Iter<'_, String, Answer> {
288 self.0.iter()
289 }
290
291 pub fn len(&self) -> usize {
293 self.0.len()
294 }
295
296 pub fn is_empty(&self) -> bool {
298 self.0.is_empty()
299 }
300
301 pub fn as_inner(&self) -> &IndexMap<String, Answer> {
303 &self.0
304 }
305
306 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 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 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
563impl 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
604macro_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
617macro_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
630impl From<f64> for Answer {
632 fn from(value: f64) -> Self {
633 Answer::Number(Value::Single(value))
634 }
635}
636
637impl_integer_from!(i8, i16, i32, i64, u8, u16, u32);
639impl_float_from!(f32);
641
642impl 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
670impl 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
701impl 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 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 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 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 pub fn text(s: impl Into<String>) -> Self {
881 Answer::Text(Value::Single(s.into()))
882 }
883
884 pub fn number(n: f64) -> Self {
886 Answer::Number(Value::Single(n))
887 }
888
889 pub fn boolean(b: bool) -> Self {
891 Answer::Boolean(Value::Single(b))
892 }
893
894 pub fn integer(n: i64) -> Self {
896 Answer::Integer(n)
897 }
898
899 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 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 #[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 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 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 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 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 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 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 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 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 pub fn is_null(&self) -> bool {
1160 matches!(self, Answer::Null)
1161 }
1162
1163 #[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 #[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 #[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 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 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 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 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 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}