fluidattacks-blends-domain 0.6.1

//! Counterpart of `blends/syntax/readers/yaml/flow_node.py`.

use alloc::borrow::ToOwned;
use alloc::vec::Vec;

use crate::query::{adj_ast, label_text};
use crate::syntax::builders::array_node::build_array_node;
use crate::syntax::builders::literal::build_literal_node;
use crate::syntax::builders::object::build_object_node;
use crate::syntax::builders::string_literal::build_string_literal_node;
use crate::syntax::{SyntaxGraphArgs, SyntaxGraphError};
use crate::utilities::text_nodes::node_to_str;
use crate::{CodeGraph, NodeId};

const FLOW_PUNCTUATION: [&str; 6] = ["[", "]", "{", "}", ",", ";"];
const PAIR_TYPES: [&str; 2] = ["block_mapping_pair", "flow_pair"];

fn read_plain_scalar(
    args: &mut SyntaxGraphArgs<'_>,
    n_id: NodeId,
    child_id: NodeId,
) -> Result<Option<NodeId>, SyntaxGraphError> {
    let graph = args.ast_graph;
    let lit_id = adj_ast(graph, child_id, None, &[])
        .into_iter()
        .next()
        .ok_or(SyntaxGraphError::UnexpectedAstShape)?;
    let literal_type = graph.label_type(lit_id);
    let literal_text = label_text(graph, lit_id)
        .ok_or(SyntaxGraphError::UnexpectedAstShape)?
        .to_owned();
    if literal_type == Some("integer_scalar") || literal_type == Some("float_scalar") {
        return Ok(Some(build_literal_node(
            args,
            n_id,
            literal_text,
            "number".to_owned(),
        )));
    }
    if literal_type == Some("boolean_scalar") {
        return Ok(Some(build_literal_node(
            args,
            n_id,
            literal_text,
            "bool".to_owned(),
        )));
    }
    if literal_type == Some("string_scalar") {
        return Ok(Some(build_string_literal_node(
            args,
            n_id,
            literal_text,
            &[],
        )?));
    }
    Ok(None)
}

pub fn reader(
    args: &mut SyntaxGraphArgs<'_>,
    n_id: NodeId,
) -> Result<Option<NodeId>, SyntaxGraphError> {
    let graph = args.ast_graph;
    let child_id = adj_ast(graph, n_id, None, &[])
        .into_iter()
        .next()
        .ok_or(SyntaxGraphError::UnexpectedAstShape)?;
    let child_type = graph.label_type(child_id);

    if child_type == Some("plain_scalar") {
        if let Some(built) = read_plain_scalar(args, n_id, child_id)? {
            return Ok(Some(built));
        }
    }

    if child_type == Some("flow_sequence") {
        let valid_childs: Vec<NodeId> = adj_ast(graph, child_id, None, &[])
            .into_iter()
            .filter(|c_id| {
                !graph
                    .label_type(*c_id)
                    .is_some_and(|kind| FLOW_PUNCTUATION.contains(&kind))
            })
            .collect();
        return build_array_node(args, n_id, &valid_childs).map(Some);
    }

    if child_type == Some("flow_mapping") {
        let valid_childs: Vec<NodeId> = adj_ast(graph, child_id, None, &[])
            .into_iter()
            .filter(|c_id| {
                graph
                    .label_type(*c_id)
                    .is_some_and(|kind| PAIR_TYPES.contains(&kind))
            })
            .collect();
        return build_object_node(args, n_id, &valid_childs, None, None).map(Some);
    }

    let text_node = node_to_str(graph, n_id);
    Ok(Some(build_string_literal_node(args, n_id, text_node, &[])?))
}