[Question] String length limit! Can it be disabled?

[EverNife]

It seems that when a line is too long, the dump process will "split" it into several lines to keep ir "readable" (?)

I would like to know if its possible to disable it (or change it), or this feature has something to do with performance?

I asks about the perforamance reaseon because a few years ago i had to split myself a giant string into a List because the yaml file was getting laggy to be readen.

[EverNife]

Ok, found out!

SnakeYamlImplementation implementation = (SnakeYamlImplementation) yamlFile.getImplementation();
implementation.getDumperOptions().setSplitLines(false);

This is the way!

The rest of the DumpOptions can be found at https://bitbucket.org/snakeyaml/snakeyaml/wiki/Documentation#markdown-header-dumping-a-custom-yaml-document

[Carleslc]

Customize the snakeyaml dumper options

There are two options available in the snakeyaml DumperOptions that you can configure for this use case:

setWidth (80 by default): the desired line length. If the string is larger, it is split into multiple lines (no new line is included in the string itself, only in the yaml file).

setSplitLines (true by default): If this setting is false, then the width is ignored and strings will not be split no matter its length.

These options are not present in the yamlFile.options() but all configurations related to the snakeyaml implementation are available through yamlFile.getImplementation(). As you already guessed, you need to cast to either SimpleYamlImplementation or SnakeYamlImplementation to get access to the getDumperOptions method.

DumperOptions yamlOptions = ((SimpleYamlImplementation) yamlFile.getImplementation()).getDumperOptions();
yamlOptions.setWidth(100);

Using literal strings

You can also use literal strings, which are not split by width like plain scalar strings.

String longLine = "This is a very long string line that we want to be dumped in a single line in the yaml file. To achieve this behaviour, we configure the line width and split lines in the dumper options, or dump this as a literal string.";

yamlFile.set("long-line-100", longLine); // QuoteStyle.PLAIN by default, with the width 100 set above
yamlFile.set("long-line-literal", longLine, QuoteStyle.LITERAL);

long-line-100: This is a very long string line that we want to be dumped in a single line in the yaml
  file. To achieve this behaviour, we configure the line width and split lines in the dumper options,
  or dump this as a literal string.
long-line-literal: |-
  This is a very long string line that we want to be dumped in a single line in the yaml file. To achieve this behaviour, we configure the line width and split lines in the dumper options, or dump this as a literal string.

Literal strings are split only if new lines \n are actually present in the provided string.

If needed, to always use literal style with strings you can set it to be the string default instead of QuoteStyle.PLAIN:

yamlFile.options().quoteStyleDefaults().setQuoteStyle(String.class, QuoteStyle.LITERAL);

yamlFile.set("long-line-literal", longLine); // Now QuoteStyle.LITERAL is the default

Providing your own configured implementation

Another way to customize the dumper options is to create a custom YamlImplementation that inherits SimpleYamlImplementation, overriding the configure method to apply your own values.

public class CustomYamlConfiguration extends SimpleYamlImplementation {

    @Override
    public void configure(YamlConfigurationOptions options) {
        // Don't forget this line to apply default configurations first!
        super.configure(options);

        // Customize options to your choice
        options.quoteStyleDefaults().setQuoteStyle(String.class, QuoteStyle.DOUBLE);

        // Customize dumper options to your choice
        DumperOptions yamlOptions = this.getDumperOptions();
        yamlOptions.setSplitLines(false);
    }
}

Then, to create a YamlFile using this implementation, you can override the default implementation:

YamlFile yamlFile = new YamlFile("config.yml");
yamlFile.setImplementation(new CustomYamlConfiguration());

Or just use the implementation constructor:

YamlFile yamlFile = new YamlFile(new CustomYamlConfiguration());
yamlFile.setConfigurationFile("config.yml"); // Set your yml file here (also available with File or URI)

// Then, set up your file as usual without worrying about configuration options here
yamlFile.createOrLoad();

String longLine = "This is a very long string line that we want to be dumped in a single line in the yaml file. To achieve this behaviour, we configure the line width and split lines in the dumper options, or dump this as a literal string.";

yamlFile.set("long-line", longLine);

yamlFile.save();

long-line: "This is a very long string line that we want to be dumped in a single line in the yaml file. To achieve this behaviour, we configure the line width and split lines in the dumper options, or dump this as a literal string."

This is somewhat advanced but is the optimal way if you have several configuration options to customize. Hope it helps to you or other users with similar use cases.

More details about implementations can be found here.

[EverNife]

Thank You very much for all the in-deep details and recomendations :D