Absorb stray Input-styled widget-dump cells when opening Manipulate notebooks (#450)

Wolfram Demonstrations Project source notebooks (the authoring copy
downloaded from demonstrations.wolfram.com) sometimes store an extra
Input-styled cell between the real Manipulate[...] source and its
cached Output — a leftover evaluation snapshot whose content is itself
a raw FrontEnd widget dump (DynamicModuleBox[...]), never meaningful
as code. editors_from_notebook only recognized Output/Print cells as
part of an Input cell's evaluation result, so this stray cell broke
the pairing: the real source lost its cached output (no live widget),
and the stray cell rendered as its own empty, broken "code" cell.

Treat an Input-styled cell whose content is itself a dynamic-box dump
the same as a stored Output when scanning forward from a source cell,
so it is absorbed into the widget instantiation instead of shown as
its own broken cell.

Author: ad-si

woxi-studio/src/main.rs

@@ -568,18 +568,27 @@ impl WoxiStudio {
           while i < cells.len() {
             let cell = &cells[i];
             if matches!(cell.style, CellStyle::Input | CellStyle::Code) {
-              // Collect following Output/Print cells
+              // Collect following Output/Print cells. Source notebooks
+              // downloaded from the Wolfram Demonstrations Project
+              // sometimes carry a stray *Input*-styled cell between the
+              // real source and its cached Output — a leftover evaluation
+              // snapshot whose content is itself a raw FrontEnd widget
+              // dump (`DynamicModuleBox[…]`), never meaningful as code.
+              // Treat such a cell the same as a stored Output so it is
+              // absorbed here instead of rendered as a broken, empty
+              // "code" cell of its own.
               let mut output = None;
               let mut stdout = None;
               let mut j = i + 1;
               while j < cells.len()
-                && matches!(
+                && (matches!(
                   cells[j].style,
                   CellStyle::Output | CellStyle::Print
-                )
+                ) || (cells[j].style == CellStyle::Input
+                  && is_dynamic_box_dump(&cells[j].content)))
               {
                 match cells[j].style {
-                  CellStyle::Output => {
+                  CellStyle::Output | CellStyle::Input => {
                     output = Some(cells[j].content.clone());
                   }
                   CellStyle::Print => {
@@ -7264,6 +7273,40 @@ Cell[BoxData["DynamicModuleBox[{$CellContext`a$$ = 1}, \"…\"]"], "Output"]
     );
   }
 
+  /// Wolfram Demonstrations Project "source" notebooks (the authoring
+  /// copy downloaded from demonstrations.wolfram.com, as opposed to the
+  /// deployed cloud embed) sometimes carry a stray *Input*-styled cell
+  /// between the real `Manipulate[…]` source and its cached Output — a
+  /// leftover evaluation snapshot whose content is itself a raw
+  /// FrontEnd widget dump (`DynamicModuleBox[…]`), never meaningful as
+  /// code. That extra cell must be absorbed rather than rendered as its
+  /// own broken, empty "code" cell, and must not be mistaken for the
+  /// real source when the live widget is instantiated.
+  #[test]
+  fn stray_input_styled_widget_dump_between_source_and_output_is_absorbed() {
+    let nb_src = r#"Notebook[{
+Cell[CellGroupData[{
+Cell[BoxData["Manipulate[x^2, {x, 1, 10}]"], "Input"],
+Cell[BoxData["DynamicModuleBox[{$CellContext`x$$ = 5}, \"…\"]"], "Input"],
+Cell[BoxData["DynamicModuleBox[{$CellContext`x$$ = 1}, \"…\"]"], "Output"]
+}, Open]]
+}]"#;
+    let nb = woxi::notebook::parse_notebook(nb_src).unwrap();
+    let editors = WoxiStudio::editors_from_notebook(&nb);
+    // The stray widget-dump Input cell is absorbed into the real source
+    // cell's editor, not rendered as its own (broken, empty) entry.
+    assert_eq!(editors.len(), 1);
+    let widget = editors[0]
+      .manipulate_state
+      .as_ref()
+      .expect("the stored Manipulate must instantiate on load");
+    assert!(
+      widget.error.is_none(),
+      "body must evaluate cleanly: {:?}",
+      widget.error
+    );
+  }
+
   /// A stored Manipulate whose body composes `Tooltip`-wrapped series
   /// (one built with `Table`, one with `NestList`/`Partition`) into a
   /// `ListLinePlot` with a `PlotLabel` assembled from `ToString`/