zsv 1.3.0

data/ext/zsv/options_internal.h

@@ -0,0 +1,8 @@
+/* Internal options symbols - forward declaration */
+#ifndef ZSV_RUBY_OPTIONS_INTERNAL_H
+#define ZSV_RUBY_OPTIONS_INTERNAL_H
+
+/* Initialize option symbols (called from Init_zsv) */
+void Init_zsv_options(void);
+
+#endif /* ZSV_RUBY_OPTIONS_INTERNAL_H */

data/ext/zsv/parser.c

@@ -0,0 +1,300 @@
+/* Parser wrapper implementation using zsv's callback API */
+#include "parser.h"
+#include <errno.h>
+#include <string.h>
+
+/* Forward declarations */
+static void zsv_parser_init_common(zsv_ruby_parser_t *parser, VALUE opts_hash);
+static void zsv_parser_finish_safe(zsv_ruby_parser_t *parser);
+
+/* Row handler callback for zsv */
+static void zsv_row_handler(void *ctx)
+{
+    zsv_ruby_parser_t *parser = (zsv_ruby_parser_t *)ctx;
+
+    /* Don't allocate Ruby objects during cleanup/GC */
+    if (parser->in_cleanup) {
+        return;
+    }
+
+    /* Reset row builder for new row */
+    zsv_row_builder_reset(parser->row_builder);
+
+    /* Get all cells in this row */
+    size_t cell_count = zsv_cell_count(parser->zsv);
+    for (size_t i = 0; i < cell_count; i++) {
+        struct zsv_cell cell = zsv_get_cell(parser->zsv, i);
+        zsv_row_builder_add_cell(parser->row_builder, cell.str, cell.len);
+    }
+
+    /* Skip lines if configured */
+    if (parser->lines_skipped < (size_t)parser->options.skip_lines) {
+        parser->lines_skipped++;
+        return;
+    }
+
+    /* Process header row - only if headers:true and no custom headers provided */
+    if (parser->options.headers && NIL_P(parser->options.header_array) &&
+        !parser->header_row_processed) {
+        parser->headers = zsv_row_builder_to_array(parser->row_builder);
+        zsv_row_builder_set_headers(parser->row_builder, parser->headers);
+        parser->header_row_processed = true;
+        return; /* Don't store header row */
+    }
+
+    /* Build row as array or hash */
+    VALUE row;
+    if (!NIL_P(parser->headers)) {
+        row = zsv_row_builder_to_hash(parser->row_builder);
+    } else {
+        row = zsv_row_builder_to_array(parser->row_builder);
+    }
+
+    /* Add row to buffer */
+    rb_ary_push(parser->row_buffer, row);
+    parser->row_count++;
+}
+
+/* Initialize common parser setup */
+static void zsv_parser_init_common(zsv_ruby_parser_t *parser, VALUE opts_hash)
+{
+    /* Parse options */
+    zsv_options_parse(opts_hash, &parser->options);
+
+    /* Create row builder */
+    parser->row_builder = zsv_row_builder_new(parser->options.encoding);
+
+    /* Initialize zsv parser with callback */
+    struct zsv_opts zopts = {0};
+    zopts.delimiter = parser->options.delimiter;
+    zopts.row_handler = zsv_row_handler;
+    zopts.ctx = parser;
+
+    if (parser->file) {
+        zopts.stream = parser->file;
+        parser->zsv = zsv_new(&zopts);
+    } else {
+        /* IO object handling would require custom read callback */
+        rb_raise(rb_eNotImpError, "IO object parsing not yet implemented");
+    }
+
+    /* Set headers: use custom headers if provided, otherwise will be read from first row */
+    if (!NIL_P(parser->options.header_array)) {
+        parser->headers = parser->options.header_array;
+        zsv_row_builder_set_headers(parser->row_builder, parser->headers);
+        parser->header_row_processed = true; /* Skip reading headers from file */
+    } else {
+        parser->headers = Qnil;
+    }
+
+    parser->row_buffer = rb_ary_new();
+    parser->closed = false;
+    parser->eof_reached = false;
+    parser->in_cleanup = false;
+    parser->current_row = Qnil;
+}
+
+/* Create parser from file path */
+zsv_ruby_parser_t *zsv_parser_new_from_path(const char *path, VALUE opts_hash)
+{
+    zsv_ruby_parser_t *parser = ZSV_ALLOC(zsv_ruby_parser_t);
+    memset(parser, 0, sizeof(zsv_ruby_parser_t));
+
+    /* Open file */
+    parser->file = fopen(path, "rb");
+    if (!parser->file) {
+        xfree(parser);
+        rb_sys_fail(path);
+    }
+
+    zsv_parser_init_common(parser, opts_hash);
+    return parser;
+}
+
+/* Create parser from Ruby IO */
+zsv_ruby_parser_t *zsv_parser_new_from_io(VALUE io, VALUE opts_hash)
+{
+    zsv_ruby_parser_t *parser = ZSV_ALLOC(zsv_ruby_parser_t);
+    memset(parser, 0, sizeof(zsv_ruby_parser_t));
+
+    parser->io = io;
+    zsv_parser_init_common(parser, opts_hash);
+
+    return parser;
+}
+
+/* Create parser from string */
+zsv_ruby_parser_t *zsv_parser_new_from_string(VALUE string, VALUE opts_hash)
+{
+    Check_Type(string, T_STRING);
+
+    zsv_ruby_parser_t *parser = ZSV_ALLOC(zsv_ruby_parser_t);
+    memset(parser, 0, sizeof(zsv_ruby_parser_t));
+
+    /* Create memory-backed file */
+    const char *str_ptr = RSTRING_PTR(string);
+    size_t str_len = RSTRING_LEN(string);
+
+    parser->file = fmemopen((void *)str_ptr, str_len, "rb");
+    if (!parser->file) {
+        xfree(parser);
+        rb_raise(rb_eRuntimeError, "Failed to create memory stream");
+    }
+
+    zsv_parser_init_common(parser, opts_hash);
+    return parser;
+}
+
+/* Free parser */
+void zsv_parser_free(zsv_ruby_parser_t *parser)
+{
+    if (!parser)
+        return;
+
+    zsv_parser_close(parser);
+
+    if (parser->row_builder) {
+        zsv_row_builder_free(parser->row_builder);
+    }
+
+    if (parser->error_message) {
+        xfree(parser->error_message);
+    }
+
+    zsv_options_free(&parser->options);
+    xfree(parser);
+}
+
+/* Parse next row - pull-based interface */
+VALUE zsv_parser_shift(zsv_ruby_parser_t *parser)
+{
+    if (parser->closed) {
+        return Qnil;
+    }
+
+    /* If we have buffered rows, return the first one */
+    if (RARRAY_LEN(parser->row_buffer) > 0) {
+        return rb_ary_shift(parser->row_buffer);
+    }
+
+    /* If we've reached EOF, no more rows */
+    if (parser->eof_reached) {
+        return Qnil;
+    }
+
+    /* Parse more data */
+    enum zsv_status status = zsv_parse_more(parser->zsv);
+
+    /* Check for errors */
+    if (status != zsv_status_ok && status != zsv_status_no_more_input) {
+        RAISE_MALFORMED_CSV("CSV parsing error");
+    }
+
+    /* If EOF reached, finish to flush final row */
+    if (status == zsv_status_no_more_input && !parser->eof_reached) {
+        /* Call finish() BEFORE marking EOF to flush any pending row */
+        zsv_parser_finish_safe(parser);
+        parser->eof_reached = true;
+    }
+
+    /* Return first buffered row, or nil if buffer is empty */
+    if (RARRAY_LEN(parser->row_buffer) > 0) {
+        return rb_ary_shift(parser->row_buffer);
+    }
+
+    return Qnil; /* EOF or no rows yet */
+}
+
+/* Parse all rows with block */
+void zsv_parser_each(zsv_ruby_parser_t *parser)
+{
+    VALUE row;
+    while (!NIL_P(row = zsv_parser_shift(parser))) {
+        rb_yield(row);
+    }
+}
+
+/* Rewind parser */
+void zsv_parser_rewind(zsv_ruby_parser_t *parser)
+{
+    if (!parser->file) {
+        rb_raise(rb_eIOError, "Cannot rewind non-file parser");
+    }
+
+    rewind(parser->file);
+    zsv_finish(parser->zsv);
+    zsv_delete(parser->zsv);
+
+    /* Reinitialize parser */
+    struct zsv_opts zopts = {0};
+    zopts.delimiter = parser->options.delimiter;
+    zopts.row_handler = zsv_row_handler;
+    zopts.ctx = parser;
+    zopts.stream = parser->file;
+
+    parser->zsv = zsv_new(&zopts);
+
+    parser->row_count = 0;
+    parser->lines_skipped = 0;
+    parser->header_row_processed = false;
+    parser->eof_reached = false;
+    parser->in_cleanup = false;
+    parser->row_buffer = rb_ary_new();
+    parser->current_row = Qnil;
+}
+
+/* Finish parsing safely (flush final row if needed) */
+static void zsv_parser_finish_safe(zsv_ruby_parser_t *parser)
+{
+    if (!parser->zsv) {
+        return; /* No parser */
+    }
+
+    /* Only finish if we can allocate (not in GC) */
+    if (!parser->in_cleanup) {
+        zsv_finish(parser->zsv);
+    }
+}
+
+/* Close parser */
+void zsv_parser_close(zsv_ruby_parser_t *parser)
+{
+    if (!parser || parser->closed)
+        return;
+
+    /* Mark as closed and in_cleanup FIRST to prevent Ruby allocations
+     * during GC phase. This is critical because dfree may be called
+     * during GC, and zsv_finish/zsv_delete can trigger row callbacks. */
+    parser->closed = true;
+    parser->in_cleanup = true;
+
+    if (parser->zsv) {
+        /* Delete parser - this calls zsv_finish internally and frees buffers.
+         * Row callbacks may fire but in_cleanup flag prevents allocations. */
+        zsv_delete(parser->zsv);
+        parser->zsv = NULL;
+    }
+
+    if (parser->file) {
+        fclose(parser->file);
+        parser->file = NULL;
+    }
+}
+
+/* Get headers */
+VALUE zsv_parser_headers(zsv_ruby_parser_t *parser)
+{
+    return parser->headers;
+}
+
+/* Check if closed */
+bool zsv_parser_closed(zsv_ruby_parser_t *parser)
+{
+    return parser->closed;
+}
+
+/* Get row count */
+size_t zsv_parser_row_count(zsv_ruby_parser_t *parser)
+{
+    return parser->row_count;
+}

data/ext/zsv/parser.h

@@ -0,0 +1,62 @@
+/* Parser wrapper around zsv */
+#ifndef ZSV_RUBY_PARSER_H
+#define ZSV_RUBY_PARSER_H
+
+#include "common.h"
+#include "options.h"
+#include "row.h"
+
+/* Parser state structure */
+typedef struct {
+    zsv_parser zsv;                 /* zsv parser instance */
+    FILE *file;                     /* File handle (if parsing file) */
+    VALUE io;                       /* Ruby IO object (if parsing IO) */
+    zsv_ruby_options_t options;     /* Parser options */
+    zsv_row_builder_t *row_builder; /* Row builder */
+    VALUE current_row;              /* Current row being built */
+    VALUE row_buffer;               /* Buffer of parsed rows (Ruby array) */
+    VALUE headers;                  /* Parsed headers (if header mode) */
+    size_t row_count;               /* Number of rows parsed */
+    size_t lines_skipped;           /* Number of lines skipped */
+    bool header_row_processed;      /* Whether header row was processed */
+    bool closed;                    /* Whether parser is closed */
+    bool eof_reached;               /* Whether EOF was reached */
+    bool in_cleanup;                /* True during zsv_finish cleanup */
+    int error_code;                 /* Last error code */
+    char *error_message;            /* Last error message */
+} zsv_ruby_parser_t;
+
+/* Create new parser from file path */
+zsv_ruby_parser_t *zsv_parser_new_from_path(const char *path, VALUE opts_hash);
+
+/* Create new parser from Ruby IO object */
+zsv_ruby_parser_t *zsv_parser_new_from_io(VALUE io, VALUE opts_hash);
+
+/* Create new parser from string */
+zsv_ruby_parser_t *zsv_parser_new_from_string(VALUE string, VALUE opts_hash);
+
+/* Free parser and associated resources */
+void zsv_parser_free(zsv_ruby_parser_t *parser);
+
+/* Parse next row, returns Ruby array or hash */
+VALUE zsv_parser_shift(zsv_ruby_parser_t *parser);
+
+/* Parse all rows, yielding to block */
+void zsv_parser_each(zsv_ruby_parser_t *parser);
+
+/* Rewind parser to beginning */
+void zsv_parser_rewind(zsv_ruby_parser_t *parser);
+
+/* Close parser */
+void zsv_parser_close(zsv_ruby_parser_t *parser);
+
+/* Get headers */
+VALUE zsv_parser_headers(zsv_ruby_parser_t *parser);
+
+/* Check if parser is closed */
+bool zsv_parser_closed(zsv_ruby_parser_t *parser);
+
+/* Get row count */
+size_t zsv_parser_row_count(zsv_ruby_parser_t *parser);
+
+#endif /* ZSV_RUBY_PARSER_H */

data/ext/zsv/row.c

@@ -0,0 +1,122 @@
+/* Row handling and conversion implementation */
+#include "row.h"
+
+#define INITIAL_ROW_CAPACITY 32
+
+zsv_row_builder_t *zsv_row_builder_new(rb_encoding *encoding)
+{
+    zsv_row_builder_t *builder = ZSV_ALLOC(zsv_row_builder_t);
+
+    builder->capacity = INITIAL_ROW_CAPACITY;
+    builder->cells = ZSV_ALLOC_N(VALUE, builder->capacity);
+    builder->count = 0;
+    builder->headers = Qnil;
+    builder->header_cache = NULL;
+    builder->header_count = 0;
+    builder->encoding = encoding;
+
+    return builder;
+}
+
+void zsv_row_builder_free(zsv_row_builder_t *builder)
+{
+    if (builder) {
+        xfree(builder->cells);
+        if (builder->header_cache) {
+            xfree(builder->header_cache);
+        }
+        xfree(builder);
+    }
+}
+
+void zsv_row_builder_reset(zsv_row_builder_t *builder)
+{
+    builder->count = 0;
+}
+
+static void zsv_row_builder_ensure_capacity(zsv_row_builder_t *builder, size_t needed)
+{
+    if (needed <= builder->capacity) {
+        return;
+    }
+
+    /* Double capacity until we have enough */
+    size_t new_capacity = builder->capacity;
+    while (new_capacity < needed) {
+        new_capacity *= 2;
+    }
+
+    ZSV_REALLOC_N(builder->cells, VALUE, new_capacity);
+    builder->capacity = new_capacity;
+}
+
+void zsv_row_builder_add_cell(zsv_row_builder_t *builder, const unsigned char *data, size_t length)
+{
+    zsv_row_builder_ensure_capacity(builder, builder->count + 1);
+
+    /* Create Ruby string with proper encoding */
+    VALUE str = rb_enc_str_new((const char *)data, length, builder->encoding);
+
+    /* Freeze string for memory efficiency (shared strings) */
+    rb_str_freeze(str);
+
+    builder->cells[builder->count++] = str;
+}
+
+VALUE zsv_row_builder_to_array(zsv_row_builder_t *builder)
+{
+    VALUE row = rb_ary_new_from_values(builder->count, builder->cells);
+    return row;
+}
+
+VALUE zsv_row_builder_to_hash(zsv_row_builder_t *builder)
+{
+    if (NIL_P(builder->headers)) {
+        rb_raise(rb_eRuntimeError, "Headers not set for hash conversion");
+    }
+
+    /* Use cached header count for efficiency */
+    size_t header_count = builder->header_count;
+    size_t cell_count = builder->count;
+
+    /* Pre-allocate hash with expected size (Ruby 3.2+) */
+#ifdef HAVE_RB_HASH_NEW_CAPA
+    VALUE hash = rb_hash_new_capa(cell_count);
+#else
+    VALUE hash = rb_hash_new();
+#endif
+
+    /* Fast path: use cached header pointers (no rb_ary_entry calls) */
+    size_t matched = (cell_count < header_count) ? cell_count : header_count;
+    for (size_t i = 0; i < matched; i++) {
+        rb_hash_aset(hash, builder->header_cache[i], builder->cells[i]);
+    }
+
+    /* Rare case: more cells than headers, add with numeric keys */
+    for (size_t i = header_count; i < cell_count; i++) {
+        rb_hash_aset(hash, SIZET2NUM(i), builder->cells[i]);
+    }
+
+    return hash;
+}
+
+void zsv_row_builder_set_headers(zsv_row_builder_t *builder, VALUE headers)
+{
+    Check_Type(headers, T_ARRAY);
+    builder->headers = headers;
+
+    /* Cache header count and pointers for fast access in to_hash */
+    builder->header_count = RARRAY_LEN(headers);
+
+    /* Free old cache if exists */
+    if (builder->header_cache) {
+        xfree(builder->header_cache);
+    }
+
+    /* Allocate and populate header cache */
+    builder->header_cache = ZSV_ALLOC_N(VALUE, builder->header_count);
+    const VALUE *header_ptr = RARRAY_CONST_PTR(headers);
+    for (size_t i = 0; i < builder->header_count; i++) {
+        builder->header_cache[i] = header_ptr[i];
+    }
+}

data/ext/zsv/row.h

@@ -0,0 +1,39 @@
+/* Row handling and conversion */
+#ifndef ZSV_RUBY_ROW_H
+#define ZSV_RUBY_ROW_H
+
+#include "common.h"
+
+/* Row builder for efficient conversion from zsv cells to Ruby arrays/hashes */
+typedef struct {
+    VALUE *cells;          /* Array of Ruby string cells */
+    size_t count;          /* Number of cells in current row */
+    size_t capacity;       /* Allocated capacity */
+    VALUE headers;         /* Header array (for hash mode) */
+    VALUE *header_cache;   /* Cached header VALUE pointers for fast access */
+    size_t header_count;   /* Number of headers (cached) */
+    rb_encoding *encoding; /* String encoding */
+} zsv_row_builder_t;
+
+/* Initialize row builder */
+zsv_row_builder_t *zsv_row_builder_new(rb_encoding *encoding);
+
+/* Free row builder */
+void zsv_row_builder_free(zsv_row_builder_t *builder);
+
+/* Reset row builder for next row */
+void zsv_row_builder_reset(zsv_row_builder_t *builder);
+
+/* Add cell to current row */
+void zsv_row_builder_add_cell(zsv_row_builder_t *builder, const unsigned char *data, size_t length);
+
+/* Build Ruby array from current row */
+VALUE zsv_row_builder_to_array(zsv_row_builder_t *builder);
+
+/* Build Ruby hash from current row (requires headers) */
+VALUE zsv_row_builder_to_hash(zsv_row_builder_t *builder);
+
+/* Set headers for hash mode */
+void zsv_row_builder_set_headers(zsv_row_builder_t *builder, VALUE headers);
+
+#endif /* ZSV_RUBY_ROW_H */