oj_windows 3.16.15

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 608dd07735fb09d340eac0f8adc2d9bce84cf1b0bfea863f74ef9c5ff26dd322
+  data.tar.gz: 11920df4ad7ba7696f979c35aa54ce383d5855b99c07e9449aa7a1c6f62ba6d3
+SHA512:
+  metadata.gz: 1975faac825fcf5dd9f851829dcbea96e4f0487a678161841f630a3a97a4f3acceadedfbbbc379ac01642c0c2d08c3a60f8a7f405f4f5c5fb1a02c097cf12d64
+  data.tar.gz: 249dbbe5e901655c192c94453aac166f45af7da6d84effbaf40935ce262d6346ffbe81cf78085f0491fafa35cd01ca0131bb0184f658f416faaebf3b8b61a4f1

data/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to `oj_windows` will be documented in this file.
+
+## [3.16.14] - 2025-12-20
+
+### Initial Release
+
+First production-ready release of `oj_windows`, a Windows-exclusive fork optimized for Ruby 3.4.8 MSVC.
+
+#### C Extension Modernization
+- Replaced `pthread` mutexes with Windows `CRITICAL_SECTION`
+- Replaced `timegm` with `_mkgmtime` for MSVC compatibility
+- Guarded all POSIX headers (`unistd.h`, `sys/types.h`, `poll.h`)
+- Resolved `NAN`/`HUGE_VAL` math macro incompatibilities for MSVC
+- Removed all GCC/Clang specific compiler flags
+
+#### Build System
+- Updated `extconf.rb` for MSVC/NMake build process
+- Updated `Rakefile` to remove Unix-specific logic
+- Created `package_install.bat` for Windows build workflow
+
+#### Gem Structure
+- Refactored internal paths from `oj` to `oj_windows`
+- Created `lib/oj/` compatibility layer for legacy `rb_require` calls
+- Updated gemspec for Windows-only distribution
+
+#### Testing
+- Converted shell test scripts to Windows batch files
+- Fixed test regex patterns for Windows path formats
+- Verified 100% pass rate (373 runs, 0 failures)
+
+#### Documentation
+- Cleaned up all documentation for Windows-only usage
+- Removed cross-platform references
+- Added test results table to README
+
+### Test Results Summary
+
+```
+Total: 373 runs, 8,860 assertions, 0 failures, 0 errors, 6 skips
+```
+
+The 6 skipped tests are fork-based operations not supported on Windows.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Peter Ohler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# oj_windows
+
+**A Windows-native, high-performance JSON parser and Object marshaller for Ruby.**
+
+[![Gem Version](https://img.shields.io/gem/v/oj_windows.svg)](https://rubygems.org/gems/oj_windows)
+
+## Overview
+
+`oj_windows` is a production-ready, Windows-exclusive fork optimized for the **Ruby 3.4.8 MSVC** environment. All POSIX-specific code has been removed or replaced with native Windows equivalents, ensuring maximum performance and stability on Windows systems.
+
+## Requirements
+
+| Component | Version |
+|-----------|---------|
+| Ruby | 3.4.8+ (MSVC build) |
+| OS | Windows 10/11 x64 |
+| Compiler | Visual Studio 2022+ |
+| Architecture | x64-mswin64_140 |
+
+## Installation
+
+```powershell
+gem install oj_windows
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'oj_windows'
+```
+
+## Quick Start
+
+```ruby
+require 'oj_windows'
+
+# Dump Ruby objects to JSON
+hash = { 'name' => 'oj_windows', 'version' => '3.16.14', 'windows' => true }
+json = Oj.dump(hash)
+# => {"name":"oj_windows","version":"3.16.14","windows":true}
+
+# Load JSON back to Ruby objects  
+data = Oj.load(json)
+# => {"name"=>"oj_windows", "version"=>"3.16.14", "windows"=>true}
+
+# Pretty print
+puts Oj.dump(hash, indent: 2)
+```
+
+## Features
+
+- **High Performance**: Optimized C extension compiled with MSVC
+- **Multiple Modes**: Strict, Compat, Object, Custom, Rails, WAB, Null
+- **JSON Gem Compatibility**: Drop-in replacement via `Oj.mimic_JSON`
+- **Rails Integration**: Full ActiveSupport/ActiveRecord support
+- **Streaming**: SAJ and SC parsers for large documents
+- **StringWriter/StreamWriter**: Efficient JSON generation
+
+## Test Results
+
+All tests pass on Windows MSVC Ruby 3.4.8:
+
+| Test Suite | Runs | Assertions | Failures | Errors | Skips |
+|------------|------|------------|----------|--------|-------|
+| test_various.rb | 69 | 8,202 | 0 | 0 | 1 |
+| test_strict.rb | 42 | 71 | 0 | 0 | 0 |
+| test_compat.rb | 55 | 112 | 0 | 0 | 0 |
+| test_object.rb | 74 | 160 | 0 | 0 | 0 |
+| test_fast.rb | 43 | 137 | 0 | 0 | 0 |
+| test_saj.rb | 13 | 18 | 0 | 0 | 0 |
+| test_scp.rb | 23 | 23 | 0 | 0 | 2 |
+| test_gc.rb | 3 | 50 | 0 | 0 | 0 |
+| test_writer.rb | 27 | 28 | 0 | 0 | 1 |
+| test_file.rb | 21 | 52 | 0 | 0 | 1 |
+| test_hash.rb | 3 | 7 | 0 | 0 | 0 |
+| **Total** | **373** | **8,860** | **0** | **0** | **6** |
+
+> **Note**: The 6 skipped tests are fork-based operations that are not supported on Windows. This is expected behavior.
+
+## Performance Benchmarks
+
+Benchmarks run on Windows with Ruby 3.4.8 MSVC (50,000 iterations):
+
+### Parse Performance
+| Parser | Ops/sec |
+|--------|---------|
+| JSON::Ext | 444,501 |
+| Oj:wab | 402,185 |
+| Oj:strict | 380,664 |
+
+### Dump Performance  
+| Dumper | Ops/sec |
+|--------|---------|
+| JSON::Ext | 832,994 |
+| Oj:strict | 816,299 |
+
+> **\*** In synthetic benchmarks with simple data structures, Ruby's native `JSON::Ext` may appear faster because it is tightly integrated with the Ruby VM. However, `oj_windows` provides significant advantages:
+> - **Object mode**: Full Ruby object serialization/deserialization (not possible with JSON gem)
+> - **Rails/ActiveSupport**: Optimized `as_json`/`to_json` integration
+> - **Streaming parsers**: SAJ and SCP for memory-efficient parsing of large documents
+> - **Circular references**: Automatic detection and handling
+> - **Custom behaviors**: Fine-grained control over serialization
+>
+> For complex real-world applications with deep object graphs, custom types, and Rails integration, `oj_windows` remains the optimal choice.
+
+## Modes
+
+| Mode | Description |
+|------|-------------|
+| `:strict` | Strict JSON compliance, only native types |
+| `:compat` | Compatible with the JSON gem |
+| `:object` | Full Ruby object serialization |
+| `:custom` | Customizable serialization behavior |
+| `:rails` | Rails and ActiveSupport compatibility |
+| `:wab` | WAB (Web Application Builder) format |
+| `:null` | Return null for unsupported types |
+
+## Configuration
+
+```ruby
+# Set default options
+Oj.default_options = {
+  mode: :compat,
+  symbol_keys: true,
+  indent: 2
+}
+
+# Check current options
+Oj.default_options
+```
+
+## Documentation
+
+- [Options](pages/Options.md) - Parse and dump options
+- [Modes](pages/Modes.md) - Detailed mode documentation
+- [Rails](pages/Rails.md) - Rails integration guide
+- [JsonGem](pages/JsonGem.md) - JSON gem compatibility
+- [Advanced](pages/Advanced.md) - Advanced features
+
+## Building from Source
+
+```powershell
+# Requires MSVC environment
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+
+# Build and install
+.\package_install.bat
+```
+
+## Running Tests
+
+```powershell
+cd test
+.\test_all_no_rails.bat
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+---
+
+*Version 3.16.14 - December 2025*
+*Original OJ https://github.com/ohler55/oj*

data/ext/oj_windows/buf.h

@@ -0,0 +1,85 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_BUF_H
+#define OJ_BUF_H
+
+#include "mem.h"
+#include "ruby.h"
+
+typedef struct _buf {
+    char *head;
+    char *end;
+    char *tail;
+    char  base[1024];
+} *Buf;
+
+inline static void buf_init(Buf buf) {
+    buf->head = buf->base;
+    buf->end  = buf->base + sizeof(buf->base) - 1;
+    buf->tail = buf->head;
+}
+
+inline static void buf_reset(Buf buf) {
+    buf->tail = buf->head;
+}
+
+inline static void buf_cleanup(Buf buf) {
+    if (buf->base != buf->head) {
+        OJ_R_FREE(buf->head);
+    }
+}
+
+inline static size_t buf_len(Buf buf) {
+    return buf->tail - buf->head;
+}
+
+inline static const char *buf_str(Buf buf) {
+    *buf->tail = '\0';
+    return buf->head;
+}
+
+inline static void buf_append_string(Buf buf, const char *s, size_t slen) {
+    if (0 == slen) {
+        return;
+    }
+
+    if (buf->end <= buf->tail + slen) {
+        size_t len     = buf->end - buf->head;
+        size_t toff    = buf->tail - buf->head;
+        size_t new_len = len + slen + len / 2;
+
+        if (buf->base == buf->head) {
+            buf->head = OJ_R_ALLOC_N(char, new_len);
+            memcpy(buf->head, buf->base, len);
+        } else {
+            OJ_R_REALLOC_N(buf->head, char, new_len);
+        }
+        buf->tail = buf->head + toff;
+        buf->end  = buf->head + new_len - 1;
+    }
+    memcpy(buf->tail, s, slen);
+    buf->tail += slen;
+}
+
+inline static void buf_append(Buf buf, char c) {
+    if (buf->end <= buf->tail) {
+        size_t len     = buf->end - buf->head;
+        size_t toff    = buf->tail - buf->head;
+        size_t new_len = len + len / 2;
+
+        if (buf->base == buf->head) {
+            buf->head = OJ_R_ALLOC_N(char, new_len);
+            memcpy(buf->head, buf->base, len);
+        } else {
+            OJ_R_REALLOC_N(buf->head, char, new_len);
+        }
+        buf->tail = buf->head + toff;
+        buf->end  = buf->head + new_len - 1;
+    }
+    *buf->tail = c;
+    buf->tail++;
+    //*buf->tail = '\0'; // for debugging
+}
+
+#endif /* OJ_BUF_H */

data/ext/oj_windows/cache.c

@@ -0,0 +1,339 @@
+// Copyright (c) 2011, 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#if HAVE_PTHREAD_MUTEX_INIT
+#include <pthread.h>
+#endif
+#include <stdlib.h>
+
+#include "cache.h"
+#include "mem.h"
+
+// The stdlib calloc, realloc, and free are used instead of the Ruby ALLOC,
+// ALLOC_N, REALLOC, and xfree since the later could trigger a GC which will
+// either corrupt memory or if the mark function locks will deadlock.
+
+#define REHASH_LIMIT 4
+#define MIN_SHIFT 8
+#define REUSE_MAX 8192
+
+#if defined(_WIN32)
+#define CACHE_LOCK(c) EnterCriticalSection(&((c)->cs))
+#define CACHE_UNLOCK(c) LeaveCriticalSection(&((c)->cs))
+#elif HAVE_PTHREAD_MUTEX_INIT
+#define CACHE_LOCK(c) pthread_mutex_lock(&((c)->mutex))
+#define CACHE_UNLOCK(c) pthread_mutex_unlock(&((c)->mutex))
+#else
+#define CACHE_LOCK(c) rb_mutex_lock((c)->mutex)
+#define CACHE_UNLOCK(c) rb_mutex_unlock((c)->mutex)
+#endif
+
+// almost the Murmur hash algorithm
+#define M 0x5bd1e995
+
+typedef struct _slot {
+    struct _slot     *next;
+    VALUE             val;
+    uint64_t          hash;
+    volatile uint32_t use_cnt;
+    uint8_t           klen;
+    char              key[CACHE_MAX_KEY];
+} *Slot;
+
+typedef struct _cache {
+    volatile Slot  *slots;
+    volatile size_t cnt;
+    VALUE (*form)(const char *str, size_t len);
+    uint64_t size;
+    uint64_t mask;
+    VALUE (*intern)(struct _cache *c, const char *key, size_t len);
+    volatile Slot reuse;
+    size_t        rcnt;
+#if defined(_WIN32)
+    CRITICAL_SECTION cs;
+#elif HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_t mutex;
+#else
+    VALUE mutex;
+#endif
+    uint8_t xrate;
+    bool    mark;
+} *Cache;
+
+void cache_set_form(Cache c, VALUE (*form)(const char *str, size_t len)) {
+    c->form = form;
+}
+
+static uint64_t hash_calc(const uint8_t *key, size_t len) {
+    const uint8_t *end     = key + len;
+    const uint8_t *endless = key + (len & 0xFFFFFFFC);
+    uint64_t       h       = (uint64_t)len;
+    uint64_t       k;
+
+    while (key < endless) {
+        k = (uint64_t)*key++;
+        k |= (uint64_t)*key++ << 8;
+        k |= (uint64_t)*key++ << 16;
+        k |= (uint64_t)*key++ << 24;
+
+        k *= M;
+        k ^= k >> 24;
+        h *= M;
+        h ^= k * M;
+    }
+    if (1 < end - key) {
+        uint16_t k16 = (uint16_t)*key++;
+
+        k16 |= (uint16_t)*key++ << 8;
+        h ^= k16 << 8;
+    }
+    if (key < end) {
+        h ^= *key;
+    }
+    h *= M;
+    h ^= h >> 13;
+    h *= M;
+    h ^= h >> 15;
+
+    return h;
+}
+
+static void rehash(Cache c) {
+    uint64_t osize;
+    Slot    *end;
+    Slot    *sp;
+
+    osize    = c->size;
+    c->size  = osize * 4;
+    c->mask  = c->size - 1;
+    c->slots = OJ_REALLOC((void *)c->slots, sizeof(Slot) * c->size);
+    memset((Slot *)c->slots + osize, 0, sizeof(Slot) * osize * 3);
+    end = (Slot *)c->slots + osize;
+    for (sp = (Slot *)c->slots; sp < end; sp++) {
+        Slot s    = *sp;
+        Slot next = NULL;
+
+        *sp = NULL;
+        for (; NULL != s; s = next) {
+            uint64_t h      = s->hash & c->mask;
+            Slot    *bucket = (Slot *)c->slots + h;
+
+            next    = s->next;
+            s->next = *bucket;
+            *bucket = s;
+        }
+    }
+}
+
+static VALUE lockless_intern(Cache c, const char *key, size_t len) {
+    uint64_t       h      = hash_calc((const uint8_t *)key, len);
+    Slot          *bucket = (Slot *)c->slots + (h & c->mask);
+    Slot           b;
+    volatile VALUE rkey;
+
+    while (REUSE_MAX < c->rcnt) {
+        if (NULL != (b = c->reuse)) {
+            c->reuse = b->next;
+            OJ_FREE(b);
+            c->rcnt--;
+        } else {
+            // An accounting error occured somewhere so correct it.
+            c->rcnt = 0;
+        }
+    }
+    for (b = *bucket; NULL != b; b = b->next) {
+        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+            b->use_cnt += 16;
+            return b->val;
+        }
+    }
+    rkey = c->form(key, len);
+    if (NULL == (b = c->reuse)) {
+        b = OJ_CALLOC(1, sizeof(struct _slot));
+    } else {
+        c->reuse = b->next;
+        c->rcnt--;
+    }
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 4;
+    b->next     = *bucket;
+    *bucket     = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
+    }
+    return rkey;
+}
+
+static VALUE locking_intern(Cache c, const char *key, size_t len) {
+    uint64_t       h;
+    Slot          *bucket;
+    Slot           b;
+    uint64_t       old_size;
+    volatile VALUE rkey;
+
+    CACHE_LOCK(c);
+    while (REUSE_MAX < c->rcnt) {
+        if (NULL != (b = c->reuse)) {
+            c->reuse = b->next;
+            OJ_FREE(b);
+            c->rcnt--;
+        } else {
+            // An accounting error occured somewhere so correct it.
+            c->rcnt = 0;
+        }
+    }
+    h      = hash_calc((const uint8_t *)key, len);
+    bucket = (Slot *)c->slots + (h & c->mask);
+    for (b = *bucket; NULL != b; b = b->next) {
+        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+            b->use_cnt += 4;
+            CACHE_UNLOCK(c);
+
+            return b->val;
+        }
+    }
+    old_size = c->size;
+    // The creation of a new value may trigger a GC which be a problem if the
+    // cache is locked so make sure it is unlocked for the key value creation.
+    if (NULL != (b = c->reuse)) {
+        c->reuse = b->next;
+        c->rcnt--;
+    }
+    CACHE_UNLOCK(c);
+    if (NULL == b) {
+        b = OJ_CALLOC(1, sizeof(struct _slot));
+    }
+    rkey    = c->form(key, len);
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 16;
+
+    // Lock again to add the new entry.
+    CACHE_LOCK(c);
+    if (old_size != c->size) {
+        h      = hash_calc((const uint8_t *)key, len);
+        bucket = (Slot *)c->slots + (h & c->mask);
+    }
+    b->next = *bucket;
+    *bucket = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
+    }
+    CACHE_UNLOCK(c);
+
+    return rkey;
+}
+
+Cache cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking) {
+    Cache c     = OJ_CALLOC(1, sizeof(struct _cache));
+    int   shift = 0;
+
+    for (; REHASH_LIMIT < size; size /= 2, shift++) {
+    }
+    if (shift < MIN_SHIFT) {
+        shift = MIN_SHIFT;
+    }
+#if defined(_WIN32)
+    InitializeCriticalSection(&c->cs);
+#elif HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_init(&c->mutex, NULL);
+#else
+    c->mutex = rb_mutex_new();
+#endif
+    c->size  = 1 << shift;
+    c->mask  = c->size - 1;
+    c->slots = OJ_CALLOC(c->size, sizeof(Slot));
+    c->form  = form;
+    c->xrate = 1;  // low
+    c->mark  = mark;
+    if (locking) {
+        c->intern = locking_intern;
+    } else {
+        c->intern = lockless_intern;
+    }
+    return c;
+}
+
+void cache_set_expunge_rate(Cache c, int rate) {
+    c->xrate = (uint8_t)rate;
+}
+
+void cache_free(void *data) {
+    Cache    c = (Cache)data;
+    uint64_t i;
+
+    for (i = 0; i < c->size; i++) {
+        Slot next;
+        Slot s;
+
+        for (s = c->slots[i]; NULL != s; s = next) {
+            next = s->next;
+            OJ_FREE(s);
+        }
+    }
+    OJ_FREE((void *)c->slots);
+#if defined(_WIN32)
+    DeleteCriticalSection(&c->cs);
+#endif
+    OJ_FREE(c);
+}
+
+void cache_mark(void *data) {
+    Cache    c = (Cache)data;
+    uint64_t i;
+
+#if !HAVE_PTHREAD_MUTEX_INIT && !defined(_WIN32)
+    rb_gc_mark(c->mutex);
+#endif
+    if (0 == c->cnt) {
+        return;
+    }
+    for (i = 0; i < c->size; i++) {
+        Slot s;
+        Slot prev = NULL;
+        Slot next;
+
+        for (s = c->slots[i]; NULL != s; s = next) {
+            next = s->next;
+            if (0 == s->use_cnt) {
+                if (NULL == prev) {
+                    c->slots[i] = next;
+                } else {
+                    prev->next = next;
+                }
+                c->cnt--;
+                s->next  = c->reuse;
+                c->reuse = s;
+                c->rcnt++;
+                continue;
+            }
+            switch (c->xrate) {
+            case 0: break;
+            case 2: s->use_cnt -= 2; break;
+            case 3: s->use_cnt /= 2; break;
+            default: s->use_cnt--; break;
+            }
+            if (c->mark) {
+                rb_gc_mark(s->val);
+            }
+            prev = s;
+        }
+    }
+}
+
+VALUE
+cache_intern(Cache c, const char *key, size_t len) {
+    if (CACHE_MAX_KEY <= len) {
+        return c->form(key, len);
+    }
+    return c->intern(c, key, len);
+}

data/ext/oj_windows/cache.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2021 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef CACHE_H
+#define CACHE_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#define CACHE_MAX_KEY 35
+
+struct _cache;
+typedef struct _cache *Cache;
+
+extern struct _cache *cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
+extern void           cache_free(void *data);
+extern void           cache_mark(void *data);
+extern void           cache_set_form(struct _cache *c, VALUE (*form)(const char *str, size_t len));
+extern VALUE          cache_intern(struct _cache *c, const char *key, size_t len);
+extern void           cache_set_expunge_rate(struct _cache *c, int rate);
+
+#endif /* CACHE_H */