fast-json-lint 0.1.0__tar.gz

fast_json_lint-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,108 @@
+# This file is autogenerated by maturin v1.15.0
+# To update, run
+#
+#    maturin generate-ci github --platform linux --platform macos
+#
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ${{ matrix.platform.runner }}
+    strategy:
+      matrix:
+        platform:
+          - runner: ubuntu-22.04
+            target: x86_64
+          - runner: ubuntu-22.04
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist
+          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+          manylinux: auto
+      - name: Upload wheels
+        uses: actions/upload-artifact@v6
+        with:
+          name: wheels-linux-${{ matrix.platform.target }}
+          path: dist
+
+  macos:
+    runs-on: ${{ matrix.platform.runner }}
+    strategy:
+      matrix:
+        platform:
+          - runner: macos-15-intel
+            target: x86_64
+          - runner: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist
+          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      - name: Upload wheels
+        uses: actions/upload-artifact@v6
+        with:
+          name: wheels-macos-${{ matrix.platform.target }}
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v6
+        with:
+          name: wheels-sdist
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    needs: [linux, macos, sdist]
+    permissions:
+      # Use to sign the release artifacts
+      id-token: write
+      # Used to upload release artifacts
+      contents: write
+      # Used to generate artifact attestation
+      attestations: write
+    steps:
+      - uses: actions/download-artifact@v7
+      - name: Generate artifact attestation
+        uses: actions/attest@v4
+        with:
+          subject-path: 'wheels-*/*'
+      - name: Install uv
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        uses: astral-sh/setup-uv@v7
+      - name: Publish to PyPI
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        # Trusted Publishing (OIDC): configure this repo + release.yml on PyPI, no token needed.
+        run: uv publish --trusted-publishing always 'wheels-*/*'

fast_json_lint-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+/target
+/dist

fast_json_lint-0.1.0/Cargo.lock

@@ -0,0 +1,135 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "json-lint"
+version = "0.1.0"
+dependencies = [
+ "libc",
+ "serde_json",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

fast_json_lint-0.1.0/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "json-lint"
+version = "0.1.0"
+edition = "2024"
+readme = "README.md"
+
+[dependencies]
+libc = "0.2.189"
+serde_json = { version = "1.0.151", features = ["preserve_order", "arbitrary_precision"] }
+
+[profile.release]
+lto = "fat"
+codegen-units = 1
+panic = "abort"

fast_json_lint-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: fast-json-lint
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Environment :: Console
+Summary: Fast JSON linter and fixer: natural key sorting and 2-space formatting
+Keywords: json,lint,formatter
+Author-email: Kamil Kobza <kamil1pl@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# json-lint
+
+A fast Rust JSON linter and fixer, inspired by
+[json-linter](https://github.com/atomicptr/json-linter). It is distributed as a
+prebuilt binary on PyPI, the same way as ruff.
+
+```bash
+pip install fast-json-lint
+json-lint my-file.json some-dir/
+```
+
+For every file (or every `*.json` file in a given directory) it:
+
+- sorts object keys recursively in natural order (`a2` before `a10`)
+- rewrites the file with 2-space indentation and a trailing newline
+- reports files that are not valid JSON and leaves them unchanged
+
+It exits with status 1 if any file fails.
+

fast_json_lint-0.1.0/README.md

@@ -0,0 +1,18 @@
+# json-lint
+
+A fast Rust JSON linter and fixer, inspired by
+[json-linter](https://github.com/atomicptr/json-linter). It is distributed as a
+prebuilt binary on PyPI, the same way as ruff.
+
+```bash
+pip install fast-json-lint
+json-lint my-file.json some-dir/
+```
+
+For every file (or every `*.json` file in a given directory) it:
+
+- sorts object keys recursively in natural order (`a2` before `a10`)
+- rewrites the file with 2-space indentation and a trailing newline
+- reports files that are not valid JSON and leaves them unchanged
+
+It exits with status 1 if any file fails.

fast_json_lint-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["maturin>=1.5,<2"]
+build-backend = "maturin"
+
+[project]
+name = "fast-json-lint"
+description = "Fast JSON linter and fixer: natural key sorting and 2-space formatting"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Kamil Kobza", email = "kamil1pl@gmail.com" }]
+keywords = ["json", "lint", "formatter"]
+classifiers = [
+    "Programming Language :: Rust",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Environment :: Console",
+]
+dynamic = ["version"]
+
+[tool.maturin]
+bindings = "bin"
+strip = true

fast_json_lint-0.1.0/src/main.rs

@@ -0,0 +1,173 @@
+//! A Rust take on `json-linter PATH... --fix --config-set indent=2`
+//! (json-linter 1.3.0, https://github.com/atomicptr/json-linter): sorts object
+//! keys naturally, rewrites files with 2-space indent, then lints them.
+
+mod natural;
+
+use std::collections::BTreeMap;
+use std::ffi::OsStr;
+use std::io::{self, Write};
+use std::os::unix::ffi::OsStrExt;
+use std::path::Path;
+use std::{env, fs};
+
+use serde_json::Value;
+
+
+const COLOR_GREEN: &str = "\x1b[92m";
+const COLOR_RED: &str = "\x1b[91m";
+const COLOR_RESET: &str = "\x1b[00m";
+
+/// One rule outcome: its name and the failure message, if it failed.
+type RuleResult = (&'static str, Option<String>);
+
+fn main() {
+    let args: Vec<_> = env::args_os().skip(1).collect();
+    if args.is_empty() || args.iter().any(|a| a.as_bytes().starts_with(b"-")) {
+        eprintln!("usage: json-lint PATH [PATH ...]");
+        eprintln!("Fixes and lints like: json-linter PATH... --fix --config-set indent=2");
+        std::process::exit(2);
+    }
+    let mut out = io::BufWriter::new(io::stdout().lock());
+    let code = run(&args, &mut out);
+    let _ = out.flush();
+    std::process::exit(code);
+}
+
+fn run(args: &[std::ffi::OsString], out: &mut impl Write) -> i32 {
+    let cwd = normalize(b"", env::current_dir().unwrap().as_os_str().as_bytes());
+    let files: Vec<Vec<u8>> = args.iter().flat_map(|a| gather_files(&cwd, a.as_bytes())).collect();
+    if files.is_empty() {
+        let _ = writeln!(out, "No files found.");
+        return 1;
+    }
+
+    let mut per_path: BTreeMap<Vec<u8>, Vec<RuleResult>> = BTreeMap::new();
+    for file in &files {
+        let results = per_path.entry(display_path(file, &cwd)).or_default();
+        results.extend(fix_and_lint(file));
+    }
+
+    print_header(out, "json-linter", None);
+    let (mut passed, mut total) = (0, 0);
+    for (path, results) in &per_path {
+        let _ = out.write_all(path);
+        let _ = out.write_all(b" ");
+        for (_, err) in results {
+            let (color, marker) = if err.is_none() { (COLOR_GREEN, '.') } else { (COLOR_RED, 'F') };
+            let _ = write!(out, "{color}{marker}{COLOR_RESET}");
+        }
+        let _ = writeln!(out);
+        for (name, err) in results {
+            if let Some(msg) = err {
+                let msg = if msg.is_empty() { String::new() } else { format!(": {msg}") };
+                let _ = writeln!(out, "\t{COLOR_RED}{name}{msg}{COLOR_RESET}");
+            }
+        }
+        total += results.len();
+        passed += results.iter().filter(|(_, e)| e.is_none()).count();
+    }
+    print_header(out, &format!("{passed} / {total} passed"), Some(COLOR_GREEN));
+    if passed == total { 0 } else { 1 }
+}
+
+/// Rewrites the file with naturally sorted keys and 2-space indent, then
+/// returns the rule results. Unparseable files are reported and left alone.
+fn fix_and_lint(path: &[u8]) -> Vec<RuleResult> {
+    let value = match fix_file(path) {
+        Ok(v) => v,
+        Err(e) => return vec![("lint_file", Some(e))],
+    };
+    let sorted = natural::keys_are_sorted(&value);
+    vec![
+        ("rule_keys_are_sorted", (!sorted).then(String::new)),
+        // No naming style is configured, so every key name is accepted.
+        ("rule_naming_style_is_correct", None),
+    ]
+}
+
+fn fix_file(path: &[u8]) -> Result<Value, String> {
+    let p = as_path(path);
+    let data = fs::read(p).map_err(|e| format!("IOError: {e}"))?;
+    let mut value: Value =
+        serde_json::from_slice(&data).map_err(|e| format!("JSONDecodeError: {e}"))?;
+    natural::sort_keys(&mut value);
+    let mut fixed = serde_json::to_vec_pretty(&value).map_err(|e| e.to_string())?;
+    fixed.push(b'\n');
+    fs::write(p, fixed).map_err(|e| format!("IOError: {e}"))?;
+    Ok(value)
+}
+
+// ------------------------------------------------------------------- files --
+
+/// Joins `path` onto `base` and normalizes it lexically, like `pathlib.Path`.
+fn normalize(base: &[u8], path: &[u8]) -> Vec<u8> {
+    let joined = if path.starts_with(b"/") { path.to_vec() } else { [base, b"/", path].concat() };
+    let mut out = Vec::with_capacity(joined.len());
+    for part in joined.split(|&c| c == b'/').filter(|p| !p.is_empty() && *p != b".") {
+        out.push(b'/');
+        out.extend_from_slice(part);
+    }
+    if out.is_empty() {
+        out.push(b'/');
+    }
+    out
+}
+
+fn as_path(p: &[u8]) -> &Path {
+    Path::new(OsStr::from_bytes(p))
+}
+
+/// The file itself, or a directory's `*.json` entries (non-recursive, sorted).
+fn gather_files(cwd: &[u8], arg: &[u8]) -> Vec<Vec<u8>> {
+    let path = normalize(cwd, arg);
+    let p = as_path(&path);
+    if p.is_file() {
+        return vec![path];
+    }
+    let Ok(entries) = fs::read_dir(p) else {
+        return vec![];
+    };
+    let mut files: Vec<_> = entries
+        .filter_map(Result::ok)
+        .filter(|e| e.path().is_file() && e.file_name().as_bytes().ends_with(b".json"))
+        .map(|e| normalize(&path, e.file_name().as_bytes()))
+        .collect();
+    files.sort();
+    files
+}
+
+/// The path relative to cwd when it is inside it, otherwise absolute.
+fn display_path(path: &[u8], cwd: &[u8]) -> Vec<u8> {
+    if cwd == b"/" {
+        return path[1..].to_vec();
+    }
+    match path.strip_prefix(cwd) {
+        Some(rest) if rest.starts_with(b"/") => rest[1..].to_vec(),
+        _ => path.to_vec(),
+    }
+}
+
+// ------------------------------------------------------------------ output --
+
+/// The text centered in `=` signs, 80 per side when stdout is not a terminal.
+fn print_header(out: &mut impl Write, text: &str, color: Option<&str>) {
+    let width = match terminal_columns() {
+        Some(cols) => (cols as f64 / 2.0 - (text.chars().count() as f64 + 2.0) / 2.0).floor(),
+        None => 80.0,
+    };
+    let segment = "=".repeat(width.max(0.0) as usize);
+    let _ = match color {
+        Some(c) => writeln!(out, "{c}{segment} {text} {segment}{COLOR_RESET}"),
+        None => writeln!(out, "{segment} {text} {segment}"),
+    };
+}
+
+/// Width of the terminal attached to stdout, if any.
+fn terminal_columns() -> Option<u16> {
+    // SAFETY: TIOCGWINSZ only writes into the provided winsize struct.
+    unsafe {
+        let mut ws: libc::winsize = std::mem::zeroed();
+        (libc::ioctl(libc::STDOUT_FILENO, libc::TIOCGWINSZ, &mut ws) == 0).then_some(ws.ws_col)
+    }
+}

fast_json_lint-0.1.0/src/natural.rs

@@ -0,0 +1,100 @@
+//! Natural key ordering ("a2" < "a10") and the recursive key-sorting fixer.
+
+use std::cmp::Ordering;
+
+use serde_json::{Map, Value};
+
+/// Compares strings with ASCII digit runs ordered by numeric value.
+pub fn natural_cmp(a: &str, b: &str) -> Ordering {
+    let (mut a, mut b) = (a.as_bytes(), b.as_bytes());
+    loop {
+        match (a.first(), b.first()) {
+            (None, None) => return Ordering::Equal,
+            (None, Some(_)) => return Ordering::Less,
+            (Some(_), None) => return Ordering::Greater,
+            (Some(x), Some(y)) if x.is_ascii_digit() && y.is_ascii_digit() => {
+                let (na, ra) = split_digits(a);
+                let (nb, rb) = split_digits(b);
+                let ord = na.len().cmp(&nb.len()).then_with(|| na.cmp(nb));
+                if ord != Ordering::Equal {
+                    return ord;
+                }
+                (a, b) = (ra, rb);
+            }
+            // A digit run ends the text before it, so it sorts before any other char.
+            (Some(x), Some(_)) if x.is_ascii_digit() => return Ordering::Less,
+            (Some(_), Some(y)) if y.is_ascii_digit() => return Ordering::Greater,
+            (Some(x), Some(y)) => {
+                if x != y {
+                    return x.cmp(y);
+                }
+                (a, b) = (&a[1..], &b[1..]);
+            }
+        }
+    }
+}
+
+/// Splits off a leading digit run, returning it without leading zeros.
+fn split_digits(s: &[u8]) -> (&[u8], &[u8]) {
+    let end = s.iter().position(|c| !c.is_ascii_digit()).unwrap_or(s.len());
+    let zeros = s[..end].iter().take_while(|&&c| c == b'0').count();
+    (&s[zeros..end], &s[end..])
+}
+
+/// Recursively sorts every object's keys in natural order (stable on ties).
+pub fn sort_keys(v: &mut Value) {
+    match v {
+        Value::Array(items) => items.iter_mut().for_each(sort_keys),
+        Value::Object(map) => {
+            let mut entries: Vec<_> = std::mem::take(map).into_iter().collect();
+            entries.sort_by(|(a, _), (b, _)| natural_cmp(a, b));
+            *map = entries
+                .into_iter()
+                .map(|(k, mut v)| {
+                    sort_keys(&mut v);
+                    (k, v)
+                })
+                .collect::<Map<_, _>>();
+        }
+        _ => {}
+    }
+}
+
+/// The `keys_are_sorted` rule.
+pub fn keys_are_sorted(v: &Value) -> bool {
+    match v {
+        Value::Array(items) => items.iter().all(keys_are_sorted),
+        Value::Object(map) => {
+            let keys: Vec<_> = map.keys().collect();
+            keys.windows(2).all(|w| natural_cmp(w[0], w[1]) != Ordering::Greater)
+                && map.values().all(keys_are_sorted)
+        }
+        _ => true,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn natural_order() {
+        assert_eq!(natural_cmp("a2", "a10"), Ordering::Less);
+        assert_eq!(natural_cmp("a01", "a1"), Ordering::Equal);
+        assert_eq!(natural_cmp("", "a"), Ordering::Less);
+        assert_eq!(natural_cmp("10b", "9b"), Ordering::Greater);
+        assert_eq!(natural_cmp("x1", "x1y"), Ordering::Less);
+        assert_eq!(natural_cmp("B", "a"), Ordering::Less);
+        assert_eq!(natural_cmp("20Z", "-a"), Ordering::Less);
+        assert_eq!(natural_cmp("a1", "a "), Ordering::Less);
+    }
+
+    #[test]
+    fn sorts_nested() {
+        let mut v = json!([{"b10": {"z": 1, "y": 2}, "b9": 0, "a01": 1, "a1": 2}]);
+        sort_keys(&mut v);
+        assert_eq!(v.to_string(), r#"[{"a01":1,"a1":2,"b9":0,"b10":{"y":2,"z":1}}]"#);
+        assert!(keys_are_sorted(&v));
+    }
+}