trying to auto generate a page that will report what functions need t…

…o be implemented or not...

doc/mdbook-slosh-eval/Cargo.toml

@@ -15,6 +15,7 @@ log = "*"
 pulldown-cmark = "0.10.2"
 pulldown-cmark-to-cmark = "13.0.0"
 slosh_lib = { path = "../../slosh_lib" }
+slosh_test_lib = { path = "../../slosh_test_lib" }
 toml = "*"
 
 [workspace]

doc/mdbook-slosh-eval/src/main.rs

@@ -2,6 +2,7 @@ extern crate pulldown_cmark;
 extern crate pulldown_cmark_to_cmark;
 
 use crate::slosh_eval_lib::EvalSlosh;
+use slosh_test_lib::docs;
 use clap::{Arg, ArgMatches, Command};
 use mdbook::book::{Book, BookItem};
 use mdbook::errors::Error;
@@ -12,6 +13,8 @@ use semver::{Version, VersionReq};
 use std::io;
 use std::process;
 
+pub const SLOSH_AS_CODE_BLOCK_TAG: &str = "slosh";
+
 pub fn make_app() -> Command {
     Command::new("mdbook-slosh-eval")
         .about(
@@ -112,7 +115,7 @@ mod slosh_eval_lib {
                         match event {
                             Event::Start(Tag::CodeBlock(ref kind)) => match kind {
                                 CodeBlockKind::Fenced(name) if !tracking => {
-                                    if name.starts_with("slosh") && !name.contains("no-execute") {
+                                    if name.starts_with(SLOSH_AS_CODE_BLOCK_TAG) && !name.contains("no-execute") {
                                         slosh_code_block_num += 1;
                                         log::debug!(
                                             "File: {}: block #{}",
@@ -142,10 +145,10 @@ mod slosh_eval_lib {
                                     buf += "\n";
                                 }
                                 tracking = false;
-                                log::debug!("```slosh\n{}", buf);
+                                log::debug!("```{}\n{}", SLOSH_AS_CODE_BLOCK_TAG, buf);
                                 log::debug!("```");
                                 events.push(Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(
-                                    "slosh".into(),
+                                    SLOSH_AS_CODE_BLOCK_TAG.into(),
                                 ))));
                                 events.push(Event::Text(buf.clone().into()));
                                 events.push(Event::End(TagEnd::CodeBlock));
@@ -187,6 +190,7 @@ mod slosh_eval_lib {
 
     fn exec_code(code: String) -> String {
         let mut vm = slosh_lib::new_slosh_vm_with_builtins_and_core();
+        docs::add_builtins(&mut vm);
 
         let code = format!(
             r#"(import test)

doc/mk-site.sh

@@ -45,4 +45,6 @@ export PATH="$PATH:./mdbook-slosh-eval/target/debug"
 #
 #../target/debug/slosh -c "(build-doc \"${PWD}\")"
 
+# doing this because im tryingto use the mk-site.slosh script but don't
+# see a need to re-write this shell script in slosh at this moment too.
 ./search-hack-patch.sh

doc/src/SUMMARY.md

@@ -8,6 +8,7 @@
 - [Syntax and Macros](./syntax-and-macros.md)
 - [Iterators](./iterators.md)
 - [Shell Redirects](./shell-redirects.md)
+- [Transition from Legacy](./transition-from-legacy.md)
 
 # General
 

doc/src/transition-from-legacy.md

@@ -0,0 +1,10 @@
+# Transition Tracking
+
+## TODO sort these and then try to get out of the google doc (maybe need a hash map that pre-maps the one's we're skipping so the count is accurate)
+```slosh
+(get-globals-sorted)
+```
+
+```slosh
+(legacy_forms)
+```

slosh_test/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 
 [dependencies]
 slosh_lib = { path = "../slosh_lib" }
+slosh_test_lib = { path = "../slosh_test_lib" }
 regex = { workspace = true }
 lazy_static = { workspace = true }
 bridge_adapters = { path = "../bridge_adapters" }

slosh_test/src/main.rs

@@ -1,12 +1,11 @@
-pub mod docs;
-
+use slosh_test_lib::docs;
 use bridge_adapters::add_builtin;
 use compile_state::state::SloshVm;
 use sl_compiler::load_eval::run_reader;
 use sl_compiler::Reader;
 use slosh_lib::run;
-use slvm::{VMError, VMResult, Value};
 use std::process;
+use slvm::{VMError, VMResult, Value};
 
 pub const VERSION_STRING: &str = env!("VERSION_STRING");
 
@@ -17,6 +16,7 @@ fn version(vm: &mut SloshVm, registers: &[Value]) -> VMResult<Value> {
     Ok(vm.alloc_string(VERSION_STRING.to_string()))
 }
 
+
 fn modify_vm(vm: &mut SloshVm) {
     docs::add_builtins(vm);
 

slosh_test_lib/README.md

@@ -0,0 +1,3 @@
+The slosh_test crate contains some special functions that use additional dependencies
+used to build slosh documentation and run the slosh tests. These actions can
+be performed manually but are also done by CI.

slosh_test_lib/build.rs

@@ -0,0 +1,105 @@
+use std::env::consts::{ARCH, OS};
+use std::process::Command;
+
+use chrono::prelude::Utc;
+
+#[cfg(debug_assertions)]
+const BUILD_TYPE: &str = "debug";
+#[cfg(not(debug_assertions))]
+const BUILD_TYPE: &str = "release";
+
+fn main() {
+    let version_string = if have_git() {
+        format!(
+            "{} {} ({}:{}{}, {} build, {} [{}], {} UTC [{}])",
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+            get_branch_name(),
+            get_commit_hash(),
+            if is_working_tree_clean() { "" } else { "+" },
+            BUILD_TYPE,
+            OS,
+            ARCH,
+            Utc::now().format("%b %d %Y, %T"),
+            get_rustc_version(),
+        )
+    } else {
+        format!(
+            "{} {} ({} build, {} [{}], {} UTC [{}])",
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+            BUILD_TYPE,
+            OS,
+            ARCH,
+            Utc::now().format("%b %d %Y, %T"),
+            get_rustc_version(),
+        )
+    };
+
+    println!("cargo:rustc-env=VERSION_STRING={}", version_string);
+}
+
+fn have_git() -> bool {
+    Command::new("git")
+        .arg("--version")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .is_ok()
+}
+
+fn get_commit_hash() -> String {
+    let output = Command::new("git")
+        .arg("log")
+        .arg("-1")
+        .arg("--pretty=format:%h") // Abbreviated commit hash
+        // .arg("--pretty=format:%H") // Full commit hash
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .unwrap();
+
+    assert!(output.status.success());
+
+    String::from_utf8_lossy(&output.stdout).to_string()
+}
+
+fn get_branch_name() -> String {
+    let output = Command::new("git")
+        .arg("rev-parse")
+        .arg("--abbrev-ref")
+        .arg("HEAD")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .unwrap();
+
+    assert!(output.status.success());
+
+    String::from_utf8_lossy(&output.stdout)
+        .trim_end()
+        .to_string()
+}
+
+fn is_working_tree_clean() -> bool {
+    let status = Command::new("git")
+        .arg("diff")
+        .arg("--quiet")
+        .arg("--exit-code")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .status()
+        .unwrap();
+
+    status.code().unwrap() == 0
+}
+
+fn get_rustc_version() -> String {
+    let output = Command::new("rustc")
+        .arg("--version")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .unwrap();
+
+    assert!(output.status.success());
+
+    String::from_utf8_lossy(&output.stdout)
+        .trim_end()
+        .to_string()
+}

slosh_test_lib/run-tests.slosh

@@ -0,0 +1,28 @@
+#!/usr/bin/env slosh_test
+
+(let (globals (get-globals-sorted)
+      globals-len (len globals)
+      i 0
+      failing-tests {})
+    (while (< i globals-len)
+        (prn "Symbol: " globals.~i)
+        (prn "===")
+        (let (doc (doc-map globals.~i))
+        ;; for some reason printing usage for vec-slice causes rust to panic with 'Handle 2045 is not a string!'
+            (prn "Usage: " (str doc.:usage))
+            (prn "Description: " (str doc.:description))
+            (prn "Section: " (str doc.:section))
+            (if (not (err? (get failing-tests (->key globals.~i))))
+                (prn "~~~~~~~~~~~~~~~~~~~~~ Skipping failing test")
+                (let (example (str doc.:example)
+                              read-in (read-all example))
+                    (prn "Example: " example)
+                    (dotimes-i j (len read-in)
+                        (let (line (prn (str read-in.~j))
+                            evaled (eval read-in.~j))
+                            (if (err? evaled)
+                                (do (prn "Err: " (str evaled))
+                                   (err (mk-err :test (str "Err: " evaled))))
+                                (prn "Result: " (str evaled)))))))
+        (prn "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
+        (inc! i))))

slosh_test_lib/src/lib.rs

@@ -0,0 +1 @@
+pub mod docs;