Simplify utils.find_json function

Instead of trying to parse all combinations of json blobs to find the
largest valid one, track open JSON objects and lists and try to parse
them one-by-one, ordered by size.

Author: agraul

salt/utils/json.py

@@ -24,66 +24,46 @@ def __split(raw):
     return raw.splitlines()
 
 
-def find_json(raw):
-    """
-    Pass in a raw string and load the json when it starts. This allows for a
-    string to start or end with garbage but the JSON be cleanly loaded
+def find_json(s):
+    """Pass in a string and load json within it.
+
+    The string may contain non-json text before and after the a json blob.
     """
-    ret = {}
-    lines = __split(raw)
-    lengths = list(map(len, lines))
-    starts = []
-    ends = []
-
-    # Search for possible starts and ends of the json fragments
-    for ind, line in enumerate(lines):
-        line = line.lstrip()
-        line = line[0] if line else line
-        if line == "{" or line == "[":
-            starts.append((ind, line))
-        if line == "}" or line == "]":
-            ends.append((ind, line))
-
-    # List all the possible pairs of starts and ends,
-    # and fill the length of each block to sort by size after
-    starts_ends = []
-    for start, start_char in starts:
-        for end, end_br in reversed(ends):
-            if end > start and (
-                (start_char == "{" and end_br == "}")
-                or (start_char == "[" and end_br == "]")
-            ):
-                starts_ends.append((start, end, sum(lengths[start : end + 1])))
-
-    # Iterate through all the possible pairs starting from the largest
-    starts_ends.sort(key=lambda x: (x[2], x[1] - x[0], x[0]), reverse=True)
-    for start, end, _ in starts_ends:
-        # Try filtering non-JSON text right after the last closing character
-        end_str = lines[end].lstrip()[0]
-        working = "\n".join(lines[start:end]) + end_str
+    # Contains tuples (start_idx, end_idx, length) for JSON objects / lists
+    json_structures = []
+
+    # Track currently open objects
+    open_obj = []
+    open_list = []
+
+    # Iterate through all chars, saving JSON structures when they are closed
+    for idx, char in enumerate(s):
+        if char == "{":
+            open_obj.append(idx)
+        elif char == "}":
+            start = open_obj.pop()
+            json_structures.append((start, idx, idx - start))
+        elif char == "[":
+            open_list.append(idx)
+        elif char == "]":
+            start = open_list.pop()
+            json_structures.append((start, idx, idx - start))
+
+    def length_start(x):
+        """Sort key function. Sort by length, then by start index."""
+        return x[2], x[0]
+
+    json_structures.sort(key=length_start)
+
+    while json_structures:
+        start, end, _ = json_structures.pop()
+        substring = s[start : end + 1]
         try:
-            ret = json.loads(working)
+            ret = json.loads(substring)
             return ret
         except ValueError:
             continue
-
-    # Fall back to old implementation for backward compatibility
-    # expecting json after the text
-    for ind, _ in enumerate(lines):
-        try:
-            working = "\n".join(lines[ind:])
-        except UnicodeDecodeError:
-            working = "\n".join(salt.utils.data.decode(lines[ind:]))
-
-        try:
-            ret = json.loads(working)
-        except ValueError:
-            continue
-        if ret:
-            return ret
-    if not ret:
-        # Not json, raise an error
-        raise ValueError
+    raise ValueError
 
 
 def import_json():