deepwoken_reqparse/parse/

reqfile.rs

use std::collections::{HashMap, HashSet};
use std::path::Path;

use crate::model::req::{ReqVecExt, Requirement, Timing};
use crate::util::reqtree::ReqTree;
use crate::error::{Result, ReqparseError};
use crate::model::{opt::OptionalGroup};
use winnow::ascii::{digit1, multispace0};
use winnow::combinator::{alt, separated};
use winnow::prelude::*;

use super::req::{identifier, requirement};

enum BaseReqfileLine {
    Requirement(Requirement),
    DepedencyWithIdentifier {
        prereqs: Vec<String>,
        dependent: String,
    },
}

/// A full reqfile line.
/// Note a required requirement cannot have optional prereqs.
enum ReqfileLine {
    /// The regular requirement line.
    Unspecified(BaseReqfileLine),
    /// A line with the prefix '+', that forces it and its dependents to all be required. 
    /// Used to force a prereq of an optional req to be required. 
    ForceRequired(BaseReqfileLine),
    /// A line with the prefix 'n ;', where n is an integer from 0-5. Marks the req as optional
    /// and assigns n as the weight. Recursively marks all prereqs as optional and ties their obtainment
    /// to each other.  
    Optional { base: BaseReqfileLine, weight: i64 }
}

/// The parsed representation of a reqfile
#[derive(Debug)]
pub struct Reqfile {
    pub general: Vec<Requirement>,
    pub post: Vec<Requirement>,

    pub optional: Vec<OptionalGroup>
}

impl ReqfileLine {
    pub fn base(&self) -> &BaseReqfileLine {
        match self {
            ReqfileLine::Unspecified(base)
            | ReqfileLine::ForceRequired(base) 
            | ReqfileLine::Optional { base, .. } => base,
        }
    }

    pub fn base_mut(&mut self) -> &mut BaseReqfileLine {
        match self {
            ReqfileLine::Unspecified(base)
            | ReqfileLine::ForceRequired(base) 
            | ReqfileLine::Optional { base, .. } => base,
        }
    }

    pub fn is_explicit_optional(&self) -> bool {
        match self {
            ReqfileLine::Optional { .. } => true,
            _ => false
        }
    }
}

fn parse_reqfile_line(input: &str) -> std::result::Result<ReqfileLine, String> {
    let input = input.trim();
    reqfile_line
        .parse(&input)
        .map_err(|e| format!("Parse error: {}", e))
}

fn reqfile_line(input: &mut &str) -> ModalResult<ReqfileLine> {
    let _ = multispace0.parse_next(input)?;
    alt((
        optional_line,
        force_required_line,
        base_reqfile_line.map(ReqfileLine::Unspecified),
    ))
    .parse_next(input)
}

// optional_line = weight ';' base_reqfile_line
fn optional_line(input: &mut &str) -> ModalResult<ReqfileLine> {
    let weight = 
        digit1.try_map(|s: &str| s.parse::<i64>())
        .verify(|&n| (1..=20).contains(&n))
        .parse_next(input)?;

    let _ = (multispace0, ';', multispace0).parse_next(input)?;
    let base = base_reqfile_line.parse_next(input)?;
    Ok(ReqfileLine::Optional { base, weight })
}

// force_reqfile_line = '+' base_reqfile_line
fn force_required_line(input: &mut &str) -> ModalResult<ReqfileLine> {
    let _ = ('+', multispace0).parse_next(input)?;
    let base = base_reqfile_line.parse_next(input)?;
    Ok(ReqfileLine::ForceRequired(base))
}

// base_reqfile_line = dependency_statement | requirement
fn base_reqfile_line(input: &mut &str) -> ModalResult<BaseReqfileLine> {
    let _ = multispace0.parse_next(input)?;

    alt((
        dependency_statement,
        requirement.map(BaseReqfileLine::Requirement),
    ))
    .parse_next(input)
}

// dependency_statement = identifier (',' identifier)* '=>' (requirement | identifier)
fn dependency_statement(input: &mut &str) -> ModalResult<BaseReqfileLine> {
    let prereqs: Vec<String> =
        separated(1.., identifier, (multispace0, ',', multispace0)).parse_next(input)?;

    let _ = multispace0.parse_next(input)?;
    let _ = "=>".parse_next(input)?;
    let _ = multispace0.parse_next(input)?;

    alt((
        |i: &mut &str| {
            let mut req = requirement.parse_next(i)?;
            req.prereqs = prereqs.clone();
            Ok(BaseReqfileLine::Requirement(req))
        },
        |i: &mut &str| {
            let dependent = identifier.parse_next(i)?;
            Ok(BaseReqfileLine::DepedencyWithIdentifier {
                prereqs: prereqs.clone(),
                dependent,
            })
        },
    ))
    .parse_next(input)
}

struct ParsedLine {
    rf_line: ReqfileLine,
    line_num: usize,
    timing: Timing
}

fn validate_and_transform(mut lines: Vec<ParsedLine>) -> Result<Reqfile> {
    // store indices of all the named requirements for referencing later
    let mut named: HashMap<String, usize> = HashMap::new();

    // store indices of all the reqs using their str representation if none
    let str_to_idx: HashMap<String, usize> = lines.iter().enumerate()
        .filter_map(|(i, l)| {
        match l.rf_line.base() {
            BaseReqfileLine::Requirement(req) 
                => Some((req.name_or_default(), i)),
            _ => None
        }
    }).collect();

    // a list of all reqs with prereq identifiers (prereqs, req, line_num)
    let mut dependent_ids: Vec<(Vec<String>, String, u64)> = vec![];

    // collect the dependence statements and push all named identifiers
    // into a map
    for (vec_idx, line) in lines.iter().enumerate() {
        let line_num = line.line_num;

        let base = line.rf_line.base();

        match base {
            BaseReqfileLine::DepedencyWithIdentifier { prereqs, dependent } 
            => {
                // TODO! DependencyWithId should actually be a top level enum variatn.
                // since its not affected by required, forced, unmarked semantics
                // so yea for now we error if the user misuses the api (FOR NOW)
                if let ReqfileLine::Unspecified(_) = &line.rf_line {
                    
                } else {
                    return Err(ReqparseError::Reqfile {
                        line: line.line_num, 
                        message: "Optional annotations '+' or ';' must be used \
                        at the requirement definition, not in a dependency statement, unless \
                        the definition is in the dependency statement itself.".into()
                    })
                };

                dependent_ids.push(
                    (prereqs.clone(), dependent.clone(), line_num as u64)
                );
            },
            BaseReqfileLine::Requirement(req) => {
                // update the named reqs map
                if let Some(name) = &req.name {
                    // if its a duplicate identifier, err
                    if named.insert(name.clone(), vec_idx).is_some() {
                        return Err(ReqparseError::Reqfile {
                            line: (line_num + 1) as usize,
                            message: format!("Duplicate identifier: {}", name),
                        }); 
                    }
                }
            }
        };
    }

    // sanity check: an anonymous req with prereqs is not equal 
    // to another anonymous req anywhere (more specifically their string forms). 
    // (since this may fuck up the tree creation. force the user to identify them uniquely)
    for line in &lines {
        let base = line.rf_line.base(); 

        if let BaseReqfileLine::Requirement(req) = base {
            // only lf anon reqs 
            if req.name.is_some() { continue }

            let other_anon = lines.iter().map(|line| line.rf_line.base())
            .find(|other| {
                if let BaseReqfileLine::Requirement(other_req) = other {
                    other_req.name.is_none()
                    && other_req.name_or_default() == req.name_or_default()
                    // if any one of them has prereqs, we want to raise this err
                    && (!other_req.prereqs.is_empty() || !req.prereqs.is_empty())
                    && other_req != req
                } else {
                    false 
                }
            });

            if other_anon.is_some() {
                return Err(ReqparseError::Reqfile { 
                    line: line.line_num, 
                    message: format!(
                        "You may not have duplicate anonymous requirements if either of them have prerequisites: {}",
                        req.name_or_default()
                    )
                })
            }
        }
    }

    // resolve dependency statements within the parsed lines vec
    for (prereqs, name, line_num) in dependent_ids {
        match named.get(&name) {
            Some(vec_idx) => {
                // quick validation loop to check if
                // the prereqs do in fact exist
                for prereq in &prereqs {
                    if !named.contains_key(prereq) {
                        return Err(ReqparseError::Reqfile { 
                            line: line_num as usize, 
                            message: format!("Prerequisite: no variable named '{name}'.")
                        })
                    }
                }

                let line = &mut lines[*vec_idx];
                
                let base: &mut BaseReqfileLine = line.rf_line.base_mut();

                match base {
                    BaseReqfileLine::Requirement(req) => {
                        if !req.prereqs.is_empty() {
                            return Err(ReqparseError::Reqfile { 
                                line: line_num as usize, 
                                message: format!("'{name}' has multiple prerequisite assignments.")
                            })
                        }

                        req.prereqs = prereqs;
                    },
                    _ => {}
                };
            },
            None => {
                return Err(ReqparseError::Reqfile { 
                    line: line_num as usize, 
                    message: format!("Dependent: no variable named '{name}'.")
                })
            }
        }
    }

    let mut tree = ReqTree::new();

    // build the requirement tree
    for line in &lines {
        let base = line.rf_line.base();

        match base {
            BaseReqfileLine::Requirement(req) => {
                tree.insert(req.clone());
            },
            _ => {}
        }
    }

    // sanity check: why tf would we have a cycle 
    if let Some(cycle) = tree.find_cycle() {
        return Err(ReqparseError::Reqfile {
            line: 0, 
            message: format!(
                "Prereqs cannot be dependent on each other. Found cycle: {}", 
                cycle.join(" => ")
            ) 
        })
    }

    // sanity check: a required req cannot have an optional prereq
    let check_opt_prereq = || {
        for line in &lines {
            match &line.rf_line {
                // check dependents of Optional reqs to see if dependents are strict, 
                // faster and simpler bc they must be named to have dependents by the standard
                // (yes the reqfile standard trust me bro)
                ReqfileLine::Optional { base, .. } => {
                    if let BaseReqfileLine::Requirement(req) = base {
                        if let Some(name) = &req.name {
                            for dependent in tree.all_dependents(name) {
                                let vec_idx = str_to_idx[&dependent];

                                let dependent_line = &lines[vec_idx];
     
                                if !dependent_line.rf_line.is_explicit_optional() {
                                    return Err(ReqparseError::Reqfile { 
                                        line: line.line_num, 
                                        message: format!(
                                            "'{}' was declared as optional, however one of its \
                                            dependents are required: '{} at line {}'.\n\
                                            Try marking '{}' as optional instead.",
                                            name, 
                                            dependent,
                                            dependent_line.line_num,
                                            dependent
                                        )
                                    })
                                }
                            }
                        }
                    }
                },
                _ => {}
            }
        }

        Ok(())
    };

    check_opt_prereq()?;

    // payload is validated, now build payload
    
    // mark all transitive prereqs of an optional as optional, while

    let mut optional: Vec<OptionalGroup> = vec![];

    let mut marked_opt: HashSet<String> = HashSet::new();

    for line in &lines {
        match &line.rf_line {
            ReqfileLine::Optional { base, weight } => {
                // explicitly marked optional, so mark all previous
                
                if let BaseReqfileLine::Requirement(req) = base {
                    let mut group = OptionalGroup {
                        general: HashSet::new(),
                        post: HashSet::new(),
                        weight: *weight,
                    };

                    // build the subtree

                    for req in tree
                        .all_prereqs(&req.name_or_default())
                        .iter().chain(&[req.name_or_default()]) {

                        let vec_idx = str_to_idx[req];

                        let req_line = &lines[vec_idx];

                        match req_line.rf_line.base() {
                            BaseReqfileLine::Requirement(req) => {
                                group.get_set(req_line.timing)
                                    .insert(req.clone());
                            },
                            _ => {}
                        }

                        marked_opt.insert(req.clone());
                    }

                    optional.push(group)
                }
            },
            _ => {}
        }
    }

    // mark all forced required reqs and their transitive prereqs

    for line in &lines {
        match &line.rf_line {
            ReqfileLine::ForceRequired(base) => {
                if let BaseReqfileLine::Requirement(req) = base {
                    // go thru the optional vec and remove it and its prereqs
                    // wherever possible

                    for req in tree
                        .all_prereqs(&req.name_or_default())
                        .iter().chain(&[req.name_or_default()]) {

                        let vec_idx = str_to_idx[req];

                        let req_line = &lines[vec_idx];

                        match req_line.rf_line.base() {
                            BaseReqfileLine::Requirement(req) => {
                                for group in &mut optional {
                                    group.get_set(req_line.timing).remove(req);
                                }
                            },
                            _ => {}
                        }

                        // remove mark
                        marked_opt.remove(req);
                    }                    
                }
            },
            _ => {}
        }
    }

    // dump the rest of the reqs into their respective free/post bucket
    let mut general: Vec<Requirement> = vec![];
    let mut post: Vec<Requirement> = vec![];

    for line in &lines {
        // dont have to match on anyting specific, because
        // marked_opt tells us if it's final state was optional or not
        let base = line.rf_line.base();
        if let BaseReqfileLine::Requirement(req) = base {
            if marked_opt.contains(&req.name_or_default()) { continue }

            match line.timing {
                Timing::Free => general.push(req.clone()),
                Timing::Post => post.push(req.clone()),
            }
        }
    }

   Ok( Reqfile {
        general,
        post,
        optional
    })
}

// TODO! this should really be the only entry point to create a Reqfile, 
// since it also validates if the payload will be semantically correct
pub fn parse_reqfile_str(content: &String) -> Result<Reqfile> {
    let mut lines: Vec<ParsedLine> = vec![];

    let mut current = Timing::Free;

    for (i, line) in content.lines().enumerate() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') || line.starts_with("//") {
            continue;
        }

        if line.to_uppercase().starts_with("FREE") {
            current = Timing::Free;
            continue;
        }

        if line.to_uppercase().starts_with("POST") {
            current = Timing::Post;
            continue;
        }

        let parsed = parse_reqfile_line(&line).map_err(|e| ReqparseError::Reqfile {
            line: i + 1,
            message: e.to_string(),
        })?;

        lines.push(ParsedLine {
            rf_line: parsed, 
            line_num: i, 
            timing: current 
        });
    }

    validate_and_transform(lines)
}

/// Parse '.req' files into a SolverPayload
pub fn parse_reqfile(path: &Path) -> Result<Reqfile> {
    use std::fs;

    let content = fs::read_to_string(path)?;

    parse_reqfile_str(&content)
}

pub fn gen_reqfile(payload: &Reqfile) -> String {
    let mut output = String::new();

    output.push_str("# Auto-generated reqfile\n\n");
    output.push_str("Free:\n");

    // remove spaces from names
    //
    // we also give anonymous reqs with prereqs an identifier
    // (we don't assign names to potentially unnammed prereqs bc
    // it is a requirement that prereqs are already named)

    let clean_name = |name: &str| {
        name.replace(" ", "_")
            .replace("[", "")
            .replace("]", "")
            .replace("'", "")
            .replace(":", "")
            .replace("(", "")
            .replace(")", "")
    };

    let mut i = 0;

    let mut general = payload
        .general
        .iter()
        .map(|req: &Requirement| {
            i += 1;

            let mut req = req.clone();

            req.name = req.name.clone().or_else(|| {
                if !req.prereqs.is_empty() {
                    Some(format!("id_{}", i))
                } else {
                    None
                }
            });

            req
        })
        .collect::<Vec<_>>();

    let mut post = payload
        .post
        .iter()
        .map(|req: &Requirement| {
            i += 1;

            let mut req = req.clone();

            req.name = req.name.clone().or_else(|| {
                if !req.prereqs.is_empty() {
                    Some(format!("id_{}", i))
                } else {
                    None
                }
            });

            req
        })
        .collect::<Vec<_>>();

    general.map_names(clean_name);

    post.map_names(clean_name);

    for req in &general {
        output.push_str(&format!("{}\n", req));
    }

    if !post.is_empty() {
        output.push_str("\nPost:\n");

        for req in &post {
            output.push_str(&format!("{}\n", req));
        }
    }

    output
}