hypen_parser/

parser.rs

use chumsky::prelude::*;

use crate::ast::*;

/// Parse a line comment: // ... until end of line
fn line_comment<'a>() -> impl Parser<'a, &'a str, (), extra::Err<Rich<'a, char>>> + Clone {
    just("//")
        .then(none_of('\n').repeated())
        .ignored()
}

/// Parse a block comment: /* ... */
fn block_comment<'a>() -> impl Parser<'a, &'a str, (), extra::Err<Rich<'a, char>>> + Clone {
    just("/*")
        .then(any().and_is(just("*/").not()).repeated())
        .then(just("*/"))
        .ignored()
}

/// Parse any comment (line or block)
fn comment<'a>() -> impl Parser<'a, &'a str, (), extra::Err<Rich<'a, char>>> + Clone {
    line_comment().or(block_comment())
}

/// Parse whitespace and comments (replaces .padded() for comment support)
fn ws<'a>() -> impl Parser<'a, &'a str, (), extra::Err<Rich<'a, char>>> + Clone {
    text::whitespace()
        .then(comment().then(text::whitespace()).repeated())
        .ignored()
}

/// Extension trait to add comment-aware padding to parsers
trait PaddedWithComments<'a, O>: Parser<'a, &'a str, O, extra::Err<Rich<'a, char>>> + Sized {
    fn padded_with_comments(self) -> impl Parser<'a, &'a str, O, extra::Err<Rich<'a, char>>> + Clone
    where
        Self: Clone,
    {
        ws().ignore_then(self).then_ignore(ws())
    }
}

impl<'a, O, P> PaddedWithComments<'a, O> for P where P: Parser<'a, &'a str, O, extra::Err<Rich<'a, char>>> {}

/// Parse a Hypen value (string, number, boolean, reference, list, map)
fn value_parser<'a>() -> impl Parser<'a, &'a str, Value, extra::Err<Rich<'a, char>>> + Clone {
    recursive(|value| {
        // String literal: "hello world"
        let string = just('"')
            .ignore_then(none_of('"').repeated())
            .then_ignore(just('"'))
            .to_slice()
            .map(|s: &str| Value::String(s.to_string()));

        // Boolean: true or false
        let boolean = text::keyword("true")
            .to(Value::Boolean(true))
            .or(text::keyword("false").to(Value::Boolean(false)));

        // Number: 123, 123.45, -123, -123.45
        let number = just('-')
            .or_not()
            .then(text::int(10))
            .then(just('.').then(text::digits(10)).or_not())
            .to_slice()
            .map(|s: &str| Value::Number(s.parse().unwrap()));

        // Reference: @state.user, @actions.login
        let reference = just('@')
            .ignore_then(
                text::ascii::ident()
                    .then(just('.').ignore_then(text::ascii::ident()).repeated())
                    .to_slice(),
            )
            .map(|s: &str| Value::Reference(s.to_string()));

        // List: [item1, item2, item3]
        let list = value
            .clone()
            .padded_with_comments()
            .separated_by(just(','))
            .allow_trailing()
            .collect()
            .delimited_by(just('['), just(']'))
            .map(Value::List);

        // Map: {key1: value1, key2: value2}
        let map_entry = text::ascii::ident()
            .padded_with_comments()
            .then_ignore(just(':'))
            .then(value.clone().padded_with_comments());

        let map = map_entry
            .separated_by(just(','))
            .allow_trailing()
            .collect::<Vec<_>>()
            .delimited_by(just('{'), just('}'))
            .map(|entries: Vec<(&str, Value)>| {
                Value::Map(entries.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
            });

        // Bare identifier (unquoted string for simple cases)
        let identifier = text::ascii::ident()
            .map(|s: &str| Value::String(s.to_string()));

        choice((string, reference, boolean, number, list, map, identifier))
    })
}

/// Parse a complete component with optional children
pub fn component_parser<'a>(
) -> impl Parser<'a, &'a str, ComponentSpecification, extra::Err<Rich<'a, char>>> + Clone {
    recursive(|component| {
        // Optional declaration keyword: "module" or "component"
        let declaration_keyword = text::keyword("module")
            .to(DeclarationType::Module)
            .or(text::keyword("component").to(DeclarationType::ComponentKeyword))
            .padded_with_comments()
            .or_not();

        // Component name (supports dot notation for applicators)
        let name = just('.')
            .or_not()
            .then(text::ascii::ident())
            .to_slice()
            .map(|s: &str| s.to_string())
            .padded_with_comments();

        // Parse single argument (named or positional)
        let value = value_parser();

        let arg = text::ascii::ident()
            .then_ignore(just(':').padded_with_comments())
            .then(value.clone())
            .map(|(key, value)| (Some(key.to_string()), value))
            .or(value.map(|value| (None, value)));

        // Arguments parser
        let arg_parser = arg
            .clone()
            .padded_with_comments()
            .separated_by(just(','))
            .allow_trailing()
            .collect::<Vec<_>>()
            .delimited_by(just('('), just(')'))
            .map(|args| {
                let arguments = args
                    .into_iter()
                    .enumerate()
                    .map(|(i, (key, value))| match key {
                        Some(k) => Argument::Named { key: k, value },
                        None => Argument::Positioned { position: i, value },
                    })
                    .collect();
                ArgumentList::new(arguments)
            })
            .or(empty().to(ArgumentList::empty()));

        let args = arg_parser.clone().padded_with_comments().or_not();

        // Children block: { child1 child2 child3 }
        // Parse explicitly to handle empty braces { }
        let children_block = just('{')
            .padded_with_comments()
            .ignore_then(
                component
                    .clone()
                    .padded_with_comments()
                    .repeated()
                    .collect::<Vec<_>>()
            )
            .then_ignore(just('}').padded_with_comments())
            .or_not();

        // Applicators: .applicator1() .applicator2(args)
        let applicators = just('.')
            .ignore_then(text::ascii::ident())
            .then(arg_parser.clone())
            .map(|(name, args)| ApplicatorSpecification {
                name: name.to_string(),
                arguments: args,
                children: vec![],
                internal_id: String::new(),
            })
            .padded_with_comments()
            .repeated()
            .collect::<Vec<_>>();

        declaration_keyword
            .then(name)
            .then(args)
            .then(children_block)
            .then(applicators)
            .map(|((((decl_type, name), args), children), applicators)| {
                // Fold applicators into the component hierarchy
                let base_component = ComponentSpecification::new(
                    id_gen::NodeId::next().to_string(),
                    name.clone(),
                    args.unwrap_or_else(ArgumentList::empty),
                    vec![],
                    fold_applicators(children.unwrap_or_default()),
                    MetaData {
                        internal_id: String::new(),
                        name_range: 0..0,
                        block_range: None,
                    },
                )
                .with_declaration_type(decl_type.unwrap_or(DeclarationType::Component));

                // If there are applicators, add them to the component
                if applicators.is_empty() {
                    base_component
                } else {
                    ComponentSpecification {
                        applicators,
                        ..base_component
                    }
                }
            })
    })
}

/// Fold applicators into component hierarchy
/// Components starting with '.' are treated as applicators of the previous component
fn fold_applicators(components: Vec<ComponentSpecification>) -> Vec<ComponentSpecification> {
    let mut result: Vec<ComponentSpecification> = Vec::new();

    for component in components {
        if component.name.starts_with('.') && !result.is_empty() {
            // This is an applicator - attach it to the previous component
            let mut owner: ComponentSpecification = result.pop().unwrap();
            owner.applicators.push(component.to_applicator());
            result.push(owner);
        } else {
            result.push(component);
        }
    }

    result
}

/// Parse an import statement
/// Syntax: import { Component1, Component2 } from "path"
///     or: import Component from "path"
pub fn import_parser<'a>() -> impl Parser<'a, &'a str, ImportStatement, extra::Err<Rich<'a, char>>> + Clone {
    // Parse import keyword
    let import_keyword = text::keyword("import").padded_with_comments();

    // Parse a string literal for the source path (properly removing quotes)
    let string_literal = just('"')
        .ignore_then(none_of('"').repeated().to_slice())
        .then_ignore(just('"'))
        .map(|s: &str| s.to_string());

    // Parse named imports: { Component1, Component2, ... }
    let named_imports = text::ascii::ident()
        .map(|s: &str| s.to_string())
        .padded_with_comments()
        .separated_by(just(','))
        .allow_trailing()
        .collect::<Vec<String>>()
        .delimited_by(just('{').padded_with_comments(), just('}').padded_with_comments())
        .map(ImportClause::Named);

    // Parse default import: ComponentName
    let default_import = text::ascii::ident()
        .map(|s: &str| s.to_string())
        .map(ImportClause::Default);

    // Import clause can be either named or default
    let import_clause = named_imports.or(default_import).padded_with_comments();

    // Parse "from" keyword
    let from_keyword = text::keyword("from").padded_with_comments();

    // Parse the full import statement
    import_keyword
        .ignore_then(import_clause)
        .then_ignore(from_keyword)
        .then(string_literal.padded_with_comments())
        .map(|(clause, source_str)| {
            // Determine if source is a URL or local path
            let source = if source_str.starts_with("http://") || source_str.starts_with("https://") {
                ImportSource::Url(source_str)
            } else {
                ImportSource::Local(source_str)
            };
            ImportStatement::new(clause, source)
        })
}

/// Parse a complete Hypen document with imports and components
pub fn document_parser<'a>() -> impl Parser<'a, &'a str, Document, extra::Err<Rich<'a, char>>> + Clone {
    // Parse imports (zero or more)
    let imports = import_parser()
        .padded_with_comments()
        .repeated()
        .collect::<Vec<ImportStatement>>();

    // Parse components (zero or more)
    let components = component_parser()
        .padded_with_comments()
        .repeated()
        .collect::<Vec<ComponentSpecification>>();

    // Combine imports and components into a document
    imports
        .then(components)
        .map(|(imports, components)| Document::new(imports, components))
}

/// Parse a list of components from text
pub fn parse_components(
    input: &str,
) -> Result<Vec<ComponentSpecification>, Vec<Rich<char>>> {
    component_parser()
        .padded_with_comments()
        .repeated()
        .collect()
        .then_ignore(end())
        .parse(input)
        .into_result()
}

/// Parse a single component from text
pub fn parse_component(
    input: &str,
) -> Result<ComponentSpecification, Vec<Rich<char>>> {
    component_parser()
        .padded_with_comments()
        .then_ignore(end())
        .parse(input)
        .into_result()
}

/// Parse a complete Hypen document (imports + components)
pub fn parse_document(
    input: &str,
) -> Result<Document, Vec<Rich<char>>> {
    document_parser()
        .padded_with_comments()
        .then_ignore(end())
        .parse(input)
        .into_result()
}

/// Parse a single import statement
pub fn parse_import(
    input: &str,
) -> Result<ImportStatement, Vec<Rich<char>>> {
    import_parser()
        .padded_with_comments()
        .then_ignore(end())
        .parse(input)
        .into_result()
}

// Simple sequential ID generator for AST nodes
mod id_gen {
    use std::sync::atomic::{AtomicUsize, Ordering};

    static COUNTER: AtomicUsize = AtomicUsize::new(0);

    pub struct NodeId(usize);

    impl NodeId {
        /// Generate the next sequential ID
        pub fn next() -> Self {
            NodeId(COUNTER.fetch_add(1, Ordering::SeqCst))
        }

        pub fn to_string(&self) -> String {
            format!("id-{}", self.0)
        }
    }
}