generate kcl examples in docs from macro (#1710)

* rearrange

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* examples

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix tests

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* recast

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* add more tests

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixups

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* add more samples

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* more docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* more

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* more samples

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* more

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixups

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixups

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* make serial

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix hang

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix import

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* atan

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* atan

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* make all tests pass

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* must have code balock

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* new docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* new docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

---------

Signed-off-by: Jess Frazelle <github@jessfraz.com>

src/wasm-lib/derive-docs/tests/array.gen

@@ -1,11 +1,94 @@
+#[cfg(test)]
+mod test_examples_show {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_show0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nshow");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_show1() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Show {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 pub(crate) const Show: Show = Show {};
 fn boxed_show(
     args: crate::std::Args,
@@ -25,11 +108,11 @@ impl crate::docs::StdLibFn for Show {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +151,24 @@ impl crate::docs::StdLibFn for Show {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec![
+            "This is another code block.\nyes sirrr.\nshow",
+            "This is code.\nIt does other shit.\nshow",
+        ];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_show
     }
@@ -77,6 +178,18 @@ impl crate::docs::StdLibFn for Show {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     show"]
+#[doc = r""]
+#[doc = r" ```"]
+#[doc = r" This is another code block."]
+#[doc = r" yes sirrr."]
+#[doc = r" show"]
+#[doc = r" ```"]
 fn inner_show(#[doc = r" The args to do shit to."] args: [f64; 2]) -> Result<Box<f64>> {
     args
 }

src/wasm-lib/derive-docs/tests/box.gen

@@ -1,11 +1,54 @@
+#[cfg(test)]
+mod test_examples_show {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_show0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Show {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 pub(crate) const Show: Show = Show {};
 fn boxed_show(
     args: crate::std::Args,
@@ -25,11 +68,11 @@ impl crate::docs::StdLibFn for Show {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +111,21 @@ impl crate::docs::StdLibFn for Show {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nshow"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_show
     }
@@ -77,6 +135,12 @@ impl crate::docs::StdLibFn for Show {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     show"]
 fn inner_show(#[doc = r" The args to do shit to."] args: Box<f64>) -> Box<f64> {
     args
 }

src/wasm-lib/derive-docs/tests/doc_comment_with_code.gen

@@ -0,0 +1,197 @@
+#[cfg(test)]
+mod test_examples_my_func {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_my_func0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nmyFunc");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_my_func1() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nmyFunc");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
+#[allow(non_camel_case_types, missing_docs)]
+#[doc = "Std lib function: myFunc\nThis is some function.\nIt does shit."]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
+#[ts(export)]
+pub(crate) struct MyFunc {}
+
+#[allow(non_upper_case_globals, missing_docs)]
+#[doc = "Std lib function: myFunc\nThis is some function.\nIt does shit."]
+pub(crate) const MyFunc: MyFunc = MyFunc {};
+fn boxed_my_func(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(my_func(args))
+}
+
+impl crate::docs::StdLibFn for MyFunc {
+    fn name(&self) -> String {
+        "myFunc".to_string()
+    }
+
+    fn summary(&self) -> String {
+        "This is some function.".to_string()
+    }
+
+    fn description(&self) -> String {
+        "It does shit.".to_string()
+    }
+
+    fn tags(&self) -> Vec<String> {
+        vec![]
+    }
+
+    fn args(&self) -> Vec<crate::docs::StdLibFnArg> {
+        let mut settings = schemars::gen::SchemaSettings::openapi3();
+        settings.inline_subschemas = true;
+        let mut generator = schemars::gen::SchemaGenerator::new(settings);
+        vec![crate::docs::StdLibFnArg {
+            name: "args".to_string(),
+            type_: "kittycad::types::InputFormat".to_string(),
+            schema: <Option<kittycad::types::InputFormat>>::json_schema(&mut generator),
+            required: false,
+        }]
+    }
+
+    fn return_value(&self) -> Option<crate::docs::StdLibFnArg> {
+        let mut settings = schemars::gen::SchemaSettings::openapi3();
+        settings.inline_subschemas = true;
+        let mut generator = schemars::gen::SchemaGenerator::new(settings);
+        Some(crate::docs::StdLibFnArg {
+            name: "".to_string(),
+            type_: "[SketchGroup]".to_string(),
+            schema: <Vec<SketchGroup>>::json_schema(&mut generator),
+            required: true,
+        })
+    }
+
+    fn unpublished(&self) -> bool {
+        false
+    }
+
+    fn deprecated(&self) -> bool {
+        false
+    }
+
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec![
+            "This is another code block.\nyes sirrr.\nmyFunc",
+            "This is code.\nIt does other shit.\nmyFunc",
+        ];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
+    fn std_lib_fn(&self) -> crate::std::StdFn {
+        boxed_my_func
+    }
+
+    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
+        Box::new(self.clone())
+    }
+}
+
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     myFunc"]
+#[doc = r""]
+#[doc = r" ```"]
+#[doc = r" This is another code block."]
+#[doc = r" yes sirrr."]
+#[doc = r" myFunc"]
+#[doc = r" ```"]
+fn inner_my_func(
+    #[doc = r" The args to do shit to."] args: Option<kittycad::types::InputFormat>,
+) -> Result<Vec<Box<SketchGroup>>> {
+    args
+}

src/wasm-lib/derive-docs/tests/doc_comment_with_code_on_ignored_function.gen

@@ -0,0 +1,199 @@
+#[cfg(test)]
+mod test_examples_import {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    #[ignore]
+    async fn serial_test_example_import0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nimport");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    #[ignore]
+    async fn serial_test_example_import1() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
+#[allow(non_camel_case_types, missing_docs)]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
+#[ts(export)]
+pub(crate) struct Import {}
+
+#[allow(non_upper_case_globals, missing_docs)]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
+pub(crate) const Import: Import = Import {};
+fn boxed_import(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(import(args))
+}
+
+impl crate::docs::StdLibFn for Import {
+    fn name(&self) -> String {
+        "import".to_string()
+    }
+
+    fn summary(&self) -> String {
+        "This is some function.".to_string()
+    }
+
+    fn description(&self) -> String {
+        "It does shit.".to_string()
+    }
+
+    fn tags(&self) -> Vec<String> {
+        vec![]
+    }
+
+    fn args(&self) -> Vec<crate::docs::StdLibFnArg> {
+        let mut settings = schemars::gen::SchemaSettings::openapi3();
+        settings.inline_subschemas = true;
+        let mut generator = schemars::gen::SchemaGenerator::new(settings);
+        vec![crate::docs::StdLibFnArg {
+            name: "args".to_string(),
+            type_: "kittycad::types::InputFormat".to_string(),
+            schema: <Option<kittycad::types::InputFormat>>::json_schema(&mut generator),
+            required: false,
+        }]
+    }
+
+    fn return_value(&self) -> Option<crate::docs::StdLibFnArg> {
+        let mut settings = schemars::gen::SchemaSettings::openapi3();
+        settings.inline_subschemas = true;
+        let mut generator = schemars::gen::SchemaGenerator::new(settings);
+        Some(crate::docs::StdLibFnArg {
+            name: "".to_string(),
+            type_: "[SketchGroup]".to_string(),
+            schema: <Vec<SketchGroup>>::json_schema(&mut generator),
+            required: true,
+        })
+    }
+
+    fn unpublished(&self) -> bool {
+        false
+    }
+
+    fn deprecated(&self) -> bool {
+        false
+    }
+
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec![
+            "This is another code block.\nyes sirrr.\nimport",
+            "This is code.\nIt does other shit.\nimport",
+        ];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
+    fn std_lib_fn(&self) -> crate::std::StdFn {
+        boxed_import
+    }
+
+    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
+        Box::new(self.clone())
+    }
+}
+
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     import"]
+#[doc = r""]
+#[doc = r" ```"]
+#[doc = r" This is another code block."]
+#[doc = r" yes sirrr."]
+#[doc = r" import"]
+#[doc = r" ```"]
+fn inner_import(
+    #[doc = r" The args to do shit to."] args: Option<kittycad::types::InputFormat>,
+) -> Result<Vec<Box<SketchGroup>>> {
+    args
+}

src/wasm-lib/derive-docs/tests/lineTo.gen

@@ -1,11 +1,94 @@
+#[cfg(test)]
+mod test_examples_line_to {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_line_to0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nlineTo");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_line_to1() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nlineTo");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: lineTo"]
+#[doc = "Std lib function: lineTo\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct LineTo {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: lineTo"]
+#[doc = "Std lib function: lineTo\nThis is some function.\nIt does shit."]
 pub(crate) const LineTo: LineTo = LineTo {};
 fn boxed_line_to(
     args: crate::std::Args,
@@ -25,11 +108,11 @@ impl crate::docs::StdLibFn for LineTo {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -76,6 +159,24 @@ impl crate::docs::StdLibFn for LineTo {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec![
+            "This is another code block.\nyes sirrr.\nlineTo",
+            "This is code.\nIt does other shit.\nlineTo",
+        ];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_line_to
     }
@@ -85,6 +186,18 @@ impl crate::docs::StdLibFn for LineTo {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     lineTo"]
+#[doc = r""]
+#[doc = r" ```"]
+#[doc = r" This is another code block."]
+#[doc = r" yes sirrr."]
+#[doc = r" lineTo"]
+#[doc = r" ```"]
 fn inner_line_to(
     data: LineToData,
     sketch_group: SketchGroup,

src/wasm-lib/derive-docs/tests/min.gen

@@ -1,11 +1,94 @@
+#[cfg(test)]
+mod test_examples_min {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_min0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nmin");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_min1() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nmin");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: min"]
+#[doc = "Std lib function: min\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Min {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: min"]
+#[doc = "Std lib function: min\nThis is some function.\nIt does shit."]
 pub(crate) const Min: Min = Min {};
 fn boxed_min(
     args: crate::std::Args,
@@ -25,11 +108,11 @@ impl crate::docs::StdLibFn for Min {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +151,24 @@ impl crate::docs::StdLibFn for Min {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec![
+            "This is another code block.\nyes sirrr.\nmin",
+            "This is code.\nIt does other shit.\nmin",
+        ];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_min
     }
@@ -77,6 +178,18 @@ impl crate::docs::StdLibFn for Min {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     min"]
+#[doc = r""]
+#[doc = r" ```"]
+#[doc = r" This is another code block."]
+#[doc = r" yes sirrr."]
+#[doc = r" min"]
+#[doc = r" ```"]
 fn inner_min(#[doc = r" The args to do shit to."] args: Vec<f64>) -> f64 {
     let mut min = std::f64::MAX;
     for arg in args.iter() {

src/wasm-lib/derive-docs/tests/option.gen

@@ -1,11 +1,54 @@
+#[cfg(test)]
+mod test_examples_show {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_show0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Show {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 pub(crate) const Show: Show = Show {};
 fn boxed_show(
     args: crate::std::Args,
@@ -25,11 +68,11 @@ impl crate::docs::StdLibFn for Show {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +111,21 @@ impl crate::docs::StdLibFn for Show {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nshow"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_show
     }
@@ -77,6 +135,12 @@ impl crate::docs::StdLibFn for Show {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     show"]
 fn inner_show(#[doc = r" The args to do shit to."] args: Option<f64>) -> Result<Box<f64>> {
     args
 }

src/wasm-lib/derive-docs/tests/option_input_format.gen

@@ -1,11 +1,55 @@
+#[cfg(test)]
+mod test_examples_import {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    #[ignore]
+    async fn serial_test_example_import0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Import {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 pub(crate) const Import: Import = Import {};
 fn boxed_import(
     args: crate::std::Args,
@@ -25,11 +69,11 @@ impl crate::docs::StdLibFn for Import {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +112,21 @@ impl crate::docs::StdLibFn for Import {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nimport"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_import
     }
@@ -77,6 +136,12 @@ impl crate::docs::StdLibFn for Import {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     import"]
 fn inner_import(
     #[doc = r" The args to do shit to."] args: Option<kittycad::types::InputFormat>,
 ) -> Result<Box<f64>> {

src/wasm-lib/derive-docs/tests/return_vec_box_sketch_group.gen

@@ -1,11 +1,55 @@
+#[cfg(test)]
+mod test_examples_import {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    #[ignore]
+    async fn serial_test_example_import0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Import {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 pub(crate) const Import: Import = Import {};
 fn boxed_import(
     args: crate::std::Args,
@@ -25,11 +69,11 @@ impl crate::docs::StdLibFn for Import {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +112,21 @@ impl crate::docs::StdLibFn for Import {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nimport"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_import
     }
@@ -77,6 +136,12 @@ impl crate::docs::StdLibFn for Import {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     import"]
 fn inner_import(
     #[doc = r" The args to do shit to."] args: Option<kittycad::types::InputFormat>,
 ) -> Result<Vec<Box<SketchGroup>>> {

src/wasm-lib/derive-docs/tests/return_vec_sketch_group.gen

@@ -1,11 +1,55 @@
+#[cfg(test)]
+mod test_examples_import {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    #[ignore]
+    async fn serial_test_example_import0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Import {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: import"]
+#[doc = "Std lib function: import\nThis is some function.\nIt does shit."]
 pub(crate) const Import: Import = Import {};
 fn boxed_import(
     args: crate::std::Args,
@@ -25,11 +69,11 @@ impl crate::docs::StdLibFn for Import {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +112,21 @@ impl crate::docs::StdLibFn for Import {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nimport"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_import
     }
@@ -77,6 +136,12 @@ impl crate::docs::StdLibFn for Import {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     import"]
 fn inner_import(
     #[doc = r" The args to do shit to."] args: Option<kittycad::types::InputFormat>,
 ) -> Result<Vec<SketchGroup>> {

src/wasm-lib/derive-docs/tests/show.gen

@@ -1,11 +1,54 @@
+#[cfg(test)]
+mod test_examples_show {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
+    async fn serial_test_example_show0() {
+        let user_agent = concat!(env!("CARGO_PKG_NAME"), ".rs/", env!("CARGO_PKG_VERSION"),);
+        let http_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60));
+        let ws_client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .timeout(std::time::Duration::from_secs(600))
+            .connect_timeout(std::time::Duration::from_secs(60))
+            .connection_verbose(true)
+            .tcp_keepalive(std::time::Duration::from_secs(600))
+            .http1_only();
+        let token = std::env::var("KITTYCAD_API_TOKEN").expect("KITTYCAD_API_TOKEN not set");
+        let client = kittycad::Client::new_from_reqwest(token, http_client, ws_client);
+        let ws = client
+            .modeling()
+            .commands_ws(None, None, None, None, None, Some(false))
+            .await
+            .unwrap();
+        let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow");
+        let parser = crate::parser::Parser::new(tokens);
+        let program = parser.ast().unwrap();
+        let mut mem: crate::executor::ProgramMemory = Default::default();
+        let ctx = crate::executor::ExecutorContext {
+            engine: std::sync::Arc::new(Box::new(
+                crate::engine::conn::EngineConnection::new(ws)
+                    .await
+                    .unwrap(),
+            )),
+            fs: crate::fs::FileManager::new(),
+            stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
+            units: kittycad::types::UnitLength::Mm,
+        };
+        crate::executor::execute(program, &mut mem, crate::executor::BodyType::Root, &ctx)
+            .await
+            .unwrap();
+    }
+}
+
 #[allow(non_camel_case_types, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars :: JsonSchema, ts_rs :: TS)]
 #[ts(export)]
 pub(crate) struct Show {}
 
 #[allow(non_upper_case_globals, missing_docs)]
-#[doc = "Std lib function: show"]
+#[doc = "Std lib function: show\nThis is some function.\nIt does shit."]
 pub(crate) const Show: Show = Show {};
 fn boxed_show(
     args: crate::std::Args,
@@ -25,11 +68,11 @@ impl crate::docs::StdLibFn for Show {
     }
 
     fn summary(&self) -> String {
-        "".to_string()
+        "This is some function.".to_string()
     }
 
     fn description(&self) -> String {
-        "".to_string()
+        "It does shit.".to_string()
     }
 
     fn tags(&self) -> Vec<String> {
@@ -68,6 +111,21 @@ impl crate::docs::StdLibFn for Show {
         false
     }
 
+    fn examples(&self) -> Vec<String> {
+        let code_blocks = vec!["This is code.\nIt does other shit.\nshow"];
+        code_blocks
+            .iter()
+            .map(|cb| {
+                let tokens = crate::token::lexer(cb);
+                let parser = crate::parser::Parser::new(tokens);
+                let program = parser.ast().unwrap();
+                let mut options: crate::ast::types::FormatOptions = Default::default();
+                options.insert_final_newline = false;
+                program.recast(&options, 0)
+            })
+            .collect::<Vec<String>>()
+    }
+
     fn std_lib_fn(&self) -> crate::std::StdFn {
         boxed_show
     }
@@ -77,4 +135,10 @@ impl crate::docs::StdLibFn for Show {
     }
 }
 
+#[doc = r" This is some function."]
+#[doc = r" It does shit."]
+#[doc = r""]
+#[doc = r"     This is code."]
+#[doc = r"     It does other shit."]
+#[doc = r"     show"]
 fn inner_show(#[doc = r" The args to do shit to."] _args: Vec<f64>) {}