Easiest should be by showing the issue in an example.
Lets imagine we load the following yaml file:

g0:
  g1:

Now we want to add a new module with these keys: [g0, g1, g2].
Because of this in the createUnifiedList() method:

if (inEditModule.getKeys().size() > 1) {
                DYModule parent = new UtilsDYModule().getExisting(inEditModule.getKeys().subList(0, inEditModule.getKeys().size() - 1), loadedModules);
...

we get the following output after adding the new module and saving:

g0:
  g1:
g0:
  g1:
    g2:

instead of:

g0:
  g1:
    g2:

public List<String> get(String path, String[] defaultValue, int topLineBreaks, String... comments) throws NotLoadedException, IllegalKeyException {
        YamlSection yamlSection;
        if (isPathSplitRequired(path)) {
            yamlSection = this.config.put(pathSplit(path)).setDefValues(defaultValue).setCountTopLineBreaks(topLineBreaks).setComments(comments);
        } else {
            yamlSection = this.config.put(path).setDefValues(defaultValue).setCountTopLineBreaks(topLineBreaks).setComments(comments);
        }
        System.out.println(yamlSection.asStringList().toString());

        return isValueNull(yamlSection) ? List.of(defaultValue) : yamlSection.asStringList();
    }

I'm using the same code as above. If I put parameter(defaultValue) in setDefValues, it does not work properly(Unconditional initialization, asStringList() return empty list etc...). Can you check about this situation? (If I enter a value directly instead of the defaultValue parameter, it works properly, The defaultValue parameter is new String[]{"foo", "bar"})

EDIT : The "List<SmartString>" parameter is not working properly either.

Drop support for side-comments to increase performance and fix some bugs that otherwise would require more complicated solutions.
Also nobody uses really side-comments anyways.

Example:

ClassLoader classLoader = getClass().getClassLoader();

DreamYaml yaml = new DreamYaml(classLoader.getResourceAsStream("somePath/yamlStuff.yml"));

With a little change on DYReader:

public void parse(DreamYaml yaml) {
    ...
    if (yaml.getFile() != null) {
        // Some stuff if file path is present
        ...
        reader = new BufferedReader(new FileReader(file));
    } else {
        // Use InputStream instead
        reader = new BufferedReader(new InputStreamReader(yaml.getStream()));
    }
}

There is a problem that certain characters are breaking. Can't I save the file as UTF-8?

Dyml behaves weird if \ are inside it. Example:

windows-path D:\Coding\C\LJDB

Add support for updating plugins from polymart (it has rich open api so premium plugins can be easily supported)

Methods:

module.getTopLineSpacing() // Returns int representing the amount of empty lines to the next upper module
module.setTopLineSpacing() 

module.getBottomLineSpacing() // Returns int representing the amount of empty lines to the next lower module
module.setBottomLineSpacing()

Example usage:

m1: val # has 0 top line spacings and 0 bottom line spacings
m2: val # has 0 top line spacings and 2 bottom line spacings 


m3: val # has 2 top line spacings and 0 bottom line spacings 

Lets imagine we set the 'm2' modules bottom line spacings to 4?
Then what happens to the "m3" module?
Edit we could remove setBottomLineSpacing() and only use setTopLineSpacing() instead, to prevent that inconsitency between modules.

What about comments?
Since the line spacing is between modules (a comment is part of a module) the comment wouldn't have line spacings to its key.

See this file: https://github.com/Osiris-Team/Dream-Yaml/blob/main/DYML-SPEC.md.

[20-11-2021 21:03:25][AP][WARN] Type: java.lang.NullPointerException
[20-11-2021 21:03:25][AP][WARN] Stacktrace:
[20-11-2021 21:03:25][AP][WARN] com.osiris.dyml.DYModule.setDefComments(DYModule.java:514)
[20-11-2021 21:03:25][AP][WARN] com.osiris.dyml.DYModule.setDefComments(DYModule.java:508)

A single YAML file could be divided into tables.
Example:

tables:
  - table1Name:
      - column1:
         - "This value is in column1" # First row
         - "Another value"
         - 
      - column2:
         -  "This value is in colum2"   
         -      # This means there is no value
         -  "" # This means the value is empty

  # A tastier example
  - favorite-food:
     food, likes:
       - 1: "Bread" "1240" 
       - 2: "Milk" "889"  

Suppose I have the following yaml:

something: true
alot_of_things:
  athing: "something is not right"
  anotherthing: "nah its right"

When I save it, it becomes this:

something: true
something:
  athing: "something is not right"
  anotherthing: "nah its right"
alot_of_things:
  athing:
  anotherthing:

Any idea on why this is happening?

key value

Expected value: value
Actual: value

Example .dyml file saved on windows:

key value\r\n

Expected value: value
Actual value: value\r

Note that \r and \n stand for carriage return and next line, and are invisible chars also called control chars.

Example:

softdepend:
    # We depend either ProtocolLib or ProtocolSupport
    - ProtocolSupport
    - ProtocolLib
    # Premium variable
    - PlaceholderAPI
    # Auth plugins
    - AuthMe
    - LoginSecurity
    - xAuth
    - LogIt
    - UltraAuth
    - CrazyLogin

In a single String data type, the inclusion of colon in the value does not cause errors,
but in the List data type, errors occur.

ex)

TestKey1: "TestValue1: abc"
TestListKey1:
  TestListKey2: "defaultTestValue2"

TestKey1 works fine without any problems, but TestListKey2 does not work properly.

So that something like this is possible:

key1:
  child1:
    child2: value

Yaml child1 = yaml.get("key1", "child1");
child1.get("child2").asString();

This would require a tree-based design (linked list), where parent objects contain children.

test:

list:
  - hello: there

output:

list:
  - hello: there
    -
    -
...

if the space after : is missing it wont trigger a line break:

list:
  - hello:there

Example:

First run:

yaml.put("hello").setComment("my comment");
yaml.save();

First run output:

# my comment
hello:

Then in the second run, I change the code to this:

yaml.put("hello");
yaml.save();

Second run output is something like this:

#                                               my comment
hello:

Example:

        yaml.put("g0", "g1a", "g2a").setCountTopSpaces(1).setDefValues("wow!");

Output:

g0: 

  g1a: 

    g2a: wow!

Instead of:

g0: 
  g1a: 

    g2a: wow!

Expected:

key:
  - -value

Expected value: "-value"
Actual value: "value"
Actual:

key:
  - value

example:

key: this is a text
with two line breaks inside it!
  child-key: this is a text
  with two line breaks inside it!

To run this benchmark yourself simply clone this repo and run this test: https://github.com/Osiris-Team/Dream-Yaml/blob/d06e9d1a4985c985f9b3f589875d818938e2bb8d/src/test/java/YamlBenchmarks.java#L46

Research (read)

• The postprocessing costs around 0,050ms - 0,100ms of extra time
• The debugger costs around 0,100ms of extra time
• Currently, we are using .readLine() and then go through that line again and check it char by char. Instead of going through it twice maybe there is a way of going through it only once.

Research (write)

The java.nio.channels package, specifically the FileChannel class provides methods for reading/writing stuff at specific positions of the file. This may drastically increase the writing speed for bigger files, since we would only write the changes instead of the whole file.
Possible logic for the above:

1. Check if the file is empty. If it is simply parse and write all modules to it. Otherwise, continue:
2. During read attach the keys and values start/end positions to the module. Now if the module was modified, aka the value/key was changed we write to those specific positions only.

There are however some negative aspects to this approach:

• Extra memory needed to store each keys/values positions
• The more time passes between read and write, the more likely it is that the file was changed in between and thus the positions are not accurate anymore which could lead to breaking the yaml file
• We would need to recalculate the position of all keys/values with each modification I think
• The above would not work for Input-/Output- Streams
• We would also need to store the old/unmodified value/key to recalculate the location

Excepted:

key: value# # comment 

Expected value: "value#"
Excpeted side-comment: "comment"
Actual value: "value"
Actual side-comment: " # comment"