onedrop_parser/

parser.rs

//! Parser implementation for .milk files.

use crate::error::{ParseError, Result};
use crate::preset::*;

/// Parse a complete .milk preset file.
pub fn parse_milk_preset(input: &str) -> Result<MilkPreset> {
    let mut preset = MilkPreset::default();
    let mut lines = input.lines().enumerate();

    // Parse header
    for (_line_num, line) in lines.by_ref() {
        let line = line.trim();
        if line.is_empty() {
            continue;
        }

        if line.starts_with("MILKDROP_PRESET_VERSION=") {
            preset.version = parse_version_line(line)?;
        } else if line.starts_with("PSVERSION_WARP=") {
            preset.ps_version_warp = parse_psversion_line(line)?;
        } else if line.starts_with("PSVERSION_COMP=") {
            preset.ps_version_comp = parse_psversion_line(line)?;
        } else if line.starts_with("[preset") {
            // Found preset section, break to parse body
            break;
        }
    }

    // Parse preset body
    for (_line_num, line) in lines {
        let line = line.trim();
        if line.is_empty() {
            continue;
        }

        // Parse per-frame init equations (must check before per_frame_*)
        if line.starts_with("per_frame_init_") {
            if let Some(equation) = parse_equation_line(line) {
                preset.per_frame_init_equations.push(equation);
            }
        }
        // Parse per-frame equations
        else if line.starts_with("per_frame_") {
            if let Some(equation) = parse_equation_line(line) {
                preset.per_frame_equations.push(equation);
            }
        }
        // Parse per-pixel equations
        else if line.starts_with("per_pixel_") {
            if let Some(equation) = parse_equation_line(line) {
                preset.per_pixel_equations.push(equation);
            }
        }
        // Parse warp shader
        else if line.starts_with("warp_") {
            let shader_line = parse_shader_line(line);
            if let Some(ref mut shader) = preset.warp_shader {
                shader.push_str(&shader_line);
                shader.push('\n');
            } else {
                preset.warp_shader = Some(shader_line + "\n");
            }
        }
        // Parse comp shader
        else if line.starts_with("comp_") {
            let shader_line = parse_shader_line(line);
            if let Some(ref mut shader) = preset.comp_shader {
                shader.push_str(&shader_line);
                shader.push('\n');
            } else {
                preset.comp_shader = Some(shader_line + "\n");
            }
        }
        // Parse wavecode (scalar params: wavecode_N_*=...)
        else if line.starts_with("wavecode_") {
            parse_wavecode_line(line, &mut preset.waves)?;
        }
        // Parse shapecode (scalar params: shapecode_N_*=...)
        else if line.starts_with("shapecode_") {
            parse_shapecode_line(line, &mut preset.shapes)?;
        }
        // Parse custom-wave equations (wave_N_per_frameX, wave_N_per_pointX, wave_N_initX)
        else if is_indexed_block(line, "wave_") {
            parse_wave_equation_line(line, &mut preset.waves)?;
        }
        // Parse custom-shape equations (shape_N_per_frameX, shape_N_initX)
        else if is_indexed_block(line, "shape_") {
            parse_shape_equation_line(line, &mut preset.shapes)?;
        }
        // Parse regular parameters
        else if let Some((key, value)) = line.split_once('=') {
            parse_parameter(key.trim(), value.trim(), &mut preset.parameters)?;
        }
    }

    Ok(preset)
}

/// Parse version line (e.g., "MILKDROP_PRESET_VERSION=201")
fn parse_version_line(line: &str) -> Result<u32> {
    line.split('=')
        .nth(1)
        .and_then(|v| v.trim().parse().ok())
        .ok_or_else(|| ParseError::InvalidVersion(line.to_string()))
}

/// Parse PS version line
fn parse_psversion_line(line: &str) -> Result<u32> {
    line.split('=')
        .nth(1)
        .and_then(|v| v.trim().parse().ok())
        .ok_or_else(|| ParseError::ParseFailed(format!("Invalid PSVERSION: {}", line)))
}

/// Parse equation line (e.g., "per_frame_1=wave_r = 0.5;")
fn parse_equation_line(line: &str) -> Option<String> {
    line.split_once('=')
        .map(|(_, equation)| equation.trim().to_string())
}

/// Parse shader line (e.g., "warp_1=`shader_body")
fn parse_shader_line(line: &str) -> String {
    line.split_once('=')
        .map(|(_, code)| {
            // Remove backtick prefix if present
            code.trim().trim_start_matches('`').to_string()
        })
        .unwrap_or_default()
}

/// Parse a parameter and store it in PresetParameters
fn parse_parameter(key: &str, value: &str, params: &mut PresetParameters) -> Result<()> {
    // Helper to parse float
    let parse_f32 = |v: &str| -> Result<f32> {
        v.parse().map_err(|_| ParseError::InvalidParameter {
            name: key.to_string(),
            value: v.to_string(),
            reason: "Expected float".to_string(),
        })
    };

    // Helper to parse int
    let parse_i32 = |v: &str| -> Result<i32> {
        v.parse().map_err(|_| ParseError::InvalidParameter {
            name: key.to_string(),
            value: v.to_string(),
            reason: "Expected integer".to_string(),
        })
    };

    // Helper to parse bool
    let parse_bool = |v: &str| -> Result<bool> {
        match v {
            "0" => Ok(false),
            "1" => Ok(true),
            _ => Err(ParseError::InvalidParameter {
                name: key.to_string(),
                value: v.to_string(),
                reason: "Expected 0 or 1".to_string(),
            }),
        }
    };

    match key {
        // Float parameters
        "fRating" => params.f_rating = parse_f32(value)?,
        "fGammaAdj" => params.f_gamma_adj = parse_f32(value)?,
        "fDecay" => params.f_decay = parse_f32(value)?,
        "fVideoEchoZoom" => params.f_video_echo_zoom = parse_f32(value)?,
        "fVideoEchoAlpha" => params.f_video_echo_alpha = parse_f32(value)?,
        "fWaveAlpha" => params.f_wave_alpha = parse_f32(value)?,
        "fWaveScale" => params.f_wave_scale = parse_f32(value)?,
        "fWaveSmoothing" => params.f_wave_smoothing = parse_f32(value)?,
        "fWaveParam" => params.f_wave_param = parse_f32(value)?,
        "fModWaveAlphaStart" => params.f_mod_wave_alpha_start = parse_f32(value)?,
        "fModWaveAlphaEnd" => params.f_mod_wave_alpha_end = parse_f32(value)?,
        "fWarpAnimSpeed" => params.f_warp_anim_speed = parse_f32(value)?,
        "fWarpScale" => params.f_warp_scale = parse_f32(value)?,
        "fZoomExponent" => params.f_zoom_exponent = parse_f32(value)?,
        "fShader" => params.f_shader = parse_f32(value)?,

        // Motion parameters
        "zoom" => params.zoom = parse_f32(value)?,
        "rot" => params.rot = parse_f32(value)?,
        "cx" => params.cx = parse_f32(value)?,
        "cy" => params.cy = parse_f32(value)?,
        "dx" => params.dx = parse_f32(value)?,
        "dy" => params.dy = parse_f32(value)?,
        "warp" => params.warp = parse_f32(value)?,
        "sx" => params.sx = parse_f32(value)?,
        "sy" => params.sy = parse_f32(value)?,

        // Wave colors
        "wave_r" => params.wave_r = parse_f32(value)?,
        "wave_g" => params.wave_g = parse_f32(value)?,
        "wave_b" => params.wave_b = parse_f32(value)?,
        "wave_x" => params.wave_x = parse_f32(value)?,
        "wave_y" => params.wave_y = parse_f32(value)?,

        // Borders
        "ob_size" => params.ob_size = parse_f32(value)?,
        "ob_r" => params.ob_r = parse_f32(value)?,
        "ob_g" => params.ob_g = parse_f32(value)?,
        "ob_b" => params.ob_b = parse_f32(value)?,
        "ob_a" => params.ob_a = parse_f32(value)?,
        "ib_size" => params.ib_size = parse_f32(value)?,
        "ib_r" => params.ib_r = parse_f32(value)?,
        "ib_g" => params.ib_g = parse_f32(value)?,
        "ib_b" => params.ib_b = parse_f32(value)?,
        "ib_a" => params.ib_a = parse_f32(value)?,

        // Motion vectors
        "nMotionVectorsX" => params.n_motion_vectors_x = parse_f32(value)?,
        "nMotionVectorsY" => params.n_motion_vectors_y = parse_f32(value)?,
        "mv_dx" => params.mv_dx = parse_f32(value)?,
        "mv_dy" => params.mv_dy = parse_f32(value)?,
        "mv_l" => params.mv_l = parse_f32(value)?,
        "mv_r" => params.mv_r = parse_f32(value)?,
        "mv_g" => params.mv_g = parse_f32(value)?,
        "mv_b" => params.mv_b = parse_f32(value)?,
        "mv_a" => params.mv_a = parse_f32(value)?,

        // Beat detection
        "b1n" => params.b1n = parse_f32(value)?,
        "b2n" => params.b2n = parse_f32(value)?,
        "b3n" => params.b3n = parse_f32(value)?,
        "b1x" => params.b1x = parse_f32(value)?,
        "b2x" => params.b2x = parse_f32(value)?,
        "b3x" => params.b3x = parse_f32(value)?,
        "b1ed" => params.b1ed = parse_f32(value)?,

        // Integer parameters
        "nVideoEchoOrientation" => params.n_video_echo_orientation = parse_i32(value)?,
        "nWaveMode" => params.n_wave_mode = parse_i32(value)?,

        // Boolean parameters
        "bAdditiveWaves" => params.b_additive_waves = parse_bool(value)?,
        "bWaveDots" => params.b_wave_dots = parse_bool(value)?,
        "bWaveThick" => params.b_wave_thick = parse_bool(value)?,
        "bModWaveAlphaByVolume" => params.b_mod_wave_alpha_by_volume = parse_bool(value)?,
        "bMaximizeWaveColor" => params.b_maximize_wave_color = parse_bool(value)?,
        "bTexWrap" => params.b_tex_wrap = parse_bool(value)?,
        "bDarkenCenter" => params.b_darken_center = parse_bool(value)?,
        "bRedBlueStereo" => params.b_red_blue_stereo = parse_bool(value)?,
        "bBrighten" => params.b_brighten = parse_bool(value)?,
        "bDarken" => params.b_darken = parse_bool(value)?,
        "bSolarize" => params.b_solarize = parse_bool(value)?,
        "bInvert" => params.b_invert = parse_bool(value)?,

        // Unknown parameters go to extra map
        _ => {
            params.extra.insert(key.to_string(), value.to_string());
        }
    }

    Ok(())
}

/// Build a default `WaveCode` for index N. Used when wavecode_N_* or wave_N_* lines
/// reference a wave that hasn't been seen yet — both code paths must agree on defaults.
fn default_wave_code(index: usize) -> WaveCode {
    WaveCode {
        index,
        enabled: false,
        samples: 512,
        sep: 0,
        b_spectrum: false,
        b_use_dots: false,
        b_draw_thick: false,
        b_additive: false,
        scaling: 1.0,
        smoothing: 0.5,
        r: 1.0,
        g: 1.0,
        b: 1.0,
        a: 1.0,
        per_frame_equations: Vec::new(),
        per_point_equations: Vec::new(),
        per_frame_init_equations: Vec::new(),
    }
}

/// Build a default `ShapeCode` for index N. Mirrors `default_wave_code`.
fn default_shape_code(index: usize) -> ShapeCode {
    ShapeCode {
        index,
        enabled: false,
        sides: 4,
        additive: false,
        thick_outline: false,
        textured: false,
        num_inst: 1,
        x: 0.5,
        y: 0.5,
        rad: 0.1,
        ang: 0.0,
        tex_ang: 0.0,
        tex_zoom: 1.0,
        r: 1.0,
        g: 1.0,
        b: 1.0,
        a: 1.0,
        r2: 0.0,
        g2: 0.0,
        b2: 0.0,
        a2: 0.0,
        border_r: 1.0,
        border_g: 1.0,
        border_b: 1.0,
        border_a: 0.0,
        per_frame_equations: Vec::new(),
        per_frame_init_equations: Vec::new(),
    }
}

/// Returns true if `line` starts with `<prefix><digit>_` — i.e., an indexed block like
/// `wave_0_per_frame1=...` or `shape_3_init1=...`. Used to distinguish from scalar
/// param names like `wave_r=...` that share the `wave_` prefix.
fn is_indexed_block(line: &str, prefix: &str) -> bool {
    let Some(rest) = line.strip_prefix(prefix) else {
        return false;
    };
    let bytes = rest.as_bytes();
    let mut i = 0;
    while i < bytes.len() && bytes[i].is_ascii_digit() {
        i += 1;
    }
    i > 0 && i < bytes.len() && bytes[i] == b'_'
}

/// Parse a custom-wave equation line:
///   `wave_N_per_frameM=expr`  → per_frame_equations
///   `wave_N_per_pointM=expr`  → per_point_equations
///   `wave_N_initM=expr`       → per_frame_init_equations
fn parse_wave_equation_line(line: &str, waves: &mut Vec<WaveCode>) -> Result<()> {
    let Some((key, value)) = line.split_once('=') else {
        return Ok(());
    };
    let rest = key.strip_prefix("wave_").unwrap_or("");
    let Some((index_str, kind)) = rest.split_once('_') else {
        return Ok(());
    };
    let Ok(index) = index_str.parse::<usize>() else {
        return Ok(());
    };
    while waves.len() <= index {
        waves.push(default_wave_code(waves.len()));
    }
    let wave = &mut waves[index];
    let equation = value.trim().to_string();
    if equation.is_empty() {
        return Ok(());
    }
    if kind.starts_with("per_frame") {
        wave.per_frame_equations.push(equation);
    } else if kind.starts_with("per_point") {
        wave.per_point_equations.push(equation);
    } else if kind.starts_with("init") {
        wave.per_frame_init_equations.push(equation);
    }
    Ok(())
}

/// Parse a custom-shape equation line:
///   `shape_N_per_frameM=expr` → per_frame_equations
///   `shape_N_initM=expr`      → per_frame_init_equations
fn parse_shape_equation_line(line: &str, shapes: &mut Vec<ShapeCode>) -> Result<()> {
    let Some((key, value)) = line.split_once('=') else {
        return Ok(());
    };
    let rest = key.strip_prefix("shape_").unwrap_or("");
    let Some((index_str, kind)) = rest.split_once('_') else {
        return Ok(());
    };
    let Ok(index) = index_str.parse::<usize>() else {
        return Ok(());
    };
    while shapes.len() <= index {
        shapes.push(default_shape_code(shapes.len()));
    }
    let shape = &mut shapes[index];
    let equation = value.trim().to_string();
    if equation.is_empty() {
        return Ok(());
    }
    if kind.starts_with("per_frame") {
        shape.per_frame_equations.push(equation);
    } else if kind.starts_with("init") {
        shape.per_frame_init_equations.push(equation);
    }
    Ok(())
}

/// Parse wavecode line
fn parse_wavecode_line(line: &str, waves: &mut Vec<WaveCode>) -> Result<()> {
    // Extract wave index and parameter name
    // Format: wavecode_N_param=value
    let parts: Vec<&str> = line.split('_').collect();
    if parts.len() < 3 {
        return Ok(()); // Skip malformed lines
    }

    let index: usize = parts[1].parse().unwrap_or(0);
    let param_and_value = line.split_once('=');

    if let Some((param_full, value)) = param_and_value {
        let param = param_full.split('_').skip(2).collect::<Vec<_>>().join("_");

        // Ensure wave exists
        while waves.len() <= index {
            waves.push(default_wave_code(waves.len()));
        }

        // Parse parameter
        let wave = &mut waves[index];
        match param.as_str() {
            "enabled" => wave.enabled = value == "1",
            "samples" => wave.samples = value.parse().unwrap_or(512),
            "sep" => wave.sep = value.parse().unwrap_or(0),
            "bSpectrum" => wave.b_spectrum = value == "1",
            "bUseDots" => wave.b_use_dots = value == "1",
            "bDrawThick" => wave.b_draw_thick = value == "1",
            "bAdditive" => wave.b_additive = value == "1",
            "scaling" => wave.scaling = value.parse().unwrap_or(1.0),
            "smoothing" => wave.smoothing = value.parse().unwrap_or(0.5),
            "r" => wave.r = value.parse().unwrap_or(1.0),
            "g" => wave.g = value.parse().unwrap_or(1.0),
            "b" => wave.b = value.parse().unwrap_or(1.0),
            "a" => wave.a = value.parse().unwrap_or(1.0),
            _ => {} // Ignore unknown parameters
        }
    }

    Ok(())
}

/// Parse shapecode line
fn parse_shapecode_line(line: &str, shapes: &mut Vec<ShapeCode>) -> Result<()> {
    // Extract shape index and parameter name
    // Format: shapecode_N_param=value
    let parts: Vec<&str> = line.split('_').collect();
    if parts.len() < 3 {
        return Ok(()); // Skip malformed lines
    }

    let index: usize = parts[1].parse().unwrap_or(0);
    let param_and_value = line.split_once('=');

    if let Some((param_full, value)) = param_and_value {
        let param = param_full.split('_').skip(2).collect::<Vec<_>>().join("_");

        // Ensure shape exists
        while shapes.len() <= index {
            shapes.push(default_shape_code(shapes.len()));
        }

        // Parse parameter
        let shape = &mut shapes[index];
        match param.as_str() {
            "enabled" => shape.enabled = value == "1",
            "sides" => shape.sides = value.parse().unwrap_or(4),
            "additive" => shape.additive = value == "1",
            "thickOutline" => shape.thick_outline = value == "1",
            "textured" => shape.textured = value == "1",
            "num_inst" | "num inst" => shape.num_inst = value.parse().unwrap_or(1),
            "x" => shape.x = value.parse().unwrap_or(0.5),
            "y" => shape.y = value.parse().unwrap_or(0.5),
            "rad" => shape.rad = value.parse().unwrap_or(0.1),
            "ang" => shape.ang = value.parse().unwrap_or(0.0),
            "tex_ang" | "tex ang" => shape.tex_ang = value.parse().unwrap_or(0.0),
            "tex_zoom" | "tex zoom" => shape.tex_zoom = value.parse().unwrap_or(1.0),
            "r" => shape.r = value.parse().unwrap_or(1.0),
            "g" => shape.g = value.parse().unwrap_or(1.0),
            "b" => shape.b = value.parse().unwrap_or(1.0),
            "a" => shape.a = value.parse().unwrap_or(1.0),
            "r2" => shape.r2 = value.parse().unwrap_or(0.0),
            "g2" => shape.g2 = value.parse().unwrap_or(0.0),
            "b2" => shape.b2 = value.parse().unwrap_or(0.0),
            "a2" => shape.a2 = value.parse().unwrap_or(0.0),
            "border_r" | "border r" => shape.border_r = value.parse().unwrap_or(1.0),
            "border_g" | "border g" => shape.border_g = value.parse().unwrap_or(1.0),
            "border_b" | "border b" => shape.border_b = value.parse().unwrap_or(1.0),
            "border_a" | "border a" => shape.border_a = value.parse().unwrap_or(0.0),
            _ => {} // Ignore unknown parameters
        }
    }

    Ok(())
}

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

    #[test]
    fn test_parse_version() {
        let line = "MILKDROP_PRESET_VERSION=201";
        assert_eq!(parse_version_line(line).unwrap(), 201);
    }

    #[test]
    fn test_parse_equation() {
        let line = "per_frame_1=wave_r = 0.5;";
        assert_eq!(parse_equation_line(line), Some("wave_r = 0.5;".to_string()));
    }

    #[test]
    fn test_parse_shader() {
        let line = "warp_1=`shader_body";
        assert_eq!(parse_shader_line(line), "shader_body");
    }

    #[test]
    fn test_is_indexed_block() {
        assert!(is_indexed_block("wave_0_per_frame1=...", "wave_"));
        assert!(is_indexed_block("wave_3_init1=...", "wave_"));
        assert!(is_indexed_block("shape_2_per_frame4=...", "shape_"));
        // Single-token scalars must NOT be treated as indexed blocks
        assert!(!is_indexed_block("wave_r=1.0", "wave_"));
        assert!(!is_indexed_block("wave_g=0.5", "wave_"));
        assert!(!is_indexed_block("wave_x=0.5", "wave_"));
        assert!(!is_indexed_block("warp_1=`code`", "wave_"));
    }

    #[test]
    fn test_parse_wave_equation_line() {
        let mut waves: Vec<WaveCode> = Vec::new();
        parse_wave_equation_line("wave_0_init1=t1 = 0.5;", &mut waves).unwrap();
        parse_wave_equation_line("wave_0_per_frame1=t1 = t1 + 0.1;", &mut waves).unwrap();
        parse_wave_equation_line("wave_0_per_point1=x = sample; y = value1;", &mut waves).unwrap();
        parse_wave_equation_line("wave_0_per_point2=r = 1.0; g = 0.5;", &mut waves).unwrap();
        assert_eq!(waves.len(), 1);
        assert_eq!(waves[0].per_frame_init_equations, vec!["t1 = 0.5;"]);
        assert_eq!(waves[0].per_frame_equations, vec!["t1 = t1 + 0.1;"]);
        assert_eq!(
            waves[0].per_point_equations,
            vec!["x = sample; y = value1;", "r = 1.0; g = 0.5;"]
        );
    }

    #[test]
    fn test_parse_wave_equation_extends_vec_to_index() {
        let mut waves: Vec<WaveCode> = Vec::new();
        parse_wave_equation_line("wave_3_init1=t1 = 0.5;", &mut waves).unwrap();
        assert_eq!(waves.len(), 4);
        assert_eq!(waves[3].index, 3);
        assert_eq!(waves[0].per_frame_init_equations.len(), 0);
    }

    #[test]
    fn test_parse_shape_equation_line() {
        let mut shapes: Vec<ShapeCode> = Vec::new();
        parse_shape_equation_line("shape_0_init1=q1 = 0;", &mut shapes).unwrap();
        parse_shape_equation_line("shape_0_per_frame1=x = 0.5;", &mut shapes).unwrap();
        assert_eq!(shapes.len(), 1);
        assert_eq!(shapes[0].per_frame_init_equations, vec!["q1 = 0;"]);
        assert_eq!(shapes[0].per_frame_equations, vec!["x = 0.5;"]);
    }

    #[test]
    fn test_per_frame_init_routed_to_init_vec() {
        let src = "MILKDROP_PRESET_VERSION=201\n[preset00]\n\
                   per_frame_init_1=t1 = 0;\n\
                   per_frame_1=t1 = t1 + 1;\n";
        let preset = parse_milk_preset(src).unwrap();
        assert_eq!(preset.per_frame_init_equations, vec!["t1 = 0;"]);
        assert_eq!(preset.per_frame_equations, vec!["t1 = t1 + 1;"]);
    }

    #[test]
    fn test_full_preset_with_custom_wave() {
        let src = "MILKDROP_PRESET_VERSION=201\n[preset00]\n\
                   wavecode_0_enabled=1\n\
                   wavecode_0_samples=64\n\
                   wavecode_0_bSpectrum=1\n\
                   wave_0_init1=q1 = 0;\n\
                   wave_0_per_frame1=q1 = q1 + 0.01;\n\
                   wave_0_per_point1=x = sample; y = value1 * 0.5;\n";
        let preset = parse_milk_preset(src).unwrap();
        assert_eq!(preset.waves.len(), 1);
        let w = &preset.waves[0];
        assert!(w.enabled);
        assert_eq!(w.samples, 64);
        assert!(w.b_spectrum);
        assert_eq!(w.per_frame_init_equations, vec!["q1 = 0;"]);
        assert_eq!(w.per_frame_equations, vec!["q1 = q1 + 0.01;"]);
        assert_eq!(w.per_point_equations, vec!["x = sample; y = value1 * 0.5;"]);
    }

    #[test]
    fn test_full_preset_with_custom_shape() {
        let src = "MILKDROP_PRESET_VERSION=201\n[preset00]\n\
                   shapecode_0_enabled=1\n\
                   shapecode_0_sides=6\n\
                   shapecode_0_num_inst=8\n\
                   shapecode_0_textured=1\n\
                   shapecode_0_thickOutline=1\n\
                   shapecode_0_additive=1\n\
                   shapecode_0_x=0.4\n\
                   shapecode_0_y=0.6\n\
                   shapecode_0_rad=0.15\n\
                   shapecode_0_r=0.8\n\
                   shapecode_0_g=0.2\n\
                   shapecode_0_b=0.5\n\
                   shapecode_0_a=0.9\n\
                   shapecode_0_r2=0.0\n\
                   shapecode_0_g2=0.6\n\
                   shapecode_0_b2=1.0\n\
                   shapecode_0_a2=0.4\n\
                   shapecode_0_border_r=1.0\n\
                   shapecode_0_border_g=1.0\n\
                   shapecode_0_border_b=1.0\n\
                   shapecode_0_border_a=0.5\n\
                   shape_0_init1=t1 = 0;\n\
                   shape_0_init2=t2 = 42;\n\
                   shape_0_per_frame1=ang = ang + 0.05 * instance;\n\
                   shape_0_per_frame2=rad = rad + 0.001;\n";
        let preset = parse_milk_preset(src).unwrap();
        assert_eq!(preset.shapes.len(), 1);
        let s = &preset.shapes[0];
        assert!(s.enabled);
        assert_eq!(s.sides, 6);
        assert_eq!(s.num_inst, 8);
        assert!(s.textured);
        assert!(s.thick_outline);
        assert!(s.additive);
        assert!((s.x - 0.4).abs() < 1e-5);
        assert!((s.y - 0.6).abs() < 1e-5);
        assert!((s.r2 - 0.0).abs() < 1e-5);
        assert!((s.g2 - 0.6).abs() < 1e-5);
        assert!((s.border_a - 0.5).abs() < 1e-5);
        assert_eq!(s.per_frame_init_equations, vec!["t1 = 0;", "t2 = 42;"]);
        assert_eq!(
            s.per_frame_equations,
            vec!["ang = ang + 0.05 * instance;", "rad = rad + 0.001;"]
        );
    }
}