Bind hb_buffer_serialize()

Author: khaledhosny

src/uharfbuzz/_harfbuzz.pyx

@@ -142,6 +142,21 @@ class BufferContentType(IntEnum):
     UNICODE = HB_BUFFER_CONTENT_TYPE_UNICODE
     GLYPHS = HB_BUFFER_CONTENT_TYPE_GLYPHS
 
+class BufferSerializeFormat(IntEnum):
+    TEXT = HB_BUFFER_SERIALIZE_FORMAT_TEXT
+    JSON = HB_BUFFER_SERIALIZE_FORMAT_JSON
+    INVALID = HB_BUFFER_SERIALIZE_FORMAT_INVALID
+
+class BufferSerializeFlags(IntFlag):
+    DEFAULT = HB_BUFFER_SERIALIZE_FLAG_DEFAULT
+    NO_CLUSTERS = HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS
+    NO_POSITIONS = HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS
+    NO_GLYPH_NAMES = HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES
+    GLYPH_EXTENTS = HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS
+    GLYPH_FLAGS = HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS
+    NO_ADVANCES = HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES
+    DEFINED = HB_BUFFER_SERIALIZE_FLAG_DEFINED
+
 cdef class Buffer:
     cdef hb_buffer_t* _hb_buffer
     cdef object _message_callback
@@ -371,6 +386,34 @@ cdef class Buffer:
         self._message_callback = callback
         hb_buffer_set_message_func(self._hb_buffer, msgcallback, <void*>callback, NULL)
 
+    def serialize(self,
+                  font: Font,
+                  format: BufferSerializeFormat = BufferSerializeFormat.TEXT,
+                  flags: BufferSerializeFlags = BufferSerializeFlags.DEFAULT) -> str:
+        cdef unsigned int num_glyphs = hb_buffer_get_length(self._hb_buffer)
+        cdef unsigned int start = 0
+        cdef char cstr[STATIC_ARRAY_SIZE]
+        cdef unsigned int consumed
+        cdef bytes packed = b""
+
+        while start < num_glyphs:
+            start += hb_buffer_serialize(
+                self._hb_buffer,
+                start,
+                num_glyphs,
+                cstr,
+                STATIC_ARRAY_SIZE,
+                &consumed,
+                font._hb_font,
+                format,
+                flags
+            )
+            if consumed == 0:
+                break
+            packed += cstr[:consumed]
+
+        return packed.decode()
+
 
 cdef class Blob:
     cdef hb_blob_t* _hb_blob

src/uharfbuzz/charfbuzz.pxd

@@ -155,6 +155,21 @@ cdef extern from "hb.h":
 
         HB_BUFFER_FLAG_DEFINED
 
+    ctypedef enum hb_buffer_serialize_format_t:
+        HB_BUFFER_SERIALIZE_FORMAT_TEXT
+        HB_BUFFER_SERIALIZE_FORMAT_JSON
+        HB_BUFFER_SERIALIZE_FORMAT_INVALID
+
+    ctypedef enum hb_buffer_serialize_flags_t:
+        HB_BUFFER_SERIALIZE_FLAG_DEFAULT
+        HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS
+        HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS
+        HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES
+        HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS
+        HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS
+        HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES
+        HB_BUFFER_SERIALIZE_FLAG_DEFINED
+
     hb_buffer_t* hb_buffer_create()
     hb_bool_t hb_buffer_allocation_successful(hb_buffer_t* buffer)
     void hb_buffer_reset(hb_buffer_t *buffer)
@@ -215,6 +230,15 @@ cdef extern from "hb.h":
     hb_codepoint_t hb_buffer_get_invisible_glyph(const hb_buffer_t *buffer)
     void hb_buffer_set_not_found_glyph(hb_buffer_t *buffer, hb_codepoint_t  not_found)
     hb_codepoint_t hb_buffer_get_not_found_glyph(const hb_buffer_t *buffer)
+    unsigned int hb_buffer_serialize(hb_buffer_t *buffer,
+        unsigned int start,
+        unsigned int end,
+        char *buf,
+        unsigned int buf_size,
+        unsigned int *buf_consumed,
+        hb_font_t *font,
+        hb_buffer_serialize_format_t format,
+        hb_buffer_serialize_flags_t flags)
 
 
     # hb-face.h

tests/test_uharfbuzz.py

@@ -220,6 +220,79 @@ def test_properties(self):
         buf.reset()
         assert buf.flags == hb.BufferFlags.DEFAULT
 
+    @pytest.mark.parametrize(
+        "glyphs,format,flags,expected",
+        [
+            (
+                False,
+                hb.BufferSerializeFormat.TEXT,
+                hb.BufferSerializeFlags.DEFAULT,
+                "<U+0061=0|U+0062=1|U+0063=2|U+0064=3|U+0065=4>",
+            ),
+            (
+                False,
+                hb.BufferSerializeFormat.TEXT,
+                hb.BufferSerializeFlags.NO_CLUSTERS,
+                "<U+0061|U+0062|U+0063|U+0064|U+0065>",
+            ),
+            (
+                True,
+                hb.BufferSerializeFormat.TEXT,
+                hb.BufferSerializeFlags.DEFAULT,
+                "[a=0+0|b=1+0|c=2+0|d=3+0|e=4+0]",
+            ),
+            (
+                True,
+                hb.BufferSerializeFormat.TEXT,
+                hb.BufferSerializeFlags.DEFAULT
+                | hb.BufferSerializeFlags.NO_CLUSTERS
+                | hb.BufferSerializeFlags.NO_POSITIONS,
+                "[a|b|c|d|e]",
+            ),
+            (
+                False,
+                hb.BufferSerializeFormat.JSON,
+                hb.BufferSerializeFlags.DEFAULT,
+                '[{"u":97,"cl":0},{"u":98,"cl":1},{"u":99,"cl":2},'
+                '{"u":100,"cl":3},{"u":101,"cl":4}]',
+            ),
+            (
+                False,
+                hb.BufferSerializeFormat.JSON,
+                hb.BufferSerializeFlags.NO_CLUSTERS,
+                '[{"u":97},{"u":98},{"u":99},{"u":100},{"u":101}]',
+            ),
+            (
+                True,
+                hb.BufferSerializeFormat.JSON,
+                hb.BufferSerializeFlags.DEFAULT,
+                '[{"g":"a","cl":0,"dx":0,"dy":0,"ax":0,"ay":0},'
+                '{"g":"b","cl":1,"dx":0,"dy":0,"ax":0,"ay":0},'
+                '{"g":"c","cl":2,"dx":0,"dy":0,"ax":0,"ay":0},'
+                '{"g":"d","cl":3,"dx":0,"dy":0,"ax":0,"ay":0},'
+                '{"g":"e","cl":4,"dx":0,"dy":0,"ax":0,"ay":0}]',
+            ),
+            (
+                True,
+                hb.BufferSerializeFormat.JSON,
+                hb.BufferSerializeFlags.DEFAULT
+                | hb.BufferSerializeFlags.NO_CLUSTERS
+                | hb.BufferSerializeFlags.NO_POSITIONS,
+                '[{"g":"a"},{"g":"b"},{"g":"c"},{"g":"d"},{"g":"e"}]',
+            ),
+        ],
+    )
+    def test_serialize(self, glyphs, format, flags, expected):
+        font = hb.Font(hb.Face(ADOBE_BLANK_TTF_PATH.read_bytes()))
+
+        buf = hb.Buffer()
+        buf.add_str("abcde")
+        buf.guess_segment_properties()
+        if glyphs:
+            hb.shape(font, buf)
+
+        assert buf.serialize(font, format=format, flags=flags) == expected
+
 
 class TestBlob:
     def test_from_file_path_fail(self):