This is required for composition with other libraries like serde_ignored.

This is harder than just slapping pub on the thing because the Deserializer currently borrows some data owned by the serde_yaml::from_str method:

struct Deserializer<'a> {
    events: &'a [(Event, Marker)],
    /// Map from alias id to index in events.
    aliases: &'a BTreeMap<usize, usize>,
    pos: &'a mut usize,
    path: Path<'a>,
}

May need to refactor into a public owned Deserializer and an internal borrowed Deserializer.

The Serializer is also hard because it doesn't write to an underlying io::Write like JSON's serializer does.

Hi, I was wondering if there is a way (besides just not upgrading the crate version) to opt out of the !Tag syntax for enums and keep the old behaviour?

Simple change to make ErrorImpl public.

I'd like to be able to use the Marker Information from the scanner error to provide users that are changing files the ability to check to see whether their yaml is valid and, if not, where the issue lies. To do this i need the Marker information from the ScannerError in a structured format, so I can feed that into an editor.

This resolves https://github.com/dtolnay/serde-yaml/issues/78

I also have a PR out about getting access to the Marker for Scanner errors, which is also not public.

Moved from https://github.com/dtolnay/serde-yaml/issues/49#issuecomment-304899926.

Hi, I ran into the Out of bounds access in the wild with some output generated by PyYAML. I minimized it to a pretty simple example:

---
content: "Foo\
    Bar"

Is this just a case of missing support for line continuations? Should I file a separate ticket for that?

@radix

The newly released 0.8.6 includes u128 support. However, values of 2^64 or larger serialize as floats instead of integers, as shown by this test case.

#[test]
fn test_u128_big() {
    let thing: u128 = 18446744073709551616;   // 2^64
    let yaml = unindent(
        "
        ---
        18446744073709551616",
    );
    test_serde(&thing, &yaml);
}

---- test_u128_big stdout ----
thread 'test_u128_big' panicked at 'assertion failed: `(left == right)`
  left: `"---\n18446744073709551616"`,
 right: `"---\n18446744073709553000.0"`', tests/test_serde.rs:40:5
note: Run with `RUST_BACKTRACE=1` for a backtrace.

The i128 branch in my fork of this repo does not exhibit the same bug at revision d79d55e.

In the following example, both inputs deserialize to field: "~". I would expect the first one to deserialize to field: "".

#[macro_use]
extern crate serde_derive;

extern crate serde;
extern crate serde_yaml;

#[derive(Deserialize, Debug)]
struct S {
    field: String,
}

fn main() {
    println!("{:?}", serde_yaml::from_str::<S>("field:"));
    println!("{:?}", serde_yaml::from_str::<S>("field: ~"));
}

These two maps, when turned to serde_yaml::Value give the same hashes:

foo: 1.2

foo: 8.7

The reason is the Hash instance of Number:

#[allow(clippy::derive_hash_xor_eq)]
impl Hash for Number {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match self.n {
            N::Float(_) => {
                // you should feel bad for using f64 as a map key
                3.hash(state)
            }
            N::PosInt(u) => u.hash(state),
            N::NegInt(i) => i.hash(state),
        }
    }
}

It gives constant values for f64. The comment tries to shame the user about using floats as keys. Sadly, it completely forgets that Number can be used elsewhere. In this case, we have:

#[derive(Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd)]
pub struct Mapping {
    map: LinkedHashMap<Value, Value>,
}

The Hash for the LinkedHashMap just hashes the (key, value) values.

This means that when value is N::Float, the hash doesn't change when the value does. This makes it pretty much unfit for purpose...

Apologies if this feature already exists, but I didn't see it in the documentation.

Info

the literal scalar | can be used in YAML to break up a string to multiple lines, treating the line breaks literally.

the folded scalar > also can be used to break up a string into multiple lines, but it treats line breaks as spaces.

Request

When serializing a value containing a multiline string, it seems to always serialize that string to a single line with line breaks represented as \n (reproduction) I think that there should be some way to specify how you want your string to be serialized (single line, folded scalar, literal scalar).

Scalar Examples

Literal: |

Input

key: |
  line 1
  line 2

Output (JSON)

{ "key": "line 1\nline 2\n" }

Folded: >

Input

key: >
  word1
  word2

Output (JSON)

{ "key": "word1 word2" }

i128 and u128 can now be serialized and deserialized. Support is conditionalized on the disabled-by-default i128 feature flag, and requires rustc 1.26.0 or later. The minimum required version of Serde is now 1.0.60.

... even though there are no non-optional fields in the struct. Or any fields at all, for that matter.

Attempting to deserialize an empty file (or a file containing only newlines) produces the following error:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: EndOfStream', /checkout/src/libcore/result.rs:916:4

IMO deserializing an empty file should succeed as long as there are no required fields in the struct.

(I'm using serde_yaml 0.7.3)

This PR makes it possible to directly inspect a tag as a string slice.

For my use case, I want to do some more advanced inspection than only testing for equality.

To avoid surprising behavior with the potential presence of an exclamation mark, the function is called as_str_stripped() and documents that it strips the leading exclamation mark if it is present.

TL;DR

If you create an enum that contains a newtype variant, wrap the enum in a struct, wrap the said struct in another struct and use #[serde(flatten)] on it, the struct can no longer successfully deserialize (while serialization is unaffected).

Deserialization fails with message: untagged and internally tagged enums do not support enum input.

That's not a very helpful description so here's a MRE:

use serde::{Deserialize, Serialize};

fn main() {
    // this works
    let gender = Gender::Other("F22".into());
    assert_eq!(
        &gender,
        &serde_yaml::from_str(&dbg!(serde_yaml::to_string(&gender).unwrap())).unwrap()
    );

    // this still works
    let info = Info { gender };
    assert_eq!(
        &info,
        &serde_yaml::from_str(&dbg!(serde_yaml::to_string(&info).unwrap())).unwrap()
    );

    // this errors
    let user = User { info };
    assert_eq!(
        &user,
        &serde_yaml::from_str(&dbg!(serde_yaml::to_string(&user).unwrap())).unwrap()
    );
}

#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
enum Gender {
    Female,
    Male,
    Other(String),
}

#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
struct Info {
    gender: Gender,
}

#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
struct User {
    #[serde(flatten)]
    info: Info,
}

Misc

I tried the exact same example using serde_json, no errors. So I think this is a serde_yaml issue rather than a serde issue.

A quick search did find this issue though, not sure if it's related: https://github.com/ron-rs/ron/issues/217.

Versions

• OS: Linux 6.0.8 x86_64
• rust: 1.65.0 (stable-x86_64-unknown-linux-gnu)
• serde: 1.0.147
• serde_yaml: 0.9.14

Hello, I'm working on a feature where we inherit settings from .editorconfig to determine the pretty formatting options when writing JSON/YAML. Here's an example of this working here: https://github.com/moonrepo/moon/pull/446/files#diff-eecbfd85b3348b94eb93e82dc28debcfbaca9a8e9664c43635a8ce5eecf613e9R97

This is super easy with serde_json, as we can simply use this: https://docs.rs/serde_json/latest/serde_json/ser/struct.PrettyFormatter.html#method.with_indent

However, with serde_yaml, there doesn't seem to be a way to change the pretty settings, or indentation. I briefly dug into the source code, but this looks to be abstracted away via the libyaml crate? Regardless, it would be nice if custom indentation would be supported, both spaces and tabs.

Cheers!

I am using https://github.com/juhaku/utoipa 's to_yaml which uses serde_yaml::to_string, to generate a openapi 3 yaml file, and there is a lack of typical indentation in the output of arrays/sequences.

e.g.

openapi: 3.0.3
info:
  title: foobar
  description: Service to do blah ...
  contact:
    name: ''
  license:
    name: ''
  version: 0.1.0
paths:
  /my_endpoint_name:
    post:
      tags:
      - my_tag

Typical linters, e.g. https://pypi.org/project/yamllint/, require the - my_tag to be indented an extra two spaces. A lot of python cloud tools use yamllint, e.g. ansible-lint. More can be seen at https://www.wheelodex.org/projects/yamllint/rdepends/ , and that is just Python. https://developers.home-assistant.io/docs/documenting/yaml-style-guide/ is another style guide which expects that indentation.

I did a quick test against serde_yaml directly, and it looks like that the lack of indentation is the default. i.e. the following is true

let mut buffer = Vec::new();
let mut ser = serde_yaml::Serializer::new(&mut buffer);
let deserialized: BTreeMap<&str, Vec<&str>> = serde_yaml::from_str("k:\n  - a\n  - b\n  - c\n").unwrap();
deserialized.serialize(&mut ser).unwrap();
assert_eq!(buffer, b"k:\n- a\n- b\n- c\n");

i.e. the indentation is dropped.

It would be great if the default could be updated. And allow something like serde_json::PrettyFormatter::with_indent. It would also be handy to be able to specify other defaults, like whether strings should be enclosed in ' or " by default. I see something similar was asked in https://github.com/dtolnay/serde-yaml/issues/226

Greetings,

I have YAML files such as:

foo-bar: baz

I'd like to use serde-yaml to parse into:

struct FooBar {
    foo_bar: String,
}

Do you know if there is some simple/elegant way to deserialize this mismatch between hyphens and underscores?

Thanks for the help!

-m

Thanks for reading this, and making serde-yaml.

I wonder if there is a way to create minified YAML output using this? https://onlineyamltools.com/minify-yaml

I am having an issue with preserving string values of "yes" and "no" after converting from str -> yaml value -> (string/str). "yes" is not the same as yes (YAML version 1.1 interprets the latter as bool). Is there a setting or flag I can set to preserve the double quotes around strings yes and no, so they do not get interpreted as bools?

let _str = r#"
QuoteYes: "yes"
QuoteNo: "no"
RegYes: yes
RegNo: no
"#;
let to_yaml = serde_yaml::from_str::<serde_yaml::Value>(_str).unwrap();
let to_str = serde_yaml::to_string(&to_yaml).unwrap();
std::fs::write("./test.yaml", &to_str);

expected output file:

QuoteYes: "yes"
QuoteNo: "no"
RegYes: yes
RegNo: no

actual output file:

QuoteYes: yes
QuoteNo: no
RegYes: yes
RegNo: no