jsonreflow 0.4.0__tar.gz

jsonreflow-0.4.0/.gitignore

@@ -0,0 +1,223 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer,
+#   you could uncomment the following to ignore the entire vscode folder
+.vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+
+# Generic temporary files and folders
+tmp/
+temp/
+tmp-*
+temp-*

jsonreflow-0.4.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stefaan Lippens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsonreflow-0.4.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: jsonreflow
+Version: 0.4.0
+Summary: Indented JSON, but with one-line arrays or objects if they fit a desired line length.
+Project-URL: Repository, https://github.com/soxofaan/jsonreflow
+Project-URL: Changelog, https://github.com/soxofaan/jsonreflow/blob/main/CHANGELOG.md
+Author-email: Stefaan Lippens <soxofaan@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: JSON,serialization
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: File Formats :: JSON
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+
+# JSON Reflow
+
+Python library and CLI tool to reflow JSON files and streams,
+to allow a better compromise between
+
+- compactness:
+  try to fit short arrays and objects on a single line,
+  within a given line length limit
+- human readability:
+  indented JSON for larger constructs otherwise.
+
+
+
+## The problem
+
+Standard JSON serialization tools typically only support two extremes:
+
+- put everything on a single line:
+  the most compact, but very poor for human readability
+
+- spread out each and every array item and object property on its own line
+  with appropriate indentation to visualize the structure.
+  This is easier for humans to parse visually
+  (which is why it is often referred to as "prettifying" or "beautifying"),
+  but for larger documents, this easily becomes unwieldy, "too vertical"
+  and very space-inefficient because of all the repeated indentation.
+
+JSON Reflow allows to find a better compromise:
+only serialize arrays or objects over multiple lines
+if the single-line approach would exceed a given line length.

jsonreflow-0.4.0/README.md

@@ -0,0 +1,31 @@
+
+# JSON Reflow
+
+Python library and CLI tool to reflow JSON files and streams,
+to allow a better compromise between
+
+- compactness:
+  try to fit short arrays and objects on a single line,
+  within a given line length limit
+- human readability:
+  indented JSON for larger constructs otherwise.
+
+
+
+## The problem
+
+Standard JSON serialization tools typically only support two extremes:
+
+- put everything on a single line:
+  the most compact, but very poor for human readability
+
+- spread out each and every array item and object property on its own line
+  with appropriate indentation to visualize the structure.
+  This is easier for humans to parse visually
+  (which is why it is often referred to as "prettifying" or "beautifying"),
+  but for larger documents, this easily becomes unwieldy, "too vertical"
+  and very space-inefficient because of all the repeated indentation.
+
+JSON Reflow allows to find a better compromise:
+only serialize arrays or objects over multiple lines
+if the single-line approach would exceed a given line length.

jsonreflow-0.4.0/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "jsonreflow"
+dynamic = ["version"]
+description = "Indented JSON, but with one-line arrays or objects if they fit a desired line length."
+readme = "README.md"
+requires-python = ">= 3.8"
+authors = [
+  {name = "Stefaan Lippens", email = "soxofaan@gmail.com"},
+]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+keywords = ["JSON", "serialization"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: File Formats :: JSON",
+  "Topic :: Utilities",
+]
+
+
+[project.urls]
+Repository = "https://github.com/soxofaan/jsonreflow"
+Changelog = "https://github.com/soxofaan/jsonreflow/blob/main/CHANGELOG.md"
+
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3",
+]
+
+
+[project.scripts]
+jsonreflow = "jsonreflow.cli:main"
+
+
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jsonreflow"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/",
+  "tests/",
+]
+
+[tool.hatch.version]
+path = "src/jsonreflow/__init__.py"
+
+
+[tool.ruff.lint]
+select = [
+  # pycodestyle
+  "E",
+  # Pyflakes
+  "F",
+  # pyupgrade
+  "UP",
+  # flake8-bugbear
+  "B",
+  # flake8-simplify
+  "SIM",
+  # isort
+  "I",
+]

jsonreflow-0.4.0/src/jsonreflow/__init__.py

@@ -0,0 +1,5 @@
+from jsonreflow.reflow import dumps, reflow, reflow_iter
+
+__version__ = "0.4.0"
+
+__all__ = ["reflow_iter", "reflow", "dumps", "__version__"]

jsonreflow-0.4.0/src/jsonreflow/cli.py

@@ -0,0 +1,46 @@
+import argparse
+import json
+
+from jsonreflow.reflow import MAX_WIDTH_DEFAULT, dumps, reflow_iter
+
+
+def main():
+    cli = argparse.ArgumentParser(description="Reflow JSON to fit within a given width")
+    cli.add_argument(
+        "input",
+        nargs="?",
+        type=argparse.FileType("r", encoding="utf-8"),
+        default="-",
+        help="Input JSON file (defaults to stdin)",
+    )
+    cli.add_argument(
+        "--assume-formatted",
+        action="store_true",
+        help="""
+            Assume the input is already properly formatted as multiline, indented JSON.
+            Allows to reflow without parsing the JSON, which is more efficient,
+            and avoids subtle re-encoding issues.
+        """,
+    )
+    cli.add_argument(
+        "-w",
+        "--max-width",
+        type=int,
+        default=MAX_WIDTH_DEFAULT,
+        help=f"Maximum line width to reflow for (default: {MAX_WIDTH_DEFAULT})",
+    )
+
+    args = cli.parse_args()
+    if args.assume_formatted:
+        for line in reflow_iter(
+            (s.rstrip() for s in args.input.readlines()), max_width=args.max_width
+        ):
+            print(line)
+    else:
+        data = json.load(args.input)
+        # TODO: integrate with streaming JSON encoding
+        print(dumps(data, max_width=args.max_width))
+
+
+if __name__ == "__main__":
+    main()

jsonreflow-0.4.0/src/jsonreflow/reflow.py

@@ -0,0 +1,59 @@
+import json
+from typing import Iterable, Iterator, List
+
+MAX_WIDTH_DEFAULT = 80
+
+
+def reflow_iter(
+    lines: Iterable[str], max_width: int = MAX_WIDTH_DEFAULT
+) -> Iterator[str]:
+    # Stack of buffers of possibly foldable levels.
+    # Note that only the currently deepest levels are tracked,
+    # levels more towards the top that are already collapsed
+    # are not represented here anymore.
+    buffer_stack: List[List[str]] = []
+
+    for line in lines:
+        stripped = line.strip()
+
+        if stripped.endswith("{") or stripped.endswith("["):
+            # Start a new level on the stack
+            buffer_stack.append([])
+
+        # Depending on whether we are at a possibly foldable level:
+        # yield (collapse) or try folding
+        if not buffer_stack:
+            yield line
+        else:
+            buffer_stack[-1].append(line)
+
+            if stripped in {"}", "},", "]", "],"}:
+                # Close current level: time to see if we can fold to one-liner
+                # or have to collapse to multi-line
+                closed = buffer_stack.pop()
+                folded = (
+                    closed[0]
+                    + " ".join(s.strip() for s in closed[1:-1])
+                    + closed[-1].strip()
+                )
+
+                if len(folded) > max_width:
+                    # Current level doesn't fit: collapse all levels we've been tracking
+                    for level in buffer_stack:
+                        yield from level
+                    buffer_stack = []
+                    yield from closed
+                else:
+                    # Move folded result up one level (unless it's collapsed already)
+                    if buffer_stack:
+                        buffer_stack[-1].append(folded)
+                    else:
+                        yield folded
+
+
+def reflow(encoded: str, max_width: int = MAX_WIDTH_DEFAULT) -> str:
+    return "\n".join(reflow_iter(encoded.split("\n"), max_width=max_width))
+
+
+def dumps(obj, max_width: int = MAX_WIDTH_DEFAULT) -> str:
+    return reflow(json.dumps(obj=obj, indent=2), max_width=max_width)

jsonreflow-0.4.0/tests/test_jsonreflow.py

@@ -0,0 +1,499 @@
+import json
+import textwrap
+from typing import Iterable, List
+
+import pytest
+
+from jsonreflow import dumps, reflow_iter
+
+
+def test_dumps_none():
+    assert dumps(None) == "null"
+
+
+def test_dumps_int():
+    assert dumps(123) == "123"
+    assert dumps(-123) == "-123"
+
+
+def test_dumps_float():
+    assert dumps(123.5) == "123.5"
+
+
+def test_dumps_bool():
+    assert dumps(True) == "true"
+    assert dumps(False) == "false"
+
+
+def test_dumps_string():
+    assert dumps("hello world") == '"hello world"'
+
+
+def test_dumps_empty_list():
+    assert dumps([]) == "[]"
+    assert dumps(()) == "[]"
+
+
+def test_dumps_empty_dict():
+    assert dumps({}) == "{}"
+
+
+def test_dumps_flat_list():
+    assert dumps([1, 2, 3, 4, 5]) == "[1, 2, 3, 4, 5]"
+    assert dumps([1, 2, 3, 4, 5], max_width=10) == "[\n  1,\n  2,\n  3,\n  4,\n  5\n]"
+    assert dumps([1, 2, 3, 4, 5], max_width=1) == "[\n  1,\n  2,\n  3,\n  4,\n  5\n]"
+
+
+def test_dumps_flat_dict():
+    assert (
+        dumps({"name": "alice", "color": "green"})
+        == '{"name": "alice", "color": "green"}'
+    )
+    assert (
+        dumps({"name": "alice", "color": "green"}, max_width=10)
+        == '{\n  "name": "alice",\n  "color": "green"\n}'
+    )
+    assert (
+        dumps({"name": "alice", "color": "green"}, max_width=1)
+        == '{\n  "name": "alice",\n  "color": "green"\n}'
+    )
+
+
+@pytest.mark.parametrize(
+    ["max_width", "obj", "expected"],
+    [
+        (
+            80,
+            {"five": list(range(5)), "ten": list(range(10))},
+            '{"five": [0, 1, 2, 3, 4], "ten": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}',
+        ),
+        (
+            40,
+            {"five": list(range(5)), "ten": list(range(10))},
+            """\
+            {
+              "five": [0, 1, 2, 3, 4],
+              "ten": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+            }""",
+        ),
+        (
+            30,
+            {"five": list(range(5)), "ten": list(range(10))},
+            """\
+            {
+              "five": [0, 1, 2, 3, 4],
+              "ten": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9
+              ]
+            }""",
+        ),
+        (
+            80,
+            {str(x): chr(97 + x) * x for x in range(5)},
+            '{"0": "", "1": "b", "2": "cc", "3": "ddd", "4": "eeee"}',
+        ),
+        (
+            40,
+            {str(x): chr(97 + x) * x for x in range(5)},
+            """\
+            {
+              "0": "",
+              "1": "b",
+              "2": "cc",
+              "3": "ddd",
+              "4": "eeee"
+            }""",
+        ),
+    ],
+)
+def test_dumps_listings(max_width, obj, expected):
+    expected = textwrap.dedent(expected)
+    assert dumps(obj, max_width=max_width) == expected
+
+
+@pytest.mark.parametrize(
+    ["max_width", "obj", "expected"],
+    [
+        (
+            80,
+            {
+                "query": "get stuff",
+                "results": {
+                    "count": 5,
+                    "data": [
+                        {"id": 1, "name": "Alice", "payments": None},
+                        {"id": 23, "name": "Bob", "payments": [100, 200]},
+                        {
+                            "id": 3000,
+                            "name": "Carol",
+                            "status": "premium",
+                            "payments": [1000, 3000, 2000, 2, -5],
+                        },
+                        {"id": 44, "name": "Dave", "payments": [1, 5]},
+                        {
+                            "id": 555,
+                            "name": "Eric",
+                            "payments": [44, {"price": 666, "currency": "tulip bulbs"}],
+                        },
+                    ],
+                },
+                "_id": "123kthxbye",
+            },
+            """\
+            {
+              "query": "get stuff",
+              "results": {
+                "count": 5,
+                "data": [
+                  {"id": 1, "name": "Alice", "payments": null},
+                  {"id": 23, "name": "Bob", "payments": [100, 200]},
+                  {
+                    "id": 3000,
+                    "name": "Carol",
+                    "status": "premium",
+                    "payments": [1000, 3000, 2000, 2, -5]
+                  },
+                  {"id": 44, "name": "Dave", "payments": [1, 5]},
+                  {
+                    "id": 555,
+                    "name": "Eric",
+                    "payments": [44, {"price": 666, "currency": "tulip bulbs"}]
+                  }
+                ]
+              },
+              "_id": "123kthxbye"
+            }""",
+        ),
+        (
+            120,
+            {
+                "query": "get stuff",
+                "results": {
+                    "count": 5,
+                    "data": [
+                        {"id": 1, "name": "Alice", "payments": None},
+                        {"id": 23, "name": "Bob", "payments": [100, 200]},
+                        {
+                            "id": 3000,
+                            "name": "Carol",
+                            "status": "premium",
+                            "payments": [1000, 3000, 2000, 2, -5],
+                        },
+                        {"id": 44, "name": "Dave", "payments": [1, 5]},
+                        {
+                            "id": 555,
+                            "name": "Eric",
+                            "payments": [44, {"price": 666, "currency": "tulip bulbs"}],
+                        },
+                    ],
+                },
+                "_id": "123kthxbye",
+            },
+            """\
+            {
+              "query": "get stuff",
+              "results": {
+                "count": 5,
+                "data": [
+                  {"id": 1, "name": "Alice", "payments": null},
+                  {"id": 23, "name": "Bob", "payments": [100, 200]},
+                  {"id": 3000, "name": "Carol", "status": "premium", "payments": [1000, 3000, 2000, 2, -5]},
+                  {"id": 44, "name": "Dave", "payments": [1, 5]},
+                  {"id": 555, "name": "Eric", "payments": [44, {"price": 666, "currency": "tulip bulbs"}]}
+                ]
+              },
+              "_id": "123kthxbye"
+            }""",  # noqa: E501
+        ),
+        (
+            80,
+            {
+                "a": {
+                    "bb": {
+                        "ccc": {
+                            "dddd": {
+                                "eeeee": {
+                                    "ffffff": "foo",
+                                },
+                            }
+                        },
+                        "CCC": {
+                            "D": 13,
+                            "DD": 133,
+                            "DDD": 1333,
+                        },
+                    }
+                }
+            },
+            """\
+            {
+              "a": {
+                "bb": {
+                  "ccc": {"dddd": {"eeeee": {"ffffff": "foo"}}},
+                  "CCC": {"D": 13, "DD": 133, "DDD": 1333}
+                }
+              }
+            }""",
+        ),
+        (
+            120,
+            {
+                "a": {
+                    "bb": {
+                        "ccc": {
+                            "dddd": {
+                                "eeeee": {
+                                    "ffffff": "foo",
+                                },
+                            }
+                        },
+                        "CCC": {
+                            "D": 13,
+                            "DD": 133,
+                            "DDD": 1333,
+                        },
+                    }
+                }
+            },
+            '{"a": {"bb": {"ccc": {"dddd": {"eeeee": {"ffffff": "foo"}}}, "CCC": {"D": 13, "DD": 133, "DDD": 1333}}}}',  # noqa: E501
+        ),
+        (
+            40,
+            {
+                "a": {
+                    "bb": {
+                        "ccc": {
+                            "dddd": {
+                                "eeeee": {
+                                    "ffffff": "foo",
+                                },
+                            }
+                        },
+                        "CCC": {
+                            "D": 13,
+                            "DD": 133,
+                            "DDD": 1333,
+                        },
+                    }
+                }
+            },
+            """\
+            {
+              "a": {
+                "bb": {
+                  "ccc": {
+                    "dddd": {
+                      "eeeee": {"ffffff": "foo"}
+                    }
+                  },
+                  "CCC": {
+                    "D": 13,
+                    "DD": 133,
+                    "DDD": 1333
+                  }
+                }
+              }
+            }""",
+        ),
+    ],
+)
+def test_dumps_deep_nesting(obj, max_width, expected):
+    expected = textwrap.dedent(expected)
+    assert dumps(obj, max_width=max_width) == expected
+
+
+class TrackingIterator:
+    """
+    Wrapper for an iterable of strings, to keep track of what has been consumed already.
+    """
+
+    def __init__(self, items: Iterable[str]):
+        self._items = iter(items)
+        self.consumed = []
+        self._report_index = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        item = next(self._items)
+        self.consumed.append(item)
+        return item
+
+    def new_consumed(self) -> List[str]:
+        """Report newly consumed items since the last call."""
+        index = self._report_index
+        self._report_index = len(self.consumed)
+        return self.consumed[index:]
+
+
+def test_tracking_iterator_basic():
+    iterator = TrackingIterator(["a", "b", "c"])
+
+    assert iterator.consumed == []
+    assert iterator.new_consumed() == []
+
+    assert next(iterator) == "a"
+    assert iterator.consumed == ["a"]
+    assert iterator.new_consumed() == ["a"]
+
+    assert next(iterator) == "b"
+    assert iterator.consumed == ["a", "b"]
+
+    assert next(iterator) == "c"
+    assert iterator.consumed == ["a", "b", "c"]
+    assert iterator.new_consumed() == ["b", "c"]
+    assert iterator.new_consumed() == []
+
+    with pytest.raises(StopIteration):
+        next(iterator)
+    assert iterator.consumed == ["a", "b", "c"]
+    assert iterator.new_consumed() == []
+
+
+def test_reflow_iter_flushing_simple_one_line():
+    """
+    Trivial case: everything fits on one line,
+    so we should consume all input lines immediately.
+    """
+    data = {"color": "green", "shape": "square"}
+    input_lines = TrackingIterator(json.dumps(data, indent=2).split("\n"))
+
+    folded = reflow_iter(input_lines, max_width=80)
+    assert input_lines.consumed == []
+
+    line = next(folded)
+    assert line == '{"color": "green", "shape": "square"}'
+    assert input_lines.consumed == [
+        "{",
+        '  "color": "green",',
+        '  "shape": "square"',
+        "}",
+    ]
+
+
+def test_reflow_iter_flushing_simple_multiline():
+    """
+    Multi-line result, but just one level,
+    so all lines should be consumed immediately.
+    """
+    data = {"color": "green", "shape": "square"}
+    input_lines = TrackingIterator(json.dumps(data, indent=2).split("\n"))
+
+    folded = reflow_iter(input_lines, max_width=20)
+    assert input_lines.new_consumed() == []
+
+    assert next(folded) == "{"
+    assert input_lines.new_consumed() == [
+        "{",
+        '  "color": "green",',
+        '  "shape": "square"',
+        "}",
+    ]
+
+    assert next(folded) == '  "color": "green",'
+    assert input_lines.new_consumed() == []
+
+    assert next(folded) == '  "shape": "square"'
+    assert input_lines.new_consumed() == []
+
+    assert next(folded) == "}"
+    assert input_lines.new_consumed() == []
+
+    with pytest.raises(StopIteration):
+        _ = next(folded)
+
+
+def test_reflow_iter_flushing_nested():
+    """Multi-line result with nesting: input is consumed in chunks."""
+    data = {"three": list(range(3)), "five": list(range(5)), "ten": list(range(10))}
+    input_lines = TrackingIterator(json.dumps(data, indent=2).split("\n"))
+
+    folded = reflow_iter(input_lines, max_width=25)
+    assert input_lines.new_consumed() == []
+
+    # Top level flush: while "three" would fit on one line, "five" would overflow.
+    assert next(folded) == "{"
+    assert input_lines.new_consumed() == [
+        "{",
+        '  "three": [',
+        "    0,",
+        "    1,",
+        "    2",
+        "  ],",
+        # TODO: with the next line, it should already be possible to determine
+        #       that "five" won't fit, and it's already time to flush
+        #       without further consumption.
+        '  "five": [',
+        "    0,",
+        "    1,",
+        "    2,",
+        "    3,",
+        "    4",
+        "  ],",
+    ]
+
+    # "three" fits on one line
+    assert next(folded) == '  "three": [0, 1, 2],'
+    assert input_lines.new_consumed() == []
+
+    # "five" doesn't fit, so we get multiple lines
+    assert next(folded) == '  "five": ['
+    assert input_lines.new_consumed() == []
+
+    for x in range(4):
+        assert next(folded) == f"    {x},"
+        assert input_lines.new_consumed() == []
+
+    assert next(folded) == "    4"
+    assert input_lines.new_consumed() == []
+
+    assert next(folded) == "  ],"
+    assert input_lines.new_consumed() == []
+
+    # Time for "ten": also doesn't fit. Buffer is empty at this point,
+    # so we have to consume a bit too.
+    assert next(folded) == '  "ten": ['
+    assert input_lines.new_consumed() == [
+        '  "ten": [',
+        "    0,",
+        "    1,",
+        "    2,",
+        "    3,",
+        "    4,",
+        "    5,",
+        "    6,",
+        "    7,",
+        "    8,",
+        "    9",
+        "  ]",
+    ]
+
+    for x in range(9):
+        assert next(folded) == f"    {x},"
+        assert input_lines.new_consumed() == []
+
+    assert next(folded) == "    9"
+    assert input_lines.new_consumed() == []
+
+    assert next(folded) == "  ]"
+    assert input_lines.new_consumed() == []
+
+    # Final closing brace
+    assert next(folded) == "}"
+    assert input_lines.new_consumed() == [
+        "}",
+    ]
+
+    with pytest.raises(StopIteration):
+        _ = next(folded)
+    assert input_lines.new_consumed() == []