headson 0.6.5__tar.gz → 0.6.6__tar.gz

{headson-0.6.5 → headson-0.6.6}/Cargo.lock

@@ -298,7 +298,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.6.5"
+version = "0.6.6"
 dependencies = [
  "anyhow",
  "assert_cmd",

{headson-0.6.5 → headson-0.6.6}/Cargo.toml

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

{headson-0.6.5 → headson-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: headson
-Version: 0.6.5
+Version: 0.6.6
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
@@ -70,7 +70,8 @@ If you’re comfortable with tools like `head` and `tail`, use `headson` when yo
 
 Common flags:
 
-- `-c, --bytes <BYTES>`: per‑file output budget. For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
+- `-c, --bytes <BYTES>`: per‑file output budget (bytes). For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
+- `-u, --chars <CHARS>`: per‑file output budget (Unicode code points). Behaves like `--bytes` but counts characters instead of bytes.
 - `-C, --global-bytes <BYTES>`: total output budget across all inputs. With `--bytes`, the effective total is the smaller of the two.
 - `-f, --format <auto|json|yaml|text>`: output format (default: `auto`).
   - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML, unknown → Text).
@@ -97,6 +98,25 @@ Notes:
   - Directories and binary files are ignored; a notice is printed to stderr for each. Stdin reads the stream as‑is.
   - Head vs Tail sampling: these options bias which part of arrays are kept before rendering. Display styles may still insert internal gap markers to honor very small budgets; strict JSON stays unannotated.
 
+## Budget Modes
+
+- Bytes (`-c/--bytes`, `-C/--global-bytes`)
+  - Measures UTF‑8 bytes in the output.
+  - Default per‑file budget is 500 bytes when neither `--lines` nor `--chars` is provided.
+  - Multiple inputs: total default budget is `<BYTES> * number_of_inputs`; `--global-bytes` caps the total.
+
+- Characters (`-u/--chars`)
+  - Measures Unicode code points (not grapheme clusters).
+
+- Lines (`-n/--lines`, `-N/--global-lines`)
+  - Caps the number of lines in the output.
+  - Incompatible with `--no-newline`.
+  - Multiple inputs: defaults to `<LINES> * number_of_inputs`; `--global-lines` caps the total.
+
+- Interactions and precedence
+  - All active budgets are enforced simultaneously. The render must satisfy all of: bytes (if set), chars (if set), and lines (if set). The strictest cap wins.
+  - When only lines are specified, no implicit byte cap applies. When neither lines nor chars are specified, a 500‑byte default applies.
+
 Quick one‑liners:
 
 - Peek a big JSON stream (keeps structure):

{headson-0.6.5 → headson-0.6.6}/README.md

@@ -56,7 +56,8 @@ If you’re comfortable with tools like `head` and `tail`, use `headson` when yo
 
 Common flags:
 
-- `-c, --bytes <BYTES>`: per‑file output budget. For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
+- `-c, --bytes <BYTES>`: per‑file output budget (bytes). For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
+- `-u, --chars <CHARS>`: per‑file output budget (Unicode code points). Behaves like `--bytes` but counts characters instead of bytes.
 - `-C, --global-bytes <BYTES>`: total output budget across all inputs. With `--bytes`, the effective total is the smaller of the two.
 - `-f, --format <auto|json|yaml|text>`: output format (default: `auto`).
   - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML, unknown → Text).
@@ -83,6 +84,25 @@ Notes:
   - Directories and binary files are ignored; a notice is printed to stderr for each. Stdin reads the stream as‑is.
   - Head vs Tail sampling: these options bias which part of arrays are kept before rendering. Display styles may still insert internal gap markers to honor very small budgets; strict JSON stays unannotated.
 
+## Budget Modes
+
+- Bytes (`-c/--bytes`, `-C/--global-bytes`)
+  - Measures UTF‑8 bytes in the output.
+  - Default per‑file budget is 500 bytes when neither `--lines` nor `--chars` is provided.
+  - Multiple inputs: total default budget is `<BYTES> * number_of_inputs`; `--global-bytes` caps the total.
+
+- Characters (`-u/--chars`)
+  - Measures Unicode code points (not grapheme clusters).
+
+- Lines (`-n/--lines`, `-N/--global-lines`)
+  - Caps the number of lines in the output.
+  - Incompatible with `--no-newline`.
+  - Multiple inputs: defaults to `<LINES> * number_of_inputs`; `--global-lines` caps the total.
+
+- Interactions and precedence
+  - All active budgets are enforced simultaneously. The render must satisfy all of: bytes (if set), chars (if set), and lines (if set). The strictest cap wins.
+  - When only lines are specified, no implicit byte cap applies. When neither lines nor chars are specified, a 500‑byte default applies.
+
 Quick one‑liners:
 
 - Peek a big JSON stream (keeps structure):

{headson-0.6.5 → headson-0.6.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "headson"
-version = "0.6.5"
+version = "0.6.6"
 description = "Budget‑constrained JSON preview renderer (Python bindings)"
 readme = "README.md"
 requires-python = ">=3.10"

{headson-0.6.5 → headson-0.6.6}/python/Cargo.lock

@@ -214,7 +214,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.6.5"
+version = "0.6.6"
 dependencies = [
  "anyhow",
  "clap",
@@ -228,7 +228,7 @@ dependencies = [
 
 [[package]]
 name = "headson-python"
-version = "0.6.5"
+version = "0.6.6"
 dependencies = [
  "anyhow",
  "headson",

{headson-0.6.5 → headson-0.6.6}/python/Cargo.toml

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

{headson-0.6.5 → headson-0.6.6}/src/lib.rs

@@ -38,6 +38,7 @@ pub use serialization::types::{
 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
 pub struct Budgets {
     pub byte_budget: Option<usize>,
+    pub char_budget: Option<usize>,
     pub line_budget: Option<usize>,
 }
 
@@ -54,6 +55,7 @@ pub fn headson(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -73,6 +75,7 @@ pub fn headson_many(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -93,6 +96,7 @@ pub fn headson_yaml(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -113,6 +117,7 @@ pub fn headson_many_yaml(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -133,6 +138,7 @@ pub fn headson_text(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -153,6 +159,7 @@ pub fn headson_many_text(
         config,
         Budgets {
             byte_budget: Some(budget),
+            char_budget: None,
             line_budget: None,
         },
     );
@@ -201,10 +208,14 @@ fn find_largest_render_under_budgets(
         render_set_id = render_set_id.wrapping_add(1).max(1);
         // Measure output using a unified stats helper and enforce
         // all provided caps (chars and/or lines).
-        let stats = crate::utils::measure::count_output_stats(&s);
-        let fits_chars = budgets.byte_budget.is_none_or(|c| stats.bytes <= c);
+        let stats = crate::utils::measure::count_output_stats(
+            &s,
+            budgets.char_budget.is_some(),
+        );
+        let fits_bytes = budgets.byte_budget.is_none_or(|c| stats.bytes <= c);
+        let fits_chars = budgets.char_budget.is_none_or(|c| stats.chars <= c);
         let fits_lines = budgets.line_budget.is_none_or(|l| stats.lines <= l);
-        if fits_chars && fits_lines {
+        if fits_bytes && fits_chars && fits_lines {
             best_k = Some(mid);
             true
         } else {

{headson-0.6.5 → headson-0.6.6}/src/main.rs

@@ -23,6 +23,13 @@ type IgnoreNotices = Vec<String>;
 struct Cli {
     #[arg(short = 'c', long = "bytes")]
     bytes: Option<usize>,
+    #[arg(
+        short = 'u',
+        long = "chars",
+        value_name = "CHARS",
+        help = "Per-file Unicode character budget (adds up across files if no global chars limit)"
+    )]
+    chars: Option<usize>,
     #[arg(
         short = 'n',
         long = "lines",
@@ -53,7 +60,8 @@ struct Cli {
     #[arg(
         long = "no-newline",
         default_value_t = false,
-        help = "Do not add newlines in the output. With --lines/--global-lines, line counts reflect actual breaks; without newlines, any non-empty output counts as a single line."
+        conflicts_with_all = ["lines", "global_lines"],
+        help = "Do not add newlines in the output. Incompatible with --lines/--global-lines."
     )]
     no_newline: bool,
     #[arg(
@@ -170,21 +178,28 @@ fn main() -> Result<()> {
 
 // Build budgets from CLI flags. If only line caps are provided, avoid imposing
 // the default byte cap; keep the 500-byte default only when neither lines nor
-// bytes are specified. If any byte-related flag is present, enforce bytes.
+// chars nor bytes are specified. If any byte-related flag is present, enforce bytes.
 fn make_budgets(
     cli: &Cli,
     eff_bytes: usize,
     eff_lines: Option<usize>,
+    eff_chars: Option<usize>,
 ) -> headson::Budgets {
-    let byte_budget = if cli.bytes.is_some() || cli.global_bytes.is_some() {
+    let any_bytes = cli.bytes.is_some() || cli.global_bytes.is_some();
+    let any_lines = cli.lines.is_some() || cli.global_lines.is_some();
+    let any_chars = cli.chars.is_some();
+
+    // Apply default 500-byte only when no explicit budgets provided.
+    let byte_budget = if any_bytes {
         Some(eff_bytes)
-    } else if cli.lines.is_some() || cli.global_lines.is_some() {
+    } else if any_lines || any_chars {
         None
     } else {
         Some(eff_bytes)
     };
     headson::Budgets {
         byte_budget,
+        char_budget: if any_chars { eff_chars } else { None },
         line_budget: eff_lines,
     }
 }
@@ -198,6 +213,10 @@ fn compute_effective_bytes(cli: &Cli, input_count: usize) -> usize {
     }
 }
 
+fn compute_effective_chars(cli: &Cli, input_count: usize) -> Option<usize> {
+    cli.chars.map(|n| n.saturating_mul(input_count))
+}
+
 fn compute_effective_lines(cli: &Cli, input_count: usize) -> Option<usize> {
     match (cli.global_lines, cli.lines) {
         (Some(g), Some(n)) => Some(g.min(n.saturating_mul(input_count))),
@@ -209,18 +228,19 @@ fn compute_effective_lines(cli: &Cli, input_count: usize) -> Option<usize> {
 
 fn compute_priority(
     cli: &Cli,
-    effective_budget: usize,
+    effective_bytes: usize,
+    effective_chars: Option<usize>,
     input_count: usize,
 ) -> headson::PriorityConfig {
-    let per_file_for_priority =
-        if cli.global_bytes.is_some() && cli.bytes.is_some() {
-            // When both limits are provided, base per-file heuristics on the per-file
-            // budget but also respect the effective per-file slice of the final global.
-            let eff_per_file = (effective_budget / input_count.max(1)).max(1);
-            cli.bytes.unwrap().min(eff_per_file).max(1)
-        } else {
-            (effective_budget / input_count.max(1)).max(1)
-        };
+    // Choose a unit for heuristics: prefer bytes if present; else chars if present; else default bytes.
+    let chosen_global = if cli.bytes.is_some() || cli.global_bytes.is_some() {
+        effective_bytes
+    } else if let Some(c) = effective_chars {
+        c
+    } else {
+        effective_bytes
+    };
+    let per_file_for_priority = (chosen_global / input_count.max(1)).max(1);
     get_priority_config(per_file_for_priority, cli)
 }
 
@@ -274,14 +294,18 @@ fn run_from_stdin(
     let input_bytes = read_stdin()?;
     let input_count = 1usize;
     let eff = compute_effective_bytes(cli, input_count);
+    let eff_chars = compute_effective_chars(cli, input_count);
     let eff_lines = compute_effective_lines(cli, input_count);
-    let prio = compute_priority(cli, eff, input_count);
+    let prio = compute_priority(cli, eff, eff_chars, input_count);
     let mut cfg = render_cfg.clone();
     // Resolve effective output template for stdin:
     cfg.template = resolve_effective_template_for_stdin(cli.format, cfg.style);
-    let budgets = make_budgets(cli, eff, eff_lines);
+    let budgets = make_budgets(cli, eff, eff_lines, eff_chars);
     // Enable free string prefix when in line-only mode
-    if budgets.byte_budget.is_none() && budgets.line_budget.is_some() {
+    if budgets.byte_budget.is_none()
+        && budgets.char_budget.is_none()
+        && budgets.line_budget.is_some()
+    {
         cfg.string_free_prefix_graphemes = Some(40);
     }
     match cli.input_format {
@@ -315,15 +339,19 @@ fn run_from_paths(
     let included = entries.len();
     let input_count = included.max(1);
     let eff = compute_effective_bytes(cli, input_count);
+    let eff_chars = compute_effective_chars(cli, input_count);
     let eff_lines = compute_effective_lines(cli, input_count);
-    let prio = compute_priority(cli, eff, input_count);
+    let prio = compute_priority(cli, eff, eff_chars, input_count);
     if cli.inputs.len() > 1 {
         let chosen_input = choose_input_format_fileset(cli, &entries);
         let mut cfg = render_cfg.clone();
         // For filesets: if format=auto, enable per-file template selection.
         cfg.template = effective_fileset_template(cli, cfg.style);
-        let budgets = make_budgets(cli, eff, eff_lines);
-        if budgets.byte_budget.is_none() && budgets.line_budget.is_some() {
+        let budgets = make_budgets(cli, eff, eff_lines, eff_chars);
+        if budgets.byte_budget.is_none()
+            && budgets.char_budget.is_none()
+            && budgets.line_budget.is_some()
+        {
             cfg.string_free_prefix_graphemes = Some(40);
         }
         let out = match chosen_input {
@@ -361,8 +389,11 @@ fn run_from_paths(
         cfg.template = resolve_effective_template_for_single(
             cli.format, cfg.style, &lower,
         );
-        let budgets = make_budgets(cli, eff, eff_lines);
-        if budgets.byte_budget.is_none() && budgets.line_budget.is_some() {
+        let budgets = make_budgets(cli, eff, eff_lines, eff_chars);
+        if budgets.byte_budget.is_none()
+            && budgets.char_budget.is_none()
+            && budgets.line_budget.is_some()
+        {
             cfg.string_free_prefix_graphemes = Some(40);
         }
         let out = match chosen_input {
@@ -496,7 +527,7 @@ fn get_priority_config(
     per_file_budget: usize,
     cli: &Cli,
 ) -> headson::PriorityConfig {
-    // Detect line-only mode: lines flag present and no explicit bytes flags.
+    // Detect line-only mode: lines flag present and no explicit bytes/chars flags.
     let line_only = (cli.lines.is_some() || cli.global_lines.is_some())
         && cli.bytes.is_none()
         && cli.global_bytes.is_none();

{headson-0.6.5 → headson-0.6.6}/src/order/build.rs

@@ -14,7 +14,7 @@ struct Entry {
     priority_index: usize,
     depth: usize,
     // When present, we can read kind from the arena (parsed JSON) node.
-    // When None, this is a synthetic entry (currently only string grapheme).
+    // When None, this is a synthetic entry (used for string grapheme entries).
     arena_index: Option<usize>,
 }
 impl PartialEq for Entry {

{headson-0.6.5 → headson-0.6.6}/src/utils/measure.rs

@@ -1,21 +1,15 @@
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub(crate) struct OutputStats {
     pub bytes: usize,
+    pub chars: usize,
     pub lines: usize,
 }
 
-/// Count bytes and logical lines in a string, normalizing CRLF/CR/LF.
-///
-/// Rules:
-/// - An empty string has 0 lines.
-/// - Otherwise, lines = number of line break sequences + 1.
-/// - A CRLF pair counts as a single line break.
-pub(crate) fn count_output_stats(s: &str) -> OutputStats {
-    let bytes = s.len();
-    if bytes == 0 {
-        return OutputStats { bytes, lines: 0 };
+#[inline]
+fn count_lines_from_bytes(b: &[u8]) -> usize {
+    if b.is_empty() {
+        return 0;
     }
-    let b = s.as_bytes();
     let mut i = 0usize;
     let mut breaks = 0usize;
     while i < b.len() {
@@ -35,8 +29,22 @@ pub(crate) fn count_output_stats(s: &str) -> OutputStats {
             _ => i += 1,
         }
     }
+    breaks + 1
+}
+
+/// Count bytes and logical lines in a string, normalizing CRLF/CR/LF.
+///
+/// Rules:
+/// - An empty string has 0 lines.
+/// - Otherwise, lines = number of line break sequences + 1.
+/// - A CRLF pair counts as a single line break.
+pub(crate) fn count_output_stats(s: &str, want_chars: bool) -> OutputStats {
+    let bytes = s.len();
+    let chars = if want_chars { s.chars().count() } else { 0 };
+    let lines = count_lines_from_bytes(s.as_bytes());
     OutputStats {
         bytes,
-        lines: breaks + 1,
+        chars,
+        lines,
     }
 }