simplify custom predicate's frontend interfaces, making it less verbose to define Statement Template arguments

The main idea is that when defining the arguments at a statement
template, it can be done from 3 different inputs:
i. `(&str, literal)`: this is to set a POD and a field, ie. `(POD, literal("field")`)
ii. `(&str, &str)`: this is to define a origin-key wildcard pair, ie. `(src_origin, src_dest)`
iii. `Value`: this is to define a literal value, ie. `0`

Author: arnaucube

src/frontend/custom.rs

@@ -7,34 +7,52 @@ use crate::middleware::{
 };
 
 /// Argument to an statement template
-enum HashOrWildcardStr {
-    Hash(Hash), // represents a literal
+pub enum HashOrWildcardStr {
+    Hash(Hash), // represents a literal key
     Wildcard(String),
 }
 
 /// helper to build a literal HashOrWildcardStr::Hash from the given str
-fn literal(s: &str) -> HashOrWildcardStr {
+pub fn literal(s: &str) -> HashOrWildcardStr {
     HashOrWildcardStr::Hash(hash_str(s))
 }
 
-/// helper to build a HashOrWildcardStr::Wildcard from the given str
+/// helper to build a HashOrWildcardStr::Wildcard from the given str. For the
+/// moment this method does not need to be public.
 fn wildcard(s: &str) -> HashOrWildcardStr {
     HashOrWildcardStr::Wildcard(s.to_string())
 }
 
 /// Builder Argument for the StatementTmplBuilder
-enum BuilderArg {
+pub enum BuilderArg {
     Literal(Value),
     /// Key: (origin, key), where origin & key can be both Hash or Wildcard
     Key(HashOrWildcardStr, HashOrWildcardStr),
 }
 
-impl From<(HashOrWildcardStr, HashOrWildcardStr)> for BuilderArg {
-    fn from((pod_id, key): (HashOrWildcardStr, HashOrWildcardStr)) -> Self {
-        Self::Key(pod_id, key)
+/// When defining a `BuilderArg`, it can be done from 3 different inputs:
+///   i. (&str, literal): this is to set a POD and a field, ie. (POD, literal("field"))
+///  ii. (&str, &str): this is to define a origin-key wildcard pair, ie. (src_origin, src_dest)
+/// iii. Value: this is to define a literal value, ie. 0
+///
+/// case i.
+impl From<(&str, HashOrWildcardStr)> for BuilderArg {
+    fn from((origin, lit): (&str, HashOrWildcardStr)) -> Self {
+        // ensure that `lit` is of HashOrWildcardStr::Hash type
+        match lit {
+            HashOrWildcardStr::Hash(_) => (),
+            _ => panic!("not supported"),
+        };
+        Self::Key(wildcard(&origin), lit)
     }
 }
-
+/// case ii.
+impl From<(&str, &str)> for BuilderArg {
+    fn from((origin, field): (&str, &str)) -> Self {
+        Self::Key(wildcard(&origin), wildcard(&field))
+    }
+}
+/// case iii.
 impl<V> From<V> for BuilderArg
 where
     V: Into<Value>,
@@ -163,23 +181,23 @@ mod tests {
         let mut builder = CustomPredicateBatchBuilder::new("eth_friend".into());
         let _eth_friend = builder.predicate_and(
             // arguments:
-            &["src_or", "src_key", "dst_or", "dst_key"],
+            &["src_ori", "src_key", "dst_ori", "dst_key"],
             // private arguments:
             &["attestation_pod"],
             // statement templates:
             &[
                 // there is an attestation pod that's a SignedPod
                 STB::new(NP::ValueOf)
-                    .arg((wildcard("attestation_pod"), literal("type")))
+                    .arg(("attestation_pod", literal("type")))
                     .arg(PodType::Signed),
                 // the attestation pod is signed by (src_or, src_key)
                 STB::new(NP::Equal)
-                    .arg((wildcard("attestation_pod"), literal("signer")))
-                    .arg((wildcard("src_or"), wildcard("src_key"))),
+                    .arg(("attestation_pod", literal("signer")))
+                    .arg(("src_ori", "src_key")),
                 // that same attestation pod has an "attestation"
                 STB::new(NP::Equal)
-                    .arg((wildcard("attestation_pod"), literal("attestation")))
-                    .arg((wildcard("dst_or"), wildcard("dst_key"))),
+                    .arg(("attestation_pod", literal("attestation")))
+                    .arg(("dst_ori", "dst_key")),
             ],
         );
 
@@ -197,22 +215,22 @@ mod tests {
         let eth_dos_distance_base = builder.predicate_and(
             &[
                 // arguments:
-                "src_or",
+                "src_ori",
                 "src_key",
-                "dst_or",
+                "dst_ori",
                 "dst_key",
-                "distance_or",
+                "distance_ori",
                 "distance_key",
             ],
             &[  // private arguments:
             ],
             &[
                 // statement templates:
                 STB::new(NP::Equal)
-                    .arg((wildcard("src_or"), literal("src_key")))
-                    .arg((wildcard("dst_or"), wildcard("dst_key"))),
+                    .arg(("src_ori", "src_key"))
+                    .arg(("dst_ori", "dst_key")),
                 STB::new(NP::ValueOf)
-                    .arg((wildcard("distance_or"), wildcard("distance_key")))
+                    .arg(("distance_ori", "distance_key"))
                     .arg(0),
             ],
         );
@@ -224,59 +242,41 @@ mod tests {
         let eth_dos_distance = Predicate::BatchSelf(3);
 
         // next chunk builds:
-        // eth_dos_distance_ind_0(src_or, src_key, dst_or, dst_key, distance_or, distance_key) = and<
-        //   eth_dos_distance(src_or, src_key, intermed_or, intermed_key, shorter_distance_or, shorter_distance_key)
-
-        //   // distance == shorter_distance + 1
-        //   ValueOf(one_or, one_key, 1)
-        //   SumOf(distance_or, distance_key, shorter_distance_or, shorter_distance_key, one_or, one_key)
-
-        //   // intermed is a friend of dst
-        //   eth_friend(intermed_or, intermed_key, dst_or, dst_key)
-        // >
         let eth_dos_distance_ind = builder.predicate_and(
             &[
                 // arguments:
-                "src_or",
+                "src_ori",
                 "src_key",
-                "dst_or",
+                "dst_ori",
                 "dst_key",
-                "distance_or",
+                "distance_ori",
                 "distance_key",
             ],
             &[
                 // private arguments:
-                "one_or",
+                "one_ori",
                 "one_key",
-                "shorter_distance_or",
+                "shorter_distance_ori",
                 "shorter_distance_key",
-                "intermed_or",
+                "intermed_ori",
                 "intermed_key",
             ],
             &[
                 // statement templates:
                 STB::new(eth_dos_distance)
-                    .arg((wildcard("src_or"), wildcard("src_key")))
-                    .arg((wildcard("intermed_or"), wildcard("intermed_key")))
-                    .arg((
-                        wildcard("shorter_distance_or"),
-                        wildcard("shorter_distance_key"),
-                    )),
+                    .arg(("src_ori", "src_key"))
+                    .arg(("intermed_ori", "intermed_key"))
+                    .arg(("shorter_distance_ori", "shorter_distance_key")),
                 // distance == shorter_distance + 1
-                STB::new(NP::ValueOf)
-                    .arg((wildcard("one_or"), wildcard("one_key")))
-                    .arg(1),
+                STB::new(NP::ValueOf).arg(("one_ori", "one_key")).arg(1),
                 STB::new(NP::SumOf)
-                    .arg((wildcard("distance_or"), wildcard("distance_key")))
-                    .arg((
-                        wildcard("shorter_distance_or"),
-                        wildcard("shorter_distance_key"),
-                    ))
-                    .arg((wildcard("one_or"), wildcard("one_key"))),
+                    .arg(("distance_ori", "distance_key"))
+                    .arg(("shorter_distance_ori", "shorter_distance_key"))
+                    .arg(("one_ori", "one_key")),
                 // intermed is a friend of dst
                 STB::new(eth_friend)
-                    .arg((wildcard("intermed_or"), wildcard("intermed_key")))
-                    .arg((wildcard("dst_or"), wildcard("dst_key"))),
+                    .arg(("intermed_ori", "intermed_key"))
+                    .arg(("dst_ori", "dst_key")),
             ],
         );
 
@@ -287,23 +287,23 @@ mod tests {
 
         let _eth_dos_distance = builder.predicate_or(
             &[
-                "src_or",
+                "src_ori",
                 "src_key",
-                "dst_or",
+                "dst_ori",
                 "dst_key",
-                "distance_or",
+                "distance_ori",
                 "distance_key",
             ],
             &[],
             &[
                 STB::new(eth_dos_distance_base)
-                    .arg((wildcard("src_or"), wildcard("src_key")))
-                    .arg((wildcard("dst_or"), wildcard("dst_key")))
-                    .arg((wildcard("distance_or"), wildcard("distance_key"))),
+                    .arg(("src_ori", "src_key"))
+                    .arg(("dst_ori", "dst_key"))
+                    .arg(("distance_ori", "distance_key")),
                 STB::new(eth_dos_distance_ind)
-                    .arg((wildcard("src_or"), wildcard("src_key")))
-                    .arg((wildcard("dst_or"), wildcard("dst_key")))
-                    .arg((wildcard("distance_or"), wildcard("distance_key"))),
+                    .arg(("src_ori", "src_key"))
+                    .arg(("dst_ori", "dst_key"))
+                    .arg(("distance_ori", "distance_key")),
             ],
         );