412 lines
13 KiB
Rust
412 lines
13 KiB
Rust
#![allow(clippy::module_name_repetitions)]
|
|
|
|
use crate::parser::{Event, MarkedEventReceiver, Parser, Tag};
|
|
use crate::scanner::{Marker, ScanError, TScalarStyle};
|
|
use linked_hash_map::LinkedHashMap;
|
|
use std::collections::BTreeMap;
|
|
use std::mem;
|
|
use std::ops::Index;
|
|
|
|
/// A YAML node is stored as this `Yaml` enumeration, which provides an easy way to
|
|
/// access your YAML document.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use yaml_rust::Yaml;
|
|
/// let foo = Yaml::from_str("-123"); // convert the string to the appropriate YAML type
|
|
/// assert_eq!(foo.as_i64().unwrap(), -123);
|
|
///
|
|
/// // iterate over an Array
|
|
/// let vec = Yaml::Array(vec![Yaml::Integer(1), Yaml::Integer(2)]);
|
|
/// for v in vec.as_vec().unwrap() {
|
|
/// assert!(v.as_i64().is_some());
|
|
/// }
|
|
/// ```
|
|
#[derive(Clone, PartialEq, PartialOrd, Debug, Eq, Ord, Hash)]
|
|
pub enum Yaml {
|
|
/// Float types are stored as String and parsed on demand.
|
|
/// Note that `f64` does NOT implement Eq trait and can NOT be stored in `BTreeMap`.
|
|
Real(String),
|
|
/// YAML int is stored as i64.
|
|
Integer(i64),
|
|
/// YAML scalar.
|
|
String(String),
|
|
/// YAML bool, e.g. `true` or `false`.
|
|
Boolean(bool),
|
|
/// YAML array, can be accessed as a `Vec`.
|
|
Array(Array),
|
|
/// YAML hash, can be accessed as a `LinkedHashMap`.
|
|
///
|
|
/// Insertion order will match the order of insertion into the map.
|
|
Hash(Hash),
|
|
/// Alias, not fully supported yet.
|
|
Alias(usize),
|
|
/// YAML null, e.g. `null` or `~`.
|
|
Null,
|
|
/// Accessing a nonexistent node via the Index trait returns `BadValue`. This
|
|
/// simplifies error handling in the calling code. Invalid type conversion also
|
|
/// returns `BadValue`.
|
|
BadValue,
|
|
}
|
|
|
|
pub type Array = Vec<Yaml>;
|
|
pub type Hash = LinkedHashMap<Yaml, Yaml>;
|
|
|
|
// parse f64 as Core schema
|
|
// See: https://github.com/chyh1990/yaml-rust/issues/51
|
|
fn parse_f64(v: &str) -> Option<f64> {
|
|
match v {
|
|
".inf" | ".Inf" | ".INF" | "+.inf" | "+.Inf" | "+.INF" => Some(f64::INFINITY),
|
|
"-.inf" | "-.Inf" | "-.INF" => Some(f64::NEG_INFINITY),
|
|
".nan" | "NaN" | ".NAN" => Some(f64::NAN),
|
|
_ => v.parse::<f64>().ok(),
|
|
}
|
|
}
|
|
|
|
/// Main structure for quickly parsing YAML.
|
|
///
|
|
/// See [`YamlLoader::load_from_str`].
|
|
pub struct YamlLoader {
|
|
docs: Vec<Yaml>,
|
|
// states
|
|
// (current node, anchor_id) tuple
|
|
doc_stack: Vec<(Yaml, usize)>,
|
|
key_stack: Vec<Yaml>,
|
|
anchor_map: BTreeMap<usize, Yaml>,
|
|
}
|
|
|
|
impl MarkedEventReceiver for YamlLoader {
|
|
fn on_event(&mut self, ev: Event, _: Marker) {
|
|
// println!("EV {:?}", ev);
|
|
match ev {
|
|
Event::DocumentStart => {
|
|
// do nothing
|
|
}
|
|
Event::DocumentEnd => {
|
|
match self.doc_stack.len() {
|
|
// empty document
|
|
0 => self.docs.push(Yaml::BadValue),
|
|
1 => self.docs.push(self.doc_stack.pop().unwrap().0),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
Event::SequenceStart(aid, _) => {
|
|
self.doc_stack.push((Yaml::Array(Vec::new()), aid));
|
|
}
|
|
Event::SequenceEnd => {
|
|
let node = self.doc_stack.pop().unwrap();
|
|
self.insert_new_node(node);
|
|
}
|
|
Event::MappingStart(aid, _) => {
|
|
self.doc_stack.push((Yaml::Hash(Hash::new()), aid));
|
|
self.key_stack.push(Yaml::BadValue);
|
|
}
|
|
Event::MappingEnd => {
|
|
self.key_stack.pop().unwrap();
|
|
let node = self.doc_stack.pop().unwrap();
|
|
self.insert_new_node(node);
|
|
}
|
|
Event::Scalar(v, style, aid, tag) => {
|
|
let node = if style != TScalarStyle::Plain {
|
|
Yaml::String(v)
|
|
} else if let Some(Tag {
|
|
ref handle,
|
|
ref suffix,
|
|
}) = tag
|
|
{
|
|
if handle == "tag:yaml.org,2002:" {
|
|
match suffix.as_ref() {
|
|
"bool" => {
|
|
// "true" or "false"
|
|
match v.parse::<bool>() {
|
|
Err(_) => Yaml::BadValue,
|
|
Ok(v) => Yaml::Boolean(v),
|
|
}
|
|
}
|
|
"int" => match v.parse::<i64>() {
|
|
Err(_) => Yaml::BadValue,
|
|
Ok(v) => Yaml::Integer(v),
|
|
},
|
|
"float" => match parse_f64(&v) {
|
|
Some(_) => Yaml::Real(v),
|
|
None => Yaml::BadValue,
|
|
},
|
|
"null" => match v.as_ref() {
|
|
"~" | "null" => Yaml::Null,
|
|
_ => Yaml::BadValue,
|
|
},
|
|
_ => Yaml::String(v),
|
|
}
|
|
} else {
|
|
Yaml::String(v)
|
|
}
|
|
} else {
|
|
// Datatype is not specified, or unrecognized
|
|
Yaml::from_str(&v)
|
|
};
|
|
|
|
self.insert_new_node((node, aid));
|
|
}
|
|
Event::Alias(id) => {
|
|
let n = match self.anchor_map.get(&id) {
|
|
Some(v) => v.clone(),
|
|
None => Yaml::BadValue,
|
|
};
|
|
self.insert_new_node((n, 0));
|
|
}
|
|
_ => { /* ignore */ }
|
|
}
|
|
// println!("DOC {:?}", self.doc_stack);
|
|
}
|
|
}
|
|
|
|
impl YamlLoader {
|
|
fn insert_new_node(&mut self, node: (Yaml, usize)) {
|
|
// valid anchor id starts from 1
|
|
if node.1 > 0 {
|
|
self.anchor_map.insert(node.1, node.0.clone());
|
|
}
|
|
if self.doc_stack.is_empty() {
|
|
self.doc_stack.push(node);
|
|
} else {
|
|
let parent = self.doc_stack.last_mut().unwrap();
|
|
match *parent {
|
|
(Yaml::Array(ref mut v), _) => v.push(node.0),
|
|
(Yaml::Hash(ref mut h), _) => {
|
|
let cur_key = self.key_stack.last_mut().unwrap();
|
|
// current node is a key
|
|
if cur_key.is_badvalue() {
|
|
*cur_key = node.0;
|
|
// current node is a value
|
|
} else {
|
|
let mut newkey = Yaml::BadValue;
|
|
mem::swap(&mut newkey, cur_key);
|
|
h.insert(newkey, node.0);
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Load the given string as a set of YAML documents.
|
|
///
|
|
/// The `source` is interpreted as YAML documents and is parsed. Parsing succeeds if and only
|
|
/// if all documents are parsed successfully. An error in a latter document prevents the former
|
|
/// from being returned.
|
|
pub fn load_from_str(source: &str) -> Result<Vec<Yaml>, ScanError> {
|
|
Self::load_from_iter(source.chars())
|
|
}
|
|
|
|
/// Load the contents of the given iterator as a set of YAML documents.
|
|
///
|
|
/// The `source` is interpreted as YAML documents and is parsed. Parsing succeeds if and only
|
|
/// if all documents are parsed successfully. An error in a latter document prevents the former
|
|
/// from being returned.
|
|
pub fn load_from_iter<I: Iterator<Item = char>>(source: I) -> Result<Vec<Yaml>, ScanError> {
|
|
let mut loader = YamlLoader {
|
|
docs: Vec::new(),
|
|
doc_stack: Vec::new(),
|
|
key_stack: Vec::new(),
|
|
anchor_map: BTreeMap::new(),
|
|
};
|
|
let mut parser = Parser::new(source);
|
|
parser.load(&mut loader, true)?;
|
|
Ok(loader.docs)
|
|
}
|
|
}
|
|
|
|
macro_rules! define_as (
|
|
($name:ident, $t:ident, $yt:ident) => (
|
|
#[must_use]
|
|
pub fn $name(&self) -> Option<$t> {
|
|
match *self {
|
|
Yaml::$yt(v) => Some(v),
|
|
_ => None
|
|
}
|
|
}
|
|
);
|
|
);
|
|
|
|
macro_rules! define_as_ref (
|
|
($name:ident, $t:ty, $yt:ident) => (
|
|
#[must_use]
|
|
pub fn $name(&self) -> Option<$t> {
|
|
match *self {
|
|
Yaml::$yt(ref v) => Some(v),
|
|
_ => None
|
|
}
|
|
}
|
|
);
|
|
);
|
|
|
|
macro_rules! define_into (
|
|
($name:ident, $t:ty, $yt:ident) => (
|
|
#[must_use]
|
|
pub fn $name(self) -> Option<$t> {
|
|
match self {
|
|
Yaml::$yt(v) => Some(v),
|
|
_ => None
|
|
}
|
|
}
|
|
);
|
|
);
|
|
|
|
impl Yaml {
|
|
define_as!(as_bool, bool, Boolean);
|
|
define_as!(as_i64, i64, Integer);
|
|
|
|
define_as_ref!(as_str, &str, String);
|
|
define_as_ref!(as_hash, &Hash, Hash);
|
|
define_as_ref!(as_vec, &Array, Array);
|
|
|
|
define_into!(into_bool, bool, Boolean);
|
|
define_into!(into_i64, i64, Integer);
|
|
define_into!(into_string, String, String);
|
|
define_into!(into_hash, Hash, Hash);
|
|
define_into!(into_vec, Array, Array);
|
|
|
|
/// Return whether `self` is a [`Yaml::Null`] node.
|
|
#[must_use]
|
|
pub fn is_null(&self) -> bool {
|
|
matches!(*self, Yaml::Null)
|
|
}
|
|
|
|
/// Return whether `self` is a [`Yaml::BadValue`] node.
|
|
#[must_use]
|
|
pub fn is_badvalue(&self) -> bool {
|
|
matches!(*self, Yaml::BadValue)
|
|
}
|
|
|
|
/// Return whether `self` is a [`Yaml::Array`] node.
|
|
#[must_use]
|
|
pub fn is_array(&self) -> bool {
|
|
matches!(*self, Yaml::Array(_))
|
|
}
|
|
|
|
/// Return the `f64` value contained in this YAML node.
|
|
///
|
|
/// If the node is not a [`Yaml::Real`] YAML node or its contents is not a valid `f64` string,
|
|
/// `None` is returned.
|
|
#[must_use]
|
|
pub fn as_f64(&self) -> Option<f64> {
|
|
if let Yaml::Real(ref v) = self {
|
|
parse_f64(v)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Return the `f64` value contained in this YAML node.
|
|
///
|
|
/// If the node is not a [`Yaml::Real`] YAML node or its contents is not a valid `f64` string,
|
|
/// `None` is returned.
|
|
#[must_use]
|
|
pub fn into_f64(self) -> Option<f64> {
|
|
self.as_f64()
|
|
}
|
|
}
|
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(clippy::should_implement_trait))]
|
|
impl Yaml {
|
|
/// Convert a string to a [`Yaml`] node.
|
|
///
|
|
/// [`Yaml`] does not implement [`std::str::FromStr`] since conversion may not fail. This
|
|
/// function falls back to [`Yaml::String`] if nothing else matches.
|
|
///
|
|
/// # Examples
|
|
/// ```
|
|
/// # use yaml_rust::yaml::Yaml;
|
|
/// assert!(matches!(Yaml::from_str("42"), Yaml::Integer(42)));
|
|
/// assert!(matches!(Yaml::from_str("0x2A"), Yaml::Integer(42)));
|
|
/// assert!(matches!(Yaml::from_str("0o52"), Yaml::Integer(42)));
|
|
/// assert!(matches!(Yaml::from_str("~"), Yaml::Null));
|
|
/// assert!(matches!(Yaml::from_str("null"), Yaml::Null));
|
|
/// assert!(matches!(Yaml::from_str("true"), Yaml::Boolean(true)));
|
|
/// assert!(matches!(Yaml::from_str("3.14"), Yaml::Real(_)));
|
|
/// assert!(matches!(Yaml::from_str("foo"), Yaml::String(_)));
|
|
/// ```
|
|
#[must_use]
|
|
pub fn from_str(v: &str) -> Yaml {
|
|
if let Some(number) = v.strip_prefix("0x") {
|
|
if let Ok(i) = i64::from_str_radix(number, 16) {
|
|
return Yaml::Integer(i);
|
|
}
|
|
} else if let Some(number) = v.strip_prefix("0o") {
|
|
if let Ok(i) = i64::from_str_radix(number, 8) {
|
|
return Yaml::Integer(i);
|
|
}
|
|
} else if let Some(number) = v.strip_prefix('+') {
|
|
if let Ok(i) = number.parse::<i64>() {
|
|
return Yaml::Integer(i);
|
|
}
|
|
}
|
|
match v {
|
|
"~" | "null" => Yaml::Null,
|
|
"true" => Yaml::Boolean(true),
|
|
"false" => Yaml::Boolean(false),
|
|
_ => {
|
|
if let Ok(integer) = v.parse::<i64>() {
|
|
Yaml::Integer(integer)
|
|
} else if parse_f64(v).is_some() {
|
|
Yaml::Real(v.to_owned())
|
|
} else {
|
|
Yaml::String(v.to_owned())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static BAD_VALUE: Yaml = Yaml::BadValue;
|
|
impl<'a> Index<&'a str> for Yaml {
|
|
type Output = Yaml;
|
|
|
|
fn index(&self, idx: &'a str) -> &Yaml {
|
|
let key = Yaml::String(idx.to_owned());
|
|
match self.as_hash() {
|
|
Some(h) => h.get(&key).unwrap_or(&BAD_VALUE),
|
|
None => &BAD_VALUE,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Index<usize> for Yaml {
|
|
type Output = Yaml;
|
|
|
|
fn index(&self, idx: usize) -> &Yaml {
|
|
if let Some(v) = self.as_vec() {
|
|
v.get(idx).unwrap_or(&BAD_VALUE)
|
|
} else if let Some(v) = self.as_hash() {
|
|
let key = Yaml::Integer(idx as i64);
|
|
v.get(&key).unwrap_or(&BAD_VALUE)
|
|
} else {
|
|
&BAD_VALUE
|
|
}
|
|
}
|
|
}
|
|
|
|
impl IntoIterator for Yaml {
|
|
type Item = Yaml;
|
|
type IntoIter = YamlIter;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
YamlIter {
|
|
yaml: self.into_vec().unwrap_or_default().into_iter(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An iterator over a [`Yaml`] node.
|
|
pub struct YamlIter {
|
|
yaml: std::vec::IntoIter<Yaml>,
|
|
}
|
|
|
|
impl Iterator for YamlIter {
|
|
type Item = Yaml;
|
|
|
|
fn next(&mut self) -> Option<Yaml> {
|
|
self.yaml.next()
|
|
}
|
|
}
|