path: root/nix/mergePatch/default.nix

{ lib, depot, ... }:
/*
  JSON Merge-Patch for nix
  Spec: https://tools.ietf.org/html/rfc7396

  An algorithm for changing and removing fields in nested objects.

  For example, given the following original document:

  {
  a = "b";
  c = {
      d = "e";
      f = "g";
  }
  }

  Changing the value of `a` and removing `f` can be achieved by merging the patch

  {
  a = "z";
  c.f = null;
  }

  which results in

  {
  a = "z";
  c = {
      d = "e";
  };
  }

  Pseudo-code:
  define MergePatch(Target, Patch):
      if Patch is an Object:
        if Target is not an Object:
          Target = {} # Ignore the contents and set it to an empty Object
        for each Name/Value pair in Patch:
          if Value is null:
            if Name exists in Target:
              remove the Name/Value pair from Target
          else:
            Target[Name] = MergePatch(Target[Name], Value)
        return Target
      else:
        return Patch
*/

let
  foldlAttrs = op: init: attrs:
    lib.foldl' op init
      (lib.mapAttrsToList lib.nameValuePair attrs);

  mergePatch = target: patch:
    if lib.isAttrs patch
    then
      let target' = if lib.isAttrs target then target else { };
      in foldlAttrs
        (acc: patchEl:
          if patchEl.value == null
          then removeAttrs acc [ patchEl.name ]
          else acc // {
            ${patchEl.name} =
              mergePatch
                (acc.${patchEl.name} or "unnused")
                patchEl.value;
          })
        target'
        patch
    else patch;

  inherit (depot.nix.runTestsuite)
    runTestsuite
    it
    assertEq
    ;

  tests =
    let
      # example target from the RFC
      testTarget = {
        a = "b";
        c = {
          d = "e";
          f = "g";
        };
      };
      # example patch from the RFC
      testPatch = {
        a = "z";
        c.f = null;
      };
      emptyPatch = it "the empty patch returns the original target" [
        (assertEq "id"
          (mergePatch testTarget { })
          testTarget)
      ];
      nonAttrs = it "one side is a non-attrset value" [
        (assertEq "target is a value means the value is replaced by the patch"
          (mergePatch 42 testPatch)
          (mergePatch { } testPatch))
        (assertEq "patch is a value means it replaces target alltogether"
          (mergePatch testTarget 42)
          42)
      ];
      rfcExamples = it "the examples from the RFC" [
        (assertEq "a subset is deleted and overwritten"
          (mergePatch testTarget testPatch)
          {
            a = "z";
            c = {
              d = "e";
            };
          })
        (assertEq "a more complicated example from the example section"
          (mergePatch
            {
              title = "Goodbye!";
              author = {
                givenName = "John";
                familyName = "Doe";
              };
              tags = [ "example" "sample" ];
              content = "This will be unchanged";
            }
            {
              title = "Hello!";
              phoneNumber = "+01-123-456-7890";
              author.familyName = null;
              tags = [ "example" ];
            })
          {
            title = "Hello!";
            phoneNumber = "+01-123-456-7890";
            author = {
              givenName = "John";
            };
            tags = [ "example" ];
            content = "This will be unchanged";
          })
      ];

      rfcTests =
        let
          r = index: target: patch: res:
            (assertEq "test number ${toString index}"
              (mergePatch target patch)
              res);
        in
        it "the test suite from the RFC" [
          (r 1 { "a" = "b"; } { "a" = "c"; } { "a" = "c"; })
          (r 2 { "a" = "b"; } { "b" = "c"; } { "a" = "b"; "b" = "c"; })
          (r 3 { "a" = "b"; } { "a" = null; } { })
          (r 4 { "a" = "b"; "b" = "c"; }
            { "a" = null; }
            { "b" = "c"; })
          (r 5 { "a" = [ "b" ]; } { "a" = "c"; } { "a" = "c"; })
          (r 6 { "a" = "c"; } { "a" = [ "b" ]; } { "a" = [ "b" ]; })
          (r 7 { "a" = { "b" = "c"; }; }
            { "a" = { "b" = "d"; "c" = null; }; }
            { "a" = { "b" = "d"; }; })
          (r 8 { "a" = [{ "b" = "c"; }]; }
            { "a" = [ 1 ]; }
            { "a" = [ 1 ]; })
          (r 9 [ "a" "b" ] [ "c" "d" ] [ "c" "d" ])
          (r 10 { "a" = "b"; } [ "c" ] [ "c" ])
          (r 11 { "a" = "foo"; } null null)
          (r 12 { "a" = "foo"; } "bar" "bar")
          (r 13 { "e" = null; } { "a" = 1; } { "e" = null; "a" = 1; })
          (r 14 [ 1 2 ]
            { "a" = "b"; "c" = null; }
            { "a" = "b"; })
          (r 15 { }
            { "a" = { "bb" = { "ccc" = null; }; }; }
            { "a" = { "bb" = { }; }; })
        ];

    in
    runTestsuite "mergePatch" [
      emptyPatch
      nonAttrs
      rfcExamples
      rfcTests
    ];

in
{
  __functor = _: mergePatch;

  inherit tests;
}