textfsm_core/template/

rule.rs

//! Rule and State definitions.

use fancy_regex::Regex;
use std::collections::HashMap;

use crate::error::TemplateError;
use crate::types::{LineOp, RecordOp, Transition};

/// A rule within a state.
#[derive(Debug, Clone)]
pub struct Rule {
    /// Original match pattern from template (before variable substitution).
    pub match_pattern: String,

    /// Regex pattern after ${var} substitution.
    pub regex_pattern: String,

    /// Compiled regex for matching.
    pub(crate) regex: Regex,

    /// Line operator.
    pub line_op: LineOp,

    /// Record operator.
    pub record_op: RecordOp,

    /// State transition.
    pub transition: Transition,

    /// Line number in template (for error reporting).
    pub line_num: usize,
}

/// Reserved words that cannot be state names.
const RESERVED_LINE_OPS: &[&str] = &["Continue", "Next", "Error"];
const RESERVED_RECORD_OPS: &[&str] = &["Clear", "Clearall", "Record", "NoRecord"];

impl Rule {
    /// Parse a rule line: `  ^pattern -> LineOp.RecordOp NewState`
    pub fn parse(
        line: &str,
        line_num: usize,
        value_templates: &HashMap<String, String>,
    ) -> Result<Self, TemplateError> {
        let trimmed = line.trim();

        if !trimmed.starts_with('^') {
            return Err(TemplateError::InvalidRule {
                line: line_num,
                message: "rule must start with '^'".into(),
            });
        }

        // Split on " -> " to separate pattern from action
        let (match_pattern, action_str) = if let Some(idx) = trimmed.find(" -> ") {
            (&trimmed[..idx], Some(&trimmed[idx + 4..]))
        } else {
            (trimmed, None)
        };

        // Substitute ${var} with named capture patterns
        let regex_pattern = Self::substitute_variables(match_pattern, value_templates, line_num)?;

        // Compile regex
        let regex = Regex::new(&regex_pattern).map_err(|e| TemplateError::InvalidRegex {
            pattern: regex_pattern.clone(),
            message: e.to_string(),
        })?;

        // Parse action if present
        let (line_op, record_op, transition) = if let Some(action) = action_str {
            Self::parse_action(action.trim(), line_num)?
        } else {
            (LineOp::default(), RecordOp::default(), Transition::default())
        };

        // Validate: Continue cannot have state transition
        if line_op == LineOp::Continue && !matches!(transition, Transition::Stay) {
            return Err(TemplateError::ContinueWithTransition(line_num));
        }

        Ok(Self {
            match_pattern: match_pattern.to_string(),
            regex_pattern,
            regex,
            line_op,
            record_op,
            transition,
            line_num,
        })
    }

    fn substitute_variables(
        pattern: &str,
        templates: &HashMap<String, String>,
        line_num: usize,
    ) -> Result<String, TemplateError> {
        let mut result = pattern.to_string();

        // Find all ${var} patterns using a simple approach
        // We'll iterate and replace each one
        loop {
            let start = match result.find("${") {
                Some(i) => i,
                None => break,
            };

            let end = match result[start..].find('}') {
                Some(i) => start + i,
                None => {
                    return Err(TemplateError::InvalidRule {
                        line: line_num,
                        message: "unclosed variable substitution".into(),
                    })
                }
            };

            let var_name = &result[start + 2..end];

            let template = templates.get(var_name).ok_or_else(|| {
                TemplateError::InvalidSubstitution {
                    line: line_num,
                    message: format!("unknown variable '{}'", var_name),
                }
            })?;

            result = format!("{}{}{}", &result[..start], template, &result[end + 1..]);
        }

        Ok(result)
    }

    fn parse_action(
        action: &str,
        line_num: usize,
    ) -> Result<(LineOp, RecordOp, Transition), TemplateError> {
        if action.is_empty() {
            return Ok((LineOp::default(), RecordOp::default(), Transition::default()));
        }

        let parts: Vec<&str> = action.split_whitespace().collect();

        let mut line_op = LineOp::default();
        let mut record_op = RecordOp::default();
        let mut transition = Transition::default();
        let mut idx = 0;

        if idx < parts.len() {
            let first = parts[idx];

            // Check for compound operator: LineOp.RecordOp
            if let Some((line_part, record_part)) = first.split_once('.') {
                line_op = Self::parse_line_op(line_part, line_num)?;
                record_op = Self::parse_record_op(record_part, line_num)?;
                idx += 1;
            } else if let Some(op) = Self::try_parse_line_op(first) {
                line_op = op;
                idx += 1;

                // Special case: Error with quoted message
                // e.g., Error "LINE NOT FOUND" - the message is not a state
                if line_op == LineOp::Error && idx < parts.len() {
                    let rest = parts[idx..].join(" ");
                    if rest.starts_with('"') {
                        // Extract quoted error message
                        if let Some(end_quote) = rest[1..].find('"') {
                            let message = rest[1..end_quote + 1].to_string();
                            transition = Transition::State(message);
                        } else {
                            // Unterminated quote, take the rest as message
                            transition = Transition::State(rest.trim_matches('"').to_string());
                        }
                        return Ok((line_op, record_op, transition));
                    }
                }
            } else if let Some(op) = Self::try_parse_record_op(first) {
                record_op = op;
                idx += 1;
            } else {
                // Must be a state name
                transition = Self::parse_transition(first);
                idx += 1;
            }
        }

        // Parse second part if present (should be state name)
        if idx < parts.len() && matches!(transition, Transition::Stay) {
            transition = Self::parse_transition(parts[idx]);
        }

        Ok((line_op, record_op, transition))
    }

    fn try_parse_line_op(s: &str) -> Option<LineOp> {
        match s {
            "Next" => Some(LineOp::Next),
            "Continue" => Some(LineOp::Continue),
            "Error" => Some(LineOp::Error),
            _ => None,
        }
    }

    fn parse_line_op(s: &str, line_num: usize) -> Result<LineOp, TemplateError> {
        Self::try_parse_line_op(s).ok_or_else(|| TemplateError::InvalidRule {
            line: line_num,
            message: format!("invalid line operator '{}'", s),
        })
    }

    fn try_parse_record_op(s: &str) -> Option<RecordOp> {
        match s {
            "NoRecord" => Some(RecordOp::NoRecord),
            "Record" => Some(RecordOp::Record),
            "Clear" => Some(RecordOp::Clear),
            "Clearall" => Some(RecordOp::ClearAll),
            _ => None,
        }
    }

    fn parse_record_op(s: &str, line_num: usize) -> Result<RecordOp, TemplateError> {
        Self::try_parse_record_op(s).ok_or_else(|| TemplateError::InvalidRule {
            line: line_num,
            message: format!("invalid record operator '{}'", s),
        })
    }

    fn parse_transition(s: &str) -> Transition {
        match s {
            "End" => Transition::End,
            "EOF" => Transition::Eof,
            _ => {
                // Handle quoted error messages
                if s.starts_with('"') && s.ends_with('"') {
                    Transition::State(s[1..s.len() - 1].to_string())
                } else {
                    Transition::State(s.to_string())
                }
            }
        }
    }
}

/// A state containing rules.
#[derive(Debug, Clone)]
pub struct State {
    /// Name of this state.
    pub name: String,

    /// Rules in this state, checked in order.
    pub rules: Vec<Rule>,
}

impl State {
    /// Create a new empty state.
    pub fn new(name: String) -> Self {
        Self {
            name,
            rules: Vec::new(),
        }
    }

    /// Check if a name is valid for a state.
    pub fn is_valid_name(name: &str) -> bool {
        if name.is_empty() || name.len() > 48 {
            return false;
        }

        // Must be alphanumeric/underscore
        if !name.chars().all(|c| c.is_alphanumeric() || c == '_') {
            return false;
        }

        // Cannot be a reserved word
        if RESERVED_LINE_OPS.contains(&name) || RESERVED_RECORD_OPS.contains(&name) {
            return false;
        }

        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn empty_templates() -> HashMap<String, String> {
        HashMap::new()
    }

    fn sample_templates() -> HashMap<String, String> {
        let mut m = HashMap::new();
        m.insert("Interface".into(), "(?P<Interface>\\S+)".into());
        m.insert("Status".into(), "(?P<Status>up|down)".into());
        m
    }

    #[test]
    fn test_parse_simple_rule() {
        let r = Rule::parse("^Interface: (\\S+)", 1, &empty_templates()).unwrap();
        assert_eq!(r.match_pattern, "^Interface: (\\S+)");
        assert_eq!(r.line_op, LineOp::Next);
        assert_eq!(r.record_op, RecordOp::NoRecord);
        assert!(matches!(r.transition, Transition::Stay));
    }

    #[test]
    fn test_parse_rule_with_record() {
        let r = Rule::parse("^End -> Record", 1, &empty_templates()).unwrap();
        assert_eq!(r.line_op, LineOp::Next);
        assert_eq!(r.record_op, RecordOp::Record);
    }

    #[test]
    fn test_parse_rule_with_compound_action() {
        let r = Rule::parse("^Line -> Next.Record", 1, &empty_templates()).unwrap();
        assert_eq!(r.line_op, LineOp::Next);
        assert_eq!(r.record_op, RecordOp::Record);
    }

    #[test]
    fn test_parse_rule_with_state_transition() {
        let r = Rule::parse("^Start -> Continue.Record NextState", 1, &empty_templates());
        // Continue with state transition should fail
        assert!(matches!(r, Err(TemplateError::ContinueWithTransition(_))));
    }

    #[test]
    fn test_parse_rule_with_variable_substitution() {
        let templates = sample_templates();
        let r = Rule::parse("^Interface: ${Interface} is ${Status}", 1, &templates).unwrap();
        assert!(r.regex_pattern.contains("(?P<Interface>"));
        assert!(r.regex_pattern.contains("(?P<Status>"));
    }

    #[test]
    fn test_state_valid_names() {
        assert!(State::is_valid_name("Start"));
        assert!(State::is_valid_name("State1"));
        assert!(State::is_valid_name("my_state"));
        assert!(!State::is_valid_name("Continue")); // reserved
        assert!(!State::is_valid_name("Record")); // reserved
        assert!(!State::is_valid_name("")); // empty
    }
}