serde_yaml/value/

mod.rs

//! The Value enum, a loosely typed way of representing any valid YAML value.

mod de;
mod debug;
mod from;
mod index;
mod partial_eq;
mod ser;
pub(crate) mod tagged;

use crate::error::{
  self,
  Error,
  ErrorImpl,
};
use serde::de::{
  Deserialize,
  DeserializeOwned,
  IntoDeserializer,
};
use serde::Serialize;
use std::hash::{
  Hash,
  Hasher,
};
use std::mem;

pub use self::index::Index;
pub use self::ser::Serializer;
pub use self::tagged::{
  Tag,
  TaggedValue,
};
#[doc(inline)]
pub use crate::mapping::Mapping;
pub use crate::number::Number;

/// Represents any valid YAML value.
#[derive(Clone, PartialEq, PartialOrd)]
pub enum Value {
  /// Represents a YAML null value.
  Null,
  /// Represents a YAML boolean.
  Bool(bool),
  /// Represents a YAML numerical value, whether integer or floating point.
  Number(Number),
  /// Represents a YAML string.
  String(String),
  /// Represents a YAML sequence in which the elements are
  /// `serde_yaml::Value`.
  Sequence(Sequence),
  /// Represents a YAML mapping in which the keys and values are both
  /// `serde_yaml::Value`.
  Mapping(Mapping),
  /// A representation of YAML's `!Tag` syntax, used for enums.
  Tagged(Box<TaggedValue>),
}

/// The default value is `Value::Null`.
///
/// This is useful for handling omitted `Value` fields when deserializing.
///
/// # Examples
///
/// ```
/// # use serde_derive::Deserialize;
/// use serde::Deserialize;
/// use serde_yaml::Value;
///
/// #[derive(Deserialize)]
/// struct Settings {
///     level: i32,
///     #[serde(default)]
///     extras: Value,
/// }
///
/// # fn try_main() -> Result<(), serde_yaml::Error> {
/// let data = r#" { "level": 42 } "#;
/// let s: Settings = serde_yaml::from_str(data)?;
///
/// assert_eq!(s.level, 42);
/// assert_eq!(s.extras, Value::Null);
/// #
/// #     Ok(())
/// # }
/// #
/// # try_main().unwrap()
/// ```
impl Default for Value {
  fn default() -> Value {
    Value::Null
  }
}

/// A YAML sequence in which the elements are `serde_yaml::Value`.
pub type Sequence = Vec<Value>;

/// Convert a `T` into `serde_yaml::Value` which is an enum that can represent
/// any valid YAML data.
///
/// This conversion can fail if `T`'s implementation of `Serialize` decides to
/// return an error.
///
/// ```
/// # use serde_yaml::Value;
/// let val = serde_yaml::to_value("s").unwrap();
/// assert_eq!(val, Value::String("s".to_owned()));
/// ```
pub fn to_value<T>(value: T) -> Result<Value, Error>
where
  T: Serialize,
{
  value.serialize(Serializer)
}

/// Interpret a `serde_yaml::Value` as an instance of type `T`.
///
/// This conversion can fail if the structure of the Value does not match the
/// structure expected by `T`, for example if `T` is a struct type but the Value
/// contains something other than a YAML map. It can also fail if the structure
/// is correct but `T`'s implementation of `Deserialize` decides that something
/// is wrong with the data, for example required struct fields are missing from
/// the YAML map or some number is too big to fit in the expected primitive
/// type.
///
/// ```
/// # use serde_yaml::Value;
/// let val = Value::String("foo".to_owned());
/// let s: String = serde_yaml::from_value(val).unwrap();
/// assert_eq!("foo", s);
/// ```
pub fn from_value<T>(value: Value) -> Result<T, Error>
where
  T: DeserializeOwned,
{
  Deserialize::deserialize(value)
}

impl Value {
  /// Index into a YAML sequence or map. A string index can be used to access
  /// a value in a map, and a usize index can be used to access an element of
  /// an sequence.
  ///
  /// Returns `None` if the type of `self` does not match the type of the
  /// index, for example if the index is a string and `self` is a sequence or
  /// a number. Also returns `None` if the given key does not exist in the map
  /// or the given index is not within the bounds of the sequence.
  ///
  /// ```
  /// # fn main() -> serde_yaml::Result<()> {
  /// use serde_yaml::Value;
  ///
  /// let object: Value = serde_yaml::from_str(r#"{ A: 65, B: 66, C: 67 }"#)?;
  /// let x = object.get("A").unwrap();
  /// assert_eq!(x, 65);
  ///
  /// let sequence: Value = serde_yaml::from_str(r#"[ "A", "B", "C" ]"#)?;
  /// let x = sequence.get(2).unwrap();
  /// assert_eq!(x, &Value::String("C".into()));
  ///
  /// assert_eq!(sequence.get("A"), None);
  /// # Ok(())
  /// # }
  /// ```
  ///
  /// Square brackets can also be used to index into a value in a more concise
  /// way. This returns `Value::Null` in cases where `get` would have returned
  /// `None`.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// #
  /// # fn main() -> serde_yaml::Result<()> {
  /// let object: Value = serde_yaml::from_str(r#"
  /// A: [a, á, à]
  /// B: [b, b́]
  /// C: [c, ć, ć̣, ḉ]
  /// 42: true
  /// "#)?;
  /// assert_eq!(object["B"][0], Value::String("b".into()));
  ///
  /// assert_eq!(object[Value::String("D".into())], Value::Null);
  /// assert_eq!(object["D"], Value::Null);
  /// assert_eq!(object[0]["x"]["y"]["z"], Value::Null);
  ///
  /// assert_eq!(object[42], Value::Bool(true));
  /// # Ok(())
  /// # }
  /// ```
  pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
    index.index_into(self)
  }

  /// Index into a YAML sequence or map. A string index can be used to access
  /// a value in a map, and a usize index can be used to access an element of
  /// an sequence.
  ///
  /// Returns `None` if the type of `self` does not match the type of the
  /// index, for example if the index is a string and `self` is a sequence or
  /// a number. Also returns `None` if the given key does not exist in the map
  /// or the given index is not within the bounds of the sequence.
  pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
    index.index_into_mut(self)
  }

  /// Returns true if the `Value` is a Null. Returns false otherwise.
  ///
  /// For any Value on which `is_null` returns true, `as_null` is guaranteed
  /// to return `Some(())`.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("null").unwrap();
  /// assert!(v.is_null());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert!(!v.is_null());
  /// ```
  pub fn is_null(&self) -> bool {
    if let Value::Null = self.untag_ref() {
      true
    } else {
      false
    }
  }

  /// If the `Value` is a Null, returns (). Returns None otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("null").unwrap();
  /// assert_eq!(v.as_null(), Some(()));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_null(), None);
  /// ```
  pub fn as_null(&self) -> Option<()> {
    match self.untag_ref() {
      Value::Null => Some(()),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a Boolean. Returns false otherwise.
  ///
  /// For any Value on which `is_boolean` returns true, `as_bool` is
  /// guaranteed to return the boolean value.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert!(v.is_bool());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("42").unwrap();
  /// assert!(!v.is_bool());
  /// ```
  pub fn is_bool(&self) -> bool {
    self.as_bool().is_some()
  }

  /// If the `Value` is a Boolean, returns the associated bool. Returns None
  /// otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert_eq!(v.as_bool(), Some(true));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("42").unwrap();
  /// assert_eq!(v.as_bool(), None);
  /// ```
  pub fn as_bool(&self) -> Option<bool> {
    match self.untag_ref() {
      Value::Bool(b) => Some(*b),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a Number. Returns false otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("5").unwrap();
  /// assert!(v.is_number());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert!(!v.is_number());
  /// ```
  pub fn is_number(&self) -> bool {
    match self.untag_ref() {
      Value::Number(_) => true,
      _ => false,
    }
  }

  /// Returns true if the `Value` is an integer between `i64::MIN` and
  /// `i64::MAX`.
  ///
  /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
  /// return the integer value.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("1337").unwrap();
  /// assert!(v.is_i64());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("null").unwrap();
  /// assert!(!v.is_i64());
  /// ```
  pub fn is_i64(&self) -> bool {
    self.as_i64().is_some()
  }

  /// If the `Value` is an integer, represent it as i64 if possible. Returns
  /// None otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("1337").unwrap();
  /// assert_eq!(v.as_i64(), Some(1337));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_i64(), None);
  /// ```
  pub fn as_i64(&self) -> Option<i64> {
    match self.untag_ref() {
      Value::Number(n) => n.as_i64(),
      _ => None,
    }
  }

  /// Returns true if the `Value` is an integer between `u64::MIN` and
  /// `u64::MAX`.
  ///
  /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
  /// return the integer value.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("1337").unwrap();
  /// assert!(v.is_u64());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("null").unwrap();
  /// assert!(!v.is_u64());
  /// ```
  pub fn is_u64(&self) -> bool {
    self.as_u64().is_some()
  }

  /// If the `Value` is an integer, represent it as u64 if possible. Returns
  /// None otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("1337").unwrap();
  /// assert_eq!(v.as_u64(), Some(1337));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_u64(), None);
  /// ```
  pub fn as_u64(&self) -> Option<u64> {
    match self.untag_ref() {
      Value::Number(n) => n.as_u64(),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a number that can be represented by f64.
  ///
  /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
  /// return the floating point value.
  ///
  /// Currently this function returns true if and only if both `is_i64` and
  /// `is_u64` return false but this is not a guarantee in the future.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("256.01").unwrap();
  /// assert!(v.is_f64());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert!(!v.is_f64());
  /// ```
  pub fn is_f64(&self) -> bool {
    match self.untag_ref() {
      Value::Number(n) => n.is_f64(),
      _ => false,
    }
  }

  /// If the `Value` is a number, represent it as f64 if possible. Returns
  /// None otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("13.37").unwrap();
  /// assert_eq!(v.as_f64(), Some(13.37));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_f64(), None);
  /// ```
  pub fn as_f64(&self) -> Option<f64> {
    match self.untag_ref() {
      Value::Number(i) => i.as_f64(),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a String. Returns false otherwise.
  ///
  /// For any Value on which `is_string` returns true, `as_str` is guaranteed
  /// to return the string slice.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("'lorem ipsum'").unwrap();
  /// assert!(v.is_string());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("42").unwrap();
  /// assert!(!v.is_string());
  /// ```
  pub fn is_string(&self) -> bool {
    self.as_str().is_some()
  }

  /// If the `Value` is a String, returns the associated str. Returns None
  /// otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("'lorem ipsum'").unwrap();
  /// assert_eq!(v.as_str(), Some("lorem ipsum"));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_str(), None);
  /// ```
  pub fn as_str(&self) -> Option<&str> {
    match self.untag_ref() {
      Value::String(s) => Some(s),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a sequence. Returns false otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("[1, 2, 3]").unwrap();
  /// assert!(v.is_sequence());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert!(!v.is_sequence());
  /// ```
  pub fn is_sequence(&self) -> bool {
    self.as_sequence().is_some()
  }

  /// If the `Value` is a sequence, return a reference to it if possible.
  /// Returns None otherwise.
  ///
  /// ```
  /// # use serde_yaml::{Value, Number};
  /// let v: Value = serde_yaml::from_str("[1, 2]").unwrap();
  /// assert_eq!(v.as_sequence(), Some(&vec![Value::Number(Number::from(1)), Value::Number(Number::from(2))]));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_sequence(), None);
  /// ```
  pub fn as_sequence(&self) -> Option<&Sequence> {
    match self.untag_ref() {
      Value::Sequence(seq) => Some(seq),
      _ => None,
    }
  }

  /// If the `Value` is a sequence, return a mutable reference to it if
  /// possible. Returns None otherwise.
  ///
  /// ```
  /// # use serde_yaml::{Value, Number};
  /// let mut v: Value = serde_yaml::from_str("[1]").unwrap();
  /// let s = v.as_sequence_mut().unwrap();
  /// s.push(Value::Number(Number::from(2)));
  /// assert_eq!(s, &vec![Value::Number(Number::from(1)), Value::Number(Number::from(2))]);
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let mut v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_sequence_mut(), None);
  /// ```
  pub fn as_sequence_mut(&mut self) -> Option<&mut Sequence> {
    match self.untag_mut() {
      Value::Sequence(seq) => Some(seq),
      _ => None,
    }
  }

  /// Returns true if the `Value` is a mapping. Returns false otherwise.
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("a: 42").unwrap();
  /// assert!(v.is_mapping());
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("true").unwrap();
  /// assert!(!v.is_mapping());
  /// ```
  pub fn is_mapping(&self) -> bool {
    self.as_mapping().is_some()
  }

  /// If the `Value` is a mapping, return a reference to it if possible.
  /// Returns None otherwise.
  ///
  /// ```
  /// # use serde_yaml::{Value, Mapping, Number};
  /// let v: Value = serde_yaml::from_str("a: 42").unwrap();
  ///
  /// let mut expected = Mapping::new();
  /// expected.insert(Value::String("a".into()),Value::Number(Number::from(42)));
  ///
  /// assert_eq!(v.as_mapping(), Some(&expected));
  /// ```
  ///
  /// ```
  /// # use serde_yaml::Value;
  /// let v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_mapping(), None);
  /// ```
  pub fn as_mapping(&self) -> Option<&Mapping> {
    match self.untag_ref() {
      Value::Mapping(map) => Some(map),
      _ => None,
    }
  }

  /// If the `Value` is a mapping, return a reference to it if possible.
  /// Returns None otherwise.
  ///
  /// ```
  /// # use serde_yaml::{Value, Mapping, Number};
  /// let mut v: Value = serde_yaml::from_str("a: 42").unwrap();
  /// let m = v.as_mapping_mut().unwrap();
  /// m.insert(Value::String("b".into()), Value::Number(Number::from(21)));
  ///
  /// let mut expected = Mapping::new();
  /// expected.insert(Value::String("a".into()), Value::Number(Number::from(42)));
  /// expected.insert(Value::String("b".into()), Value::Number(Number::from(21)));
  ///
  /// assert_eq!(m, &expected);
  /// ```
  ///
  /// ```
  /// # use serde_yaml::{Value, Mapping};
  /// let mut v: Value = serde_yaml::from_str("false").unwrap();
  /// assert_eq!(v.as_mapping_mut(), None);
  /// ```
  pub fn as_mapping_mut(&mut self) -> Option<&mut Mapping> {
    match self.untag_mut() {
      Value::Mapping(map) => Some(map),
      _ => None,
    }
  }

  /// Performs merging of `<<` keys into the surrounding mapping.
  ///
  /// The intended use of this in YAML is described in
  /// <https://yaml.org/type/merge.html>.
  ///
  /// ```
  /// use serde_yaml::Value;
  ///
  /// let config = "\
  /// tasks:
  ///   build: &webpack_shared
  ///     command: webpack
  ///     args: build
  ///     inputs:
  ///       - 'src/**/*'
  ///   start:
  ///     <<: *webpack_shared
  ///     args: start
  /// ";
  ///
  /// let mut value: Value = serde_yaml::from_str(config).unwrap();
  /// value.apply_merge().unwrap();
  ///
  /// assert_eq!(value["tasks"]["start"]["command"], "webpack");
  /// assert_eq!(value["tasks"]["start"]["args"], "start");
  /// ```
  pub fn apply_merge(&mut self) -> Result<(), Error> {
    let mut stack = Vec::new();
    stack.push(self);
    while let Some(node) = stack.pop() {
      match node {
        Value::Mapping(mapping) => {
          match mapping.remove("<<") {
            Some(Value::Mapping(merge)) => {
              for (k, v) in merge {
                mapping.entry(k).or_insert(v);
              }
            },
            Some(Value::Sequence(sequence)) => {
              for value in sequence {
                match value {
                  Value::Mapping(merge) => {
                    for (k, v) in merge {
                      mapping.entry(k).or_insert(v);
                    }
                  },
                  Value::Sequence(_) => {
                    return Err(error::new(ErrorImpl::SequenceInMergeElement));
                  },
                  Value::Tagged(_) => {
                    return Err(error::new(ErrorImpl::TaggedInMerge));
                  },
                  _unexpected => {
                    return Err(error::new(ErrorImpl::ScalarInMergeElement));
                  },
                }
              }
            },
            None => {},
            Some(Value::Tagged(_)) => return Err(error::new(ErrorImpl::TaggedInMerge)),
            Some(_unexpected) => return Err(error::new(ErrorImpl::ScalarInMerge)),
          }
          stack.extend(mapping.values_mut());
        },
        Value::Sequence(sequence) => stack.extend(sequence),
        Value::Tagged(tagged) => stack.push(&mut tagged.value),
        _ => {},
      }
    }
    Ok(())
  }
}

impl Eq for Value {}

// NOTE: This impl must be kept consistent with HashLikeValue's Hash impl in
// mapping.rs in order for value[str] indexing to work.
impl Hash for Value {
  fn hash<H: Hasher>(&self, state: &mut H) {
    mem::discriminant(self).hash(state);
    match self {
      Value::Null => {},
      Value::Bool(v) => v.hash(state),
      Value::Number(v) => v.hash(state),
      Value::String(v) => v.hash(state),
      Value::Sequence(v) => v.hash(state),
      Value::Mapping(v) => v.hash(state),
      Value::Tagged(v) => v.hash(state),
    }
  }
}

impl IntoDeserializer<'_, Error> for Value {
  type Deserializer = Self;

  fn into_deserializer(self) -> Self::Deserializer {
    self
  }
}