GKaszewski/movies-diary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fmt
Some checks failed
CI / Check / Test / Build (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-05-13 23:38:57 +02:00
parent 7415b91e23
commit 19171806b9
142 changed files with 4140 additions and 2025 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
crates/adapters/importer/src/lib.rs
View File

@@ -15,9 +15,13 @@ impl DocumentParser for ImporterDocumentParser {
FileFormat::Json => parsers::parse_json(bytes),
FileFormat::Xlsx => {
#[cfg(feature = "xlsx")]
{ parsers::parse_xlsx(bytes) }
{
parsers::parse_xlsx(bytes)
}
#[cfg(not(feature = "xlsx"))]
{ Err(ImportError::Xlsx("XLSX support not compiled in".into())) }
{
Err(ImportError::Xlsx("XLSX support not compiled in".into()))
}
}
}
}

31
crates/adapters/importer/src/mapper.rs
View File

@@ -3,10 +3,16 @@ use domain::models::{
};
pub fn apply_mapping(file: &ParsedFile, mappings: &[FieldMapping]) -> Vec<AnnotatedRow> {
file.rows.iter().map(|row| {
let result = map_row(row, &file.columns, mappings);
AnnotatedRow { result, is_duplicate: false }
}).collect()
file.rows
.iter()
.map(|row| {
let result = map_row(row, &file.columns, mappings);
AnnotatedRow {
result,
is_duplicate: false,
}
})
.collect()
}
fn map_row(row: &[String], columns: &[String], mappings: &[FieldMapping]) -> RowResult {
@@ -39,7 +45,8 @@ fn map_row(row: &[String], columns: &[String], mappings: &[FieldMapping]) -> Row
if errors.is_empty() {
RowResult::Valid(import_row)
} else {
let raw = columns.iter()
let raw = columns
.iter()
.zip(row.iter())
.map(|(c, v)| (c.clone(), v.clone()))
.collect();
@@ -51,15 +58,13 @@ fn apply_transform(value: &str, transform: &Transform, errors: &mut Vec<String>)
match transform {
Transform::Identity => Some(value.to_string()),
Transform::DateFormat(_) => Some(value.to_string()),
Transform::RatingScale(factor) => {
match value.parse::<f64>() {
Ok(n) => Some((n * factor).round().to_string()),
Err(_) => {
errors.push(format!("rating '{}' is not a number", value));
None
}
Transform::RatingScale(factor) => match value.parse::<f64>() {
Ok(n) => Some((n * factor).round().to_string()),
Err(_) => {
errors.push(format!("rating '{}' is not a number", value));
None
}
}
},
}
}

13
crates/adapters/importer/src/parsers/csv.rs
View File

@@ -24,13 +24,12 @@ pub fn parse_csv(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
let rows: Vec<Vec<String>> = rdr
.records()
.map(|r| {
r.map_err(|e| ImportError::Csv(e.to_string()))
.map(|rec| {
let mut cells: Vec<String> = rec.iter().map(|f| f.trim().to_string()).collect();
cells.resize(columns.len(), String::new());
cells.truncate(columns.len());
cells
})
r.map_err(|e| ImportError::Csv(e.to_string())).map(|rec| {
let mut cells: Vec<String> = rec.iter().map(|f| f.trim().to_string()).collect();
cells.resize(columns.len(), String::new());
cells.truncate(columns.len());
cells
})
})
.collect::<Result<_, _>>()?;

21
crates/adapters/importer/src/parsers/json.rs
View File

@@ -2,17 +2,19 @@ use domain::models::{ImportError, ParsedFile};
use serde_json::Value;
pub fn parse_json(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
let value: Value = serde_json::from_slice(bytes)
.map_err(|e| ImportError::Json(e.to_string()))?;
let value: Value =
serde_json::from_slice(bytes).map_err(|e| ImportError::Json(e.to_string()))?;
let arr = value.as_array()
let arr = value
.as_array()
.ok_or_else(|| ImportError::Json("expected a JSON array".into()))?;
if arr.is_empty() {
return Err(ImportError::Empty);
}
let first = arr[0].as_object()
let first = arr[0]
.as_object()
.ok_or_else(|| ImportError::Json("array elements must be objects".into()))?;
let columns: Vec<String> = first.keys().cloned().collect();
@@ -20,12 +22,15 @@ pub fn parse_json(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
return Err(ImportError::NoHeader);
}
let rows: Vec<Vec<String>> = arr.iter()
let rows: Vec<Vec<String>> = arr
.iter()
.enumerate()
.map(|(idx, item)| {
let obj = item.as_object()
.ok_or_else(|| ImportError::Json(format!("element at index {} is not an object", idx)))?;
Ok(columns.iter()
let obj = item.as_object().ok_or_else(|| {
ImportError::Json(format!("element at index {} is not an object", idx))
})?;
Ok(columns
.iter()
.map(|col| obj.get(col).map(value_to_string).unwrap_or_default())
.collect())
})

19
crates/adapters/importer/src/parsers/xlsx.rs
View File

@@ -1,24 +1,27 @@
use calamine::{Reader, open_workbook_from_rs, Xlsx, Data};
use std::io::Cursor;
use calamine::{Data, Reader, Xlsx, open_workbook_from_rs};
use domain::models::{ImportError, ParsedFile};
use std::io::Cursor;
pub fn parse_xlsx(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
let cursor = Cursor::new(bytes);
let mut workbook: Xlsx<_> = open_workbook_from_rs(cursor)
.map_err(|e: calamine::XlsxError| ImportError::Xlsx(e.to_string()))?;
let sheet_name = workbook.sheet_names()
let sheet_name = workbook
.sheet_names()
.first()
.cloned()
.ok_or(ImportError::Empty)?;
let range = workbook.worksheet_range(&sheet_name)
let range = workbook
.worksheet_range(&sheet_name)
.map_err(|e| ImportError::Xlsx(e.to_string()))?;
let mut iter = range.rows();
let header = iter.next().ok_or(ImportError::NoHeader)?;
let columns: Vec<String> = header.iter()
let columns: Vec<String> = header
.iter()
.map(|c| cell_to_string(c).trim().to_string())
.collect();
@@ -46,7 +49,11 @@ fn cell_to_string(cell: &Data) -> String {
match cell {
Data::String(s) => s.clone(),
Data::Float(f) => {
if f.fract() == 0.0 { format!("{}", *f as i64) } else { format!("{}", f) }
if f.fract() == 0.0 {
format!("{}", *f as i64)
} else {
format!("{}", f)
}
}
Data::Int(i) => i.to_string(),
Data::Bool(b) => b.to_string(),

76
crates/adapters/importer/src/tests/mapper.rs
View File

@@ -14,9 +14,21 @@ fn sample_file() -> ParsedFile {
fn full_mappings() -> Vec<FieldMapping> {
vec![
FieldMapping { source_column: "Name".into(), domain_field: DomainField::Title, transform: Transform::Identity },
FieldMapping { source_column: "Stars".into(), domain_field: DomainField::Rating, transform: Transform::RatingScale(0.5) },
FieldMapping { source_column: "Date".into(), domain_field: DomainField::WatchedAt, transform: Transform::Identity },
FieldMapping {
source_column: "Name".into(),
domain_field: DomainField::Title,
transform: Transform::Identity,
},
FieldMapping {
source_column: "Stars".into(),
domain_field: DomainField::Rating,
transform: Transform::RatingScale(0.5),
},
FieldMapping {
source_column: "Date".into(),
domain_field: DomainField::WatchedAt,
transform: Transform::Identity,
},
]
}
@@ -51,9 +63,11 @@ fn marks_missing_required_fields_invalid() {
#[test]
fn ignores_unmapped_columns() {
let mappings = vec![
FieldMapping { source_column: "Name".into(), domain_field: DomainField::Title, transform: Transform::Identity },
];
let mappings = vec![FieldMapping {
source_column: "Name".into(),
domain_field: DomainField::Title,
transform: Transform::Identity,
}];
let file = ParsedFile {
columns: vec!["Name".into(), "Extra".into()],
rows: vec![vec!["Inception".into(), "ignored".into()]],
@@ -66,9 +80,11 @@ fn ignores_unmapped_columns() {
#[test]
fn nonexistent_source_column_skipped() {
let mappings = vec![
FieldMapping { source_column: "DoesNotExist".into(), domain_field: DomainField::Title, transform: Transform::Identity },
];
let mappings = vec![FieldMapping {
source_column: "DoesNotExist".into(),
domain_field: DomainField::Title,
transform: Transform::Identity,
}];
let file = ParsedFile {
columns: vec!["Name".into()],
rows: vec![vec!["Inception".into()]],
@@ -81,8 +97,16 @@ fn nonexistent_source_column_skipped() {
#[test]
fn collects_all_errors_not_just_first() {
let mappings = vec![
FieldMapping { source_column: "Name".into(), domain_field: DomainField::Title, transform: Transform::Identity },
FieldMapping { source_column: "Stars".into(), domain_field: DomainField::Rating, transform: Transform::RatingScale(0.5) },
FieldMapping {
source_column: "Name".into(),
domain_field: DomainField::Title,
transform: Transform::Identity,
},
FieldMapping {
source_column: "Stars".into(),
domain_field: DomainField::Rating,
transform: Transform::RatingScale(0.5),
},
// no watched_at mapping
];
let file = ParsedFile {
@@ -91,8 +115,16 @@ fn collects_all_errors_not_just_first() {
};
let results = apply_mapping(&file, &mappings);
if let RowResult::Invalid { errors, .. } = &results[0].result {
assert!(errors.iter().any(|e| e.contains("not a number")), "expected rating error, got: {:?}", errors);
assert!(errors.iter().any(|e| e.contains("watched_at")), "expected watched_at error, got: {:?}", errors);
assert!(
errors.iter().any(|e| e.contains("not a number")),
"expected rating error, got: {:?}",
errors
);
assert!(
errors.iter().any(|e| e.contains("watched_at")),
"expected watched_at error, got: {:?}",
errors
);
} else {
panic!("expected Invalid");
}
@@ -101,9 +133,21 @@ fn collects_all_errors_not_just_first() {
#[test]
fn non_numeric_rating_produces_error_in_row() {
let mappings = vec![
FieldMapping { source_column: "Name".into(), domain_field: DomainField::Title, transform: Transform::Identity },
FieldMapping { source_column: "Stars".into(), domain_field: DomainField::Rating, transform: Transform::RatingScale(0.5) },
FieldMapping { source_column: "Date".into(), domain_field: DomainField::WatchedAt, transform: Transform::Identity },
FieldMapping {
source_column: "Name".into(),
domain_field: DomainField::Title,
transform: Transform::Identity,
},
FieldMapping {
source_column: "Stars".into(),
domain_field: DomainField::Rating,
transform: Transform::RatingScale(0.5),
},
FieldMapping {
source_column: "Date".into(),
domain_field: DomainField::WatchedAt,
transform: Transform::Identity,
},
];
let file = ParsedFile {
columns: vec!["Name".into(), "Stars".into(), "Date".into()],