[PATCH v3 00/10] reftable: stop using `struct strbuf`

Hi,

this is the third version of my patch series that removes use of `struct strbuf` in the reftable library. The intent of this is to convert the reftable library back into a standalone library that can be used in the context of libgit2.

Changes compared to v2:

  - Provide more context around why we get rid of `stbuf_addf()`.

  - Fix a commit message type.

  - Provide better docs for `reftable_buf_add()`.

Thanks!

Patrick

Patrick Steinhardt (10):
  reftable: stop using `strbuf_addbuf()`
  reftable: stop using `strbuf_addf()`
  reftable/basics: provide new `reftable_buf` interface
  reftable: convert from `strbuf` to `reftable_buf`
  reftable/blocksource: adapt interface name
  t/unit-tests: check for `reftable_buf` allocation errors
  reftable/stack: adapt `format_name()` to handle allocation failures
  reftable/record: adapt `reftable_record_key()` to handle allocation
    failures
  reftable/stack: adapt `stack_filename()` to handle allocation failures
  reftable: handle trivial `reftable_buf` errors

 reftable/basics.c                   |  76 +++++++++-
 reftable/basics.h                   |  61 +++++++-
 reftable/block.c                    |  61 +++++---
 reftable/block.h                    |  14 +-
 reftable/blocksource.c              |  30 ++--
 reftable/blocksource.h              |   5 +-
 reftable/iter.c                     |   9 +-
 reftable/iter.h                     |   8 +-
 reftable/reader.c                   |  27 ++--
 reftable/record.c                   | 114 ++++++++------
 reftable/record.h                   |  21 +--
 reftable/stack.c                    | 221 ++++++++++++++++++----------
 reftable/system.h                   |   1 -
 reftable/writer.c                   | 102 ++++++++-----
 reftable/writer.h                   |   2 +-
 t/unit-tests/lib-reftable.c         |   4 +-
 t/unit-tests/lib-reftable.h         |   7 +-
 t/unit-tests/t-reftable-basics.c    |  16 +-
 t/unit-tests/t-reftable-block.c     |  53 +++----
 t/unit-tests/t-reftable-merged.c    |  32 ++--
 t/unit-tests/t-reftable-reader.c    |  12 +-
 t/unit-tests/t-reftable-readwrite.c | 134 +++++++++--------
 t/unit-tests/t-reftable-record.c    |  74 +++++-----
 t/unit-tests/t-reftable-stack.c     |  96 ++++++------
 24 files changed, 728 insertions(+), 452 deletions(-)

Range-diff against v2:
 1:  7408482c152 =  1:  7408482c152 reftable: stop using `strbuf_addbuf()`
 2:  6a7333b275e !  2:  634fd3c35f5 reftable: stop using `strbuf_addf()`
    @@ Commit message
         reftable: stop using `strbuf_addf()`
     
         We're about to introduce our own `reftable_buf` type to replace
    -    `strbuf`. Get rid of the seldomly-used `strbuf_addf()` function such
    -    that we have to reimplement one less function.
    +    `strbuf`. One function we'll have to convert is `strbuf_addf()`, which
    +    is used in a handful of places. This function uses `snprintf()`
    +    internally, which makes porting it a bit more involved:
    +
    +      - It is not available on all platforms.
    +
    +      - Some platforms like Windows have broken implementations.
    +
    +    So by using `snprintf()` we'd also push the burden on downstream users
    +    of the reftable library to make available a properly working version of
    +    it.
    +
    +    Most callsites of `strbuf_addf()` are trivial to convert to not using
    +    it. We do end up using `snprintf()` in our unit tests, but that isn't
    +    much of a problem for downstream users of the reftable library.
     
         While at it, remove a useless call to `strbuf_reset()` in
         `t_reftable_stack_auto_compaction_with_locked_tables()`. We don't write
 3:  0ddc8c0c896 !  3:  53c5f667f28 reftable/basics: provide new `reftable_buf` interface
    @@ Commit message
             to make things work, which is not all that sensible.
     
           - The `strbuf` interface does not use the pluggable allocators that
    -        can be set up via `refatble_set_alloc()`.
    +        can be set up via `reftable_set_alloc()`.
     
         So we have good reasons to use our own type, and the implementation is
         rather trivial. Implement our own type. Conversion of the reftable
 4:  e1ff1af1f30 !  4:  7c7ccc5d966 reftable: convert from `strbuf` to `reftable_buf`
    @@ reftable/basics.c: int names_equal(const char **a, const char **b)
      	for (; p < a->len && p < b->len; p++) {
     
      ## reftable/basics.h ##
    +@@ reftable/basics.h: int reftable_buf_setlen(struct reftable_buf *buf, size_t len);
    + int reftable_buf_cmp(const struct reftable_buf *a, const struct reftable_buf *b);
    + 
    + /*
    +- * Add the given bytes to the buffer. Returns 0 on success,
    ++ * Append `len` bytes from `data` to the buffer. This function works with
    ++ * arbitrary byte sequences, including ones that contain embedded NUL
    ++ * characters. As such, we use `void *` as input type. Returns 0 on success,
    +  * REFTABLE_OUT_OF_MEMORY_ERROR on allocation failure.
    +  */
    + int reftable_buf_add(struct reftable_buf *buf, const void *data, size_t len);
     @@ reftable/basics.h: char *reftable_strdup(const char *str);
      #endif
      
 5:  fe8c9ace463 =  5:  f9632860933 reftable/blocksource: adapt interface name
 6:  8c98745233a =  6:  d850a2fe7d0 t/unit-tests: check for `reftable_buf` allocation errors
 7:  1f08163009b =  7:  8f8e2ca3962 reftable/stack: adapt `format_name()` to handle allocation failures
 8:  5798d76d7a4 =  8:  268e4cd6fc6 reftable/record: adapt `reftable_record_key()` to handle allocation failures
 9:  a9582d51dd1 =  9:  245a428842a reftable/stack: adapt `stack_filename()` to handle allocation failures
10:  90819c90f38 = 10:  4b51ea4b628 reftable: handle trivial `reftable_buf` errors