Fix tests

Author: dhardy

src/calculator.md

@@ -142,15 +142,15 @@ fn key_button_with(label: &str, key: Key) -> Button<AccessLabel> {
 Normally, access keys are only active while holding <kbd>Alt</kbd>. To avoid this requirement we call [`with_alt_bypass`]. Further, we disable <kbd>Tab</kbd> key navigation with [`without_nav_focus`] and ensure that the window can be closed with the <kbd>Esc</kbd> key.
 ```rust
 # extern crate kas;
-# use kas::{Widget, widgets::{label_any, Adapt}};
+# use kas::{Widget, widgets::{Label, Adapt}, window::Window};
 # #[derive(Debug)]
 # struct Calculator;
 # impl Calculator {
 #   fn new() -> Self { Calculator }
 #   fn handle(&mut self, _key: ()) {}
 # }
 # fn ui() -> impl Widget<Data = ()> {
-# let ui = label_any("");
+# let ui = Label::new_any("");
     Window::new(ui, "Calculator")
         .escapable()
         .with_alt_bypass()
@@ -166,7 +166,7 @@ We already saw column and row layouts. This time, we'll use [`grid!`] for layout
 # extern crate kas;
 # use kas::event::NamedKey;
 # use kas::prelude::*;
-# use kas::widgets::{AccessLabel, Button};
+# use kas::widgets::{AccessLabel, Button, grid};
 # type Key = kas::event::Key<kas::event::SmolStr>;
 # fn key_button(label: &str) -> Button<AccessLabel> {
 #     let string = AccessString::from(label);

src/config.md

@@ -32,6 +32,7 @@ Previously we adjusted the font size before the UI was started:
     let theme = kas::theme::SimpleTheme::new();
     let mut app = kas::runner::Runner::with_theme(theme).build(())?;
     let _ = app.config_mut().font.set_size(24.0);
+    # Ok(())
 # }
 ```
 

src/counter.md

@@ -78,7 +78,7 @@ Our user interface should be a widget tree: lets use a [`row!`] of buttons and a
 ```rust
 # extern crate kas;
 # use kas::prelude::*;
-# use kas::widgets::{format_value, Adapt, Button};
+# use kas::widgets::{Adapt, AdaptWidget, Button, column, format_value, row};
 # #[derive(Clone, Debug)]
 # struct Increment(i32);
 # fn counter() -> impl Widget<Data = ()> {
@@ -90,7 +90,7 @@ Our user interface should be a widget tree: lets use a [`row!`] of buttons and a
         format_value!("{}").align(AlignHints::CENTER),
         buttons.map_any(),
     ];
-    # let _ = tree;
+    # tree.with_state(0)
 # }
 ```
 

src/custom-widget.md

@@ -113,7 +113,7 @@ There are two types of child widgets: hidden layout-generated children and expli
 The first of these is a [`Text`] widget, passed `&self.count` as input data. The second is a [`Row`] widget over [`Button`]s over [`AccessLabel`]s. Since we didn't specify a data mapping for this second widget, it is is passed the `Count` widget's input data (`()`).
 
 Omitting `#[widget]` on a field which is a child widget is an error; sometimes the outer `#[widget]` attribute-macro will report the issue but not always. For example, if we omit the attribute on `buttons` and run, we get a backtrace like the following:
-```
+```ignore
 thread 'main' (413532) panicked at /path/to/kas/crates/kas-core/src/core/data.rs:123:13:
 WidgetStatus of #INVALID: require Configured, found New
 stack backtrace:
@@ -160,9 +160,8 @@ It is however required to define the associated type [`Widget::Data`]. Since it
 # #[derive(Clone, Debug)]
 # struct Increment(i32);
 # impl_scope! {
-#     #[widget{
-#         layout = "";
-#     }]
+#     #[widget]
+#     #[layout("")]
 #     struct Counter {
 #         core: widget_core!(),
 #         count: i32,
@@ -202,24 +201,11 @@ Don't worry about remembering each step; macro diagnostics should point you in t
 ### Aside: the type of child widgets
 
 Our `Counter` has two (explicit) child widgets, and we must specify the type of each:
-```rust
-# extern crate kas;
-# use kas::impl_scope;
-# use kas::widgets::{AccessLabel, Button, Row, Text};
-# impl_scope! {
-#     #[widget{
-#         Data = ();
-#         layout = "";
-#     }]
-#     struct Counter {
-#         core: widget_core!(),
+```rust,ignore
         #[widget(&self.count)]
         display: Text<i32, String>,
         #[widget]
         buttons: Row<[Button<AccessLabel>; 2]>,
-#         count: i32,
-#     }
-# }
 ```
 There is no real issue in this case, but widget types can get significantly harder to write than `Row<[Button<AccessLabel>; 2]>`. Worse, some widget types are impossible to write (e.g. the result of [`row!`] or widget generics instantiated with a closure). So what can we do instead?
 

src/sync-counter.md

@@ -70,38 +70,35 @@ fn main() -> kas::runner::Result<()> {
 In the previous example, our top-level `AppData` was `()` and our mutable state was stored in an [`Adapt`] widget. This time, we will store our counter in top-level `AppData`, in a custom type which includes a message handler:
 ```rust
 # extern crate kas;
-# use kas::{messages::MessageStack, Action};
+# use kas::{runner::MessageStack, Action};
 # #[derive(Clone, Debug)]
 # struct Increment(i32);
 
 #[derive(Clone, Copy, Debug)]
 struct Count(i32);
 
-impl kas::app::AppData for Count {
-    fn handle_messages(&mut self, messages: &mut MessageStack) -> Action {
+impl kas::runner::AppData for Count {
+    fn handle_messages(&mut self, messages: &mut kas::runner::MessageStack) {
         if let Some(Increment(add)) = messages.try_pop() {
             self.0 += add;
-            Action::UPDATE
-        } else {
-            Action::empty()
         }
     }
 }
 ```
-[`AppData::handle_messages`] is more verbose than [`Adapt::on_message`], but does the same job. The method notifies when widgets must be updated by returning [`Action::UPDATE`].
+[`AppData::handle_messages`] is more verbose than [`Adapt::on_message`], but does the same job.
 
 To integrate this into our example, we pass a `Count` object into [`kas::runner::Builder::build`] and adjust the prototype of `counter` to:
 ```rust
 # extern crate kas;
-# use kas::{messages::MessageStack, Action};
+# use kas::{runner::MessageStack, Action};
 # #[derive(Clone, Copy, Debug)]
 # struct Count(i32);
-# impl kas::app::AppData for Count {
-#     fn handle_messages(&mut self, messages: &mut MessageStack) -> Action { Action::empty() }
+# impl kas::runner::AppData for Count {
+#     fn handle_messages(&mut self, messages: &mut kas::runner::MessageStack) {}
 # }
 fn counter() -> impl kas::Widget<Data = Count> {
     // ...
-    # kas::widgets::label_any("")
+    # kas::widgets::Label::new_any("")
 }
 ```
 
@@ -122,18 +119,19 @@ Note that our local data includes a *copy* of the top-level data `Count` (along
 We'll skip right over the widget declarations to the new [`Adapt`] node:
 ```rust
 # extern crate kas;
-# use kas::widgets::{label_any, Adapt};
+# use kas::widgets::{Adapt, AdaptWidget, Label};
 # #[derive(Clone, Copy, Debug)]
 # struct Count(i32);
 # fn counter() -> impl kas::Widget<Data = Count> {
 # #[derive(Clone, Debug)]
 # struct SetValue(i32);
-# let ui = label_any("");
+# let ui = Label::new_any("");
 # let initial = (Count(0), 1);
     let ui = ui
         .with_state(initial)
         .on_update(|_, state, count| state.0 = *count)
         .on_message(|_, state, SetValue(v)| state.1 = v);
+    # ui
 # }
 ```
 The notable addition here is [`Adapt::on_update`], which takes a closure over the expected mutable reference to local `state` as well as *input* data `count` (i.e. the top-level data), allowing us to update local state with the latest top-level `count`.
@@ -147,16 +145,18 @@ Aside aside: could we not make [`Widget::Data`] into a Generic Associated Type (
 Constructing multiple windows under a UI runner is simple:
 ```rust
 # extern crate kas;
-# use kas::{messages::MessageStack, Action, Window};
+# use kas::{runner::MessageStack, Action, window::Window};
 # #[derive(Clone, Copy, Debug)]
 # struct Count(i32);
-# impl kas::app::AppData for Count {
-#     fn handle_messages(&mut self, messages: &mut MessageStack) -> Action { Action::empty() }
+# impl kas::runner::AppData for Count {
+#     fn handle_messages(&mut self, messages: &mut kas::runner::MessageStack) {}
 # }
-# fn counter() -> impl kas::Widget<Data = Count> {
-#     kas::widgets::label_any("")
+# fn counter(title: &str) -> Window<Count> {
+#     Window::new(kas::widgets::Label::new_any(""), title)
 # }
-# fn main() -> kas::app::Result<()> {
+# fn main() -> kas::runner::Result<()> {
+    # let count = Count(0);
+    # let theme = kas_wgpu::ShadedTheme::new();
     let mut runner = kas::runner::Runner::with_theme(theme).build(count)?;
     let _ = runner.config_mut().font.set_size(24.0);
     runner