399 lines
13 KiB
Rust
399 lines
13 KiB
Rust
use serde_derive::{Deserialize, Serialize};
|
|
|
|
#[derive(
|
|
Debug, Default, Clone, Serialize, Deserialize, bincode::Decode, bincode::Encode, PartialEq,
|
|
)]
|
|
pub struct BatchInfo {
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub filename: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub description: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub author: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub comment: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub url: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub date: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub processed_by: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub redacted_by: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub copyright: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub theme: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub kind: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub source: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub rating: String,
|
|
}
|
|
|
|
#[derive(
|
|
Debug, Default, Clone, Serialize, Deserialize, bincode::Decode, bincode::Encode, PartialEq,
|
|
)]
|
|
pub struct Question {
|
|
#[serde(default, skip_serializing_if = "u32_is_zero")]
|
|
pub num: u32,
|
|
pub id: String,
|
|
|
|
pub description: String,
|
|
pub answer: String,
|
|
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub author: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub comment: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub comment1: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub tour: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub url: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub date: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub processed_by: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub redacted_by: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub copyright: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub theme: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub kind: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub source: String,
|
|
#[serde(default, skip_serializing_if = "String::is_empty")]
|
|
pub rating: String,
|
|
#[serde(default, skip_serializing_if = "BatchInfo::is_default")]
|
|
pub batch_info: BatchInfo,
|
|
}
|
|
|
|
fn u32_is_zero(num: &u32) -> bool {
|
|
*num == 0
|
|
}
|
|
|
|
impl BatchInfo {
|
|
pub fn is_default(&self) -> bool {
|
|
*self == BatchInfo::default()
|
|
}
|
|
}
|
|
|
|
#[cfg(any(feature = "convert", feature = "convert_async"))]
|
|
pub mod convert_common {
|
|
use super::{BatchInfo, Question};
|
|
use crate::source::{SourceQuestion, SourceQuestionsBatch};
|
|
|
|
macro_rules! make {
|
|
($Target:ident; by {$($field:ident),+}; from $src:expr) => {$Target {$(
|
|
$field: $src.$field
|
|
),+}};
|
|
($Target:ident; with defaults and by {$($field:ident),+}; from $src:expr) => {$Target {$(
|
|
$field: $src.$field
|
|
),+ ,..$Target::default()}}
|
|
}
|
|
|
|
impl From<SourceQuestion> for Question {
|
|
fn from(src: SourceQuestion) -> Self {
|
|
make! {Self; with defaults and by {
|
|
num, id, description, answer, author, comment, comment1, tour, url,
|
|
date, processed_by, redacted_by, copyright, theme, kind, source, rating
|
|
}; from src}
|
|
}
|
|
}
|
|
|
|
impl From<SourceQuestionsBatch> for BatchInfo {
|
|
fn from(src: SourceQuestionsBatch) -> Self {
|
|
make! {Self; by {
|
|
filename, description, author, comment, url, date,
|
|
processed_by, redacted_by, copyright, theme, kind, source, rating
|
|
}; from src}
|
|
}
|
|
}
|
|
|
|
impl From<SourceQuestionsBatch> for Vec<Question> {
|
|
fn from(src: SourceQuestionsBatch) -> Self {
|
|
let mut src = src;
|
|
let mut questions: Vec<SourceQuestion> = vec![];
|
|
std::mem::swap(&mut src.questions, &mut questions);
|
|
let mut result: Vec<Question> = questions.into_iter().map(|item| item.into()).collect();
|
|
let batch_info = BatchInfo::from(src);
|
|
result.iter_mut().for_each(|question| {
|
|
question.batch_info = batch_info.clone();
|
|
});
|
|
|
|
result
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "convert")]
|
|
pub mod convert {
|
|
use super::Question;
|
|
use crate::source::SourceQuestionsBatch;
|
|
|
|
pub trait QuestionsConverter {
|
|
fn convert<'a>(&'a mut self) -> Box<dyn Iterator<Item = Question> + 'a>;
|
|
}
|
|
|
|
impl<T> QuestionsConverter for T
|
|
where
|
|
T: Iterator<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>,
|
|
{
|
|
fn convert<'a>(&'a mut self) -> Box<dyn Iterator<Item = Question> + 'a> {
|
|
let iter = self
|
|
.filter(|(_, data)| data.is_ok())
|
|
.flat_map(|(filename, data)| {
|
|
let mut batch = data.unwrap();
|
|
batch.filename = filename;
|
|
let questions: Vec<Question> = batch.into();
|
|
questions
|
|
});
|
|
Box::new(iter)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::questions::test::convert_common::sample_batch;
|
|
|
|
use super::*;
|
|
use insta::assert_yaml_snapshot;
|
|
use std::iter;
|
|
|
|
#[test]
|
|
fn test_convert() {
|
|
let mut source = iter::once((
|
|
String::from("test.json"),
|
|
Ok::<SourceQuestionsBatch, serde_json::Error>(sample_batch()),
|
|
));
|
|
let converted: Vec<_> = source.convert().collect();
|
|
assert_yaml_snapshot!(converted, @r#"
|
|
---
|
|
- id: Вопрос 1
|
|
description: Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2
|
|
answer: "42"
|
|
batch_info:
|
|
filename: test.json
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
- id: Вопрос 2
|
|
description: Зимой и летом одним цветом
|
|
answer: ёлка
|
|
batch_info:
|
|
filename: test.json
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
|
|
"#);
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "convert")]
|
|
pub use convert::QuestionsConverter;
|
|
|
|
#[cfg(feature = "convert_async")]
|
|
pub mod convert_async {
|
|
use futures::stream;
|
|
use futures_core::stream::Stream;
|
|
use futures_util::StreamExt;
|
|
|
|
use super::Question;
|
|
use crate::source::SourceQuestionsBatch;
|
|
|
|
pub struct QuestionsConverterAsync<T>
|
|
where
|
|
T: Stream<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>
|
|
+ std::marker::Unpin,
|
|
{
|
|
inner: T,
|
|
}
|
|
|
|
impl<T> From<T> for QuestionsConverterAsync<T>
|
|
where
|
|
T: Stream<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>
|
|
+ std::marker::Unpin,
|
|
{
|
|
fn from(inner: T) -> Self {
|
|
Self { inner }
|
|
}
|
|
}
|
|
|
|
pub trait QuestionsConverterAsyncForStream<T>
|
|
where
|
|
T: Stream<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>
|
|
+ std::marker::Unpin,
|
|
{
|
|
fn converter(&mut self) -> QuestionsConverterAsync<&mut T>;
|
|
}
|
|
|
|
impl<T> QuestionsConverterAsyncForStream<T> for T
|
|
where
|
|
T: Stream<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>
|
|
+ std::marker::Unpin,
|
|
{
|
|
fn converter(&mut self) -> QuestionsConverterAsync<&mut T> {
|
|
QuestionsConverterAsync::from(self)
|
|
}
|
|
}
|
|
|
|
impl<T> QuestionsConverterAsync<T>
|
|
where
|
|
T: Stream<Item = (String, Result<SourceQuestionsBatch, serde_json::Error>)>
|
|
+ std::marker::Unpin,
|
|
{
|
|
pub fn convert(self) -> impl Stream<Item = Question> {
|
|
self.inner
|
|
.filter_map(|(name, res)| async move {
|
|
if let Ok(item) = res {
|
|
Some((name, item))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.flat_map(|(filename, batch)| {
|
|
stream::iter({
|
|
let mut batch = batch;
|
|
batch.filename = filename;
|
|
let questions: Vec<Question> = batch.into();
|
|
questions
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::questions::test::convert_common::sample_batch;
|
|
|
|
use super::*;
|
|
use futures_util::{pin_mut, StreamExt};
|
|
use insta::assert_yaml_snapshot;
|
|
|
|
#[tokio::test]
|
|
async fn test_convert_stream() {
|
|
let source = futures::stream::once(async {
|
|
(
|
|
String::from("test.json"),
|
|
Ok::<SourceQuestionsBatch, serde_json::Error>(sample_batch()),
|
|
)
|
|
});
|
|
|
|
pin_mut!(source);
|
|
let converter = source.converter();
|
|
let converter = converter.convert();
|
|
let converted: Vec<_> = converter.collect().await;
|
|
assert_yaml_snapshot!(converted, @r#"
|
|
---
|
|
- id: Вопрос 1
|
|
description: Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2
|
|
answer: "42"
|
|
batch_info:
|
|
filename: test.json
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
- id: Вопрос 2
|
|
description: Зимой и летом одним цветом
|
|
answer: ёлка
|
|
batch_info:
|
|
filename: test.json
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
|
|
"#);
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "convert_async")]
|
|
pub use convert_async::{QuestionsConverterAsync, QuestionsConverterAsyncForStream};
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use insta::assert_yaml_snapshot;
|
|
use serde_json::json;
|
|
|
|
#[cfg(any(feature = "convert", feature = "convert_async"))]
|
|
pub mod convert_common {
|
|
use crate::source::{SourceQuestion, SourceQuestionsBatch};
|
|
|
|
pub fn sample_batch() -> SourceQuestionsBatch {
|
|
SourceQuestionsBatch {
|
|
description: "Тестовый".into(),
|
|
date: "00-000-2000".into(),
|
|
questions: vec![
|
|
SourceQuestion {
|
|
id: "Вопрос 1".into(),
|
|
description: "Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2".into(),
|
|
answer: "42".into(),
|
|
..Default::default()
|
|
},
|
|
SourceQuestion {
|
|
id: "Вопрос 2".into(),
|
|
description: "Зимой и летом одним цветом".into(),
|
|
answer: "ёлка".into(),
|
|
..Default::default()
|
|
},
|
|
],
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn sample_question() -> Question {
|
|
Question {
|
|
id: "Вопрос 1".into(),
|
|
description: "Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2".into(),
|
|
answer: "42".into(),
|
|
batch_info: BatchInfo {
|
|
description: "Тестовый".into(),
|
|
date: "00-000-2000".into(),
|
|
..Default::default()
|
|
},
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_question_ser() {
|
|
assert_yaml_snapshot!(sample_question(), @r#"
|
|
---
|
|
id: Вопрос 1
|
|
description: Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2
|
|
answer: "42"
|
|
batch_info:
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
|
|
"#);
|
|
}
|
|
#[test]
|
|
fn test_question_de() {
|
|
let question_from_json: Result<Question, _> = serde_json::from_value(json!({
|
|
"id": "Вопрос 1",
|
|
"description": "Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2",
|
|
"answer": "42",
|
|
"batch_info": {
|
|
"description": "Тестовый",
|
|
"date": "00-000-2000"
|
|
}
|
|
}));
|
|
assert!(question_from_json.is_ok());
|
|
|
|
assert_yaml_snapshot!(question_from_json.unwrap(), @r#"
|
|
---
|
|
id: Вопрос 1
|
|
description: Сколько будет (2 * 2 * 2 + 2) * 2 * 2 + 2
|
|
answer: "42"
|
|
batch_info:
|
|
description: Тестовый
|
|
date: 00-000-2000
|
|
|
|
"#);
|
|
}
|
|
}
|