cypher_dto/
format.rs

1/// Utility function for formatting part of a cypher [Query].
2///
3/// [prefix] applies to placeholders only, not field names. For example, `foo: $foo` would become `foo: $prefix_foo`.
4pub fn format_query_fields<I, S>(fields: I, prefix: Option<&str>) -> String
5where
6    I: IntoIterator<Item = S>,
7    S: AsRef<str>,
8{
9    let prefix = prefix_str(prefix);
10    let mut formatted = Vec::new();
11    for field in fields {
12        if field.as_ref().is_empty() {
13            continue;
14        }
15        formatted.push(format!("{}: ${}{}", field.as_ref(), prefix, field.as_ref()));
16    }
17    formatted.join(", ")
18}
19
20/// Utility function for formatting a query object with fields.
21#[allow(dead_code)]
22pub fn format_query_obj<I, S>(name: &str, fields: I, prefix: Option<&str>) -> String
23where
24    I: IntoIterator<Item = S>,
25    S: AsRef<str>,
26{
27    let fields = format_query_fields(fields, prefix);
28    if fields.is_empty() {
29        return name.to_owned();
30    }
31    format!("{} {{ {} }}", name, fields)
32}
33
34/// Formats a parameter name with or without a prefix. For example, `foo` would become `prefix_foo`.
35pub fn format_param(name: &str, prefix: Option<&str>) -> String {
36    if name.is_empty() {
37        return "".to_owned();
38    }
39    format!("{}{}", prefix_str(prefix), name)
40}
41
42fn prefix_str(prefix: Option<&str>) -> String {
43    match prefix {
44        Some(p) => format!("{}_", p),
45        None => "".to_owned(),
46    }
47}
48
49#[cfg(test)]
50mod tests {
51    use super::*;
52
53    #[test]
54    fn params() {
55        assert_eq!(format_param("foo", None), "foo");
56        assert_eq!(format_param("foo", Some("n")), "n_foo");
57        assert_eq!(format_param("", Some("n")), "");
58    }
59
60    #[test]
61    fn fields() {
62        assert_eq!(
63            format_query_fields(["foo", "bar"], None),
64            "foo: $foo, bar: $bar"
65        );
66        assert_eq!(
67            format_query_fields(["foo", "bar"], Some("n")),
68            "foo: $n_foo, bar: $n_bar"
69        );
70        assert_eq!(format_query_fields(["foo"], None), "foo: $foo");
71        assert_eq!(format_query_fields::<&[_; 0], &String>(&[], None), "");
72        assert_eq!(format_query_fields::<&[_; 0], &String>(&[], Some("n")), "");
73        assert_eq!(format_query_fields(["", ""], Some("n")), "");
74    }
75
76    #[test]
77    fn obj() {
78        assert_eq!(
79            format_query_obj("Foo", ["foo", "bar"], None),
80            "Foo { foo: $foo, bar: $bar }"
81        );
82        assert_eq!(
83            format_query_obj("Foo", ["foo", "bar"], Some("n")),
84            "Foo { foo: $n_foo, bar: $n_bar }"
85        );
86        assert_eq!(format_query_obj("Foo", ["foo"], None), "Foo { foo: $foo }");
87        assert_eq!(
88            format_query_obj::<&[_; 0], &String>("Foo", &[], None),
89            "Foo"
90        );
91        assert_eq!(
92            format_query_obj::<&[_; 0], &String>("FOO", &[], Some("n")),
93            "FOO"
94        );
95    }
96}