<h2>File Contents: /home/planet5/www/wp-content/plugins/updraftplus/vendor/mikemccabe/json-patch-php/src/JsonPatch.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/plugins/updraftplus/vendor/mikemccabe/json-patch-php/src/JsonPatch.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/*
.---------------------------------------------------------------------------.
|  Software: JSON-Patch PHP library                                         |
|   Version: 0.0.2                                                          |
|      Site: https://github.com/mikemccabe/json-patch-php                   |
| ------------------------------------------------------------------------- |
|   License: LGPL-3.0
&#039;---------------------------------------------------------------------------&#039;

Produce and apply JSON-patch objects.

Implements IETF JSON-patch (RFC 6902) and JSON-pointer (RFC 6901):

http://tools.ietf.org/html/rfc6902

http://tools.ietf.org/html/rfc6901

Entry points
------------

- get($doc, $pointer) - get a value from a JSON document
- diff($src, $dst) - return patches to create $dst from $src
- patch($doc, $patches) - apply patches to $doc and return result

Arguments are PHP arrays, i.e. the output of
json_decode($json_string, 1).

(Note that you MUST pass 1 as the second argument to json_decode to
get an array.  This library does not work with stdClass objects.)

All structures are implemented directly as PHP arrays.  An array is
considered to be &#039;associative&#039; (e.g. like a JSON &#039;object&#039;) if it
contains at least one non-numeric key.

Because of this, empty arrays ([]) and empty objects ({}) compare the
same, and (for instance) an &#039;add&#039; of a string key to an empty array
will succeed in this implementation where it might fail in others.

$simplexml_mode is provided to help with working with arrays produced
from XML in the style of simplexml - e.g. repeated XML elements are
expressed as arrays.  When $simplexml_mode is enabled, leaves with
scalar values are implicitly treated as length-1 arrays, so this test
will succeed:

    { &quot;comment&quot;: &quot;basic simplexml array promotion&quot;,
      &quot;doc&quot;: { &quot;foo&quot;:1 },
      &quot;patch&quot;: [ { &quot;op&quot;:&quot;add&quot;, &quot;path&quot;:&quot;/foo/1&quot;, &quot;value&quot;:2 } ],
      &quot;expected&quot;: { &quot;foo&quot;:[1, 2] } },

Also, when $simplexml_mode is true, 1-length arrays are converted to
scalars on return from patch().

*/

namespace mikemccabe\JsonPatch;

class JsonPatchException extends \Exception { }


class JsonPatch
{
  // Follow a json-pointer address into a JSON document and return
  // the designated leaf value
  public static function get($doc, $pointer, $simplexml_mode=false)
  {
    $parts = self::decompose_pointer($pointer);
    return self::get_helper($doc, $pointer, $parts, $simplexml_mode);
  }


  // Compute a list of json-patch structures representing the diff
  // between $src and $dst
  public static function diff($src, $dst)
  {
    return self::diff_values(&quot;&quot;, $src, $dst);
  }


  // Compute a new document from the supplied $doc and $patches.
  public static function patch($doc, $patches, $simplexml_mode=false)
  {
    // accept singleton patches
    if (count($patches) != 0 &amp;&amp; !isset($patches[0]))
    {
      $patches = Array($patches);
    }

    foreach ($patches as $patch)
    {
      $op = $patch[&#039;op&#039;];
      $path = $patch[&#039;path&#039;];

      if (empty($op))
      {
        throw new JsonPatchException(&quot;&#039;op&#039; missing in &quot;
                                     . json_encode($patch));
      }
      if (!is_string($path))
      {
        throw new JsonPatchException(&quot;&#039;path&#039; missing in &quot;
                                     . json_encode($patch));
      }
      if (!in_array($op, array(&#039;add&#039;, &#039;remove&#039;, &#039;replace&#039;,
                               &#039;move&#039;, &#039;copy&#039;, &#039;test&#039;, &#039;append&#039;)))
      {
        throw new JsonPatchException(&quot;Unrecognized op &#039;$op&#039; in &quot;
                                     . json_encode($patch));
      }

      $parts = self::decompose_pointer($path);
      if (in_array($op, Array(&#039;test&#039;, &#039;add&#039;, &#039;replace&#039;, &#039;append&#039;)))
      {
        if (!array_key_exists(&#039;value&#039;, $patch))
        {
          throw new JsonPatchException(&quot;&#039;value&#039; missing in &quot;
                                       . json_encode($patch));
        }
        $value = $patch[&#039;value&#039;];
      }
      if (in_array($op, Array(&#039;move&#039;, &#039;copy&#039;)))
      {
        if (!array_key_exists(&#039;from&#039;, $patch))
        {
          throw new JsonPatchException(&quot;&#039;from&#039; missing in &quot;
                                       . json_encode($patch));
        }
        $from_path = $patch[&#039;from&#039;];
        $from_parts = self::decompose_pointer($from_path);
      }

      if ($op === &#039;add&#039;)
      {
        $doc = self::do_op($doc, $op, $path, $parts, $value,
                           $simplexml_mode);
      }
      if ($op === &#039;append&#039;)
      {
        $doc = self::do_op($doc, $op, $path, $parts, $value,
                           $simplexml_mode);
      }
      else if ($op == &#039;replace&#039;)
      {
        $doc = self::do_op($doc, $op, $path, $parts, $value,
                           $simplexml_mode);
      }
      else if ($op == &#039;remove&#039;)
      {
        $doc = self::do_op($doc, $op, $path, $parts, null,
                           $simplexml_mode);
      }

      else if ($op == &#039;test&#039;)
      {
        self::test($doc, $path, $parts, $value,
                   $simplexml_mode);
      }

      else if ($op == &#039;copy&#039;)
      {
        $value = self::get_helper($doc, $from_path, $from_parts,
                                  $simplexml_mode);
        $doc = self::do_op($doc, &#039;add&#039;, $path, $parts, $value,
                           $simplexml_mode);
      }
      else if ($op == &#039;move&#039;)
      {
        $value = self::get_helper($doc, $from_path, $from_parts,
                                  $simplexml_mode);
        $doc = self::do_op($doc, &#039;remove&#039;, $from_path, $from_parts, null,
                           $simplexml_mode);
        $doc = self::do_op($doc, &#039;add&#039;, $path, $parts, $value,
                           $simplexml_mode);
      }
    }

    if ($simplexml_mode)
    {
      $doc = self::re_singletize($doc);
    }

    return $doc;
  }


  public static function compose_pointer($parts)
  {
    $result = &quot;&quot;;
    foreach($parts as $part)
    {
      $part = self::escape_pointer_part($part);
      $result = $result . &quot;/&quot; . $part;
    }
    return $result;
  }


  public static function escape_pointer_part($part)
  {
    $part = str_replace(&#039;~&#039;, &#039;~0&#039;, $part);
    $part = str_replace(&#039;/&#039;, &#039;~1&#039;, $part);
    return $part;
  }


  // Private functions follow


  // Walk through the doc and turn every 1-length array into a
  // singleton value.  This follows SimpleXML behavior.
  private static function re_singletize($doc)
  {
    if (!is_array($doc))
    {
      return $doc;
    }

    if (array_key_exists(0, $doc) &amp;&amp; count($doc) == 1)
    {
      return self::re_singletize($doc[0]);
    }

    $result = array();
    foreach(array_keys($doc) as $key)
    {
      $result[$key] = self::re_singletize($doc[$key]);
    }
    return $result;
  }


  private static function decompose_pointer($pointer)
  {
    $parts = explode(&#039;/&#039;, $pointer);
    if (array_shift($parts) !== &quot;&quot;)
    {
      throw new JsonPatchException(&quot;path must start with / in $pointer&quot;);
    }
    for ($i = 0; $i &lt; count($parts); $i++)
    {
      $parts[$i] = str_replace(&#039;~1&#039;, &#039;/&#039;, $parts[$i]);
      $parts[$i] = str_replace(&#039;~0&#039;, &#039;~&#039;, $parts[$i]);
    }
    return $parts;
  }


  // only 0 or counting number; &#039;1e0&#039; is excluded.
  private static function is_index($part)
  {
    return 1 === preg_match(&#039;/^(0|[1-9][0-9]*)$/&#039;, $part);
  }


  // diff support functions


  // Dispatch to a recursive diff_assoc or diff_array call if needed,
  // or emit a patch to replace the current value.
  private static function diff_values($path, $value, $other)
  {
    // manually handle the {}-looks-like-[] case, when other is associative
    if ((count($value) == 0 || count($other) == 0)
        &amp;&amp; (self::is_associative($value) || self::is_associative($other)))
    {
      return self::diff_assoc($path, $value, $other);
    }
    else if (self::is_associative($value) &amp;&amp; self::is_associative($other))
    {
      return self::diff_assoc($path, $value, $other);
    }
    else if (is_array($value) &amp;&amp; !self::is_associative($value)
             &amp;&amp; is_array($other) &amp;&amp; !self::is_associative($value))
    {
      return self::diff_array($path, $value, $other);
    }
    else
    {
      if ($value !== $other)
      {
        return array(array(&quot;op&quot; =&gt; &quot;replace&quot;, &quot;path&quot; =&gt; &quot;$path&quot;,
                           &quot;value&quot; =&gt; $other));
      }
    }
    return array();
  }


  // Walk associative arrays $src and $dst, returning a list of patches
  private static function diff_assoc($path, $src, $dst)
  {
    $result = array();
    if (count($src) == 0 &amp;&amp; count($dst) != 0)
    {
      $result[] = array(&quot;op&quot; =&gt; &quot;replace&quot;, &quot;path&quot; =&gt; &quot;$path&quot;, &quot;value&quot; =&gt; $dst);
    }
    else
    {
      foreach (array_keys($src) as $key)
      {
        $ekey = self::escape_pointer_part($key);
        if (!array_key_exists($key, $dst))
        {
          $result[] = array(&quot;op&quot; =&gt; &quot;remove&quot;, &quot;path&quot; =&gt; &quot;$path/$ekey&quot;);
        }
        else
        {
          $result = array_merge($result,
                                self::diff_values(&quot;$path/$ekey&quot;,
                                                  $src[$key], $dst[$key]));
        }
      }
      foreach (array_keys($dst) as $key)
      {
        if (!array_key_exists($key, $src))
        {
          $ekey = self::escape_pointer_part($key);
          $result[] = array(&quot;op&quot; =&gt; &quot;add&quot;, &quot;path&quot; =&gt; &quot;$path/$ekey&quot;,
                            &quot;value&quot; =&gt; $dst[$key]);
        }
      }
    }
    return $result;
  }


  // Walk simple arrays $src and $dst, returning a list of patches
  private static function diff_array($path, $src, $dst)
  {
    $result = array();
    $lsrc = count($src);
    $ldst = count($dst);
    $max = ($lsrc &gt; $ldst) ? $lsrc : $ldst;

    // Walk backwards through arrays, starting with longest
    $i = $max - 1;
    while ($i &gt;= 0) // equivalent for loop didn&#039;t work?
    {
      if ($i &lt; $lsrc &amp;&amp; $i &lt; $ldst &amp;&amp; 
          array_key_exists($i, $src) &amp;&amp; array_key_exists($i, $dst))
      {
        $result = array_merge($result,
                              self::diff_values(&quot;$path/$i&quot;,
                                                $src[$i], $dst[$i]));
      }
      else if ($i &lt; $ldst &amp;&amp; array_key_exists($i, $dst))
      {
        $result[] = array(&quot;op&quot; =&gt; &quot;add&quot;, &quot;path&quot; =&gt; &quot;$path/$i&quot;,
                          &quot;value&quot; =&gt; $dst[$i]);
      }
      else if ($i &lt; $lsrc &amp;&amp; !array_key_exists($i, $dst))
      {
        $result[] = array(&quot;op&quot; =&gt; &quot;remove&quot;, &quot;path&quot; =&gt; &quot;$path/$i&quot;);
      }
      $i--;
    }
    return $result;
  }


  // patch support functions


  // Implements the &#039;test&#039; op
  private static function test($doc, $path, $parts, $value, $simplexml_mode)
  {
    $found = self::get_helper($doc, $path, $parts, $simplexml_mode);

    if (!self::considered_equal($found, $value))
    {
      throw new JsonPatchException(&quot;test target value different - expected &quot;
                                   . json_encode($value) . &quot;, found &quot;
                                   . json_encode($found));
    }
  }


  // Helper for get() and &#039;copy&#039;, &#039;move&#039;, &#039;test&#039; ops - get a value from a doc.
  private static function get_helper($doc, $path, $parts, $simplexml_mode)
  {
    if (count($parts) == 0)
    {
      return $doc;
    }

    $part = array_shift($parts);
    if (!is_array($doc) || !array_key_exists($part, $doc))
    {
      throw new JsonPatchException(&quot;Path &#039;$path&#039; not found&quot;);
    }
    if ($simplexml_mode
        &amp;&amp; count($parts) &gt; 0
        &amp;&amp; $parts[0] == &#039;0&#039;
        &amp;&amp; self::is_associative($doc)
        &amp;&amp; !(is_array($doc[$part]) &amp;&amp; !self::is_associative($doc[$part])))
    {
      return self::get_helper(array($doc[$part]), $path, $parts,
                              $simplexml_mode);
    }
    else
    {
      return self::get_helper($doc[$part], $path, $parts,
                              $simplexml_mode);
    }
  }


  // Test whether a php array looks &#039;associative&#039; - does it have
  // any non-numeric keys?
  //
  // note: is_associative(array()) === false
  private static function is_associative($a)
  {
    if (!is_array($a))
    {
      return false;
    }
    foreach (array_keys($a) as $key)
    {
      if (is_string($key))
      {
        return true;
      }
    }
    // Also treat php gappy arrays as associative.
    // (e.g. {&quot;0&quot;:&quot;a&quot;, &quot;2&quot;:&quot;c&quot;})
    $len = count($a);
    for ($i = 0; $i &lt; $len; $i++)
    {
      if (!array_key_exists($i, $a))
      {
        return true;
      }
    }
    return false;
  }

  // Recursively sort array keys
  private static function rksort($a)
  {
    if (!is_array($a))
    {
      return $a;
    }
    foreach (array_keys($a) as $key)
    {
      $a[$key] = self::rksort($a[$key]);
    }
    // SORT_STRING seems required, as otherwise numeric indices
    // (e.g. &quot;4&quot;) aren&#039;t sorted.
    ksort($a, SORT_STRING);
    return $a;
  }


  // Per http://tools.ietf.org/html/rfc6902#section-4.6
  public static function considered_equal($a1, $a2)
  {
    return json_encode(self::rksort($a1)) === json_encode(self::rksort($a2));
  }


  // Apply a single op to modify the given document.
  //
  // As php arrays are not passed by reference, this function works
  // recursively, rebuilding complete subarrays that need changing;
  // the revised subarray is changed in the parent array before
  // returning it.
  private static function do_op($doc, $op, $path, $parts, $value,
                                $simplexml_mode)
  {
    // Special-case toplevel
    if (count($parts) == 0)
    {
      if ($op == &#039;add&#039; || $op == &#039;replace&#039;)
      {
        return $value;
      }
      else if ($op == &#039;remove&#039;)
      {
        throw new JsonPatchException(&quot;Can&#039;t remove whole document&quot;);
      }
      else
      {
        throw new JsonPatchException(&quot;&#039;$op&#039; can&#039;t operate on whole document&quot;);
      }
    }

    $part = array_shift($parts);

    // recur until we get to the target
    if (count($parts) &gt; 0)
    {
      if (!array_key_exists($part, $doc))
      {
        throw new JsonPatchException(&quot;Path &#039;$path&#039; not found&quot;);
      }
      // recur, adding resulting sub-doc into doc returned to caller

      // special case for simplexml-style behavior - make singleton
      // scalar leaves look like 1-length arrays
      if ($simplexml_mode
          &amp;&amp; count($parts) &gt; 0
          &amp;&amp; ($parts[0] == &#039;0&#039; || $parts[0] == &#039;1&#039; || $parts[0] == &#039;-&#039;)
          &amp;&amp; self::is_associative($doc)
          &amp;&amp; !(is_array($doc[$part]) &amp;&amp; !self::is_associative($doc[$part])))
      {
        $doc[$part] = self::do_op(array($doc[$part]), $op, $path, $parts,
                                  $value, $simplexml_mode);
      }
      else
      {
        $doc[$part] = self::do_op($doc[$part], $op, $path, $parts,
                                  $value, $simplexml_mode);
      }
      return $doc;
    }

    // at target
    if (!is_array($doc))
    {
      throw new JsonPatchException(&#039;Target must be array or associative array&#039;);
    }

    if (!self::is_associative($doc)) // N.B. returns false for empty arrays
    {
      if (count($doc) &amp;&amp; !self::is_index($part)
          &amp;&amp; !($part == &#039;-&#039; &amp;&amp; ($op == &#039;add&#039; || $op == &#039;append&#039;)))
      {
        throw new JsonPatchException(&quot;Non-array key &#039;$part&#039; used on array&quot;);
      }
      else
      {
        // check range, if numeric
        if (self::is_index($part) &amp;&amp;
            ($part &lt; 0 || (($op == &#039;remove&#039; &amp;&amp; $part &gt;= count($doc))
                           || ($op != &#039;remove&#039; &amp;&amp; $part &gt; count($doc)))))
        {
          throw new JsonPatchException(&quot;Can&#039;t operate outside of array bounds&quot;);
        }
      }
    }

    if ($op == &#039;add&#039; || $op == &#039;append&#039;)
    {
      if (!self::is_associative($doc)
          &amp;&amp; (self::is_index($part) || $part == &#039;-&#039;))
      {
        // If index is &#039;-&#039;, use array length
        $index = ($part == &#039;-&#039;) ? count($doc) : $part;
        if ($op == &#039;append&#039;)
        {
          array_splice($doc, $index, 0, $value);
        }
        else
        {
          array_splice($doc, $index, 0, Array($value));
        }
      }
      else
      {
        $doc[$part] = $value;
      }
    }

    else if ($op == &#039;replace&#039;)
    {
      if (!self::is_associative($doc) &amp;&amp; self::is_index($part))
      {
        array_splice($doc, $part, 1, Array($value));
      }
      else
      {
        if (!array_key_exists($part, $doc))
        {
          throw new JsonPatchException(&quot;replace target &#039;$path&#039; not set&quot;);
        }
        $doc[$part] = $value;
      }
    }

    else if ($op == &#039;remove&#039;)
    {
      if (!self::is_associative($doc) &amp;&amp; self::is_index($part))
      {
        array_splice($doc, $part, 1);
      }
      else
      {
        if (!array_key_exists($part, $doc))
        {
          throw new JsonPatchException(&quot;remove target &#039;$path&#039; not set&quot;);
        }
        unset($doc[$part]);
      }
    }
    return $doc;
  }
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fplugins%2Fupdraftplus%2Fvendor%2Fmikemccabe%2Fjson-patch-php%2Fsrc'>⬅ Back to Directory</a>