yarn-state 0.1.2

Parser for .yarn-state.yml files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// SPDX-FileCopyrightText: 2024 The Chaste Authors
// SPDX-License-Identifier: Apache-2.0 OR BSD-2-Clause

use nom::branch::alt;
use nom::bytes::complete::{tag, take_until};
use nom::character::complete::{digit1, space1};
use nom::combinator::map_res;
use nom::multi::{many0, many1};
use nom::sequence::{preceded, terminated};
use nom::{IResult, Parser};

use crate::error::{Error, Result};

pub mod error;

#[non_exhaustive]
pub struct YarnState<'a> {
    pub version: u32,
    pub packages: Vec<Package<'a>>,
}

#[non_exhaustive]
pub struct Package<'a> {
    pub resolution: &'a str,
    pub locations: Vec<&'a str>,
}

pub fn parse(input: &str) -> Result<YarnState<'_>> {
    statefile(input)
}

fn statefile(input: &str) -> Result<YarnState> {
    match (header, many1(package)).parse(input) {
        Ok((input, _)) if !input.is_empty() => Err(Error::InvalidSyntax()),
        Err(_) => Err(Error::InvalidSyntax()),

        Ok((_, (version, packages))) => Ok(YarnState { version, packages }),
    }
}

// Returns version number
fn header(input: &str) -> IResult<&str, u32> {
    preceded(
        (
            many0((tag("#"), take_until("\n"), tag("\n"))),
            many0(newline),
            tag("__metadata:"),
            newline,
            space1,
            tag("version: "),
        ),
        terminated(
            map_res(digit1, |n: &str| n.parse()),
            (newline, many0((space1, take_until("\n"), tag("\n")))),
        ),
    )
    .parse(input)
}

fn package(input: &str) -> IResult<&str, Package> {
    (
        preceded(
            (newline, tag("\"")),
            terminated(take_until("\":"), (tag("\":"), newline)),
        ),
        many1(package_field),
    )
        .parse(input)
        .map(|(input, (resolution, fields))| {
            let mut locations = Vec::new();
            for field in fields {
                match field {
                    PackageField::Locations(l) => locations = l,
                    PackageField::Unknown => {}
                }
            }
            (
                input,
                Package {
                    resolution,
                    locations,
                },
            )
        })
}

enum PackageField<'a> {
    Locations(Vec<&'a str>),
    Unknown,
}

fn package_field(input: &str) -> IResult<&str, PackageField> {
    alt((package_field_locations, package_field_unknown)).parse(input)
}

fn package_field_locations(input: &str) -> IResult<&str, PackageField> {
    preceded(
        (space1, tag("locations:"), newline),
        many1(preceded(
            (space1, tag("- \"")),
            terminated(take_until("\""), (tag("\""), newline)),
        )),
    )
    .parse(input)
    .map(|(input, locations)| (input, PackageField::Locations(locations)))
}

fn package_field_unknown(input: &str) -> IResult<&str, PackageField> {
    let (input, indent) = space1(input)?;
    let (input, _) = (take_until("\n"), tag("\n")).parse(input)?;
    let (input, _) = many0((tag(indent), space1, take_until("\n"), tag("\n"))).parse(input)?;
    Ok((input, PackageField::Unknown))
}

fn newline(input: &str) -> IResult<&str, &str> {
    alt((tag("\n"), tag("\r\n"))).parse(input)
}