Implement JSON (#25)

* Implement minimal json parser

* Implement minimal json serializer

* Add documentation

* Update DESCRIPTION

* Fix up Valgrind issues

* Add complete escape sequence support

* Add unicode support

* Add proper escaping support

* Optimization pass

* Support top level objects for encoder and decoder

* Support top level primitives in decoder

* Review pass

* Add file path test

* Add JSON RFC 8259 link

* More explicit raw vector parsing

Author: shikokuchuo

DESCRIPTION

@@ -1,6 +1,7 @@
 Type: Package
 Package: secretbase
-Title: Cryptographic Hash, Extendable-Output and Binary Encoding Functions
+Title: Cryptographic Hash, Extendable-Output and Binary/Text Encoding
+    Functions
 Version: 1.1.1.9000
 Authors@R: c(
     person("Charlie", "Gao", , "charlie.gao@posit.co", role = c("aut", "cre"),
@@ -9,13 +10,14 @@ Authors@R: c(
            comment = c(ROR = "03wc8by49")),
     person("Hibiki AI Limited", role = "cph")
   )
-Description: Fast and memory-efficient streaming hash functions, binary
-    encoding and serialization. Hashes strings and raw vectors directly.
-    Stream hashes files which can be larger than memory, as well as
-    in-memory objects through R's serialization mechanism. Implements the
-    SHA-256, SHA-3 and 'Keccak' cryptographic hash functions, SHAKE256
-    extendable-output function (XOF), 'SipHash' pseudo-random function,
-    base64 and base58 encoding, and 'CBOR' serialization.
+Description: Fast and memory-efficient streaming hash functions,
+    binary/text encoding and serialization. Hashes strings and raw vectors
+    directly.  Stream hashes files which can be larger than memory, as
+    well as in-memory objects through R's serialization mechanism.
+    Implements the SHA-256, SHA-3 and 'Keccak' cryptographic hash
+    functions, SHAKE256 extendable-output function (XOF), 'SipHash'
+    pseudo-random function, base64 and base58 encoding, 'CBOR' and 'JSON'
+    serialization.
 License: MIT + file LICENSE
 URL: https://shikokuchuo.net/secretbase/,
     https://github.com/shikokuchuo/secretbase/

NAMESPACE

@@ -6,6 +6,8 @@ export(base64dec)
 export(base64enc)
 export(cbordec)
 export(cborenc)
+export(jsondec)
+export(jsonenc)
 export(keccak)
 export(sha256)
 export(sha3)

NEWS.md

@@ -1,5 +1,7 @@
 # secretbase (development version)
 
+* Adds `jsonenc()` and `jsondec()` for a minimal JSON encoding/decoding implementation.
+
 # secretbase 1.1.1
 
 * CBOR: performance optimizations; scalar values with attributes now encode as scalars rather than arrays.

R/base.R

@@ -1,4 +1,4 @@
-# secretbase - Base64 Functions ------------------------------------------------
+# secretbase - Encoding and Decoding Functions ---------------------------------
 
 #' Base64 Encode
 #'
@@ -206,5 +206,84 @@ cborenc <- function(x) .Call(secretbase_cborenc, x)
 #' cbordec(cborenc(original))
 #'
 #' @export
-#'
 cbordec <- function(x) .Call(secretbase_cbordec, x)
+
+#' JSON Encode
+#'
+#' Minimal JSON encoder. Converts an R object to a JSON string.
+#'
+#' This is a minimal implementation designed for creating HTTP API request
+#' bodies.
+#'
+#' @section Type Mappings:
+#' \itemize{
+#'   \item Named list -> object `{}`
+#'   \item Unnamed list -> array `[]`
+#'   \item Character -> string (with escaping)
+#'   \item Numeric/integer -> number
+#'   \item Logical -> `true`/`false`
+#'   \item `NULL`, `NA` -> `null`
+#'   \item Scalars (length 1) -> primitive value
+#'   \item Vectors (length > 1) -> array `[]`
+#'   \item Unsupported types (e.g., functions) -> `null`
+#' }
+#'
+#' @param x An R object to encode as JSON.
+#'
+#' @return A character string containing the JSON representation.
+#'
+#' @seealso [jsondec()]
+#'
+#' @examples
+#' jsonenc(list(name = "John", age = 30L))
+#' jsonenc(list(valid = TRUE, count = NULL))
+#' jsonenc(list(nested = list(a = 1, b = list(2, 3))))
+#' jsonenc(list(nums = 1:3, strs = c("a", "b")))
+#'
+#' @export
+jsonenc <- function(x) .Call(secretbase_jsonenc, x)
+
+#' JSON Decode
+#'
+#' Minimal JSON parser. Converts JSON to R objects with proper type handling.
+#'
+#' This is a minimal implementation designed for parsing HTTP API responses.
+#'
+#' @section Type Mappings:
+#' \itemize{
+#'   \item Object `{}` -> named list
+#'   \item Array `[]` -> unnamed list
+#'   \item String -> character
+#'   \item Number -> numeric
+#'   \item `true`/`false` -> logical
+#'   \item `null` -> `NULL`
+#' }
+#'
+#' @section RFC 8259 Non-conformance:
+#' \itemize{
+#'   \item Invalid JSON returns an empty list instead of erroring.
+#'   \item Duplicate keys are preserved; R accessors (`$`, `[[`) return first
+#'     match.
+#'   \item Non-standard number forms may be accepted (e.g., leading zeros,
+#'     hexadecimal).
+#'   \item Invalid escape sequences are output literally (e.g., `\\uZZZZ`
+#'     becomes `"uZZZZ"`).
+#'   \item Incomplete Unicode escape sequences for emoji are tolerated.
+#'   \item Nesting depth is limited to 512 levels.
+#' }
+#'
+#' @param x Character string or raw vector containing JSON data.
+#'
+#' @return The corresponding R object, or an empty list for invalid input.
+#'
+#' @seealso [jsonenc()]
+#'
+#' @examples
+#' jsondec('{"name": "John", "age": 30}')
+#' jsondec('[1, 2, 3]')
+#' jsondec('"a string"')
+#' jsondec('123')
+#' jsondec('true')
+#'
+#' @export
+jsondec <- function(x) .Call(secretbase_jsondec, x)

README.Rmd

@@ -32,11 +32,11 @@ knitr::opts_chunk$set(
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/shikokuchuo/secretbase)
 
-Fast and memory-efficient streaming hash functions, binary encoding and serialization.
+Fast and memory-efficient streaming hash functions, binary/text encoding and serialization.
 
 Hashes strings and raw vectors directly. Stream hashes files which can be larger than memory, as well as in-memory objects through R's serialization mechanism.
 
-Implements the SHA-256, SHA-3 and 'Keccak' cryptographic hash functions, SHAKE256 extendable-output function (XOF), 'SipHash' pseudo-random function, base64 and base58 encoding, and 'CBOR' serialization.
+Implements the SHA-256, SHA-3 and 'Keccak' cryptographic hash functions, SHAKE256 extendable-output function (XOF), 'SipHash' pseudo-random function, base64 and base58 encoding, ‘CBOR’ and 'JSON' serialization.
 
 | Function | Purpose |
 |----------|---------|
@@ -46,6 +46,7 @@ Implements the SHA-256, SHA-3 and 'Keccak' cryptographic hash functions, SHAKE25
 | `base64enc()` `base64dec()` | Base64 encoding |
 | `base58enc()` `base58dec()` | Base58 encoding with checksum |
 | `cborenc()` `cbordec()` | CBOR serialization |
+| `jsonenc()` `jsondec()`        | JSON serialization                 |
 
 ### Installation
 
@@ -175,6 +176,15 @@ cborenc(list(a = 1L, b = "hello", c = TRUE))
 cbordec(cborenc(list(a = 1L, b = "hello", c = TRUE)))
 ```
 
+#### JSON
+
+Minimal JSON encoder/decoder for HTTP API request/response bodies:
+
+```{r}
+jsonenc(list(name = "John", age = 30L, active = TRUE))
+jsondec('{"name": "John", "age": 30, "active": true}')
+```
+
 ### Implementation
 
 The SHA-3 Secure Hash Standard was published by the National Institute of Standards and Technology (NIST) in 2015 at [doi:10.6028/NIST.FIPS.202](https://dx.doi.org/10.6028/NIST.FIPS.202). SHA-3 is based on the Keccak algorithm, designed by G. Bertoni, J. Daemen, M. Peeters and G. Van Assche.
@@ -191,6 +201,8 @@ The base58 implementation is based on 'libbase58' by Luke Dashjr at <https://git
 
 The CBOR implementation follows RFC 8949, *"Concise Binary Object Representation (CBOR)"*, available at <https://www.rfc-editor.org/rfc/rfc8949>.
 
+The JSON implementation is not fully compliant with RFC 8259, *"The JavaScript Object Notation (JSON) Data Interchange Format"*, available at <https://www.rfc-editor.org/rfc/rfc8259>.
+
 ### References
 
 [1] Pierre L’Ecuyer, David Munger, Boris Oreshkin and Richard Simard (2017), *"Random numbers for parallel computers: Requirements and methods, with emphasis on GPUs"*, Mathematics and Computers in Simulation, Vol. 135, May 2017, pp. 3-17 [doi:10.1016/j.matcom.2016.05.00](https://doi.org/10.1016/j.matcom.2016.05.005).
@@ -205,7 +217,8 @@ Mbed TLS website: <https://www.trustedfirmware.org/projects/mbed-tls><br />
 SipHash streaming implementation: <https://github.com/c-util/c-siphash><br />
 SipHash reference implementation: <https://github.com/veorq/SipHash><br />
 libbase58: <https://github.com/luke-jr/libbase58><br />
-CBOR RFC 8949: <https://www.rfc-editor.org/rfc/rfc8949>
+CBOR RFC 8949: <https://www.rfc-editor.org/rfc/rfc8949><br />
+JSON RFC 8259: <https://www.rfc-editor.org/rfc/rfc8259>
 
 --
 

README.md

@@ -23,16 +23,16 @@ coverage](https://codecov.io/gh/shikokuchuo/secretbase/graph/badge.svg)](https:/
 [![Ask
 DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/shikokuchuo/secretbase)
 
-Fast and memory-efficient streaming hash functions, binary encoding and
-serialization.
+Fast and memory-efficient streaming hash functions, binary/text encoding
+and serialization.
 
 Hashes strings and raw vectors directly. Stream hashes files which can
 be larger than memory, as well as in-memory objects through R’s
 serialization mechanism.
 
 Implements the SHA-256, SHA-3 and ‘Keccak’ cryptographic hash functions,
 SHAKE256 extendable-output function (XOF), ‘SipHash’ pseudo-random
-function, base64 and base58 encoding, and ‘CBOR’ serialization.
+function, base64 and base58 encoding, ‘CBOR’ and ‘JSON’ serialization.
 
 | Function                       | Purpose                            |
 |--------------------------------|------------------------------------|
@@ -42,6 +42,7 @@ function, base64 and base58 encoding, and ‘CBOR’ serialization.
 | `base64enc()` `base64dec()`    | Base64 encoding                    |
 | `base58enc()` `base58dec()`    | Base58 encoding with checksum      |
 | `cborenc()` `cbordec()`        | CBOR serialization                 |
+| `jsonenc()` `jsondec()`        | JSON serialization                 |
 
 ### Installation
 
@@ -203,6 +204,24 @@ cbordec(cborenc(list(a = 1L, b = "hello", c = TRUE)))
 #> [1] TRUE
 ```
 
+#### JSON
+
+Minimal JSON encoder/decoder for HTTP API request/response bodies:
+
+``` r
+jsonenc(list(name = "John", age = 30L, active = TRUE))
+#> [1] "{\"name\":\"John\",\"age\":30,\"active\":true}"
+jsondec('{"name": "John", "age": 30, "active": true}')
+#> $name
+#> [1] "John"
+#> 
+#> $age
+#> [1] 30
+#> 
+#> $active
+#> [1] TRUE
+```
+
 ### Implementation
 
 The SHA-3 Secure Hash Standard was published by the National Institute
@@ -235,6 +254,10 @@ The CBOR implementation follows RFC 8949, *“Concise Binary Object
 Representation (CBOR)”*, available at
 <https://www.rfc-editor.org/rfc/rfc8949>.
 
+The JSON implementation is not fully compliant with RFC 8259, *“The
+JavaScript Object Notation (JSON) Data Interchange Format”*, available
+at <https://www.rfc-editor.org/rfc/rfc8259>.
+
 ### References
 
 \[1\] Pierre L’Ecuyer, David Munger, Boris Oreshkin and Richard Simard
@@ -257,7 +280,8 @@ streaming implementation: <https://github.com/c-util/c-siphash><br />
 SipHash reference implementation:
 <https://github.com/veorq/SipHash><br /> libbase58:
 <https://github.com/luke-jr/libbase58><br /> CBOR RFC 8949:
-<https://www.rfc-editor.org/rfc/rfc8949>
+<https://www.rfc-editor.org/rfc/rfc8949><br /> JSON RFC 8259:
+<https://www.rfc-editor.org/rfc/rfc8259>
 
 –