diff --git a/crates/rundown-converter/src/detect.rs b/crates/rundown-converter/src/detect.rs index aee87af..3c4d94a 100644 --- a/crates/rundown-converter/src/detect.rs +++ b/crates/rundown-converter/src/detect.rs @@ -1,6 +1,6 @@ use crate::{ model::*, - time::{clock, clock_range, duration, normalize, select_durations}, + time::{clock, clock_range, duration, normalize, select_duration_parts}, }; fn role(header: &str) -> Option<&'static str> { @@ -547,7 +547,7 @@ fn infer_inner( "Use strict, minimum, maximum, sum, margin or split", )); } - if duration_mode == "split" + if (profile.duration_split || duration_mode == "split") && profile .duration_separator .as_deref() @@ -667,10 +667,11 @@ fn infer_inner( "start" => clock_range(&cell).is_some(), "start_end" => clock_range(&cell).is_some_and(|(_, end)| end.is_some()), "end" => clock(&cell).is_some(), - _ => select_durations( + _ => select_duration_parts( &cell, unit.as_deref(), profile.duration_mode.as_deref(), + profile.duration_split, profile.duration_separator.as_deref(), ) .is_some(), @@ -696,6 +697,7 @@ fn infer_inner( duration_unit: unit, duration_mode: profile.duration_mode.clone(), duration_separator: profile.duration_separator.clone(), + duration_split: profile.duration_split, evidence: evidence.clone(), column_usage, column_labels, diff --git a/crates/rundown-converter/src/gui.rs b/crates/rundown-converter/src/gui.rs index 7a9b9e3..1580d20 100644 --- a/crates/rundown-converter/src/gui.rs +++ b/crates/rundown-converter/src/gui.rs @@ -69,12 +69,15 @@ fn duration_mode_label(mode: &str) -> &'static str { "maximum" => "Maximum", "sum" => "Sum", "margin" => "Add margin", - "split" => "Split into entries", _ => "Use the whole cell", } } fn duration_handling_controls(ui: &mut egui::Ui, profile: &mut Profile, id: egui::Id) { + if profile.duration_mode.as_deref() == Some("split") { + profile.duration_mode = Some("sum".into()); + profile.duration_split = true; + } ui.indent(id.with("indent"), |ui| { ui.horizontal_wrapped(|ui| { ui.weak("Duration handling"); @@ -91,7 +94,6 @@ fn duration_handling_controls(ui: &mut egui::Ui, profile: &mut Profile, id: egui ("maximum", "Maximum"), ("sum", "Sum"), ("margin", "Add margin"), - ("split", "Split into entries"), ] { ui.selectable_value(&mut mode, value.into(), label); } @@ -99,7 +101,8 @@ fn duration_handling_controls(ui: &mut egui::Ui, profile: &mut Profile, id: egui .response .on_hover_text("Choose how duration values are extracted when one cell contains several values. Add margin uses the largest value for the event and keeps the remainder as a gap."); profile.duration_mode = (mode != "strict").then_some(mode.clone()); - if mode == "split" { + ui.checkbox(&mut profile.duration_split, "Split into multiple entries"); + if profile.duration_split { let separator = profile .duration_separator .get_or_insert_with(|| "\\n".into()); @@ -567,7 +570,7 @@ impl App { self.decisions_changed(); } } - ui.label("Optional JSON profile: columns (start/start_end/end/duration/title), column_usage (notes/metadata/ignore), duration_unit, duration_mode, duration_separator, row_kinds, titles, starts, ends, durations, untimed_as_notes, ignore_warnings. Column letters and source rows are shown in diagnostics."); + ui.label("Optional JSON profile: columns (start/start_end/end/duration/title), column_usage (notes/metadata/ignore), duration_unit, duration_mode, duration_split, duration_separator, row_kinds, titles, starts, ends, durations, untimed_as_notes, ignore_warnings. Column letters and source rows are shown in diagnostics."); if ui .add( egui::TextEdit::multiline(&mut self.profile) diff --git a/crates/rundown-converter/src/gui/review.rs b/crates/rundown-converter/src/gui/review.rs index 0f7acca..4006964 100644 --- a/crates/rundown-converter/src/gui/review.rs +++ b/crates/rundown-converter/src/gui/review.rs @@ -593,6 +593,7 @@ fn column_settings_changed(current: &Profile, analyzed: &Profile) -> bool { || current.duration_unit != analyzed.duration_unit || current.duration_mode != analyzed.duration_mode || current.duration_separator != analyzed.duration_separator + || current.duration_split != analyzed.duration_split } fn schedule_settings_changed(current: &Profile, analyzed: &Profile) -> bool { @@ -3430,6 +3431,19 @@ mod tests { let profile: Profile = serde_json::from_str(&app.profile).unwrap(); assert_eq!(profile.duration_mode.as_deref(), Some("maximum")); assert!(app.dirty); + let labels = render(&mut app, &ctx, size, vec![]); + let toggle = labels + .iter() + .find(|(text, _)| text == "Split into multiple entries") + .unwrap() + .1 + .center(); + click_size(&mut app, &ctx, toggle, size); + let profile: Profile = serde_json::from_str(&app.profile).unwrap(); + assert!(profile.duration_split); + assert_eq!(profile.duration_mode.as_deref(), Some("maximum")); + let labels = render(&mut app, &ctx, size, vec![]); + assert!(labels.iter().any(|(text, _)| text == "Separator")); } #[test] diff --git a/crates/rundown-converter/src/model.rs b/crates/rundown-converter/src/model.rs index 51b46b2..04f491b 100644 --- a/crates/rundown-converter/src/model.rs +++ b/crates/rundown-converter/src/model.rs @@ -69,10 +69,12 @@ pub struct Profile { pub expected_headers: BTreeMap, /// minutes, seconds, hh:mm, mm:ss, or excel. pub duration_unit: Option, - /// strict, minimum, maximum, sum, margin, or split. + /// strict, minimum, maximum, sum, or margin (legacy split is accepted). pub duration_mode: Option, /// Separator used by split mode. Escaped forms such as \\n and \\t are accepted. pub duration_separator: Option, + #[serde(default)] + pub duration_split: bool, /// Explicitly retain rows without times as notes on the preceding event. pub untimed_as_notes: bool, /// Try excluding rows with unresolved-content warnings, then validate again. @@ -113,6 +115,8 @@ pub struct Mapping { pub duration_mode: Option, #[serde(default)] pub duration_separator: Option, + #[serde(default)] + pub duration_split: bool, pub evidence: Vec, #[serde(default)] pub column_usage: BTreeMap, diff --git a/crates/rundown-converter/src/pipeline.rs b/crates/rundown-converter/src/pipeline.rs index d148b2d..71f7fc5 100644 --- a/crates/rundown-converter/src/pipeline.rs +++ b/crates/rundown-converter/src/pipeline.rs @@ -1,7 +1,7 @@ use crate::{ detect, model::*, - time::{SelectedDurations, clock, clock_range, duration, normalize, select_durations}, + time::{SelectedDurations, clock, clock_range, duration, normalize, select_duration_parts}, }; use std::sync::atomic::{AtomicBool, Ordering}; use uuid::Uuid; @@ -53,13 +53,15 @@ fn duration_plan( .map(|value| SelectedDurations { events: vec![value], margin: 0, + margins: vec![], }) } else { map.duration.and_then(|c| { - select_durations( + select_duration_parts( &table.cell(row, c), map.duration_unit.as_deref(), profile.duration_mode.as_deref(), + profile.duration_split, profile.duration_separator.as_deref(), ) }) @@ -443,13 +445,13 @@ pub fn construct( 3, "SPLIT_MERGED_TIMING", at(table, r), - "A split duration cannot be combined with a merged timing block. Unmerge it or use Minimum, Maximum or Sum.", + "A split duration cannot be combined with a merged timing block. Unmerge it or disable Split into multiple entries.", )); continue; } let plan = duration_plan.as_ref().expect("checked above"); if let Some(end) = given_end { - let selected: i64 = plan.events.iter().sum(); + let selected: i64 = plan.events.iter().sum::() + plan.margin; if end - start != selected { errors.push(Diagnostic::new( 4, @@ -488,7 +490,19 @@ pub fn construct( .push("Start derived from the preceding virtual entry".into()); } result.entries.push(e); - part_start = part_end; + let margin = plan.margins.get(part).copied().unwrap_or(0); + if margin > 0 { + gaps.push(Gap { + after_row: Some(r + 1), + before_row: None, + start_ms: Some(part_end), + end_ms: Some(part_end + margin), + title: "Duration margin".into(), + source_rows: vec![source_row(table, r)], + display_timer: false, + }); + } + part_start = part_end + margin; } cursor = Some(part_start); continue; diff --git a/crates/rundown-converter/src/time.rs b/crates/rundown-converter/src/time.rs index d7e2b93..2d55307 100644 --- a/crates/rundown-converter/src/time.rs +++ b/crates/rundown-converter/src/time.rs @@ -83,6 +83,8 @@ pub struct SelectedDurations { pub events: Vec, /// Untimed interval inserted after the event or split entries. pub margin: i64, + /// Margin after each virtual entry when splitting. + pub margins: Vec, } fn separator(value: Option<&str>) -> &str { @@ -183,29 +185,11 @@ pub fn select_durations( return duration(cell, unit).map(|value| SelectedDurations { events: vec![value], margin: 0, + margins: vec![], }); } if mode == "split" { - let events: Vec = cell - .text - .split(separator(split_separator)) - .filter_map(|part| { - let lines: Vec> = part - .lines() - .map(|line| explicit_duration_values(line, unit)) - .filter(|values| !values.is_empty()) - .collect(); - let largest = lines.iter().map(Vec::len).max()?; - Some( - lines - .iter() - .filter(|values| values.len() == largest) - .flatten() - .sum(), - ) - }) - .collect(); - return (!events.is_empty()).then_some(SelectedDurations { events, margin: 0 }); + return select_duration_parts(cell, unit, Some("sum"), true, split_separator); } let groups: Vec> = cell .text @@ -226,14 +210,17 @@ pub fn select_durations( "minimum" => SelectedDurations { events: vec![*values.iter().min()?], margin: 0, + margins: vec![], }, "maximum" => SelectedDurations { events: vec![*values.iter().max()?], margin: 0, + margins: vec![], }, "sum" => SelectedDurations { events: vec![values.iter().sum()], margin: 0, + margins: vec![], }, "margin" => { let mut event = 0; @@ -246,12 +233,57 @@ pub fn select_durations( SelectedDurations { events: vec![event], margin, + margins: vec![], } } _ => return None, }; (!selected.events.is_empty()).then_some(selected) } +/// Apply the selected handling independently to each separated entry. +pub fn select_duration_parts( + cell: &Cell, + unit: Option<&str>, + mode: Option<&str>, + split: bool, + split_separator: Option<&str>, +) -> Option { + let legacy = mode == Some("split"); + let mode = if legacy { Some("sum") } else { mode }; + if !split && !legacy { + return select_durations(cell, unit, mode, None); + } + let separator = separator(split_separator); + if separator.is_empty() { + return None; + } + let mut result = SelectedDurations { + events: vec![], + margin: 0, + margins: vec![], + }; + for part in cell.text.split(separator) { + if part.trim().is_empty() + || clock_range(&Cell { + text: part.trim().into(), + ..Cell::default() + }) + .is_some_and(|(_, end)| end.is_some()) + { + continue; + } + let part = Cell { + text: part.into(), + ..cell.clone() + }; + let selected = select_durations(&part, unit, mode, None)?; + result.events.extend(selected.events); + result.margins.push(selected.margin); + result.margin += selected.margin; + } + (!result.events.is_empty()).then_some(result) +} + fn unsigned_duration(cell: &Cell, unit: Option<&str>) -> Option { let mut s = normalize(cell.text.trim()).replace(',', "."); if cell.numeric && cell.time_style { diff --git a/crates/rundown-converter/tests/conversion.rs b/crates/rundown-converter/tests/conversion.rs index b706412..09558f8 100644 --- a/crates/rundown-converter/tests/conversion.rs +++ b/crates/rundown-converter/tests/conversion.rs @@ -1343,3 +1343,58 @@ fn warning_policy_excludes_rows_rechecks_and_can_be_disabled() { assert!(!a.diagnostics.is_empty()); assert!(a.automatically_ignored_rows.is_empty()); } + +#[test] +fn split_combines_with_each_duration_policy_and_keeps_each_margin() { + let t = table(&[ + &["Start", "Duration", "Title"], + &["08:00", "20 min + 5 min\n10 min + 2 min", "Talks"], + ]); + for (mode, durations, margins) in [ + ("minimum", [5, 2], [0, 0]), + ("maximum", [20, 10], [0, 0]), + ("sum", [25, 12], [0, 0]), + ("margin", [20, 10], [5, 2]), + ] { + let profile = Profile { + duration_mode: Some(mode.into()), + duration_split: true, + ..Profile::default() + }; + let a = analyze(&t, &profile); + assert!(a.diagnostics.is_empty(), "{mode}: {:?}", a.diagnostics); + let r = a.rundown.unwrap(); + assert_eq!(r.entries.len(), 2); + assert_eq!(r.entries[0].duration_ms, durations[0] * 60_000); + assert_eq!(r.entries[1].duration_ms, durations[1] * 60_000); + assert_eq!( + r.entries[1].start_ms, + r.entries[0].end_ms + margins[0] * 60_000 + ); + if mode == "margin" { + assert_eq!(r.gaps.len(), 2); + for (gap, minutes) in r.gaps.iter().zip(margins) { + assert_eq!( + gap.end_ms.unwrap() - gap.start_ms.unwrap(), + minutes * 60_000 + ); + } + } + assert!(export::ontime(&r).is_ok()); + } + let mut invalid = t; + invalid.rows[1][1].text = "20 min\nunreadable duration".into(); + let a = analyze( + &invalid, + &Profile { + duration_mode: Some("maximum".into()), + duration_split: true, + ..Profile::default() + }, + ); + assert!( + a.diagnostics + .iter() + .any(|d| d.code == "INCONSISTENT_COLUMN_MEANING") + ); +} diff --git a/docs/rundown-converter-plan.md b/docs/rundown-converter-plan.md index 864ebe6..126231c 100644 --- a/docs/rundown-converter-plan.md +++ b/docs/rundown-converter-plan.md @@ -297,7 +297,7 @@ errors must remain visible with direct corrective actions. errors. Test ambiguous cells clarified by other rows, incompatible meanings in one column, structural rows and misleading headers/units. - [x] Keep one Duration column role while offering nested whole-cell, minimum, - maximum, sum, margin and split extraction policies. Let a Start mapping select + maximum, sum and margin extraction policies, plus an independent split toggle. Let a Start mapping select only the first clock in a mixed range; retain margin gaps and split entries in the IR. - [x] Stage 2: identify untimed gaps and populate draft IR constraints. Test named diff --git a/docs/rundown-converter.md b/docs/rundown-converter.md index 49a0f80..d02d513 100644 --- a/docs/rundown-converter.md +++ b/docs/rundown-converter.md @@ -122,8 +122,9 @@ visually distinct from labels and ordinary actions; the active tab uses the stro bounds. **Start** selects only the first clock from a cell, so a mixed `08h45 - 09h10` value can provide the 08:45 anchor while the selected duration column determines the timer. A duration column has a nested **Duration handling** - choice instead of extra column roles: whole cell, minimum, maximum, sum, add - margin or split into entries. Selecting one duration column explicitly resolves + choice instead of extra column roles: whole cell, minimum, maximum, sum or add + margin. A separate **Split into multiple entries** toggle applies that choice + to each separated group; Add margin then creates a gap after each entry. Selecting one duration column explicitly resolves duplicate TIMER headers. **Notes** appends a column's values to Ontime event notes. **Metadata** creates an Ontime custom field named from the source header. **Ignore** excludes @@ -264,7 +265,8 @@ Pass `--profile mapping.json`, or load/edit the same JSON in the desktop app: { "header_row": 1, "columns": {"start": "A", "duration": "B", "title": "G"}, - "duration_mode": "split", + "duration_mode": "maximum", + "duration_split": true, "duration_separator": "\\n\\n", "column_usage": {"C": "notes", "D": "metadata", "F": "ignore"}, "expected_headers": {"A": "Horaires", "B": "Durée"}, @@ -294,12 +296,14 @@ explicit mappings still undergo it. `duration_mode` is optional and remains attached to the single `duration` role. `minimum`, `maximum` and `sum` select from explicit duration values in mixed text. `margin` uses the largest value in each duration group for the event and preserves -the remainder as an untimed gap. `split` creates sequential virtual events from -groups separated by `duration_separator`; `\\n`, `\\n\\n` and `\\t` mean newline, +the remainder as an untimed gap. `duration_split: true` creates sequential virtual +events and applies the selected handling to each group separated by +`duration_separator`; `\\n`, `\\n\\n` and `\\t` mean newline, blank line and tab. The default `strict` behavior requires the complete cell to be one duration. For non-split policies, a one-value summary line followed by a more detailed multi-value line is treated as an alternative expression, avoiding double -counting. +counting. Legacy profiles using `duration_mode: "split"` are read as Sum with +splitting enabled. `column_usage` maps column letters to `notes`, `metadata` or `ignore`. Every choice prevents that column from being inferred as a start, start–end, end, duration or