Method parse_path

aiscript-runtime/src/parser.rs:408–456

(&mut self)

    }

    fn parse_path(&mut self) -> Result<(String, Vec<String>), String> {
        let mut path = String::new();
        let mut params = Vec::new();

        // Handle leading slash
        if self.check(TokenType::Slash) {
            path.push('/');
            self.advance();
        }

        while !self.is_at_end() {
            match self.current.kind {
                TokenType::Slash => {
                    path.push('/');
                    self.advance();
                }
                TokenType::Colon => {
                    self.advance(); // Consume :

                    // Parse parameter name
                    if !self.check(TokenType::Identifier) {
                        return Err("Expected parameter name after ':'".to_string());
                    }
                    let name = self.current.lexeme.to_string();
                    self.advance();

                    // Add parameter to path in the format Axum expects: {id}
                    path.push('{');
                    path.push_str(&name);
                    path.push('}');

                    // Add parameter name to our list
                    params.push(name);
                }
                TokenType::Identifier => {
                    path.push_str(self.current.lexeme);
                    self.advance();
                }
                TokenType::Minus => {
                    path.push('-');
                    self.advance();
                }
                TokenType::OpenBrace | TokenType::Comma => break,
                _ => return Err(format!("Unexpected token in path: {:?}", self.current.kind)),
            }
        }

        Ok((path, params))
    }
    fn consume(&mut self, expected: TokenType, message: &str) -> Result<(), String> {
        if self.check(expected) {
            self.advance();