Extract guard-lang so guard can be used as a library

Author: satyakigh

Cargo.lock

@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "guard",
+    "guard-lang",
     "guard-lambda",
     "guard-ffi",
     "guard-examples/library"

Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "guard-lang"
+version = "0.1.0"
+edition = "2018"
+description = "Parser, AST, and evaluation types for the AWS CloudFormation Guard DSL"
+license = "Apache-2.0"
+
+[dependencies]
+nom = "7.0.0"
+nom_locate = "4.0.0"
+indexmap = { version = "1.6.0", features = ["serde-1"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = { version = "1.0.85", features = ["preserve_order"] }
+serde_yaml = "0.9.10"
+fancy-regex = "0.13.0"
+thiserror = "1.0.38"
+lazy_static = "1.4.0"
+colored = "2.2.0"
+unsafe-libyaml = "0.2.10"
+itertools = "0.4.7"
+chrono = "0.4.38"
+cruet = "0.14.0"
+urlencoding = "2.1.0"
+wasm-bindgen = "0.2.92"
+quick-xml = "0.30.0"
+
+[dev-dependencies]
+pretty_assertions = "1.4.0"
+rstest = "0.24.0"
+indoc = "1.0.8"
+grep-searcher = "0.1.8"
+grep-matcher = "0.1.5"
+grep-regex = "0.1.9"

guard-lang/Cargo.toml

@@ -0,0 +1 @@
+../guard/assets

guard-lang/assets

@@ -1,12 +1,12 @@
-use crate::rules::eval_context::EventRecord;
-use crate::rules::exprs::SliceDisplay;
-use crate::rules::path_value::PathAwareValue;
-use crate::rules::values::{CmpOperator, RangeType, LOWER_INCLUSIVE, UPPER_INCLUSIVE};
-use crate::rules::{BlockCheck, ClauseCheck, QueryResult, RecordType, Status};
+use crate::eval_context::EventRecord;
+use crate::exprs::SliceDisplay;
+use crate::path_value::PathAwareValue;
+use crate::values::{CmpOperator, RangeType, LOWER_INCLUSIVE, UPPER_INCLUSIVE};
+use crate::{BlockCheck, ClauseCheck, QueryResult, RecordType, Status};
 use std::fmt::{Display, Formatter};
 use std::rc::Rc;
 
-pub(crate) fn display_comparison((cmp, not): (CmpOperator, bool)) -> String {
+pub fn display_comparison((cmp, not): (CmpOperator, bool)) -> String {
     format!("{} {}", if not { "not" } else { "" }, cmp)
 }
 
@@ -30,7 +30,7 @@ fn write_range<T: Display + PartialOrd>(
     Ok(())
 }
 
-pub(crate) struct ValueOnlyDisplay(pub(crate) Rc<PathAwareValue>);
+pub struct ValueOnlyDisplay(pub Rc<PathAwareValue>);
 
 impl std::fmt::Debug for ValueOnlyDisplay {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

guard/src/rules/display.rs guard-lang/src/display.rsguard/src/rules/display.rs renamed to guard-lang/src/display.rs

@@ -4,7 +4,7 @@ use std::string::FromUtf8Error;
 use thiserror::Error;
 use wasm_bindgen::JsValue;
 
-use crate::rules::parser::{ParserError, Span};
+use crate::parser::{ParserError, Span};
 
 #[derive(Debug, Error)]
 #[allow(clippy::enum_variant_names)]

guard/src/rules/errors.rs guard-lang/src/errors.rsguard/src/rules/errors.rs renamed to guard-lang/src/errors.rs

@@ -1,8 +1,8 @@
 use super::exprs::*;
 use super::*;
-use crate::rules::eval::operators::Comparator;
-use crate::rules::eval_context::{block_scope, resolve_function, ValueScope};
-use crate::rules::path_value::compare_eq;
+use crate::eval::operators::Comparator;
+use crate::eval_context::{block_scope, resolve_function, ValueScope};
+use crate::path_value::compare_eq;
 use std::collections::HashMap;
 
 mod operators;
@@ -1010,31 +1010,31 @@ pub(super) fn real_binary_operation<'value, 'loc: 'value>(
             QueryResult::Literal(l) | QueryResult::Resolved(l) => {
                 let r = match cmp {
                     (CmpOperator::Eq, is_not) => each_lhs_compare(
-                        not_compare(crate::rules::path_value::compare_eq, is_not),
+                        not_compare(crate::path_value::compare_eq, is_not),
                         Rc::clone(l),
                         rhs,
                     )?,
 
                     (CmpOperator::Ge, is_not) => each_lhs_compare(
-                        not_compare(crate::rules::path_value::compare_ge, is_not),
+                        not_compare(crate::path_value::compare_ge, is_not),
                         Rc::clone(l),
                         rhs,
                     )?,
 
                     (CmpOperator::Gt, is_not) => each_lhs_compare(
-                        not_compare(crate::rules::path_value::compare_gt, is_not),
+                        not_compare(crate::path_value::compare_gt, is_not),
                         Rc::clone(l),
                         rhs,
                     )?,
 
                     (CmpOperator::Lt, is_not) => each_lhs_compare(
-                        not_compare(crate::rules::path_value::compare_lt, is_not),
+                        not_compare(crate::path_value::compare_lt, is_not),
                         Rc::clone(l),
                         rhs,
                     )?,
 
                     (CmpOperator::Le, is_not) => each_lhs_compare(
-                        not_compare(crate::rules::path_value::compare_le, is_not),
+                        not_compare(crate::path_value::compare_le, is_not),
                         Rc::clone(l),
                         rhs,
                     )?,
@@ -1075,7 +1075,7 @@ pub(super) fn real_binary_operation<'value, 'loc: 'value>(
 }
 
 #[allow(clippy::never_loop)]
-pub(in crate::rules) fn eval_guard_access_clause<'value, 'loc: 'value>(
+pub fn eval_guard_access_clause<'value, 'loc: 'value>(
     gac: &'value GuardAccessClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1224,7 +1224,7 @@ pub(in crate::rules) fn eval_guard_access_clause<'value, 'loc: 'value>(
     }
 }
 
-pub(in crate::rules) fn eval_guard_named_clause<'value, 'loc: 'value>(
+pub fn eval_guard_named_clause<'value, 'loc: 'value>(
     gnc: &'value GuardNamedRuleClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1288,7 +1288,7 @@ pub(in crate::rules) fn eval_guard_named_clause<'value, 'loc: 'value>(
     }
 }
 
-pub(in crate::rules) fn eval_general_block_clause<'value, 'loc: 'value, T, E>(
+pub fn eval_general_block_clause<'value, 'loc: 'value, T, E>(
     block: &'value Block<'loc, T>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
     eval_fn: E,
@@ -1300,7 +1300,7 @@ where
     eval_conjunction_clauses(&block.conjunctions, &mut block_scope, eval_fn)
 }
 
-pub(in crate::rules) fn eval_guard_block_clause<'value, 'loc: 'value>(
+pub fn eval_guard_block_clause<'value, 'loc: 'value>(
     block_clause: &'value BlockGuardClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1571,7 +1571,7 @@ impl<'eval, 'value, 'loc: 'value> RecordTracer<'value>
     }
 }
 
-pub(in crate::rules) fn eval_parameterized_rule_call<'value, 'loc: 'value>(
+pub fn eval_parameterized_rule_call<'value, 'loc: 'value>(
     call_rule: &'value ParameterizedNamedRuleClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1617,7 +1617,7 @@ pub(in crate::rules) fn eval_parameterized_rule_call<'value, 'loc: 'value>(
     eval_rule(&param_rule.rule, &mut eval)
 }
 
-pub(in crate::rules) fn eval_guard_clause<'value, 'loc: 'value>(
+pub fn eval_guard_clause<'value, 'loc: 'value>(
     gc: &'value GuardClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1635,7 +1635,7 @@ pub(in crate::rules) fn eval_guard_clause<'value, 'loc: 'value>(
     }
 }
 
-pub(in crate::rules) fn eval_when_clause<'value, 'loc: 'value>(
+pub fn eval_when_clause<'value, 'loc: 'value>(
     when_clause: &'value WhenGuardClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1646,7 +1646,7 @@ pub(in crate::rules) fn eval_when_clause<'value, 'loc: 'value>(
     }
 }
 
-pub(in crate::rules) fn eval_type_block_clause<'value, 'loc: 'value>(
+pub fn eval_type_block_clause<'value, 'loc: 'value>(
     type_block: &'value TypeBlock<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1821,7 +1821,7 @@ pub(in crate::rules) fn eval_type_block_clause<'value, 'loc: 'value>(
     Ok(status)
 }
 
-pub(in crate::rules) fn eval_rule_clause<'value, 'loc: 'value>(
+pub fn eval_rule_clause<'value, 'loc: 'value>(
     rule_clause: &'value RuleClause<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1834,7 +1834,7 @@ pub(in crate::rules) fn eval_rule_clause<'value, 'loc: 'value>(
     }
 }
 
-pub(in crate::rules) fn eval_rule<'value, 'loc: 'value>(
+pub fn eval_rule<'value, 'loc: 'value>(
     rule: &'value Rule<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
 ) -> Result<Status> {
@@ -1912,7 +1912,7 @@ impl<'loc> std::fmt::Display for RulesFile<'loc> {
     }
 }
 
-pub(crate) fn eval_rules_file<'value, 'loc: 'value>(
+pub fn eval_rules_file<'value, 'loc: 'value>(
     rule: &'value RulesFile<'loc>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
     data_file_name: Option<&'value str>,
@@ -1968,7 +1968,7 @@ pub(crate) fn eval_rules_file<'value, 'loc: 'value>(
 }
 
 #[allow(clippy::never_loop)]
-pub(in crate::rules) fn eval_conjunction_clauses<'value, 'loc: 'value, T, E>(
+pub fn eval_conjunction_clauses<'value, 'loc: 'value, T, E>(
     conjunctions: &'value Conjunctions<T>,
     resolver: &mut dyn EvalContext<'value, 'loc>,
     eval_fn: E,
@@ -1979,7 +1979,15 @@ where
     Ok(loop {
         let mut num_passes = 0;
         let mut num_fails = 0;
-        let context = format!("{}#disjunction", std::any::type_name::<T>());
+        let full_name = std::any::type_name::<T>();
+        let short_name = full_name
+            .rsplit("::")
+            .next()
+            .unwrap_or(full_name)
+            .split('<')
+            .next()
+            .unwrap_or(full_name);
+        let context = format!("{}#disjunction", short_name);
         'conjunction: for conjunction in conjunctions {
             let mut num_of_disjunction_fails = 0;
             let multiple_ors_present = conjunction.len() > 1;