Add just smoke while fix doc tests

- core: Add DbC for `Transition` via static_assert
- core: Refactor `TransitionIterator` a bit
- Fix deprecate trait-object without `dyn`

Author: DrSensor

Cargo.lock

@@ -18,7 +18,7 @@ check: clear
 	watchexec --restart --clear 'just {{command}} {{args}}'
 
 # Run all kind of tests
-test: unit integration
+test: unit integration smoke
 
 # Generate and open the documentation
 docs +args='':
@@ -63,14 +63,20 @@ release version:
 build args='':
 	cargo build {{args}}
 
-# Run all unit test
+# Run all unit tests
 unit:
 	cargo test --lib --all --exclude s-crap -- --test-threads=1
 
-# Run all integration test
+# Run all integration tests
 integration:
 	cargo test --tests -p s-crap -- --test-threads=1
 
+# Run all examples and doc-tests
+smoke:
+	cargo test --doc --all --exclude s-crap
+	cargo test --examples
+# TODO: `mask --maskfile examples/xstate/nodejs/maskfile.md start` should link `scrap` to target/debug/scrap
+
 # Show reports of macro-benchmark
 @stats git-flags='':
 	./scripts/summary.sh {{git-flags}} | ./scripts/perfsum.py

Justfile

@@ -12,7 +12,8 @@ edition = "2018"
 [[bin]]
 name = "scrap"
 path = "src/main.rs"
-test = false
+test = false 	# TODO: remove integration test and replace it with evlish or bats
+							# CLI tests should be readable and close to shell scripting environment
 doc = false
 doctest = false
 

packages/cli/Cargo.toml

@@ -11,10 +11,13 @@ categories = ["parsing"]
 edition = "2018"
 
 [dependencies]
+# parser + context-free-grammar
 pest = "2"
 pest_derive = "2"
-lazy_static = "1"
-either = "1"
+# helper
+lazy_static = "1" # to define the global caches
+either = "1" # a workaround for iterator.filter that return Result<Vec, _>
+static_assertions = "0.3" # design-by-contract at compile time
 
 [badges]
 maintenance = { status = "actively-developed" }

packages/core/Cargo.toml

@@ -2,7 +2,7 @@ use crate::{cache, error::Error, external::Builder};
 use pest_derive::Parser;
 use std::collections::HashMap;
 
-#[derive(Parser, Default, Clone)] // 🤔 is it wise to derive from Copy&Clone ?
+#[derive(Debug, Parser, Default, Clone)] // 🤔 is it wise to derive from Copy&Clone ?
 #[grammar = "grammar.pest"]
 /** __Core__ parser and also [`Builder`].
 

packages/core/src/core/builder.rs

@@ -11,8 +11,12 @@ use std::{fmt, *};
 
 # Examples
 ```
+# use std::error::Error;
+use scdlang::parse;
+
 let token_pairs = parse("A -> B")?;
-println("{:#?}", token_pairs);
+println!("{:#?}", token_pairs);
+# Ok::<(), Box<dyn Error>>(())
 ``` */
 pub fn parse(source: &str) -> Result<Pairs<Rule>, RuleError> {
 	<Scdlang as pest::Parser<Rule>>::parse(Rule::DescriptionFile, source)

packages/core/src/core/parser.rs

@@ -5,10 +5,19 @@ Useful for creating transpiler, codegen, or even compiler.
 
 1. Implement trait [`Parser`] on struct with [`Scdlang`] field (or any type that implement [`Builder`]).
 ```no_run
-#[derive(Default)]
+use scdlang::{*, prelude::*};
+use std::{error, fmt};
+pub mod prelude {
+	pub use scdlang::external::*;
+}
+
+#[derive(Debug, Default)]
+struct Schema {}
+
+#[derive(Debug, Default)]
 pub struct Machine<'a> {
 	builder: Scdlang<'a>, // or any type that implmenet trait `Builder`
-	schema: std::any::Any,
+	schema: Schema,
 }
 
 impl Machine<'_> {
@@ -20,12 +29,18 @@ impl Machine<'_> {
 	}
 }
 
+impl fmt::Display for Machine<'_> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "{:?}", self.schema)
+	}
+}
+
 impl<'a> Parser<'a> for Machine<'a> {
-	fn configure(&mut self) -> &mut Builder<'a> {
+	fn configure(&mut self) -> &mut dyn Builder<'a> {
 		&mut self.builder
 	}
 
-	fn parse(&mut self, source: &str) -> Result<(), DynError> {
+	fn parse(&mut self, source: &str) -> Result<(), Box<dyn error::Error>> {
 		self.clean_cache()?;
 		unimplemented!();
 	}
@@ -42,6 +57,8 @@ impl<'a> Parser<'a> for Machine<'a> {
 
 2. Then it can be used like this:
 ```ignore
+use scdlang::external::*;
+
 let parser: Box<dyn Parser> = Box::new(match args {
 	Some(text) => module_a::Machine::try_parse(text)?,
 	None => module_b::Machine::new(),

packages/core/src/external.rs

@@ -1,6 +1,8 @@
 use crate::{utils::naming::Name, Error};
 use std::{any::Any, fmt::Debug};
 
+// TODO: test this in BDD style (possibly via cucumber-rust)
+
 #[derive(Debug)]
 /// An enum returned by [Scdlang.iter_from](../struct.Scdlang.html#method.iter_from)
 /// to access semantics type/kind
@@ -69,6 +71,6 @@ A |> doSomething
 or just a shorthand for writing a declaration in one line */
 pub trait Statement: Debug + Check {
 	fn state(&self) -> Option<Name>;
-	fn action(&self) -> Option<&Any /*👈TBD*/>;
+	fn action(&self) -> Option<&dyn Any /*👈TBD*/>;
 	fn event(&self) -> Option<Name>;
 }

packages/core/src/semantics/kind.rs

@@ -9,26 +9,26 @@ impl<'i> IntoIterator for Transition<'i> {
 	fn into_iter(mut self) -> Self::IntoIter {
 		TransitionIterator(match self.kind {
 			/*FIXME: iterator for internal transition*/
-			TransitionType::Normal | TransitionType::Internal => [self].to_vec(),
+			TransitionType::Normal | TransitionType::Internal => vec![self],
 			TransitionType::Toggle => {
 				self.kind = TransitionType::Normal;
 				let (mut left, right) = (self.clone(), self);
 				left.from = right.to.clone().expect("not Internal");
-				left.to = Some(right.from.clone());
-				[left, right].to_vec()
+				left.to = right.from.clone().into();
+				vec![left, right]
 			}
 			TransitionType::Loop { transient } => {
 				/* A ->> B @ C */
 				if self.from.name != self.to.as_ref().expect("not Internal").name {
 					let (mut self_loop, mut normal) = (self.clone(), self);
 					self_loop.from = self_loop.to.as_ref().expect("not Internal").clone();
 					normal.kind = TransitionType::Normal;
-					normal.at = if transient { None } else { normal.at };
-					[normal, self_loop].to_vec()
+					normal.at = normal.at.filter(|_| !transient);
+					vec![normal, self_loop]
 				}
 				/* ->> B @ C */
 				else {
-					[self].to_vec() // reason: see Symbol::double_arrow::right => (..) in convert.rs
+					vec![self] // reason: see Symbol::double_arrow::right => (..) in convert.rs
 				}
 			}
 			TransitionType::Inside { .. } => unreachable!("TODO: when support StateType::Compound"),
@@ -63,6 +63,6 @@ where
 	where
 		T: IntoIterator<Item = Transition<'i>>,
 	{
-		unimplemented!("TODO: on the next update")
+		unimplemented!("TODO: on the next update when const generic is stabilized")
 	}
 }

packages/core/src/semantics/transition/iter.rs

@@ -4,10 +4,18 @@ mod helper;
 mod iter;
 
 use crate::{
-	semantics::{analyze::SemanticCheck, Check, Expression, Found, Kind, Transition},
+	semantics::{analyze::*, Check, Expression, Found, Kind, Transition},
 	utils::naming::Name,
 	Error,
 };
+use static_assertions::assert_impl_all;
+
+assert_impl_all!(r#for; Transition,
+	SemanticAnalyze<'static>,
+	SemanticCheck,
+	From<TokenPair<'static>>,
+	IntoIterator // because `A <-> B` can be desugared into 2 transition
+);
 
 impl Expression for Transition<'_> {
 	fn current_state(&self) -> Name {
@@ -252,7 +260,7 @@ mod pair {
 			A -> F @ D
 			A -> C @ D[exist]
 		"#,
-			|expression| unimplemented!(),
+			|_expression| unimplemented!(),
 		)
 	}
 
@@ -265,7 +273,7 @@ mod pair {
 			A -> F
 			A -> C @ [exist]
 		"#,
-			|expression| unimplemented!(),
+			|_expression| unimplemented!(),
 		)
 	}
 
@@ -279,7 +287,7 @@ mod pair {
 			A -> C @ [exist]
 			A -> C @ E
 		"#,
-			|expression| unimplemented!(),
+			|_expression| unimplemented!(),
 		)
 	}
 
@@ -372,7 +380,7 @@ mod pair {
 					A -> B @ D[valid]
 					A -> B @ D
 				"#,
-					|expression| unimplemented!(),
+					|_expression| unimplemented!(),
 				)
 			}
 		}