feat: test all targets

kamadorueda · kamadorueda · commit 0f93c78310fd · 2022-04-01T20:48:03.000-05:00
diff --git a/README.md b/README.md
@@ -47,6 +47,16 @@ SPDX-License-Identifier: GPL-3.0-only
 
 </p>
 
+Santiago provides you:
+
+- A library for defining any
+  [context-free grammar](https://en.wikipedia.org/wiki/Context-free_grammar).
+- A [Lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis) module.
+- And facilities for building interpreters or compilers of the language.
+
+With Santiago you have everything that is needed
+to build your own programming language!
+
 ## Features
 
 - &#10004;&#65039; **Fast** &#129408;
diff --git a/buildkite.yaml b/buildkite.yaml
@@ -9,7 +9,7 @@ steps:
       - direnv allow
       - eval "$(direnv export bash)"
       - echo +++ Check
-      - cargo check
+      - cargo check --all-targets
 
   - label: coverage
     if: build.branch == "main"
@@ -40,12 +40,12 @@ steps:
       - direnv allow
       - eval "$(direnv export bash)"
       - echo +++ Lint
-      - cargo clippy
+      - cargo clippy --all-targets
 
   - label: test
     command:
       - echo --- Prepare environment
       - direnv allow
       - eval "$(direnv export bash)"
       - echo +++ Test
-      - cargo test
+      - cargo test --all-targets
diff --git a/src/lib.rs b/src/lib.rs
@@ -12,15 +12,16 @@
 #![deny(rustdoc::private_intra_doc_links)]
 #![deny(rustdoc::private_doc_tests)]
 //! Santiago is a lexing and parsing toolkit for Rust.
-//! It provides a library for defining any
-//! [context-free grammar](https://en.wikipedia.org/wiki/Context-free_grammar),
-//! a [lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis) module,
-//! and facilities for building evaluators of the language.
+//! It provides you:
+//! - A library for defining any
+//!  [context-free grammar](https://en.wikipedia.org/wiki/Context-free_grammar),
+//! - A [Lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis) module,
+//! - And facilities for building interpreters or compilers of the language.
 //!
-//! With Santiago, you have everything you need to build your own programming
-//! language, and a compiler or interpreter for it.
+//! With Santiago you have everything that is needed
+//! to build your own programming language!
 //!
-//! Santiago aims to be the Rust alternative to
+//! We are the Rust alternative to
 //! [GNU Bison](https://en.wikipedia.org/wiki/GNU_Bison),
 //! [Yacc](https://en.wikipedia.org/wiki/Yacc) and
 //! [Flex](https://en.wikipedia.org/wiki/Flex_(lexical_analyser_generator)).
@@ -118,7 +119,7 @@
 //! let parse_trees = santiago::parser::parse(&grammar, &lexemes).unwrap();
 //! ```
 //! 
-//! And voil&agrave;!
+//! Which looks like:
 //! ```text
 #![doc = include_str!("../tests/ambiguous_integer_addition/cases/addition/parse_trees")]
 //! ```
@@ -162,15 +163,19 @@
 #![doc = include_str!("../tests/integer_addition/cases/addition/parse_trees")]
 //! ```
 //! 
-//! All we are missing now is evaluating the addition,
-//! for this let's modify the grammar
+//! All we are missing now is evaluating the addition.
+//! For this let's modify the grammar
 //! so that each time a rule matches
-//! we produce an amenable data-structure:
+//! we produce an amenable data-structure
+//! that can be turned into an Abstract Syntax Tree:
 //! ```rust
 #![doc = include_str!("../tests/integer_addition_with_value/grammar.rs")]
 //! ```
 //! 
-//! We just need to call Santiago's builtin-function `as_abstract_syntax_tree()`.
+//! Now, the next time we parse,
+//! we can transform our Parse Tree into
+//! an Abstract Syntax Tree
+//! by calling Santiago's builtin-function `as_abstract_syntax_tree()`.
 //! ```rust
 //! # mod m {
 //! #   include!("../tests/integer_addition_with_value/eval.rs");
@@ -190,7 +195,7 @@
 //! let ast = parse_tree.as_abstract_syntax_tree();
 //!
 //! assert_eq!(
-//!     value,
+//!     ast,
 //!     BinaryOperation(vec![
 //!         BinaryOperation(vec![
 //!             Int(10),
@@ -232,7 +237,7 @@
 //! #
 //! let ast = parse_tree.as_abstract_syntax_tree();
 //!
-//! assert_eq!(eval(&value), 60);
+//! assert_eq!(eval(&ast), 60);
 //! ```
 //! 
 //! How nice is that?
@@ -439,7 +444,7 @@
 //!
 //! let ast = parse_tree.as_abstract_syntax_tree();
 //!
-//! assert_eq!(eval(&value), -6);
+//! assert_eq!(eval(&ast), -6);
 //! ```
 //! 
 //! ## JavaScript string interpolations
diff --git a/src/parser/tree.rs b/src/parser/tree.rs
@@ -14,7 +14,8 @@ use std::collections::HashMap;
 use std::collections::LinkedList;
 use std::rc::Rc;
 
-/// Representation of an AST.
+/// Representation of a Parse Tree,
+/// than can be turned into an Abstract Syntax Tree.
 pub enum Tree<AST> {
     /// Leaf nodes of the tree, containing a [Lexeme].
     Leaf(Lexeme),
diff --git a/tests/calculator_with_value/grammar.rs b/tests/calculator_with_value/grammar.rs
@@ -17,13 +17,13 @@ pub fn grammar() -> Grammar<AST> {
         "expr" => rules "int";
 
         "bin_op" => rules "expr" "add" "expr" =>
-            |values| AST::BinaryOperation(values);
+            AST::BinaryOperation;
         "bin_op" => rules "expr" "subtract" "expr" =>
-            |values| AST::BinaryOperation(values);
+            AST::BinaryOperation;
         "bin_op" => rules "expr" "multiply" "expr" =>
-            |values| AST::BinaryOperation(values);
+            AST::BinaryOperation;
         "bin_op" => rules "expr" "divide" "expr" =>
-            |values| AST::BinaryOperation(values);
+            AST::BinaryOperation;
 
         "add" => lexemes "+" =>
             |_| AST::OperatorAdd;
diff --git a/tests/integer_addition_with_value/grammar.rs b/tests/integer_addition_with_value/grammar.rs
@@ -14,7 +14,7 @@ pub enum AST {
 pub fn grammar() -> Grammar<AST> {
     santiago::grammar!(
         "sum" => rules "sum" "plus" "sum" =>
-            |values| AST::BinaryOperation(values);
+            AST::BinaryOperation;
 
         "sum" => lexemes "INT" => |lexemes| {
             // &str to isize conversion
