Struct ComponentSpecification 

pub struct ComponentSpecification {
    pub id: String,
    pub name: String,
    pub declaration_type: DeclarationType,
    pub arguments: ArgumentList,
    pub applicators: Vec<ApplicatorSpecification>,
    pub children: Vec<ComponentSpecification>,
    pub metadata: MetaData,
}

The main component specification representing a parsed component

Fields

id: String

name: String

declaration_type: DeclarationType

arguments: ArgumentList

applicators: Vec<ApplicatorSpecification>

children: Vec<ComponentSpecification>

metadata: MetaData

Implementations

impl ComponentSpecification

pub fn new( id: String, name: String, arguments: ArgumentList, applicators: Vec<ApplicatorSpecification>, children: Vec<ComponentSpecification>, metadata: MetaData, ) -> Self

pub fn with_declaration_type(self, declaration_type: DeclarationType) -> Self

pub fn flatten(&self) -> Vec<ComponentSpecification>

Flatten the component tree into a list

Examples found in repository

examples/usage.rs (line 157)

fn example_4() {
    println!("Example 4: Navigating the component tree\n");

    let input = r#"
        Column {
            Text("Header")
                .fontSize(24)

            Row {
                Button("Left")
                Button("Right")
            }

            Text("Footer")
        }
    "#;
    println!("Input: {}\n", input);

    match parse_component(input) {
        Ok(component) => {
            println!("✓ Root component: {}", component.name);
            println!("✓ Children count: {}", component.children.len());

            // Walk the tree
            println!("\nComponent tree:");
            print_tree(&component, 0);

            // Flatten to list
            let all_components = component.flatten();
            println!("\nFlattened tree ({} total components):", all_components.len());
            for comp in &all_components {
                println!(
                    "  - {} (applicators: {})",
                    comp.name,
                    comp.applicators.len()
                );
            }
        }
        Err(errors) => {
            print_parse_errors("input.hypen", input, &errors);
        }
    }
}

pub fn to_applicator(&self) -> ApplicatorSpecification

Convert a component to an applicator (when it starts with ‘.’)

Trait Implementations

impl Clone for ComponentSpecification

fn clone(&self) -> ComponentSpecification

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ComponentSpecification

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComponentSpecification

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ComponentSpecification

fn eq(&self, other: &ComponentSpecification) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ComponentSpecification

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ComponentSpecification