headson 0.2.5__tar.gz → 0.3.0__tar.gz

{headson-0.2.5 → headson-0.3.0}/Cargo.lock

@@ -266,7 +266,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.2.5"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "assert_cmd",

{headson-0.2.5 → headson-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "headson"
-version = "0.2.5"
+version = "0.3.0"
 edition = "2024"
 description = "Budget‑constrained JSON preview renderer"
 readme = "README.md"

headson-0.3.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: headson
+Version: 0.3.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Requires-Dist: pytest>=8 ; extra == 'test'
+Provides-Extra: test
+License-File: LICENSE
+Summary: Budget‑constrained JSON preview renderer (Python bindings)
+Keywords: json,preview,summarize,cli,bindings
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# headson
+
+Head/tail for JSON — but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget.
+
+Available as:
+- CLI (see [Usage](#usage))
+- Python library (see [Python Bindings](#python-bindings))
+
+## Install
+
+Using Cargo:
+
+    cargo install headson
+
+From source:
+
+    cargo build --release
+    target/release/headson --help
+
+
+## Features
+
+- *Budgeted output*: specify exactly how much JSON you want to see
+- *Multiple output formats* : `json` (machine‑readable), `pseudo` (human‑friendly), `js` (valid JavaScript, most detailed metadata).
+- *Multiple inputs*: preview many files at once with a shared or per‑file budget.
+- *Fast*: can process gigabyte-scale files in seconds (mostly disk-constrained)
+- *Available as a CLI app and as a Python library*
+
+## Fits into command line workflows
+
+If you’re comfortable with tools like `head` and `tail`, use `headson` when you want a quick, structured peek into a JSON file without dumping the entire thing.
+
+- `head`/`tail` operate on bytes/lines - their output is not optimized for tree structures
+- `jq` you need to craft filters to preview large JSON files
+- `headson` is like head/tail for trees: zero config but it keeps structure and represents content as much as possible 
+
+## Usage
+
+    headson [FLAGS] [INPUT...]
+
+- INPUT (optional, repeatable): file path(s). If omitted, reads JSON from stdin. Multiple input files are supported.
+- Prints the preview to stdout. On parse errors, exits non‑zero and prints an error to stderr.
+
+Common flags:
+
+- `-n, --budget <BYTES>`: per‑file output budget. When multiple input files are provided, the total budget equals `<BYTES> * number_of_inputs`.
+- `-N, --global-budget <BYTES>`: total output budget across all inputs. Useful when you want a fixed-size preview across many files (may omit entire files). Mutually exclusive with `--budget`.
+- `-f, --template <json|pseudo|js>`: output style (default: `pseudo`)
+- `-m, --compact`: no indentation, no spaces, no newlines
+- `--no-newline`: single line output
+- `--no-space`: no space after `:` in objects
+- `--indent <STR>`: indentation unit (default: two spaces)
+- `--string-cap <N>`: max graphemes to consider per string (default: 500)
+- `--tail`: prefer the end of arrays when truncating. Strings are unaffected. In `pseudo`/`js` templates the omission marker appears at the start; `json` remains strict JSON with no annotations.
+
+Notes:
+
+- With multiple input files:
+  - JSON template outputs a single JSON object keyed by the input file paths.
+  - Pseudo and JS templates render file sections with human-readable headers.
+  - Using `--global-budget` may truncate or omit entire files to respect the total budget.
+  - The tool finds the largest preview that fits the budget; if even the tiniest preview exceeds it, you still get a minimal, valid preview.
+  - When passing file paths, directories and binary files are ignored; a notice is printed to stderr for each (e.g., `Ignored binary file: ./path/to/file`). Stdin mode reads the stream as-is.
+
+Quick one‑liners:
+
+- Peek a big JSON stream (keeps structure):
+
+      zstdcat huge.json.zst | headson -n 800 -f pseudo
+
+- Many files with a fixed overall size:
+
+      headson -N 1200 -f json logs/*.json
+
+- Glance at a file, JavaScript‑style comments for omissions:
+
+      headson -n 400 -f js data.json
+
+Show help:
+
+    headson --help
+
+## Examples: head vs headson
+
+Input:
+
+```json
+{"users":[{"id":1,"name":"Ana","roles":["admin","dev"]},{"id":2,"name":"Bo"}],"meta":{"count":2,"source":"db"}}
+```
+
+Naive cut (can break mid‑token):
+
+```bash
+jq -c . users.json | head -c 80
+# {"users":[{"id":1,"name":"Ana","roles":["admin","dev"]},{"id":2,"name":"Bo"}],"me
+```
+
+Structured preview with headson (pseudo):
+
+```bash
+headson -n 120 -f pseudo users.json
+# {
+#   users: [
+#     { id: 1, name: "Ana", roles: [ "admin", … ] },
+#     …
+#   ]
+#   meta: { count: 2, … }
+# }
+```
+
+Machine‑readable preview (json):
+
+```bash
+headson -n 120 -f json users.json
+# {"users":[{"id":1,"name":"Ana","roles":["admin"]}],"meta":{"count":2}}
+```
+
+## Python Bindings
+
+A thin Python extension module is available on PyPI as `headson`.
+
+- Install: `pip install headson` (prebuilt wheels for CPython 3.10–3.12 on Linux/macOS/Windows). Older/newer Python versions may build from source if Rust is installed.
+- API:
+  - `headson.summarize(text: str, *, template: str = "pseudo", character_budget: int | None = None, tail: bool = False) -> str`
+    - `template`: one of `"json" | "pseudo" | "js"`
+    - `character_budget`: maximum output size in characters (default: 500)
+    - `tail`: prefer the end of arrays when truncating; strings unaffected. Affects only display templates (`pseudo`/`js`); `json` remains strict.
+
+Example:
+
+```python
+import json
+import headson
+
+data = {"foo": [1, 2, 3], "bar": {"x": "y"}}
+preview = headson.summarize(json.dumps(data), template="json", character_budget=200)
+print(preview)
+
+# Prefer the tail of arrays (annotations show in pseudo/js only)
+print(
+    headson.summarize(
+        json.dumps(list(range(100))),
+        template="pseudo",
+        character_budget=80,
+        tail=True,
+    )
+)
+```
+
+## License
+
+MIT
+

headson-0.3.0/README.md

@@ -0,0 +1,152 @@
+# headson
+
+Head/tail for JSON — but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget.
+
+Available as:
+- CLI (see [Usage](#usage))
+- Python library (see [Python Bindings](#python-bindings))
+
+## Install
+
+Using Cargo:
+
+    cargo install headson
+
+From source:
+
+    cargo build --release
+    target/release/headson --help
+
+
+## Features
+
+- *Budgeted output*: specify exactly how much JSON you want to see
+- *Multiple output formats* : `json` (machine‑readable), `pseudo` (human‑friendly), `js` (valid JavaScript, most detailed metadata).
+- *Multiple inputs*: preview many files at once with a shared or per‑file budget.
+- *Fast*: can process gigabyte-scale files in seconds (mostly disk-constrained)
+- *Available as a CLI app and as a Python library*
+
+## Fits into command line workflows
+
+If you’re comfortable with tools like `head` and `tail`, use `headson` when you want a quick, structured peek into a JSON file without dumping the entire thing.
+
+- `head`/`tail` operate on bytes/lines - their output is not optimized for tree structures
+- `jq` you need to craft filters to preview large JSON files
+- `headson` is like head/tail for trees: zero config but it keeps structure and represents content as much as possible 
+
+## Usage
+
+    headson [FLAGS] [INPUT...]
+
+- INPUT (optional, repeatable): file path(s). If omitted, reads JSON from stdin. Multiple input files are supported.
+- Prints the preview to stdout. On parse errors, exits non‑zero and prints an error to stderr.
+
+Common flags:
+
+- `-n, --budget <BYTES>`: per‑file output budget. When multiple input files are provided, the total budget equals `<BYTES> * number_of_inputs`.
+- `-N, --global-budget <BYTES>`: total output budget across all inputs. Useful when you want a fixed-size preview across many files (may omit entire files). Mutually exclusive with `--budget`.
+- `-f, --template <json|pseudo|js>`: output style (default: `pseudo`)
+- `-m, --compact`: no indentation, no spaces, no newlines
+- `--no-newline`: single line output
+- `--no-space`: no space after `:` in objects
+- `--indent <STR>`: indentation unit (default: two spaces)
+- `--string-cap <N>`: max graphemes to consider per string (default: 500)
+- `--tail`: prefer the end of arrays when truncating. Strings are unaffected. In `pseudo`/`js` templates the omission marker appears at the start; `json` remains strict JSON with no annotations.
+
+Notes:
+
+- With multiple input files:
+  - JSON template outputs a single JSON object keyed by the input file paths.
+  - Pseudo and JS templates render file sections with human-readable headers.
+  - Using `--global-budget` may truncate or omit entire files to respect the total budget.
+  - The tool finds the largest preview that fits the budget; if even the tiniest preview exceeds it, you still get a minimal, valid preview.
+  - When passing file paths, directories and binary files are ignored; a notice is printed to stderr for each (e.g., `Ignored binary file: ./path/to/file`). Stdin mode reads the stream as-is.
+
+Quick one‑liners:
+
+- Peek a big JSON stream (keeps structure):
+
+      zstdcat huge.json.zst | headson -n 800 -f pseudo
+
+- Many files with a fixed overall size:
+
+      headson -N 1200 -f json logs/*.json
+
+- Glance at a file, JavaScript‑style comments for omissions:
+
+      headson -n 400 -f js data.json
+
+Show help:
+
+    headson --help
+
+## Examples: head vs headson
+
+Input:
+
+```json
+{"users":[{"id":1,"name":"Ana","roles":["admin","dev"]},{"id":2,"name":"Bo"}],"meta":{"count":2,"source":"db"}}
+```
+
+Naive cut (can break mid‑token):
+
+```bash
+jq -c . users.json | head -c 80
+# {"users":[{"id":1,"name":"Ana","roles":["admin","dev"]},{"id":2,"name":"Bo"}],"me
+```
+
+Structured preview with headson (pseudo):
+
+```bash
+headson -n 120 -f pseudo users.json
+# {
+#   users: [
+#     { id: 1, name: "Ana", roles: [ "admin", … ] },
+#     …
+#   ]
+#   meta: { count: 2, … }
+# }
+```
+
+Machine‑readable preview (json):
+
+```bash
+headson -n 120 -f json users.json
+# {"users":[{"id":1,"name":"Ana","roles":["admin"]}],"meta":{"count":2}}
+```
+
+## Python Bindings
+
+A thin Python extension module is available on PyPI as `headson`.
+
+- Install: `pip install headson` (prebuilt wheels for CPython 3.10–3.12 on Linux/macOS/Windows). Older/newer Python versions may build from source if Rust is installed.
+- API:
+  - `headson.summarize(text: str, *, template: str = "pseudo", character_budget: int | None = None, tail: bool = False) -> str`
+    - `template`: one of `"json" | "pseudo" | "js"`
+    - `character_budget`: maximum output size in characters (default: 500)
+    - `tail`: prefer the end of arrays when truncating; strings unaffected. Affects only display templates (`pseudo`/`js`); `json` remains strict.
+
+Example:
+
+```python
+import json
+import headson
+
+data = {"foo": [1, 2, 3], "bar": {"x": "y"}}
+preview = headson.summarize(json.dumps(data), template="json", character_budget=200)
+print(preview)
+
+# Prefer the tail of arrays (annotations show in pseudo/js only)
+print(
+    headson.summarize(
+        json.dumps(list(range(100))),
+        template="pseudo",
+        character_budget=80,
+        tail=True,
+    )
+)
+```
+
+## License
+
+MIT

{headson-0.2.5 → headson-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "headson"
-version = "0.2.5"
+version = "0.3.0"
 description = "Budget‑constrained JSON preview renderer (Python bindings)"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -32,7 +32,7 @@ python-source = "python"
 dev = [
   "pytest>=8",
   "maturin>=1.7,<2",
-  "ruff>=0.6",
+  "ruff==0.6.9",
 ]
 
 [tool.ruff]
@@ -42,5 +42,3 @@ src = ["python", "tests_py"]
 
 [tool.ruff.lint]
 select = ["E", "F"]
-
- 

{headson-0.2.5 → headson-0.3.0}/python/Cargo.lock

@@ -169,7 +169,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.2.5"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -182,7 +182,7 @@ dependencies = [
 
 [[package]]
 name = "headson-python"
-version = "0.2.5"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "headson",

{headson-0.2.5 → headson-0.3.0}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "headson-python"
-version = "0.2.5"
+version = "0.3.0"
 edition = "2021"
 publish = false
 readme = "README.md"

{headson-0.2.5 → headson-0.3.0}/python/src/lib.rs

@@ -13,9 +13,7 @@ fn to_template(s: &str) -> Result<OutputTemplate> {
     }
 }
 
-fn render_config(
-    template: &str,
-) -> Result<RenderConfig> {
+fn render_config(template: &str, prefer_tail_arrays: bool) -> Result<RenderConfig> {
     let t = to_template(template)?;
     let space = " ".to_string();
     let newline = "\n".to_string();
@@ -25,13 +23,15 @@ fn render_config(
         indent_unit,
         space,
         newline,
+        prefer_tail_arrays,
     })
 }
 
-fn priority_config(per_file_budget: usize) -> PriorityConfig {
+fn priority_config(per_file_budget: usize, prefer_tail_arrays: bool) -> PriorityConfig {
     PriorityConfig {
         max_string_graphemes: 500,
         array_max_items: (per_file_budget / 2).max(1),
+        prefer_tail_arrays,
     }
 }
 
@@ -40,17 +40,18 @@ fn to_pyerr(e: anyhow::Error) -> PyErr {
 }
 
 #[pyfunction]
-#[pyo3(signature = (text, *, template="pseudo", character_budget=None))]
+#[pyo3(signature = (text, *, template="pseudo", character_budget=None, tail=false))]
 fn summarize(
     py: Python<'_>,
     text: &str,
     template: &str,
     character_budget: Option<usize>,
+    tail: bool,
 ) -> PyResult<String> {
-    let cfg = render_config(template).map_err(to_pyerr)?;
+    let cfg = render_config(template, tail).map_err(to_pyerr)?;
     let budget = character_budget.unwrap_or(500);
     let per_file_for_priority = budget.max(1);
-    let prio = priority_config(per_file_for_priority);
+    let prio = priority_config(per_file_for_priority, tail);
     let input = text.as_bytes().to_vec();
     py.detach(|| headson_core::headson(input, &cfg, &prio, budget).map_err(to_pyerr))
 }

{headson-0.2.5 → headson-0.3.0}/src/main.rs

@@ -53,6 +53,12 @@ struct Cli {
         help = "Total output budget across all inputs; useful to keep multiple files within a fixed overall output size (may omit entire files)."
     )]
     global_budget: Option<usize>,
+    #[arg(
+        long = "tail",
+        default_value_t = false,
+        help = "Prefer the end of arrays when truncating. Strings unaffected; JSON stays strict."
+    )]
+    tail: bool,
     #[arg(
         value_name = "INPUT",
         value_hint = clap::ValueHint::FilePath,
@@ -225,6 +231,7 @@ fn get_render_config_from(cli: &Cli) -> headson::RenderConfig {
         indent_unit,
         space,
         newline,
+        prefer_tail_arrays: cli.tail,
     }
 }
 
@@ -232,14 +239,9 @@ fn get_priority_config(
     per_file_budget: usize,
     cli: &Cli,
 ) -> headson::PriorityConfig {
-    // Optimization: derive a conservative per‑array expansion cap from the output
-    // budget to avoid allocating/walking items that could never appear in the
-    // final preview. As a simple lower bound, an array of N items needs ~2*N
-    // bytes to render (item plus comma), so we cap per‑array expansion at
-    // budget/2. This prunes unnecessary work on large inputs without changing
-    // output semantics.
     headson::PriorityConfig {
         max_string_graphemes: cli.string_cap,
         array_max_items: (per_file_budget / 2).max(1),
+        prefer_tail_arrays: cli.tail,
     }
 }

{headson-0.2.5 → headson-0.3.0}/src/order/build.rs

@@ -120,7 +120,13 @@ impl<'a> Scope<'a> {
             let child_kind = self.arena.nodes[child_arena_id].kind;
             let child_pq = *self.next_pq_id;
             *self.next_pq_id += 1;
-            let extra = (i as u128).pow(3) * ARRAY_INDEX_CUBIC_WEIGHT;
+            let idx_for_priority: usize = if self.config.prefer_tail_arrays {
+                kept.saturating_sub(1).saturating_sub(i)
+            } else {
+                i
+            };
+            let ii = idx_for_priority as u128;
+            let extra = ii * ii * ii * ARRAY_INDEX_CUBIC_WEIGHT;
             let score = entry.score + ARRAY_CHILD_BASE_INCREMENT + extra;
             let child_node = &self.arena.nodes[child_arena_id];
             self.push_child_common(

{headson-0.2.5 → headson-0.3.0}/src/order/types.rs

@@ -4,6 +4,7 @@ use serde_json;
 pub struct PriorityConfig {
     pub max_string_graphemes: usize,
     pub array_max_items: usize,
+    pub prefer_tail_arrays: bool,
 }
 
 impl PriorityConfig {
@@ -11,6 +12,7 @@ impl PriorityConfig {
         Self {
             max_string_graphemes,
             array_max_items,
+            prefer_tail_arrays: false,
         }
     }
 }

{headson-0.2.5 → headson-0.3.0}/src/serialization/mod.rs

@@ -19,6 +19,39 @@ pub(crate) struct RenderScope<'a> {
 }
 
 impl<'a> RenderScope<'a> {
+    fn render_has_newline(&self, s: &str) -> bool {
+        let nl = &self.config.newline;
+        if nl.is_empty() {
+            return false;
+        }
+        if nl == "\n" {
+            return s.as_bytes().contains(&b'\n');
+        }
+        s.contains(nl)
+    }
+
+    fn push_array_child_line(
+        &self,
+        out: &mut Vec<ArrayChildPair>,
+        index: usize,
+        child_kind: NodeKind,
+        depth: usize,
+        rendered: String,
+    ) {
+        if self.render_has_newline(&rendered) {
+            out.push((index, rendered));
+            return;
+        }
+        match child_kind {
+            NodeKind::Array | NodeKind::Object => {
+                out.push((index, rendered));
+            }
+            _ => {
+                let child_indent = indent(depth + 1, &self.config.indent_unit);
+                out.push((index, format!("{child_indent}{rendered}")));
+            }
+        }
+    }
     fn append_js_fileset_section(
         &mut self,
         out: &mut String,
@@ -172,6 +205,7 @@ impl<'a> RenderScope<'a> {
             indent_unit: &config.indent_unit,
             inline_open: inline,
             newline: &config.newline,
+            omitted_at_start: config.prefer_tail_arrays,
         };
         render_array(config.template, &ctx)
     }
@@ -278,7 +312,6 @@ impl<'a> RenderScope<'a> {
         id: usize,
         depth: usize,
     ) -> (Vec<ArrayChildPair>, usize) {
-        let config = self.config;
         let mut children_pairs: Vec<ArrayChildPair> = Vec::new();
         let mut kept = 0usize;
         if let Some(children_ids) = self.pq.children.get(id) {
@@ -287,17 +320,16 @@ impl<'a> RenderScope<'a> {
                     continue;
                 }
                 kept += 1;
+                let child_kind = self.pq.nodes[child_id.0].kind;
                 let rendered =
                     self.serialize_node(child_id.0, depth + 1, false);
-                if !config.newline.is_empty()
-                    && rendered.contains(&config.newline)
-                {
-                    children_pairs.push((i, rendered));
-                } else {
-                    let child_indent = indent(depth + 1, &config.indent_unit);
-                    children_pairs
-                        .push((i, format!("{child_indent}{rendered}")));
-                }
+                self.push_array_child_line(
+                    &mut children_pairs,
+                    i,
+                    child_kind,
+                    depth,
+                    rendered,
+                );
             }
         }
         (children_pairs, kept)
@@ -463,11 +495,49 @@ mod tests {
                 indent_unit: "  ".to_string(),
                 space: " ".to_string(),
                 newline: "\n".to_string(),
+                prefer_tail_arrays: false,
             },
         );
         assert_snapshot!("arena_render_empty", out);
     }
 
+    #[test]
+    fn newline_detection_crlf_array_child() {
+        // Ensure we exercise the render_has_newline branch that checks
+        // arbitrary newline sequences (e.g., "\r\n") via s.contains(nl).
+        let arena = crate::json_ingest::build_json_tree_arena(
+            "[{\"a\":1,\"b\":2}]",
+            &crate::PriorityConfig::new(usize::MAX, usize::MAX),
+        )
+        .unwrap();
+        let build = build_order(
+            &arena,
+            &crate::PriorityConfig::new(usize::MAX, usize::MAX),
+        )
+        .unwrap();
+        let mut marks = vec![0u32; build.total_nodes];
+        let out = render_arena_with_marks(
+            &build,
+            usize::MAX,
+            &mut marks,
+            1,
+            &crate::RenderConfig {
+                template: crate::OutputTemplate::Json,
+                indent_unit: "  ".to_string(),
+                space: " ".to_string(),
+                // Use CRLF to force the contains(nl) path.
+                newline: "\r\n".to_string(),
+                prefer_tail_arrays: false,
+            },
+        );
+        // Sanity: output should contain CRLF newlines and render the object child across lines.
+        assert!(
+            out.contains("\r\n"),
+            "expected CRLF newlines in output: {out:?}"
+        );
+        assert!(out.starts_with("["));
+    }
+
     #[test]
     fn arena_render_single_string_array() {
         let arena = crate::json_ingest::build_json_tree_arena(
@@ -491,6 +561,7 @@ mod tests {
                 indent_unit: "  ".to_string(),
                 space: " ".to_string(),
                 newline: "\n".to_string(),
+                prefer_tail_arrays: false,
             },
         );
         assert_snapshot!("arena_render_single", out);

{headson-0.2.5 → headson-0.3.0}/src/serialization/templates/core.rs

@@ -48,8 +48,13 @@ pub fn render_array_with<S: Style>(ctx: &ArrayCtx<'_>) -> String {
     out.push_str(open_indent);
     out.push('[');
     out.push_str(ctx.newline);
+    if ctx.omitted_at_start {
+        S::array_push_omitted(&mut out, ctx);
+    }
     push_array_items(&mut out, ctx);
-    S::array_push_omitted(&mut out, ctx);
+    if !ctx.omitted_at_start {
+        S::array_push_omitted(&mut out, ctx);
+    }
     out.push_str(&base);
     out.push(']');
     out

{headson-0.2.5 → headson-0.3.0}/src/serialization/templates/js.rs

@@ -18,10 +18,13 @@ impl Style for Js {
     fn array_push_omitted(out: &mut String, ctx: &ArrayCtx<'_>) {
         if ctx.omitted > 0 {
             out.push_str(&indent(ctx.depth + 1, ctx.indent_unit));
-            out.push_str(&format!(
-                "/* {} more items */{}",
-                ctx.omitted, ctx.newline
-            ));
+            out.push_str("/* ");
+            out.push_str(&ctx.omitted.to_string());
+            out.push_str(" more items */");
+            if ctx.children_len > 0 && ctx.omitted_at_start {
+                out.push(',');
+            }
+            out.push_str(ctx.newline);
         }
     }
 

{headson-0.2.5 → headson-0.3.0}/src/serialization/templates/mod.rs

@@ -13,6 +13,7 @@ pub struct ArrayCtx<'a> {
     pub indent_unit: &'a str,
     pub inline_open: bool,
     pub newline: &'a str,
+    pub omitted_at_start: bool,
 }
 
 pub struct ObjectCtx<'a> {

{headson-0.2.5 → headson-0.3.0}/src/serialization/templates/pseudo.rs

@@ -16,6 +16,9 @@ impl Style for Pseudo {
         if ctx.omitted > 0 {
             out.push_str(&indent(ctx.depth + 1, ctx.indent_unit));
             out.push('…');
+            if ctx.children_len > 0 && ctx.omitted_at_start {
+                out.push(',');
+            }
             out.push_str(ctx.newline);
         }
     }

{headson-0.2.5 → headson-0.3.0}/src/serialization/types.rs

@@ -13,4 +13,6 @@ pub struct RenderConfig {
     // Newline sequence to use in final output (e.g., "\n" or "").
     // Templates read this directly; no post-processing replacement.
     pub newline: String,
+    // When true, arrays prefer tail rendering (omission marker at start).
+    pub prefer_tail_arrays: bool,
 }

{headson-0.2.5 → headson-0.3.0}/src/utils/tree_arena.rs

@@ -6,9 +6,8 @@ pub struct JsonTreeArena {
     pub children: Vec<usize>,
     pub obj_keys: Vec<String>,
     pub root_id: usize,
-    // Marks that the root is a synthetic wrapper object representing a fileset
-    // (multi-input ingest). Rendering remains standard JSON; this is an
-    // internal marker for future behaviors.
+    // True when root is a synthetic wrapper object for multi-input ingest.
+    // Rendering remains standard JSON; used to select fileset-specific headers.
     pub is_fileset: bool,
 }
 

headson-0.2.5/PKG-INFO

@@ -1,99 +0,0 @@
-Metadata-Version: 2.4
-Name: headson
-Version: 0.2.5
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Rust
-Classifier: Operating System :: OS Independent
-Requires-Dist: pytest>=8 ; extra == 'test'
-Provides-Extra: test
-License-File: LICENSE
-Summary: Budget‑constrained JSON preview renderer (Python bindings)
-Keywords: json,preview,summarize,cli,bindings
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# headson
-
-Budget‑constrained JSON preview for the terminal.
-
-## Install
-
-Using Cargo:
-
-    cargo install headson
-
-From source:
-
-    cargo build --release
-    target/release/headson --help
-
-## Usage
-
-    headson [FLAGS] [INPUT...]
-
-- INPUT (optional, repeatable): file path(s). If omitted, reads JSON from stdin. Multiple input files are supported.
-- Prints the preview to stdout. On parse errors, exits non‑zero and prints an error to stderr.
-
-Common flags:
-
-- `-n, --budget <BYTES>`: per‑file output budget. When multiple input files are provided, the total budget equals `<BYTES> * number_of_inputs`.
-- `-N, --global-budget <BYTES>`: total output budget across all inputs. Useful when you want a fixed-size preview across many files (may omit entire files). Mutually exclusive with `--budget`.
-- `-f, --template <json|pseudo|js>`: output style (default: `pseudo`)
-- `-m, --compact`: no indentation, no spaces, no newlines
-- `--no-newline`: single line output
-- `--no-space`: no space after `:` in objects
-- `--indent <STR>`: indentation unit (default: two spaces)
-- `--string-cap <N>`: max graphemes to consider per string (default: 500)
-
-Notes:
-
-- With multiple input files:
-  - JSON template outputs a single JSON object keyed by the input file paths.
-  - Pseudo and JS templates render file sections with human-readable headers.
-  - Using `--global-budget` may truncate or omit entire files to respect the total budget.
- - When passing file paths, directories and binary files are ignored; a notice is printed to stderr for each (e.g., `Ignored binary file: ./path/to/file`). Stdin mode reads the stream as-is.
-
-Examples:
-
-- Read from stdin with defaults:
-
-      cat data.json | headson
-
-- Read from file, JS style, 200‑byte budget:
-
-      headson -n 200 -f js data.json
-
-- JSON style, compact:
-
-      headson -f json -m data.json
-
-- Multiple files (JSON template produces an object keyed by paths):
-
-      headson -f json a.json b.json
-
-- Global limit across files (fixed total size across all files):
-
-      headson -N 400 -f json a.json b.json
-
-Show help:
-
-    headson --help
-
-## Python package
-
-Headson is also available as a Python extension module built with PyO3/maturin.
-
-Install from PyPI:
-
-    pip install headson
-
-Example:
-
-    import json
-    import headson
-
-    data = {"foo": [1, 2, 3], "bar": {"x": "y"}}
-    preview = headson.summarize(json.dumps(data), template="json", character_budget=200)
-    print(preview)
-

headson-0.2.5/README.md

@@ -1,83 +0,0 @@
-# headson
-
-Budget‑constrained JSON preview for the terminal.
-
-## Install
-
-Using Cargo:
-
-    cargo install headson
-
-From source:
-
-    cargo build --release
-    target/release/headson --help
-
-## Usage
-
-    headson [FLAGS] [INPUT...]
-
-- INPUT (optional, repeatable): file path(s). If omitted, reads JSON from stdin. Multiple input files are supported.
-- Prints the preview to stdout. On parse errors, exits non‑zero and prints an error to stderr.
-
-Common flags:
-
-- `-n, --budget <BYTES>`: per‑file output budget. When multiple input files are provided, the total budget equals `<BYTES> * number_of_inputs`.
-- `-N, --global-budget <BYTES>`: total output budget across all inputs. Useful when you want a fixed-size preview across many files (may omit entire files). Mutually exclusive with `--budget`.
-- `-f, --template <json|pseudo|js>`: output style (default: `pseudo`)
-- `-m, --compact`: no indentation, no spaces, no newlines
-- `--no-newline`: single line output
-- `--no-space`: no space after `:` in objects
-- `--indent <STR>`: indentation unit (default: two spaces)
-- `--string-cap <N>`: max graphemes to consider per string (default: 500)
-
-Notes:
-
-- With multiple input files:
-  - JSON template outputs a single JSON object keyed by the input file paths.
-  - Pseudo and JS templates render file sections with human-readable headers.
-  - Using `--global-budget` may truncate or omit entire files to respect the total budget.
- - When passing file paths, directories and binary files are ignored; a notice is printed to stderr for each (e.g., `Ignored binary file: ./path/to/file`). Stdin mode reads the stream as-is.
-
-Examples:
-
-- Read from stdin with defaults:
-
-      cat data.json | headson
-
-- Read from file, JS style, 200‑byte budget:
-
-      headson -n 200 -f js data.json
-
-- JSON style, compact:
-
-      headson -f json -m data.json
-
-- Multiple files (JSON template produces an object keyed by paths):
-
-      headson -f json a.json b.json
-
-- Global limit across files (fixed total size across all files):
-
-      headson -N 400 -f json a.json b.json
-
-Show help:
-
-    headson --help
-
-## Python package
-
-Headson is also available as a Python extension module built with PyO3/maturin.
-
-Install from PyPI:
-
-    pip install headson
-
-Example:
-
-    import json
-    import headson
-
-    data = {"foo": [1, 2, 3], "bar": {"x": "y"}}
-    preview = headson.summarize(json.dumps(data), template="json", character_budget=200)
-    print(preview)