Add support for CBOR sequences

Reviewed-on: #26

Author: chrysn

Cargo.lock

@@ -15,7 +15,7 @@ name = "_cbor_diag"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-cbor-edn = { version = "0.0.8", default-features = false }
+cbor-edn = { version = "0.0.10", default-features = false }
 pyo3 = "0.28.0"
 # Not using the infer_signature feature as that is incompatible with pypy.
 #

Cargo.toml

@@ -12,6 +12,8 @@ src/lib.rs. They are manually extracted until I've figured out why `pytest
 {1: 'hello'}
 >>> cbor2.loads(diag2cbor("[1, spam'eggs']", to999=True))
 [1, CBORTag(999, ['spam', 'eggs'])]
+>>> diag2cbor("1, 2, 3", seq=True)
+b'\x01\x02\x03'
 >>> from cbor_diag import *
 >>> encoded = bytes.fromhex('a1016568656c6c6f')
 >>> cbor2diag(encoded)
@@ -23,5 +25,10 @@ src/lib.rs. They are manually extracted until I've figured out why `pytest
 '1(5)'
 >>> cbor2diag(cbor2.dumps([1, 2]), pretty=False)
 '[1,2]'
+>>> print(cbor2diag(b'\x01\x02\x03', seq=True))
+1,
+2,
+3
+<BLANKLINE>
 >>> cbor2diag(bytes.fromhex("d9 03e7 82 63 666f6f 63 626172"), from999=True)
 "foo'bar'"

doctest.txt

@@ -7,7 +7,7 @@ __all__ = [
     "diag2cbor",
 ]
 
-def cbor2diag(encoded: bytes, *, pretty: builtins.bool = ..., from999: builtins.bool = ...) -> builtins.str:
+def cbor2diag(encoded: bytes, *, pretty: builtins.bool = ..., from999: builtins.bool = ..., seq: builtins.bool = ...) -> builtins.str:
     r"""
     Given a byte string containing encoded CBOR, produce some diagnostic notation.
     
@@ -32,6 +32,15 @@ def cbor2diag(encoded: bytes, *, pretty: builtins.bool = ..., from999: builtins.
     >>> cbor2diag(cbor2.dumps([1, 2]), pretty=False)
     '[1,2]'
     
+    * With `seq=True`, [CBOR sequences](https://datatracker.ietf.org/doc/html/rfc8742)
+      are tolerated:
+    
+    >>> print(cbor2diag('\x01\x02\x03', seq=True))
+    1,
+    2,
+    3
+    <BLANKLINE>
+    
     * With ``from999=True``, CBOR tag 999 will be rendered as application oriented literal. Unlike
       other tags, this does not happen by default, as that tag is not intended to be used that way
       by default.
@@ -40,7 +49,7 @@ def cbor2diag(encoded: bytes, *, pretty: builtins.bool = ..., from999: builtins.
     "foo'bar'"
     """
 
-def diag2cbor(diagnostic: builtins.str, *, to999: builtins.bool = ...) -> bytes:
+def diag2cbor(diagnostic: builtins.str, *, to999: builtins.bool = ..., seq: builtins.bool = ...) -> bytes:
     r"""
     Given a string in CBOR diagnostic notation, produce its CBOR binary encoding.
     
@@ -60,5 +69,11 @@ def diag2cbor(diagnostic: builtins.str, *, to999: builtins.bool = ...) -> bytes:
     
     >>> cbor2.loads(diag2cbor("[1, spam'eggs']", to999=True))
     [1, CBORTag(999, ['spam', 'eggs'])]
+    
+    * With `seq=True`, [CBOR sequences](https://datatracker.ietf.org/doc/html/rfc8742)
+      are tolerated:
+    
+    >>> diag2cbor("1, 2, 3", seq=True)
+    '\x01\x02\x03'
     """
 

python/cbor_diag/__init__.pyi

@@ -20,12 +20,20 @@ use pyo3_stub_gen::{define_stub_info_gatherer, derive::gen_stub_pyfunction};
 ///
 /// >>> cbor2.loads(diag2cbor("[1, spam'eggs']", to999=True))
 /// [1, CBORTag(999, ['spam', 'eggs'])]
+///
+/// * With `seq=True`, [CBOR sequences](https://datatracker.ietf.org/doc/html/rfc8742)
+///   are tolerated:
+///
+/// >>> diag2cbor("1, 2, 3", seq=True)
+/// '\x01\x02\x03'
 #[gen_stub_pyfunction]
-#[pyfunction(signature = (diagnostic, *, to999=false))]
-fn diag2cbor(py: Python<'_>, diagnostic: &str, to999: bool) -> PyResult<Py<PyBytes>> {
-    let mut data = cbor_edn::StandaloneItem::parse(diagnostic)
+#[pyfunction(signature = (diagnostic, *, to999=false, seq=false))]
+fn diag2cbor(py: Python<'_>, diagnostic: &str, to999: bool, seq: bool) -> PyResult<Py<PyBytes>> {
+    let mut data = cbor_edn::Sequence::parse(diagnostic)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{}", e)))?;
 
+    check_sequence_expectation(&data, seq)?;
+
     data.visit_application_literals(&mut cbor_edn::application::all_aol_to_item);
     if to999 {
         data.visit_application_literals(&mut cbor_edn::application::any_aol_to_tag999);
@@ -60,23 +68,36 @@ fn diag2cbor(py: Python<'_>, diagnostic: &str, to999: bool) -> PyResult<Py<PyByt
 /// >>> cbor2diag(cbor2.dumps([1, 2]), pretty=False)
 /// '[1,2]'
 ///
+/// * With `seq=True`, [CBOR sequences](https://datatracker.ietf.org/doc/html/rfc8742)
+///   are tolerated:
+///
+/// >>> print(cbor2diag('\x01\x02\x03', seq=True))
+/// 1,
+/// 2,
+/// 3
+/// <BLANKLINE>
+///
 /// * With ``from999=True``, CBOR tag 999 will be rendered as application oriented literal. Unlike
 ///   other tags, this does not happen by default, as that tag is not intended to be used that way
 ///   by default.
 ///
 /// >>> cbor2diag(bytes.fromhex("d9 03e7 82 63 666f6f 63 626172"), from999=True)
 /// "foo'bar'"
 #[gen_stub_pyfunction]
-#[pyfunction(signature = (encoded, *, pretty=true, from999=false))]
+#[pyfunction(signature = (encoded, *, pretty=true, from999=false, seq=false))]
 fn cbor2diag(
     _py: Python<'_>,
     // Staying generic for compatibility (we do still accept a [int]), but declare just bytes.
     #[gen_stub(override_type(type_repr = "bytes"))] encoded: &[u8],
     pretty: bool,
     from999: bool,
+    seq: bool,
 ) -> PyResult<String> {
-    let mut parsed = cbor_edn::StandaloneItem::from_cbor(encoded)
+    let mut parsed = cbor_edn::Sequence::from_cbor(encoded)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{}", e)))?;
+
+    check_sequence_expectation(&parsed, seq)?;
+
     if pretty {
         parsed.visit_tag(&mut cbor_edn::application::all_tag_prettify);
     }
@@ -111,6 +132,24 @@ fn cbor2diag(
     Ok(parsed.serialize())
 }
 
+/// "Raises" a ValueError if the sequence is really a sequence (and not really just a single item),
+/// unless `seq=true` (i.e., the user *asked* for sequence handling).
+fn check_sequence_expectation(data: &cbor_edn::Sequence, seq: bool) -> PyResult<()> {
+    if seq {
+        return Ok(());
+    }
+
+    let count = data.items().count();
+    if count == 1 {
+        Ok(())
+    } else {
+        Err(pyo3::exceptions::PyValueError::new_err(format!(
+            "Expected single item, found sequence of {}",
+            count
+        )))
+    }
+}
+
 /// This provides conversion functions between CBOR's diagnostic notation (EDN) and its binary
 /// representation.
 ///

src/lib.rs

@@ -0,0 +1,34 @@
+import cbor2
+from cbor_diag import *
+
+def test_empty_c2d():
+    try:
+        cbor2diag(b'')
+    except ValueError:
+        pass
+    else:
+        raise RuntimeError('Empty CBOR item should have raised an error.')
+
+def test_empty_d2c():
+    try:
+        diag2cbor('/ just a comment /')
+    except ValueError:
+        pass
+    else:
+        raise RuntimeError('Empty CBOR item should have raised an error.')
+
+def test_multiple_c2d():
+    try:
+        cbor2diag(b'\0\0')
+    except ValueError:
+        pass
+    else:
+        raise RuntimeError('Non-singular CBOR sequence should have raised an error.')
+
+def test_multiple_d2c():
+    try:
+        diag2cbor('0, 0')
+    except ValueError:
+        pass
+    else:
+        raise RuntimeError('Non-singular CBOR sequence should have raised an error.')