jsn 0.14.0

//! Token masks are to JSON tokens what bitmasks are to bits.
//!
//! # Overview
//!
//! When the JSON parser is configured with a mask, it limits the tokens emitted by the
//! parser's [`next()`](crate::Tokens::next) method. A token mask operates on "raw" tokens borrowed
//! direcitly from the input. If a token is skipped, you do not pay the cost for
//! its heap allocation.
//!
//!
//! Here is a visualization to cement the similarity between token masks and bitmasks
//!
//! ```text
//!               [ 1 , 2 , [ { "key": "value" } ] ]
//! * index(0)  : _ x _ _ _ _ x xxxxxx xxxxxxx x _ _
//! * index(2)  : _ _ _ _ _ x x xxxxxx xxxxxxx x x _
//! * key("key"): _ _ _ _ _ _ _ ______ xxxxxxx _ _ _
//! * keys()    : _ _ _ _ _ _ _ xxxxxx _______ _ _ _
//! ```
//! ## Token mask operators
//!
//! Token masks can be combined using the [`and`](Mask::and) and [`or`](Mask::or) functions:
//!
//! Think of using `and()` to express the intersection between two masks.  
//! Think of using `or()` to express the union between two masks.  
//!
//! ```text
//!                                      { "a" : false , "b" : true }
//! * key("a")                         : _ ___ _ xxxxx _ ___ _ ____ _
//! * key("b")                         : _ ___ _ _____ _ ___ _ xxxx _
//! * key("a").and(key("b"))           : _ ___ _ _____ _ ___ _ ____ _
//! * key("a").or(key("b"))            : _ ___ _ xxxxx _ ___ _ xxxx _
//! ```
//!
//! Here is the equivalent code:
//! ```
//! use jsn::{TokenReader, mask::*};
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! let json = r#"{ "a": false, "b": true }"#;
//!
//! let mut iter = TokenReader::new(json.as_bytes())
//!     .with_mask(key("a").and(key("b")))
//!     .into_iter();
//!
//! assert_eq!(iter.next(), None);
//!
//! let mut iter = TokenReader::new(json.as_bytes())
//!     .with_mask(key("a").or(key("b")))
//!     .into_iter();
//!
//! assert_eq!(iter.next().unwrap()?, false);
//! assert_eq!(iter.next().unwrap()?, true);
//! assert_eq!(iter.next(), None);
//!
//! # Ok(())
//! # }
//! ```
//!
//! Masks are commutative:
//!
//! ```
//! use jsn::{TokenReader, mask::*};
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! let json = r#"[ { "key": true }, { "key": false } ]"#.as_bytes();
//!
//! let mut iter = TokenReader::new(json)
//!     .with_mask(index(1).and(key("key")))
//!     .into_iter();
//!
//! assert_eq!(iter.next().unwrap()?, false);
//!
//! let mut iter = TokenReader::new(json)
//!     .with_mask(key("key").and(index(1)))
//!     .into_iter();
//!
//! assert_eq!(iter.next().unwrap()?, false);
//!
//! # Ok(())
//! # }
//! ```
//!
//! Masks work as you would expect with [concatented/new-line delimited
//! JSON](crate::TokenReader::with_format).
//!
//! ## Gotchas
//!
//! - Be careful using masks when the JSON input has nested arrays. Token masks match the input, in
//! order, as many times as possible without overlapping:
//!
//! ```text
//!                           [ [ 1 ] , [ 2 ] , [ 3 ] ]
//! * index(0)              : _ x x x _ _ x _ _ _ x _ _
//! ```
//!
//! This result looks "unbalanced" because the first match is an entire array but the second &
//! third matches are single elements. But it _is_ correct. The mask is looking for things at
//! index 0, and that first array is at index 0.  _Though this be madness, yet there is method
//! in't._  
//!
//! - More to come as I discover them ...
//!
//!
//! ## Example
//!
//! Finding the top 250 most popular packages on NPM, the Javascript package registry.
//!  
//! The request[^1] will return JSON. Try it in your browser to get a feel for the schema:
//! ```text
//! https://registry.npmjs.org/-/v1/search?size=250&quality=0.0&maintenance=0.0&popularity=1.0&text=not:unstable
//! ```
//!
//! ```
//! use jsn::{TokenReader, JsonError, mask::*};
//! use std::io::BufReader;
//! use std::fs::File;
//!
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let file = File::open("tests/files/npm.json")?;
//!     let file = BufReader::new(file);
//!
//!     // Select the tokens under the `package.name` key.
//!     // Using `key("package").and(key("name"))` is not enough because
//!     // it will also match tokens under `package.author.name`.
//!     //
//!     // So use the depth mask instead to narrow down which level to look at
//!     let name_mask = depth(4).and(key("name"));
//!     let link_mask = key("links").and(key("npm"));
//!     let mask = name_mask.or(link_mask);
//!
//!     // Create the parser
//!     let mut reader = TokenReader::new(file).with_mask(mask);
//!
//!     let packages = reader.into_iter().collect::<Result<Vec<_>, JsonError>>()?;
//!
//!     // Et, voila
//!     assert_eq!(packages.len(), 500);
//!
//!     let mut packages = packages.chunks_exact(2);
//!
//!     let first = packages.next().unwrap();
//!     assert_eq!(first[0], "chalk");
//!     assert_eq!(first[1], "https://www.npmjs.com/package/chalk");
//!
//!     let mut packages = packages.skip(248);
//!
//!     let last = packages.next().unwrap();
//!     assert_eq!(last[0], "googleapis");
//!     assert_eq!(last[1], "https://www.npmjs.com/package/googleapis");
//!
//!     Ok(())
//! }
//! ```
//!
//! [^1]: [Registry API Docs](https://github.com/npm/registry/blob/master/docs/REGISTRY-API.md)  
//! [NPM Search metric definitions](https://npms.io/about)
//!

use crate::raw_token::RawToken;

mod private {
    pub trait Sealed {}
    impl Sealed for super::All {}
    impl Sealed for super::Keys {}
    impl Sealed for super::Key {}
    impl Sealed for super::Index {}
    impl Sealed for super::Values {}
    impl Sealed for super::Depth {}
    impl<M1, M2> Sealed for super::And<M1, M2> {}
    impl<M1, M2> Sealed for super::Or<M1, M2> {}
}

/// Expresses that the implementing type can be used as a JSON token mask.
///
/// The trait is sealed and cannot be implemented outside this crate.
pub trait Mask: Sized + private::Sealed {
    #[doc(hidden)]
    fn match_token(&mut self, token: &RawToken) -> bool;

    /// Returns a new JSON token mask that represents the intersection of two masks. The
    /// resulting mask matches only when both masks match the input.
    ///
    /// # Example
    ///
    /// ```
    /// use jsn::{TokenReader,  mask::*};
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let json = r#"{ "hello": [1,2], "bye": [3,4] }"#;
    ///
    /// let mut iter = TokenReader::new(json.as_bytes())
    ///     .with_mask(key("hello").and(index(0)))
    ///     .into_iter();
    ///
    /// assert_eq!(iter.next().unwrap()?, 1);
    /// assert_eq!(iter.next(), None);
    ///
    /// # Ok(())
    /// # }
    /// ```
    fn and<O: Mask>(self, other: O) -> And<Self, O> {
        And {
            left: self,
            right: other,
        }
    }

    /// Returns a new JSON token mask that represents the union of two masks. The resulting mask
    /// matches when either mask matches the input.
    ///
    /// # Example
    ///
    /// ```
    /// use jsn::{TokenReader,  mask::*};
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let json = r#"
    ///     {
    ///         "first_name": "Jane",
    ///         "last_name": "Doe",
    ///         "age": 28
    ///     }
    /// "#;
    ///
    /// let mask = key("first_name").or(key("last_name"));
    /// let mut iter = TokenReader::new(json.as_bytes())
    ///     .with_mask(mask)
    ///     .into_iter();
    ///
    /// assert_eq!(iter.next().unwrap()?, "Jane");
    /// assert_eq!(iter.next().unwrap()?, "Doe");
    /// assert_eq!(iter.next(), None);
    /// # Ok(())
    /// # }
    /// ```
    fn or<O: Mask>(self, other: O) -> Or<Self, O> {
        Or {
            left: self,
            right: other,
        }
    }
}

/// See [`all()`]
pub struct All;
impl Mask for All {
    #[inline]
    fn match_token(&mut self, _: &RawToken) -> bool {
        true
    }
}

/// See [`values()`]
pub struct Values;
impl Mask for Values {
    #[inline]
    fn match_token(&mut self, token: &RawToken) -> bool {
        token.is_primitive_value()
    }
}

/// See [`keys()`]
pub struct Keys;
impl Mask for Keys {
    #[inline]
    fn match_token(&mut self, token: &RawToken) -> bool {
        matches!(token, RawToken::ObjectKey(_))
    }
}

/// See [`Mask::and`]
pub struct And<M1, M2> {
    left: M1,
    right: M2,
}
impl<M1: Mask, M2: Mask> Mask for And<M1, M2> {
    #[inline]
    fn match_token(&mut self, token: &RawToken) -> bool {
        // Make sure to evaluate both masks so their state machines advance
        let matcha = self.left.match_token(token);
        let matchb = self.right.match_token(token);
        matcha && matchb
    }
}

/// See [`Mask::or`]
pub struct Or<M1, M2> {
    left: M1,
    right: M2,
}
impl<M1: Mask, M2: Mask> Mask for Or<M1, M2> {
    #[inline]
    fn match_token(&mut self, token: &RawToken) -> bool {
        let matcha = self.right.match_token(token);
        let matchb = self.left.match_token(token);
        matcha || matchb
    }
}

/// A wildcard-like mask: Matches any token
pub fn all() -> All {
    All
}

/// Selects the tokens that represent the value of an object at key `name`.
///
/// # Example
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use jsn::{TokenReader, Token, mask::*};
///
/// let json = r#"
///     {
///         "hello": ["world", 1]
///     }
/// "#;
/// let mut iter = TokenReader::new(json.as_bytes())
///     .with_mask(key("hello"))
///     .into_iter();
///
/// assert_eq!(iter.next().unwrap()?, Token::ArrayStart);
/// assert_eq!(iter.next().unwrap()?, "world");
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, 1);
/// assert_eq!(iter.next().unwrap()?, Token::ArrayEnd);
/// assert_eq!(iter.next(), None);
///
/// # Ok(())
/// # }
/// ```
pub fn key(name: impl AsRef<str>) -> Key {
    Key {
        name: name.as_ref().to_string(),
        state: KeyState::None,
        container_count: 0,
    }
}

/// Selects the tokens that represent the value of an array at index `idx`.
///
/// # Example
///
/// ```
/// use jsn::{TokenReader, Token, mask::*};
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let json = "[ [true, true], [false, false]]";
/// let mut iter = TokenReader::new(json.as_bytes())
///     .with_mask(index(0))
///     .into_iter();
///
/// assert_eq!(iter.next().unwrap()?, Token::ArrayStart);
/// assert_eq!(iter.next().unwrap()?, Token::Bool(true));
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, Token::Bool(true));
/// assert_eq!(iter.next().unwrap()?, Token::ArrayEnd);
/// assert_eq!(iter.next().unwrap()?, Token::Bool(false));
///
/// assert_eq!(iter.next(), None);
/// # Ok(())
/// # }
///
/// ```
pub fn index(idx: usize) -> Index {
    Index {
        idx,
        container_count: 0,
        structure: vec![],
        state: IndexState::None,
    }
}

/// Selects the tokens at the given depth
///
/// Here is a visualization of token depth:
///
/// ```text
/// JSON                      Depth
/// [                         0/1
///   "a",                    1
///   "b",                    1
///   {                       1/2
///     "c": true,            2
///     "d":                  2
///     [                     2/3
///       false               3
///     ]                     2/3
///   }                       1/2
///   ,                       1
///   "e"                     1
/// ]                         0
/// ```
///
/// Tokens at depth 0: `[]`
///
/// Tokens at depth 1: `["a","b",{},"e"]`
///
/// Tokens at depth 2: `{"c": true, "d": []}`
///
/// Notice how structural tokens straddle depths.
///
/// # Example
///
/// ```
/// use jsn::{TokenReader, Token, mask::*};
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
///
/// let json = r#"
///     [
///         "a",
///         "b",
///         { "c": true, "d": [ false ] },
///         "e"
///     ]
/// "#.as_bytes();
///
/// let mut iter = TokenReader::new(json)
///     .with_mask(depth(0))
///     .into_iter();
/// assert_eq!(iter.next().unwrap()?, Token::ArrayStart);
/// assert_eq!(iter.next().unwrap()?, Token::ArrayEnd);
///
/// let mut iter = TokenReader::new(json)
///     .with_mask(depth(1))
///     .into_iter();
/// assert_eq!(iter.next().unwrap()?, Token::ArrayStart);
/// assert_eq!(iter.next().unwrap()?, "a");
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, "b");
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, Token::ObjectStart);
/// assert_eq!(iter.next().unwrap()?, Token::ObjectEnd);
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, "e");
/// assert_eq!(iter.next().unwrap()?, Token::ArrayEnd);
///
/// let mut iter = TokenReader::new(json)
///     .with_mask(depth(2))
///     .into_iter();
/// assert_eq!(iter.next().unwrap()?, Token::ObjectStart);
/// assert_eq!(iter.next().unwrap()?, "c");
/// assert_eq!(iter.next().unwrap()?, Token::Colon);
/// assert_eq!(iter.next().unwrap()?, true);
/// assert_eq!(iter.next().unwrap()?, Token::Comma);
/// assert_eq!(iter.next().unwrap()?, "d");
/// assert_eq!(iter.next().unwrap()?, Token::Colon);
/// assert_eq!(iter.next().unwrap()?, Token::ArrayStart);
/// assert_eq!(iter.next().unwrap()?, Token::ArrayEnd);
/// assert_eq!(iter.next().unwrap()?, Token::ObjectEnd);
///
/// # Ok(())
/// # }
/// ```
///
pub fn depth(depth: usize) -> Depth {
    Depth {
        depth,
        current_depth: 0,
    }
}

/// Selects tokens corresponding to object keys
///
/// # Example
///
/// ```
/// use jsn::{TokenReader, mask::*};
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let json = r#"{ "/get": "do something", "/post": "do another thing" }"#;
///
/// let mut iter = TokenReader::new(json.as_bytes())
///     .with_mask(keys())
///     .into_iter();
///
/// assert_eq!(iter.next().unwrap()?, "/get");
/// assert_eq!(iter.next().unwrap()?, "/post");
/// # Ok(())
/// # }
/// ```
///
pub fn keys() -> Keys {
    Keys
}

/// Selects tokens that represent JSON primitive values (i.e. strings, numbers, booleans and null)
///
/// # Example
///
/// ```
/// use jsn::{TokenReader, mask::*};
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let json = "[1, 2, 3]".as_bytes();
///
/// let mut iter = TokenReader::new(json)
///     .with_mask(values())
///     .into_iter();
///
/// assert_eq!(iter.next().unwrap()?, 1);
/// assert_eq!(iter.next().unwrap()?, 2);
/// assert_eq!(iter.next().unwrap()?, 3);
/// assert_eq!(iter.next(), None);
/// # Ok(())
/// # }
/// ```
pub fn values() -> Values {
    Values
}

// == Notes on token mask implementation ==
//
// Token masks are generally implemented as mini state machines. This works very well with the
// pattern of emitting one token at a time, because the masks can "remember" where they are in the
// matching process across invocations.

#[derive(Debug, Clone, PartialEq, Eq)]
enum KeyState {
    None,
    Key,
    Colon,
}

/// See [`key()`](crate::mask::key)
#[derive(Debug, Clone)]
pub struct Key {
    name: String,
    state: KeyState,
    container_count: usize,
}

impl Mask for Key {
    #[inline]
    fn match_token(&mut self, token: &RawToken) -> bool {
        use KeyState::*;
        let token_matches = self.state == Colon;
        match (&self.state, token) {
            (None, RawToken::ObjectKey(s)) if s == &self.name => {
                self.state = Key;
            }
            (Key, RawToken::Colon) => {
                self.state = Colon;
            }
            (Colon, RawToken::ArrayStart | RawToken::ObjectStart) => {
                self.container_count += 1;
            }
            (Colon, RawToken::ArrayEnd | RawToken::ObjectEnd) => {
                self.container_count -= 1;
                if self.container_count == 0 {
                    self.state = None;
                }
            }
            (Colon, t) if t.is_primitive_value() && self.container_count == 0 => {
                self.state = None;
            }
            _ => {}
        };
        token_matches
    }
}

#[derive(Debug, Clone)]
enum Container {
    Array(usize),
    Object,
}

#[derive(Debug, Clone)]
/// See [`index()`](crate::mask::index)
pub struct Index {
    idx: usize,
    container_count: usize,
    structure: Vec<Container>,
    state: IndexState,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
enum IndexState {
    None,
    StructuralMatch,
}

impl Mask for Index {
    fn match_token(&mut self, token: &RawToken) -> bool {
        let matched_index = || {
            if let Some(Container::Array(current)) = self.structure.last() {
                current == &self.idx
            } else {
                false
            }
        };

        use IndexState::*;
        let token_matches = match (self.state, token) {
            (None, RawToken::ArrayStart | RawToken::ObjectStart) if matched_index() => {
                self.state = StructuralMatch;
                self.container_count += 1;
                true
            }
            (None, RawToken::ArrayStart) => {
                self.structure.push(Container::Array(0));
                false
            }
            (None, RawToken::ObjectStart) => {
                self.structure.push(Container::Object);
                false
            }
            (None, RawToken::ObjectEnd | RawToken::ArrayEnd) => {
                self.structure.pop();
                false
            }
            (None, RawToken::Comma) => {
                if let Some(Container::Array(current)) = self.structure.last_mut() {
                    *current += 1;
                }
                false
            }
            (None, t) if t.is_primitive_value() && matched_index() => true,
            (None, _) => false,

            (StructuralMatch, RawToken::ArrayStart | RawToken::ObjectStart) => {
                self.container_count += 1;
                true
            }
            (StructuralMatch, RawToken::ArrayEnd | RawToken::ObjectEnd) => {
                self.container_count -= 1;
                if self.container_count == 0 {
                    self.state = None;
                }
                true
            }
            (StructuralMatch, _) => true,
        };

        token_matches
    }
}

/// See [`depth()`]
#[derive(Debug, Clone, Copy)]
pub struct Depth {
    depth: usize,
    current_depth: usize,
}

impl Mask for Depth {
    fn match_token(&mut self, token: &RawToken) -> bool {
        // Brackets and braces "straddle" depths, so handle them differently
        match token {
            RawToken::ArrayStart | RawToken::ObjectStart => {
                self.current_depth += 1;
                self.current_depth == self.depth || self.current_depth - 1 == self.depth
            }
            RawToken::ArrayEnd | RawToken::ObjectEnd => {
                self.current_depth -= 1;
                self.current_depth == self.depth || self.current_depth + 1 == self.depth
            }
            _ => self.depth == self.current_depth,
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use crate::Format;
    use crate::TokenReader;

    #[track_caller]
    fn test_mask<I>(json: &str, mask: impl Mask, tokens: I)
    where
        I: IntoIterator<Item = &'static str>,
    {
        let actual_tokens = TokenReader::new(json.as_bytes())
            .with_mask(mask)
            .into_iter()
            .flatten()
            .map(|t| t.to_string())
            .collect::<Vec<_>>();

        let expected_tokens = tokens
            .into_iter()
            .map(|s| s.to_string())
            .collect::<Vec<_>>();

        assert_eq!(actual_tokens, expected_tokens);
    }

    // cjson = concatenated json
    #[track_caller]
    fn test_mask_cjson<I>(json: &str, mask: impl Mask, tokens: I)
    where
        I: IntoIterator<Item = &'static str>,
    {
        let actual_tokens = TokenReader::new(json.as_bytes())
            .with_mask(mask)
            .with_format(Format::Concatenated)
            .into_iter()
            .flatten()
            .map(|t| t.to_string())
            .collect::<Vec<_>>();

        let expected_tokens = tokens
            .into_iter()
            .map(|s| s.to_string())
            .collect::<Vec<_>>();

        assert_eq!(actual_tokens, expected_tokens);
    }

    #[test]
    fn key_mask() {
        // Does not match non-objects
        test_mask(r#"[ false ]"#, key("key"), []);

        // Does not match if key does not exist
        test_mask(r#"{"key1": "value"}"#, key("key"), []);

        // Can match twice in an object
        test_mask(
            r#"{ "key": true, "key": false }"#,
            key("key"),
            ["true", "false"],
        );

        // matches once when the same key is nested
        test_mask(
            r#"{ "key" : { "key": true } }"#,
            key("key"),
            ["{", "\"key\"", ":", "true", "}"],
        );

        // Returns structures
        test_mask(
            r#"{ "key": { "object": true } }"#,
            key("key"),
            ["{", "\"object\"", ":", "true", "}"],
        );

        test_mask(
            r#"{ "key": [true, false] }"#,
            key("key"),
            ["[", "true", ",", "false", "]"],
        );
    }

    #[test]
    fn index_mask() {
        // does not match non arrays
        test_mask(r#"{ "key": false }"#, index(0), []);

        // does not match empty arrays
        test_mask("[]", index(0), []);

        // matches sub arrays
        test_mask("[1, [2, 3, 4, 5], 6]", index(3), ["5"]);

        // matches once when the same index is nested
        test_mask(
            "[1, [2, [3]]]",
            index(1),
            ["[", "2", ",", "[", "3", "]", "]"],
        );

        // can match multiple times
        test_mask(
            "[[true], [true], [true]]",
            index(0),
            ["[", "true", "]", "true", "true"],
        )
    }

    #[test]
    fn depth_mask() {
        // Arrays straddle depths
        test_mask("[]", depth(0), ["[", "]"]);
        test_mask("[]", depth(1), ["[", "]"]);

        // objects straddle depths
        test_mask("{}", depth(0), ["{", "}"]);
        test_mask("{}", depth(1), ["{", "}"]);

        // Selecting items in the middle
        test_mask(
            "[1, [2], 3]",
            depth(1),
            ["[", "1", ",", "[", "]", ",", "3", "]"],
        );
    }

    #[test]
    fn keys_mask() {
        // empty object
        test_mask("{}", keys(), []);

        // selects keys at any depth
        test_mask(
            r#"{ "key1": { "key2":  "something" } }"#,
            keys(),
            ["\"key1\"", "\"key2\""],
        );
    }

    #[test]
    fn combining_masks() {
        let json = r#"
            [
                {
                    "name": "John Smith",
                    "age": 40,
                    "phones": [ 111, 222 ]
                },
                {
                    "name": "Jane Smith",
                    "age": 41,
                    "phones": [ 333, 444, 555 ]
                },
            ]
        "#;

        let mask = key("phones").and(values()).or(key("name"));

        test_mask(
            json,
            mask,
            [
                r#""John Smith""#,
                "111",
                "222",
                r#""Jane Smith""#,
                "333",
                "444",
                "555",
            ],
        );
    }

    #[test]
    fn masks_are_commutative() {
        test_mask(
            r#"{ "hello": [ 3 ] }"#,
            depth(1).and(key("hello")),
            ["[", "]"],
        );
        test_mask(
            r#"{ "hello": [ 3 ] }"#,
            key("hello").and(depth(1)),
            ["[", "]"],
        );
    }

    #[test]
    fn masks_work_with_concatenated_json() {
        test_mask_cjson(
            r#"[{ "idx": 1 }][{ "idx": 2 }][{ "idx": 3 }]"#,
            index(0).and(values()),
            ["1", "2", "3"],
        );

        test_mask_cjson(
            r#"
            { "name": "serde", "author": "someperson" }
            { "name": "jsn" }
            "#,
            key("name").or(key("author")),
            ["\"serde\"", "\"someperson\"", "\"jsn\""],
        );
    }
}