cisv 0.0.1

package/src/cisv_writer.h

@@ -0,0 +1,60 @@
+#ifndef CISV_WRITER_H
+#define CISV_WRITER_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct cisv_writer cisv_writer;
+
+// Writer configuration
+typedef struct {
+    char delimiter;
+    char quote_char;
+    int always_quote;
+    int use_crlf;
+    const char *null_string;
+    size_t buffer_size;
+} cisv_writer_config;
+
+// Create writer with default config
+cisv_writer *cisv_writer_create(FILE *output);
+
+// Create writer with custom config
+cisv_writer *cisv_writer_create_config(FILE *output, const cisv_writer_config *config);
+
+// Destroy writer and flush remaining data
+void cisv_writer_destroy(cisv_writer *writer);
+
+// Write a single field
+int cisv_writer_field(cisv_writer *writer, const char *data, size_t len);
+
+// Write a field from null-terminated string
+int cisv_writer_field_str(cisv_writer *writer, const char *str);
+
+// Write a numeric field
+int cisv_writer_field_int(cisv_writer *writer, int64_t value);
+int cisv_writer_field_double(cisv_writer *writer, double value, int precision);
+
+// End current row
+int cisv_writer_row_end(cisv_writer *writer);
+
+// Write complete row from array
+int cisv_writer_row(cisv_writer *writer, const char **fields, size_t count);
+
+// Flush buffer to output
+int cisv_writer_flush(cisv_writer *writer);
+
+// Get statistics
+size_t cisv_writer_bytes_written(const cisv_writer *writer);
+size_t cisv_writer_rows_written(const cisv_writer *writer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CISV_WRITER_H

package/src/index.ts

@@ -0,0 +1,2 @@
+import { cisvParser } from 'cisv';
+export { cisvParser };

package/src/test/typescript.test.ts

@@ -0,0 +1,43 @@
+import { strict as assert } from 'assert';
+import * as fs from 'fs';
+import * as path from 'path';
+import { cisvParser } from '../index';
+
+describe('TypeScript Integration', () => {
+  const testFile = path.join(__dirname, 'fixtures', 'typescript.csv');
+
+  before(() => {
+    fs.writeFileSync(testFile,
+      'id,name\n1,Test\n2,"Quoted,Name"');
+  });
+
+  it('should work with TypeScript types', () => {
+    const parser = new cisvParser();
+    const rows = parser.parseSync(testFile);
+
+    assert.strictEqual(rows.length, 2);
+    assert.deepStrictEqual(rows[0], ['1', 'Test']);
+    assert.deepStrictEqual(rows[1], ['2', 'Quoted,Name']);
+  });
+
+  it('should type check streaming API', async () => {
+    const parser = new cisvParser();
+    const stream = fs.createReadStream(testFile);
+
+    await new Promise<void>((resolve) => {
+      stream.on('data', (chunk: Buffer | string) => {
+          if (typeof chunk === 'string') {
+            parser.write(Buffer.from(chunk));
+          } else {
+            parser.write(chunk);
+          }
+      });
+      stream.on('end', () => {
+        parser.end();
+        const rows = parser.getRows();
+        assert.strictEqual(rows.length, 2);
+        resolve();
+      });
+    });
+  });
+});

package/src/win_getopt.h

@@ -0,0 +1,100 @@
+#ifdef _WIN32
+    #include <windows.h>
+
+    #ifndef WIN_GETOPT_H
+    #define WIN_GETOPT_H
+
+    #include <string.h>
+    #include <stdio.h>
+
+    // Global variables
+    char* optarg = NULL;    // Current option argument
+    int optind = 1;         // Index of next argument to process
+    int opterr = 1;         // Enable error messages (default: 1)
+    int optopt = 0;         // Current option character
+
+    // Reset getopt internal state
+    void win_getopt_reset() {
+        optarg = NULL;
+        optind = 1;
+        opterr = 1;
+        optopt = 0;
+    }
+
+    int getopt(int argc, char* const argv[], const char* optstring) {
+        static int optpos = 1;  // Position within current argument
+        const char* colon = strchr(optstring, ':');
+
+        // Reset for new scan
+        optarg = NULL;
+
+        // Argument boundary checks
+        if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') {
+            return -1;
+        }
+
+        // Handle "--" end of options
+        if (strcmp(argv[optind], "--") == 0) {
+            optind++;
+            return -1;
+        }
+
+        // Get current option character
+        optopt = argv[optind][optpos++];
+
+        // Find option in optstring
+        char* optptr = strchr(optstring, optopt);
+
+        // Unknown option
+        if (!optptr) {
+            if (opterr && *optstring != ':')
+                fprintf(stderr, "%s: invalid option -- '%c'\n", argv[0], optopt);
+            return '?';
+        }
+
+        // Handle required argument
+        if (optptr[1] == ':') {
+            // Argument in current token
+            if (argv[optind][optpos] != '\0') {
+                optarg = &argv[optind][optpos];
+                optpos = 1;
+                optind++;
+            }
+            // Argument in next token
+            else if (argc > optind + 1) {
+                optarg = argv[optind + 1];
+                optind += 2;
+                optpos = 1;
+            }
+            // Missing argument
+            else {
+                if (opterr && *optstring != ':') {
+                    fprintf(stderr, "%s: option requires an argument -- '%c'\n",
+                            argv[0], optopt);
+                }
+                optpos = 1;
+                optind++;
+                return (colon && colon[1] == ':') ? ':' : '?';
+            }
+        }
+        // No argument required
+        else {
+            if (argv[optind][optpos] == '\0') {
+                optpos = 1;
+                optind++;
+            }
+        }
+
+        return optopt;
+    }
+
+    #endif // WIN_GETOPT_H
+#elif defined(__linux__) || defined(__APPLE__)
+    #include <sys/mman.h>
+    #include <fcntl.h>
+    #include <unistd.h>
+    #include <getopt.h>
+    #include <sys/time.h>
+#else
+    #error "Unsupported platform"
+#endif

package/src/win_sys_time.h

@@ -0,0 +1,50 @@
+#ifndef WIN_SYS_TIME_H
+#define WIN_SYS_TIME_H
+
+#ifdef _WIN32
+#include <windows.h>
+#include <stdint.h>
+
+// Define timezone structure (dummy implementation)
+struct timezone {
+    int tz_minuteswest; // minutes west of Greenwich
+    int tz_dsttime;     // type of DST correction
+};
+
+// Get current time of day (Windows implementation)
+static inline int gettimeofday(struct timeval* tv, struct timezone* tz) {
+    if (tv) {
+        FILETIME ft;
+        uint64_t tmpres = 0;
+
+        // Get current time as file time
+        GetSystemTimeAsFileTime(&ft);
+
+        // Convert to 64-bit integer
+        tmpres |= ft.dwHighDateTime;
+        tmpres <<= 32;
+        tmpres |= ft.dwLowDateTime;
+
+        // Convert to microseconds (1601-01-01 to 1970-01-01 is 11644473600 seconds)
+        tmpres /= 10;  // Convert to microseconds
+        tmpres -= 11644473600000000ULL;  // Offset to Unix epoch
+
+        tv->tv_sec = (long)(tmpres / 1000000UL);
+        tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+
+    // We don't support timezone on Windows
+    if (tz) {
+        tz->tz_minuteswest = 0;
+        tz->tz_dsttime = 0;
+    }
+
+    return 0;
+}
+
+#else
+// On non-Windows platforms, use the standard header
+#include <sys/time.h>
+#endif  // _WIN32
+
+#endif  // WIN_SYS_TIME_H

package/test/basic.test.js

@@ -0,0 +1,104 @@
+const { cisvParser } = require('../build/Release/cisv');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+describe('CSV Parser Core Functionality', () => {
+  const testDir = path.join(__dirname, 'fixtures');
+  const testFile = path.join(testDir, 'test.csv');
+  const largeFile = path.join(testDir, 'large.csv');
+
+  before(() => {
+    if (!fs.existsSync(testDir)) fs.mkdirSync(testDir);
+
+    // Basic test file with quoted fields
+    fs.writeFileSync(testFile,
+      'id,name,email\n1,John,john@test.com\n2,Jane Doe,jane@test.com\n3,Alex \"The Boss\",alex@test.com');
+
+    // Generate large test file (1000 rows)
+    let largeContent = 'id,value\n';
+    for (let i = 0; i < 1000; i++) {
+      largeContent += `${i},Value ${i}\n`;
+    }
+    fs.writeFileSync(largeFile, largeContent);
+  });
+
+  after(() => {
+    fs.unlinkSync(testFile);
+    fs.unlinkSync(largeFile);
+  });
+
+  describe('Synchronous Parsing', () => {
+    it('should parse basic CSV correctly', () => {
+      const parser = new cisvParser();
+      const rows = parser.parseSync(testFile);
+      assert.strictEqual(rows.length, 3);
+      assert.deepStrictEqual(rows[0], ['id', 'name', 'email']);
+      assert.deepStrictEqual(rows[1], ['1', 'John', 'john@test.com']);
+    });
+
+    it('should handle quoted fields with commas', () => {
+      const parser = new cisvParser();
+      const rows = parser.parseSync(testFile);
+      assert.strictEqual(rows[2][1], 'Jane Doe');
+      assert.strictEqual(rows[2][2], 'jane@test.com');
+    });
+
+    it('should handle large files efficiently', () => {
+      const parser = new cisvParser();
+      const rows = parser.parseSync(largeFile);
+      assert.strictEqual(rows.length, 1001); // Header + 1000 rows
+      assert.strictEqual(rows[500][1], 'Value 499');
+    });
+  });
+
+  describe('Streaming API', () => {
+    it('should process data in chunks', (done) => {
+      const parser = new cisvParser();
+      const stream = fs.createReadStream(testFile, { highWaterMark: 16 }); // Small chunks
+
+      stream.on('data', chunk => parser.write(chunk));
+      stream.on('end', () => {
+        parser.end();
+        const rows = parser.getRows();
+        assert.strictEqual(rows.length, 3);
+        done();
+      });
+    });
+
+    it('should handle partial chunks', () => {
+      const parser = new cisvParser();
+      // Write partial lines
+      parser.write(Buffer.from('id,name,emai'));
+      parser.write(Buffer.from('l\n1,John,john@test.com\n'));
+      parser.end();
+      const rows = parser.getRows();
+      assert.strictEqual(rows.length, 2);
+      assert.deepStrictEqual(rows[0], ['id', 'name', 'email']);
+    });
+  });
+
+  // FIXME: should be fixed from the napi addon.cc
+  //describe('Error Handling', () => {
+  //    it('should throw on non-existent file', () => {
+  //      const parser = new cisvParser();
+  //      assert.throws(() => parser.parseSync('./nonexistent.csv'), /parse error/);
+  //    });
+
+  //    it('should throw on invalid write arguments', () => {
+  //      const parser = new cisvParser();
+  //      // Test with actually invalid arguments
+  //      assert.throws(() => parser.write(123), /Expected Buffer or String/);
+  //      assert.throws(() => parser.write({}), /Expected Buffer or String/);
+  //      assert.throws(() => parser.write(null), /Expected Buffer or String/);
+  //      assert.throws(() => parser.write(), /Expected one argument/);
+  //    });
+
+  //    it('should accept both Buffer and String in write', () => {
+  //      const parser = new cisvParser();
+  //      // Should not throw
+  //      assert.doesNotThrow(() => parser.write(Buffer.from('test')));
+  //      assert.doesNotThrow(() => parser.write('test'));
+  //    });
+  //});
+});

package/test_select.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+echo -ne "\n\n------------------------------"
+echo -ne "\n==== CISV PARSER checks ===\n"
+echo -ne "------------------------------\n\n"
+
+echo "Creating test CSV file..."
+cat > test_select.csv << EOF
+id,name,email,city
+1,John Doe,john@test.com,New York
+2,Jane Smith,jane@test.com,Los Angeles
+3,Bob Johnson,bob@test.com,Chicago
+EOF
+
+echo "Testing column selection..."
+echo ""
+
+echo "1. Display all columns (no selection):"
+./cisv test_select.csv
+echo ""
+
+echo "2. Select column 0 only:"
+./cisv -s 0 test_select.csv
+echo ""
+
+echo "3. Select columns 0,2:"
+./cisv -s 0,2 test_select.csv
+echo ""
+
+echo "4. Select columns 0,2,3:"
+./cisv -s 0,2,3 test_select.csv
+echo ""
+
+echo "5. Test with valgrind (if available):"
+if command -v valgrind > /dev/null 2>&1; then
+    valgrind --leak-check=full ./cisv -s 0,2,3 test_select.csv
+else
+    echo "Valgrind not installed"
+fi
+
+rm -f test_select.csv
+echo ""
+echo "All writer tests completed!"
+
+echo -ne "\n\n------------------------------"
+echo -ne "\n==== CISV WRITER checks ===\n"
+echo -ne "------------------------------\n\n"
+
+# Build if needed
+if [ ! -f "./cisv" ]; then
+    make clean
+    make cli
+fi
+
+echo ""
+echo "1. Testing basic generation (10 rows):"
+./cisv write -g 10 -o test_basic.csv
+cat test_basic.csv
+echo ""
+
+echo "2. Testing with custom delimiter (semicolon):"
+./cisv write -g 5 -d ';' -o test_delim.csv
+cat test_delim.csv
+echo ""
+
+echo "3. Testing with always quote:"
+./cisv write -g 5 -Q -o test_quoted.csv
+cat test_quoted.csv
+echo ""
+
+echo "4. Testing CRLF line endings:"
+./cisv write -g 3 -r -o test_crlf.csv
+file test_crlf.csv
+od -c test_crlf.csv | head -2
+echo ""
+
+echo "5. Testing benchmark mode (1000 rows):"
+./cisv write -g 1000 -o test_bench.csv -b
+echo ""
+
+echo "6. Testing memory leaks with valgrind:"
+if command -v valgrind > /dev/null 2>&1; then
+    valgrind --leak-check=full ./cisv write -g 100 -o test_valgrind.csv
+else
+    echo "Valgrind not installed"
+fi
+
+# Cleanup
+rm -f test_*.csv
+
+echo ""
+echo "All writer tests completed!"

package/test_transform.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+# Test script for CSV transform functionality with detailed memory leak detection
+
+set -e  # Exit on error
+
+echo "============================================"
+echo "CSV Transform Functionality & Memory Testing"
+echo "============================================"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Build if needed
+if [ ! -f "./build/Release/cisv.node" ]; then
+    echo -e "${YELLOW}Building Node.js addon...${NC}"
+    make build
+fi
+
+# Create test script
+echo -e "\n${GREEN}Running transform tests...${NC}"
+node ./examples/transform.js
+
+# Test memory leaks if valgrind is available
+if command -v valgrind > /dev/null 2>&1; then
+    echo ""
+    echo "============================================"
+    echo "MEMORY LEAK DETECTION TESTS"
+    echo "============================================"
+
+    echo -e "${YELLOW}Running Valgrind memory analysis...${NC}"
+    echo "--------------------------------------------"
+
+    # Run valgrind and save to file to avoid hanging
+    valgrind \
+        --leak-check=full \
+        --show-leak-kinds=definite,indirect \
+        --track-origins=yes \
+        --suppressions=valgrind-node.supp \
+        --log-file=valgrind_output.log \
+        node --expose-gc test_transform_leak_test.js 2>&1
+
+    VALGRIND_EXIT_CODE=$?
+
+    # Read the valgrind output from file
+    if [ -f valgrind_output.log ]; then
+        VALGRIND_OUTPUT=$(cat valgrind_output.log)
+
+        # Parse and display results
+        echo "$VALGRIND_OUTPUT" | grep -A5 "HEAP SUMMARY" || echo "No HEAP SUMMARY found"
+        echo "--------------------------------------------"
+
+        # Extract key metrics
+        DEFINITELY_LOST=$(echo "$VALGRIND_OUTPUT" | grep "definitely lost:" | tail -1)
+        INDIRECTLY_LOST=$(echo "$VALGRIND_OUTPUT" | grep "indirectly lost:" | tail -1)
+        POSSIBLY_LOST=$(echo "$VALGRIND_OUTPUT" | grep "possibly lost:" | tail -1)
+        STILL_REACHABLE=$(echo "$VALGRIND_OUTPUT" | grep "still reachable:" | tail -1)
+        ERROR_SUMMARY=$(echo "$VALGRIND_OUTPUT" | grep "ERROR SUMMARY:" | tail -1)
+
+        echo -e "\n${YELLOW}MEMORY LEAK SUMMARY:${NC}"
+        echo "--------------------------------------------"
+
+        # Check for definitely lost bytes
+        if [ -n "$DEFINITELY_LOST" ]; then
+            if echo "$DEFINITELY_LOST" | grep -q "0 bytes in 0 blocks"; then
+                echo -e "${GREEN}✓ Definitely lost: 0 bytes${NC}"
+                DEFINITELY_OK=true
+            else
+                echo -e "${RED}✗ $DEFINITELY_LOST${NC}"
+                DEFINITELY_OK=false
+            fi
+        else
+            echo -e "${YELLOW}⚠ Definitely lost: not found in output${NC}"
+            DEFINITELY_OK=false
+        fi
+
+        # Check for indirectly lost bytes
+        if [ -n "$INDIRECTLY_LOST" ]; then
+            if echo "$INDIRECTLY_LOST" | grep -q "0 bytes in 0 blocks"; then
+                echo -e "${GREEN}✓ Indirectly lost: 0 bytes${NC}"
+            else
+                echo -e "${YELLOW}⚠ $INDIRECTLY_LOST${NC}"
+            fi
+        fi
+
+        # Check for possibly lost bytes
+        if [ -n "$POSSIBLY_LOST" ]; then
+            if echo "$POSSIBLY_LOST" | grep -q "0 bytes in 0 blocks"; then
+                echo -e "${GREEN}✓ Possibly lost: 0 bytes${NC}"
+            else
+                echo -e "${YELLOW}⚠ $POSSIBLY_LOST${NC}"
+            fi
+        fi
+
+        # Display still reachable (usually OK for Node.js)
+        if [ -n "$STILL_REACHABLE" ]; then
+            echo -e "  $STILL_REACHABLE"
+        fi
+
+        # Check error summary
+        echo "--------------------------------------------"
+        if [ -n "$ERROR_SUMMARY" ]; then
+            if echo "$ERROR_SUMMARY" | grep -q "0 errors from 0 contexts"; then
+                echo -e "${GREEN}✓ $ERROR_SUMMARY${NC}"
+                ERROR_OK=true
+            else
+                echo -e "${RED}✗ $ERROR_SUMMARY${NC}"
+                ERROR_OK=false
+            fi
+        else
+            echo -e "${YELLOW}⚠ ERROR SUMMARY not found${NC}"
+            ERROR_OK=false
+        fi
+
+        # Determine overall pass/fail
+        if [ "$DEFINITELY_OK" = true ] && [ "$ERROR_OK" = true ]; then
+            echo -e "${GREEN}✓ No memory leaks detected!${NC}"
+            MEMORY_TEST_PASSED=true
+        else
+            echo -e "${RED}✗ Memory issues detected!${NC}"
+            MEMORY_TEST_PASSED=false
+
+            # Show detailed errors if any
+            echo -e "\n${YELLOW}Checking for detailed errors...${NC}"
+            grep -i "invalid\|definitely lost\|indirectly lost" valgrind_output.log | head -20 || echo "No specific errors found"
+        fi
+
+        # Save report
+        mv valgrind_output.log valgrind_report.txt
+        echo -e "\n${YELLOW}Full Valgrind report saved to: valgrind_report.txt${NC}"
+    else
+        echo -e "${RED}Error: Valgrind output file not created${NC}"
+        MEMORY_TEST_PASSED=false
+    fi
+
+    # Exit with appropriate code
+    if [ "$MEMORY_TEST_PASSED" = true ]; then
+        echo -e "\n${GREEN}============================================${NC}"
+        echo -e "${GREEN}ALL MEMORY TESTS PASSED SUCCESSFULLY!${NC}"
+        echo -e "${GREEN}============================================${NC}"
+    else
+        echo -e "\n${RED}============================================${NC}"
+        echo -e "${RED}MEMORY TESTS FAILED - LEAKS DETECTED${NC}"
+        echo -e "${RED}============================================${NC}"
+        echo -e "\n${YELLOW}Debug tips:${NC}"
+        echo "1. Check valgrind_report.txt for full details"
+        echo "2. Look for 'definitely lost' blocks in the report"
+        echo "3. Use gdb to trace the allocation points"
+        echo "4. Consider using AddressSanitizer for additional debugging"
+    fi
+else
+    echo -e "\n${YELLOW}Warning: Valgrind not installed. Skipping memory leak tests.${NC}"
+    echo "To install valgrind:"
+    echo "  Ubuntu/Debian: sudo apt-get install valgrind"
+    echo "  macOS: brew install valgrind"
+    echo "  RHEL/CentOS: sudo yum install valgrind"
+fi
+
+# Cleanup any remaining files
+rm -f leak_test*.csv valgrind_output.log
+
+echo ""
+echo "============================================"
+echo "Transform tests completed!"
+echo "============================================"