stdlib: implement json merge

[mikedanese]

Adds a merge function to the stdlib as described in:

https://tools.ietf.org/html/rfc7386
https://tools.ietf.org/html/draft-ietf-appsawg-json-merge-patch-07

There's some wierdness around patching nulls. I couldn't figure out how to remove a node from the json object so some of the test cases have an extra null in the expected output which seems okay. I've left a comment where are expected differs from the spec's expected differs from our expected.

[sparkprime]

Try this on for size:

    merge(target, patch)::
        if std.type(patch) == "object" then 

            local target_fields =
                if std.type(target) == "object" then std.objectFields(target) else [];

            local null_fields = [k for k in std.objectFields(patch) if patch[k] == null];
            local both_fields = std.setUnion(target_fields, std.objectFields(patch));
            {
                [k]:
                    if !std.objectHas(patch, k) then
                        target[k]
                    else if !std.objectHas(target, k) then
                        patch[k]
                    else
                        util.merge(target[k], patch[k])
                for k in std.setDiff(both_fields, null_fields)
            }
        else
            patch

[sparkprime]

Also, the reason you have some failing test cases is because you've changed std.jsonnet and the line numbers in the "golden" stacktraces for unrelated tests no-longer align. To fix that, use refresh_golden.sh to rewrite the "golden" files with the new content (and sanity check with git diff).

[sparkprime]

Maybe this should be called mergePatch, and it really calls out for the diff equivalent as well, although not necessarily in this PR.

[sparkprime]

It looks like 7396 is the better RFC as it obsoletes 7386

[mikedanese]

It looks like the pseudocode algorithm for applying a patch did not change between the three RFC revisions so the difference must be in the http parts.

Nice! this seems to work:

    merge(target, patch)::
        if std.type(patch) == "object" then 
            local target_object =
                if std.type(target) == "object" then target else {};

            local target_fields =
                if std.type(target_object) == "object" then std.objectFields(target_object) else [];

            local null_fields = [k for k in std.objectFields(patch) if patch[k] == null];
            local both_fields = std.setUnion(target_fields, std.objectFields(patch));

            {
                [k]:
                    if !std.objectHas(patch, k) then
                        target_object[k]
                    else if !std.objectHas(target_object, k) then
                        patch[k]
                    else
                        std.merge(target_object[k], patch[k]) tailstrict
                for k in std.setDiff(both_fields, null_fields)
            }
        else
            patch,

It fixes all extra nulls except for the one in the last test case.

[sparkprime]

I think it will work with this as the inner block:

                    if !std.objectHas(patch, k) then
                        target[k]
                    else if !std.objectHas(target, k) then
                        std.merge(null, patch[k])
                    else
                        std.merge(target[k], patch[k])

[mikedanese]

I think that is equivalent since std.merge(null, patch[k]) evaluates to patch[k](always hits the else). The problem is with the else return patch branch. To conform to the spec we would have to walk the patch object and strip out all explictly null fields.

[sparkprime]

Nah std.merge(null, patch[k]) is recursive into patch[k]

std.merge(x, null) evaluates to null though

[mikedanese]

Ok I gotcha. I've updated the patch.

[sparkprime]

Looks like error.equality_function.jsonnet.golden needs updating

[sparkprime]

Absence of a .golden file means it should expect it to output just true, so you can delete this file.

[mikedanese]

@sparkprime addressed comments and build is all green