Feature/expr parser

Cargo.toml

@@ -18,6 +18,9 @@ rust-version = "1.60"
 
 [workspace.dependencies]
 substreams-macro = { version = "0.5.13", path = "./substreams-macro" }
+pest= "2.7.10"
+pest_derive = "2.7.10"
+rstest = "0.19.0" 
 
 [profile.release]
 lto = true

substreams/Cargo.toml

@@ -24,6 +24,9 @@ prost = "0.11"
 prost-types = "0.11"
 substreams-macro = { workspace = true }
 thiserror = "1"
+pest= "2.7.10"
+pest_derive = "2.7.10"
+rstest = "0.19.0" 
 
 [build-dependencies]
 prost-build = "0.11"

substreams/src/lib.rs

@@ -125,6 +125,7 @@ mod state;
 
 pub mod key;
 pub mod store;
+pub mod parser;
 
 mod operation;
 

substreams/src/parser.rs

@@ -0,0 +1,53 @@
+use pest::{iterators::Pair, Parser};
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "parser_rule.pest"]
+pub struct EParser;
+
+pub fn evaluate_expression(keys: Vec<String>, input: &str) -> bool {
+    let successful_parse = EParser::parse(Rule::expression, input).unwrap();
+    return evaluate_rule(successful_parse.clone().into_iter().next().unwrap(), keys);
+}
+
+fn evaluate_rule(pair: Pair<Rule>,  keys: Vec<String>) -> bool {
+    match pair.as_rule() {
+        Rule::expression => {
+            let inner_pair = pair.into_inner().next().unwrap();
+            return evaluate_rule(inner_pair, keys);
+        }
+        Rule::or => {
+            let mut result = false;
+            for inner_pair in pair.into_inner() {
+                result = result || evaluate_rule(inner_pair, keys.clone());
+            }
+            return result;
+        },
+        Rule::and => {
+            let mut result = true;
+            for inner_pair in pair.into_inner() {
+                result = result && evaluate_rule(inner_pair, keys.clone());
+            }
+            return result;
+        },
+        Rule::value => {
+            let inner_pair = pair.into_inner().next().unwrap();
+            return evaluate_rule(inner_pair, keys);
+        }
+        Rule::keyterm => {
+            return keys.contains(&pair.as_str().to_string());
+        }
+        Rule::singleQuoteKeyTerm => {
+            return keys.contains(&pair.as_str().to_string().replace("'", ""));
+        }
+        Rule::doubleQuoteKeyTerm => {
+            return keys.contains(&pair.as_str().to_string().replace("\"", ""));
+        }
+        _ => {panic!("Unexpected rule encountered")}
+    } 
+}
+
+
+
+
+

substreams/src/parser_rule.pest

@@ -0,0 +1,12 @@
+expression = { or }
+or = { (and ~ (space? ~ ("||") ~ space? ~ and )* ) }
+and = { (value ~ ((space ~ value) | (space? ~ ("&&") ~ space? ~ value ~ space?))* ) }
+value = { (space? ~ singleQuoteKeyTerm ~ space?) | (space? ~ doubleQuoteKeyTerm ~ space?) | keyterm | (space? ~ "(" ~ space? ~ expression ~ space? ~ ")" ~ space?) }
+keyterm = { (letters | digits | symbols)+ }
+singleQuoteKeyTerm = { ("'") ~ (!"'" ~ ANY)+ ~ ("'")}
+doubleQuoteKeyTerm = { ("\"") ~ (!"\"" ~ ANY)+ ~ ("\"")}
+
+digits = _{ '0' .. '9' }
+letters = _{ 'a' .. 'z' | 'A' .. 'Z' }
+symbols = _{ "_" | ":" }
+space = _{ (" " | "\t" | "\n" )+ }

substreams/src/pb/mod.rs

@@ -1,2 +1,14 @@
+pub mod sf {
+    pub mod substreams {
+        pub mod index {
+            // @@protoc_insertion_point(attribute:sf.substreams.index.v1)
+            pub mod v1 {
+                include!("sf.substreams.index.v1.rs");
+                // @@protoc_insertion_point(sf.substreams.index.v1)
+            }
+        }
+    }
+}
+
 #[path = "./sf.substreams.v1.rs"]
 pub mod substreams;

substreams/src/pb/sf.substreams.index.v1.rs

@@ -0,0 +1,8 @@
+// @generated
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Keys {
+    #[prost(string, repeated, tag="1")]
+    pub keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+// @@protoc_insertion_point(module)

substreams/tests/parser_test.rs

@@ -0,0 +1,50 @@
+use rstest::rstest;
+use substreams::parser::{evaluate_expression};
+
+static TEST_KEYS: &[&str] = &["test", "test1", "test2", "test3", "test4", "test5", "test 6"];
+
+#[rstest]
+#[case(TEST_KEYS, "test", true)]
+#[case(TEST_KEYS, "'test'", true)]
+#[case(TEST_KEYS, "'test 6' || test7", true)]
+#[case(TEST_KEYS, "'test_6' && test3", false)]
+#[case(TEST_KEYS, "\"test 6\" || test7", true)]
+#[case(TEST_KEYS, "\"test 6\" && test3", true)]
+
+#[case(TEST_KEYS, "test1 || test", true)]
+#[case(TEST_KEYS, "test1 || test6", true)]
+#[case(TEST_KEYS, "test6 || test7", false)]
+
+#[case(TEST_KEYS, "test1 || test || test2", true)]
+#[case(TEST_KEYS, "test1 || test6 || test7", true)]
+#[case(TEST_KEYS, "test6 || test7 || test8", false)]
+
+#[case(TEST_KEYS, "test1 && test", true)]
+#[case(TEST_KEYS, "test1 && test6", false)]
+#[case(TEST_KEYS, "test6 && test7", false)]
+
+#[case(TEST_KEYS, "test1 && test && test2", true)]
+#[case(TEST_KEYS, "test1 && test2 && test7", false)]
+#[case(TEST_KEYS, "test6 && test7 && test8", false)]
+
+#[case(TEST_KEYS, "test1 test", true)]
+#[case(TEST_KEYS, "test1 test6", false)]
+#[case(TEST_KEYS, "test6 test7", false)]
+
+#[case(TEST_KEYS, "(test1)", true)]
+#[case(TEST_KEYS, "(test1 test6)", false)]
+
+#[case(TEST_KEYS, "test1     test2 ", true)]
+#[case(TEST_KEYS, "test1    && test2 ", true)]
+#[case(TEST_KEYS, "test1    &&     test6", false)]
+#[case(TEST_KEYS, "(test1   ||  test3)       &&  test6 ", false)]
+#[case(TEST_KEYS, "(test1  ||     test6 || test7  )     && (test4 || test5) && test3 ", true)]
+
+#[case(TEST_KEYS, "(test1 || test6 || test7) && (test4 || test5) && test3 ", true)]
+#[case(TEST_KEYS, "(test1 && test6 && test7) || (test4 && test5) || test3 ", true)]
+
+fn test_parse(#[case] keys: &[&str], #[case] input: &str, #[case] expected: bool) {
+    let keys: Vec<String> = keys.iter().map(|s| s.to_string()).collect();
+    assert_eq!(evaluate_expression(keys, input), expected);
+}
+