zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/jq.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+
+#define ZSV_COMMAND_NO_OPTIONS
+#define ZSV_COMMAND jq
+#include "zsv_command.h"
+
+#include <zsv/utils/jq.h>
+
+/**
+ * This implementation is not intended to replicate the full functionality of the `jq`
+ * utility available at https://github.com/stedolan/jq
+ *
+ * This `jq` implementation is included as a convenience so as not to require a
+ * separate `jq` installation for basic JSON parsing and manipulation
+ */
+int ZSV_MAIN_NO_OPTIONS_FUNC(ZSV_COMMAND)(int argc, const char *argv[]) {
+  if (argc < 2 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
+    printf("Usage: " APPNAME " <filter> filename [-o,--output filename] [--csv]\n");
+    return 0;
+  }
+
+  char to_csv = 0;
+#ifdef NO_STDIN
+  const int min_args = 3;
+#else
+  const int min_args = 2;
+#endif
+  if (argc < min_args) {
+    fprintf(stderr, "Please provide a filter and an input file\n");
+    return 1;
+  }
+
+#ifdef NO_STDIN
+  FILE *f_in = NULL;
+#else
+  FILE *f_in = stdin;
+#endif
+
+  FILE *f_out = stdout;
+
+  int err = 0;
+  const unsigned char *jqfilter = (const unsigned char *)argv[1];
+  struct jv_to_json_ctx ctx = {0};
+
+  for (int i = 2; !err && i < argc; i++) { // jq filter filename
+    const char *arg = argv[i];
+    if (i == 2 && *arg != '-') {
+      if (!(f_in = fopen(arg, "rb"))) {
+        err = 1;
+        fprintf(stderr, "Unable to open for read: %s\n", arg);
+      }
+    } else if (!strcmp(arg, "--csv")) {
+      to_csv = 1;
+    } else if (!strcmp(arg, "--raw-output")) {
+      ctx.raw_output = 1;
+    } else if (!strcmp(arg, "-o") || !strcmp(arg, "--output")) {
+      i++;
+      if (!(i < argc)) {
+        err = 1;
+        fprintf(stderr, "Option %s requires a filename\n", arg);
+      } else if (!(f_out = fopen(argv[i], "wb"))) {
+        err = 1;
+        fprintf(stderr, "Unable to open for write: %s\n", argv[i]);
+      }
+    } else {
+      fprintf(stderr, "Unrecognized option: %s\n", arg);
+      err = 1;
+    }
+  }
+
+  if (!f_in) {
+    fprintf(stderr, "Please specify an input file\n");
+    err = 1;
+  }
+
+  if (!err) {
+    void (*jqfunc)(jv, void *) = to_csv ? jv_to_csv : jv_to_json_func;
+    ctx.write1 = zsv_jq_fwrite1;
+    ctx.ctx = f_out;
+    ctx.flags = JV_PRINT_PRETTY | JV_PRINT_SPACE1;
+
+    void *jqctx = to_csv ? (void *)f_out : (void *)&ctx;
+    enum zsv_jq_status jqstat;
+    zsv_jq_handle zjq = zsv_jq_new(jqfilter, jqfunc, jqctx, &jqstat);
+    if (jqstat != zsv_jq_status_ok) {
+      fprintf(stderr, "Invalid filter: %s\n", jqfilter);
+      err = 1;
+    } else {
+      if ((jqstat = zsv_jq_parse_file(zjq, f_in)))
+        err = jqstat;
+      if ((jqstat = zsv_jq_finish(zjq)) && !err)
+        err = jqstat;
+      if (!err && !to_csv)
+        fprintf(f_out, "\n");
+    }
+    zsv_jq_delete(zjq);
+  }
+
+  if (f_out && f_out != stdout)
+    fclose(f_out);
+  if (f_in && f_in != stdin)
+    fclose(f_in);
+
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/jq.h

@@ -0,0 +1,6 @@
+#ifndef LQJQ_H
+#define LQJQ_H
+
+int lq_jq(int argc, const char *argv[]);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/mv.c

@@ -0,0 +1,113 @@
+/* Copyright (C) 2022 Guarnerix Inc dba Liquidaty - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited
+ * Proprietary and confidential
+ * Written by Matt Wong <matt@guarnerix.com>
+ */
+
+/*
+ * Move a given file and its cache as follows:
+ * 1. check that the destination file doesn't exist. if it does, exit with an error
+ * 2. if a cache exists, check that the destination file cache dir doesn't exist. if it does, exit with an error
+ * 3. move the file. if it fails, exit with an error
+ * 4. move the cache, if it exists. if it fails, attempt to move the file back to its original location, and exit with
+ * an error
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h> // unlink()
+#include <errno.h>
+
+#define ZSV_COMMAND_NO_OPTIONS
+#define ZSV_COMMAND mv
+#include "zsv_command.h"
+
+#include <zsv/utils/dirs.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/cache.h>
+#include <zsv/utils/os.h>
+
+const char *zsv_mv_usage_msg[] = {
+  APPNAME ": move a file and its related cache",
+  "",
+  "Usage: " APPNAME " [options] <source> <destination>",
+  "",
+  "Options:",
+  "  -v,--verbose         : verbose output",
+  "  -C,--cache           : only move related cache (not the file)",
+  NULL,
+};
+
+static int zsv_mv_usage(FILE *target) {
+  for (size_t j = 0; zsv_mv_usage_msg[j]; j++)
+    fprintf(target, "%s\n", zsv_mv_usage_msg[j]);
+  return target == stdout ? 0 : 1;
+}
+
+int ZSV_MAIN_NO_OPTIONS_FUNC(ZSV_COMMAND)(int argc, const char *argv[]) {
+  int err = 0;
+  if (argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
+    err = zsv_mv_usage(stdout);
+  else if (argc < 2)
+    err = zsv_mv_usage(stderr);
+  else {
+    const char *source = NULL;
+    const char *dest = NULL;
+
+    char move_file = 1;
+    char verbose = 0;
+    for (int i = 1; !err && i < argc; i++) {
+      const char *arg = argv[i];
+      if (*arg == '-') {
+        if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose"))
+          verbose = 1;
+        else if (!strcmp(arg, "-C") || !strcmp(arg, "--cache"))
+          move_file = 0;
+        else
+          err = zsv_printerr(1, "Unrecognized option: %s", arg);
+      } else if (!source)
+        source = arg;
+      else if (!dest)
+        dest = arg;
+      else
+        err = zsv_printerr(1, "Unrecognized option: %s", arg);
+    }
+
+    if (!err) {
+      unsigned char *source_cache_dir = zsv_cache_path((const unsigned char *)source, NULL, 0);
+      unsigned char *dest_cache_dir = zsv_cache_path((const unsigned char *)dest, NULL, 0);
+      if (!source || !dest) {
+        err = zsv_mv_usage(stderr);
+      } else if (move_file && !zsv_file_exists(source)) {
+        err = errno = ENOENT;
+        perror(source);
+      } else if (move_file && zsv_file_exists(dest)) {
+        err = errno = EEXIST;
+        perror(dest);
+      } else if (zsv_dir_exists((const char *)source_cache_dir) && zsv_dir_exists((const char *)dest_cache_dir)) {
+        err = errno = EEXIST;
+        perror((char *)dest_cache_dir);
+        fprintf(stderr, "Use `mv --cache %s <destination>` to move or `rm --cache %s` to remove, then try again\n",
+                dest, dest);
+      } else if (move_file && (verbose ? fprintf(stderr, "Renaming files\n") : 1) && zsv_replace_file(source, dest)) {
+        err = errno;
+        fprintf(stderr, "%s -> %s: ", source, dest);
+        zsv_perror(NULL);
+      } else if (zsv_dir_exists((const char *)source_cache_dir) && (verbose ? fprintf(stderr, "Moving caches\n") : 1) &&
+                 rename( // rename(): not sure will work on Win with NFS dirs...
+                   (char *)source_cache_dir, (char *)dest_cache_dir)) {
+        err = errno;
+        fprintf(stderr, "%s -> %s: ", source_cache_dir, dest_cache_dir);
+        perror(NULL);
+        if (rename(dest, source)) { // try to revert the prior rename. see above re Win + NFS
+          fprintf(stderr, "%s -> %s: ", dest, source);
+          perror(NULL);
+        }
+      }
+      free(source_cache_dir);
+      free(dest_cache_dir);
+    }
+  }
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/noop.c

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2021 Liquidaty and zsv contributors. All rights reserved.
+ *
+ * This file is part of zsv/lib, distributed under the MIT license as defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <zsv.h>
+#include <zsv/utils/writer.h>
+#include <zsv/utils/signal.h>
+#include <zsv/utils/arg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+struct data {
+  int col_count;
+  zsv_parser parser;
+};
+
+static void error(void *ctx, enum zsv_status status, const unsigned char *err_msg, size_t err_msg_len,
+                  unsigned char error_c, size_t cum_scanned_length) {
+  (void)(ctx);
+  (void)(status);
+  (void)(err_msg);
+  (void)(err_msg_len);
+  (void)(error_c);
+  (void)(cum_scanned_length);
+}
+
+static void cell(void *ctx, unsigned char *utf8_value, size_t len) {
+  (void)(ctx);
+  (void)(utf8_value);
+  (void)(len);
+}
+
+static void overflow(void *ctx, unsigned char *utf8_value, size_t len) {
+  (void)(ctx);
+  (void)(utf8_value);
+  (void)(len);
+}
+
+static void row(void *ctx) {
+  (void)(ctx);
+}
+
+int main(int argc, const char *argv[]) {
+  FILE *f = NULL;
+  struct zsv_csv_writer_options writer_opts = zsv_writer_get_default_opts();
+  struct data data = {0};
+
+  for (int i = 1; i < argc; i++) {
+    if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) {
+      fprintf(stdout, "Usage: noop [filename]\n");
+      fprintf(stdout, "  Reads CSV input and does nothing. For performance testing\n\n");
+      return 0;
+    } else if (!f) {
+      if (!(f = fopen(argv[i], "rb"))) {
+        fprintf(stderr, "Unable to open %s for writing\n", argv[i]);
+        return 1;
+      }
+    } else {
+      fprintf(stderr, "Input file specified more than once (second was %s)\n", argv[i]);
+      if (f)
+        fclose(f);
+      return 1;
+    }
+  }
+
+  if (!f)
+    f = stdin;
+
+  struct zsv_opts opts = zsv_get_default_opts();
+  opts.cell = cell;
+  opts.row = row;
+  opts.ctx = &data;
+  opts.overflow = overflow;
+  opts.error = error;
+
+  opts.stream = f;
+  if ((data.parser = zsv_new(&opts))) {
+    zsv_handle_ctrl_c_signal();
+    while (!zsv_signal_interrupted && zsv_parse_more(data.parser) == zsv_status_ok)
+      ;
+    zsv_finish(data.parser);
+    zsv_delete(data.parser);
+  }
+  fclose(f);
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/overwrite.c

@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2021 Liquidaty and zsv contributors. All rights reserved.
+ *
+ * This file is part of zsv/lib, distributed under the MIT license as defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sqlite3.h>
+#include <errno.h>
+#include <limits.h>
+
+#define _GNU_SOURCE 1
+#include <string.h>
+#include <ctype.h>
+
+#include <zsv.h>
+#include <zsv/utils/writer.h>
+#include <zsv/utils/cache.h>
+#include <zsv/utils/overwrite.h>
+#include <zsv/utils/clock.h>
+#include <zsv/utils/overwrite_writer.h>
+
+#define ZSV_COMMAND overwrite
+#include "zsv_command.h"
+
+const char *zsv_overwrite_usage_msg[] = {
+  APPNAME " - Manage overwrites associated with a CSV file",
+  "",
+  "Usage:",
+  "  " APPNAME " <file> <command> [arguments] [options]",
+  "",
+  "Commands (where <cell> can be <row>-<col> or an Excel-style address):",
+  "  list                   : Display all saved overwrite entries",
+  "  add <cell> <value>     : Add an overwrite entry",
+  "                           Example 1: overwrite the first column of the first",
+  "                           non-header row",
+  "                             overwrite mydata.csv add B2 \"new value\"",
+  "                               - or -",
+  "                             overwrite mydata.csv add 1-1 \"new value\"",
+  "                           Example 2: change the header in the second column",
+  "                           to \"ID #\"",
+  "                             overwrite mydata.csv add B1 \"new value\"",
+  "                               - or -",
+  "                             overwrite mydata.csv add 0-1 \"ID #\"",
+  "  remove <cell>          : Remove an overwrite entry",
+  "  clear                  : Remove any / all overwrites",
+  "  bulk-add <datafile>    : Bulk add overwrite entries from a CSV or JSON file",
+  "  bulk-remove <datafile> : Bulk remove overwrite entries from a CSV or JSON file",
+  "",
+  "Options:",
+  "  -h,--help              : Show this help message",
+  "  --old-value <value>    : For `add` or `remove`, only proceed if the old value",
+  "                           matches the given value",
+  "  --force.               : For `add`, proceed even if an overwrite for the specified",
+  "                           cell already exists",
+  "                           For `remove`, exit without error even if no overwrite for",
+  "                           the specified cell already exists",
+  "  --no-timestamp.        : For `add`, don't save timestamp when adding an overwrite",
+  "  --all                  : For `remove`, remove all overwrites and delete sqlite file",
+  "  --A1                   : For `list`, Display addresses in A1-notation",
+  "",
+  "Description:",
+  "  The  `overwrite`  utility  allows  you to manage a list of \"overwrites\" associated",
+  "  with a given CSV input file. Each overwrite entry is a tuple consisting  of  row,",
+  "  column,  original  value, and new value, along with optional timestamp and author",
+  "  metadata.",
+  "",
+  "  Overwrite data for a given input file `/path/to/my-data.csv` is stored in the \"over‐",
+  "  writes\"  table  of  `/path/to/.zsv/data/my-data.csv/overwrite.sqlite3`.",
+  "",
+  "  For bulk operations, the data file must be a CSV with \"row\", \"col\" and \"value\" columns",
+  "  and may optionally include \"old value\", \"timestamp\" and/or \"author\"",
+  NULL};
+
+static int zsv_overwrite_usage(void) {
+  for (size_t i = 0; zsv_overwrite_usage_msg[i]; i++)
+    fprintf(stdout, "%s\n", zsv_overwrite_usage_msg[i]);
+  return 1;
+}
+
+static char *row_col_to_a1(size_t col, size_t row) {
+  char buffer[64];
+  int index = 63;
+  buffer[index] = '\0';
+
+  while (1) {
+    if (index == 0)
+      return NULL;
+    col--;
+    buffer[--index] = 'A' + (col % 26);
+    col /= 26;
+    if (col == 0)
+      break;
+  }
+  // 20 extra bytes for row
+  char *result = malloc(strlen(&buffer[index]) + 20 + 1);
+  if (result)
+    sprintf(result, "%s%zu", &buffer[index], row + 1);
+  return result;
+}
+
+static int show_all_overwrites(struct zsv_overwrite *data, zsv_csv_writer writer) {
+  zsv_writer_cell(writer, 0, (const unsigned char *)"row", 3, 0);
+  zsv_writer_cell(writer, 0, (const unsigned char *)"column", 6, 0);
+  zsv_writer_cell(writer, 0, (const unsigned char *)"value", 5, 0);
+  zsv_writer_cell(writer, 0, (const unsigned char *)"timestamp", 9, 0);
+  zsv_writer_cell(writer, 0, (const unsigned char *)"author", 6, 0);
+  struct zsv_overwrite_data odata = {.have = 1};
+  while ((data->ctx->next(data->ctx, &odata) == zsv_status_ok) && odata.have) {
+    if (data->a1) {
+      char *a1_ix = row_col_to_a1(odata.col_ix + 1, odata.row_ix);
+      if (a1_ix)
+        zsv_writer_cell(writer, 1, (unsigned char *)a1_ix, strlen(a1_ix), 0);
+      free(a1_ix);
+    } else {
+      zsv_writer_cell_zu(writer, 1, odata.row_ix);
+      zsv_writer_cell_zu(writer, 0, odata.col_ix);
+    }
+    zsv_writer_cell(writer, 0, odata.val.str, odata.val.len, 0);
+    if (odata.timestamp)
+      zsv_writer_cell_zu(writer, 0, odata.timestamp);
+    else
+      zsv_writer_cell(writer, 0, (unsigned char *)"", 0, 0);
+    if (odata.author.len > 0 && odata.author.str)
+      zsv_writer_cell(writer, 0, odata.author.str, odata.author.len, 0);
+    else
+      zsv_writer_cell(writer, 0, (unsigned char *)"", 0, 0);
+  }
+  return 0;
+}
+
+struct xl_address {
+  size_t row, col;
+};
+
+static int parse_xl_address(const char *s, struct xl_address *address) {
+  memset(address, 0, sizeof(*address));
+  unsigned len = strlen(s);
+  for (unsigned i = 0; i < len; i++) {
+    char c = s[i];
+    if (c >= '0' && c <= '9') {
+      if (address->col == 0)
+        return 1; // alpha should come before num
+      if (address->row == 0 && c == '0')
+        return 1; // first num should not be zero
+      address->row = address->row * 10 + (c - '0');
+    } else if (c >= 'A' && c <= 'Z') {
+      if (address->row > 0)
+        return 1; // alpha should come before num
+      address->col = address->col * 26 + (c - 'A') + 1;
+    } else if (c >= 'a' && c <= 'z') {
+      if (address->row > 0)
+        return 1; // alpha should come before num
+      address->col = address->col * 26 + (c - 'a') + 1;
+    } else
+      break;
+  }
+  if (address->row > 0 && address->col > 0) {
+    address->row--;
+    address->col--;
+    return 0;
+  }
+  return 1; // error
+}
+
+static int zsv_overwrite_parse_pos(struct zsv_overwrite_data *overwrite, const char *str) {
+  // this means it's an excel-style cell, because it does not start with a number for the row
+  if (!isdigit(*str)) {
+    struct xl_address address;
+    if (parse_xl_address(str, &address) != 0)
+      return 1;
+    overwrite->row_ix = address.row;
+    overwrite->col_ix = address.col;
+    return 0;
+  }
+  return sscanf(str, "%zu-%zu", &overwrite->row_ix, &overwrite->col_ix) != 2;
+}
+
+int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *opts,
+                               struct zsv_prop_handler *custom_prop_handler) {
+  int err = 0;
+  if (argc < 3 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
+    zsv_overwrite_usage();
+    return err;
+  }
+
+  struct zsv_overwrite_opts ctx_opts = {0};
+  (void)(opts);
+  (void)(custom_prop_handler);
+
+  struct zsv_overwrite_args args = {0};
+  // By default, save timestamps
+  struct zsv_overwrite_data overwrite = {0};
+  overwrite.timestamp = (size_t)time(NULL);
+
+  args.filepath = (char *)argv[1];
+
+  for (int i = 2; !err && i < argc; i++) {
+    const char *opt = argv[i];
+    if (!strcmp(opt, "-f") || !strcmp(opt, "--force")) {
+      args.force = 1;
+    } else if (!strcmp(opt, "--old-value")) {
+      overwrite.old_value.str = (unsigned char *)strdup(argv[++i]);
+      overwrite.old_value.len = strlen((const char *)overwrite.old_value.str);
+    } else if (!strcmp(opt, "--no-timestamp")) {
+      overwrite.timestamp = 0;
+    } else if (!strcmp(opt, "--A1")) {
+      args.a1 = 1;
+    } else if (!strcmp(opt, "list")) {
+      args.mode = zsvsheet_mode_list;
+    } else if (!strcmp(opt, "clear")) {
+      args.mode = zsvsheet_mode_clear;
+    } else if (!strcmp(opt, "add")) {
+      if (argc - i > 2) {
+        args.mode = zsvsheet_mode_add;
+        err = zsv_overwrite_parse_pos(&overwrite, argv[++i]);
+        overwrite.val.str = (unsigned char *)strdup(argv[++i]);
+        overwrite.val.len = strlen((const char *)overwrite.val.str);
+        if (err || !overwrite.val.str) {
+          fprintf(stderr, "Expected row, column, and value\n");
+          err = 1;
+        }
+      } else {
+        fprintf(stderr, "Expected row, column, and value\n");
+        err = 1;
+      }
+    } else if (!strcmp(opt, "remove")) {
+      if (argc - i > 1) {
+        args.mode = zsvsheet_mode_remove;
+        if (!strcmp(argv[++i], "--all"))
+          args.all = 1;
+        else
+          err = zsv_overwrite_parse_pos(&overwrite, argv[i]);
+        if (err) {
+          fprintf(stderr, "Expected row and column\n");
+        }
+      } else {
+        fprintf(stderr, "Expected row and column\n");
+        err = 1;
+      }
+    } else if (!strcmp(opt, "bulk-add")) {
+      if (argc - i > 1) {
+        args.mode = zsvsheet_mode_bulk;
+        args.bulk_file = (unsigned char *)strdup(argv[++i]);
+        args.next = zsv_overwrite_writer_add;
+      } else {
+        fprintf(stderr, "Expected overwrite filename\n");
+        err = 1;
+      }
+    } else if (!strcmp(opt, "bulk-remove")) {
+      if (argc - i > 1) {
+        args.mode = zsvsheet_mode_bulk;
+        args.bulk_file = (unsigned char *)strdup(argv[++i]);
+        args.next = zsv_overwrite_writer_remove;
+      } else {
+        fprintf(stderr, "Expected overwrite filename\n");
+        err = 1;
+      }
+    } else {
+      err = 1;
+      if (*opt == '-')
+        fprintf(stderr, "Unrecognized option: %s\n", opt);
+      else
+        fprintf(stderr, "Unrecognized command or argument: %s\n", opt);
+    }
+  }
+
+  args.overwrite = &overwrite;
+
+  char *overwrites_fn =
+    (char *)zsv_cache_filepath((const unsigned char *)args.filepath, zsv_cache_type_overwrite, 0, 0);
+  ctx_opts.src = (char *)overwrites_fn;
+  struct zsv_overwrite *data = zsv_overwrite_writer_new(&args, &ctx_opts);
+  free(overwrites_fn);
+
+  if (!err && data) {
+    if (data->mode == zsvsheet_mode_list)
+      err = show_all_overwrites(data, data->writer);
+    else if (data->mode == zsvsheet_mode_clear)
+      err = zsv_overwrite_writer_clear(data);
+    else if (data->mode == zsvsheet_mode_add && data->ctx->sqlite3.db)
+      err = zsv_overwrite_writer_add(data);
+    else if (data->mode == zsvsheet_mode_remove && data->ctx->sqlite3.db)
+      err = zsv_overwrite_writer_remove(data);
+    else if (data->mode == zsvsheet_mode_bulk && data->ctx->sqlite3.db) {
+      err = zsv_overwrite_writer_bulk(data);
+    }
+  }
+
+  zsv_overwrite_writer_delete(data);
+
+  return err;
+}