hegeltest 0.4.0-x86_64-linux → 0.4.1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 341eaae31f3446fb2282f5c0c1beca4d4589694894e3a28f69b4c76c0262f1dc
-  data.tar.gz: c384924a4c727e53820ba86169130758c06ab53ee6d3efd04b5b882294f13a53
+  metadata.gz: 5d19d55e56d1e7b4712b080b854b953b483c953f345c83261a79985d6b19266b
+  data.tar.gz: b4f55d6d50b7c99b4183efe89540b679c171f451e60d08a59e9b96c66b5dd22c
 SHA512:
-  metadata.gz: b55a89f13cb10ae1804daca37bf9e18e95a887acc609f11882859bd44a72c687d948994c7e79b05601b0594f688a62f41dc6e3e23f3ea6c8a4b9a6662c7eac57
-  data.tar.gz: d42ef433b5675fc0d21f9ae17f336445e65421352042b9162df886d95aded68aae70304f405e246c4560d8675c60554af5eaa929fabc8aec1c9614123a16137b
+  metadata.gz: a4a57120472ea15aacfe7c9bfb91efdb637ac031d17a9e5ce5f08b4d5c3373a31111602ebf99e933769a525e569420535478016b0c75bf89c261555f54ec68a4
+  data.tar.gz: 38d6ed2f6f7713918d935bd9fb181d174cf5c827ef0a424a95fe0a332ec2c67ed7bda0ddad92613375f9294c454e809a0d25cd640e6e7574b46a4067a5ff0685

data/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-10-29
+
+### Engine: libhegel 0.49.0 (was 0.48.0)
+
+The [libhegel 0.49.0 release notes](https://github.com/hegeldev/hegel/releases/tag/libhegel/0.49.0)
+describe 0.49.0.
+
+Each platform gem carries `libhegel` 0.49.0. The engine adds functions and
+constants to its C interface, and changes no function that these bindings
+call. A caller has nothing to change in code. The engine move changes these
+results for a caller:
+
+- The engine reads new environment variables over the settings profile:
+  `HEGEL_VERBOSITY`, `HEGEL_BACKEND`, `HEGEL_PHASES`, and
+  `HEGEL_SUPPRESS_HEALTH_CHECK`. Each one applies to a run that does not set
+  the matching `Hegel.test` keyword. `HEGEL_UNBOUNDED_CHOICES` sets a setting
+  that has no `Hegel.test` keyword. A malformed value makes `Hegel.test`
+  raise `Hegel::Error` with `HEGEL_E_INVALID_ARG` and a message that names
+  the variable. In 0.48.0, the engine ignored these variables. `HEGEL_REPORT_MULTIPLE_FAILURES` has no
+  effect, because `Hegel.test` always sets `report_multiple_failures`.
+- The engine reads a `max_size` of `2**64 - 2` as "no maximum given". The gem
+  now sends a `max_size` at or above `2**64 - 2` as `2**64 - 1`, no upper
+  bound, so `text`, `binary`, `arrays`, `sets`, `hashes`, and the other sized
+  generators keep the meaning the caller wrote. A `max_size` above
+  `2**64 - 1` also means no upper bound now. Before, it raised `RangeError`.
+  See [ADR 0037](docs/adr/0037-send-a-maximum-at-the-engine-default-sentinel-as-no-bound.md).
+
+### Changed
+
+- The string generators follow the Unicode version Ruby was built with,
+  `RbConfig::CONFIG["UNICODE_VERSION"]`, through libhegel's
+  `hegel_set_unicode_version`. A drawn character falls in the General
+  Category Ruby gives it, and `from_regex` reads `\w`, `\d`, and `\s` as
+  Ruby does. Before, they followed the engine's newest tables, Unicode 17.0.0.
+  On Ruby 3.4, which follows Unicode 15.0.0, a character assigned after 15.0.0
+  is now drawn as unassigned. See
+  [ADR 0036](docs/adr/0036-follow-rubys-unicode-version.md).
+
 ## [0.4.0] - 2026-10-21
 
 ### Engine: libhegel 0.48.0 (was 0.47.2)
@@ -454,6 +492,7 @@ The engine is called through the `ffi` gem. Each platform gem carries the
 matching `libhegel` 0.32.5 build. The platform-independent gem carries none,
 so a run on it needs `HEGEL_LIBHEGEL_PATH` pointing at a local build.
 
+[0.4.1]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.4.1
 [0.4.0]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.4.0
 [0.3.4]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.4
 [0.3.3]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.3

data/docs/README.md

@@ -42,6 +42,8 @@ An index of the design records for `hegel-ruby`.
 - [0033: Cache compiled grammars for the length of a run](adr/0033-cache-compiled-grammars-for-the-length-of-a-run.md)
 - [0034: Repeat a test body with a Ruby-side indent](adr/0034-repeat-a-test-body-with-a-ruby-side-indent.md)
 - [0035: Defer concurrent state machines and the engine printer](adr/0035-defer-concurrent-state-machines-and-the-engine-printer.md)
+- [0036: Follow Ruby's Unicode version](adr/0036-follow-rubys-unicode-version.md)
+- [0037: Send a maximum at the engine's default sentinel as no bound](adr/0037-send-a-maximum-at-the-engine-default-sentinel-as-no-bound.md)
 
 A new decision gets a new record. A changed decision supersedes the old
 record instead of editing it, so the history stays readable.

data/docs/adr/0036-follow-rubys-unicode-version.md

@@ -0,0 +1,50 @@
+# 0036: Follow Ruby's Unicode version
+
+## Status
+
+Accepted.
+
+## Context
+
+libhegel 0.48.0 adds `hegel_set_unicode_version`. It sets, for the whole
+process, the Unicode version that the text, regex, and grammar generators
+follow: the General Categories an alphabet is built from, and the `\w`,
+`\d`, `\s`, word boundaries, and case-insensitive matching of patterns. The
+engine has tables for Unicode 14.0.0 to 17.0.0. A binding that never calls it
+gets the newest.
+
+Ruby classifies characters by the Unicode version it was built with, which
+`RbConfig::CONFIG["UNICODE_VERSION"]` reports: 15.0.0 on Ruby 3.4. With the
+engine's 17.0.0 tables, `text(categories: ["Lu"])` can draw a character Ruby
+calls unassigned, and `from_regex` can draw a string Ruby's own `Regexp` reads
+differently. U+20C1 is one such character: a currency sign in 17.0.0, and
+unassigned in every earlier version.
+
+The Python frontend in hegeldev/hegel calls the function at import with
+`unicodedata.unidata_version`, for the same reason. The Rust frontend declares
+it in `frontends/rust/src/ffi/sys/fns.rs`; a search of `frontends/rust/src` at
+the `libhegel/0.48.0` tag finds that declaration as its one occurrence, so this
+gem follows the Python frontend here.
+
+## Decision
+
+`LibHegel::Real#initialize` passes `RbConfig::CONFIG["UNICODE_VERSION"]` to
+`hegel_set_unicode_version`, next to the engine version check, so that every
+generator built afterwards follows Ruby's tables. No keyword exposes it. ADR
+0015 leaves mechanism to each binding, and which host's tables the engine
+follows is mechanism: the interface stays the same, and a drawn value now
+means what Ruby takes it to mean.
+
+A version the engine has no tables for raises `Hegel::Error` when the engine
+is loaded. Ruby 3.4, the oldest Ruby this gem supports, reports 15.0.0, and
+the engine answers a version newer than its own with its newest tables, so
+no supported Ruby reaches that error.
+
+## Consequences
+
+On Ruby 3.4, characters assigned in Unicode 15.1.0 to 17.0.0 are drawn as
+unassigned (`Cn`) rather than in their new categories, as Ruby classifies
+them.
+
+The setting is process-wide, so a test that changes it puts back Ruby's
+version afterwards.

data/docs/adr/0037-send-a-maximum-at-the-engine-default-sentinel-as-no-bound.md

@@ -0,0 +1,48 @@
+# 0037: Send a maximum at the engine's default sentinel as no bound
+
+## Status
+
+Accepted.
+
+## Context
+
+libhegel 0.49.0 adds `HEGEL_MAX_SIZE_DEFAULT`, which is `UINT64_MAX - 1`.
+`hegel_new_collection`, `hegel_string_generator_text`, and
+`hegel_generate_bytes` read that `max_size` as "the caller gave no maximum",
+and apply the default of text and bytes: 100, or `min_size + 100` when
+`min_size` is above 100. `UINT64_MAX` continues to mean no upper bound. The
+engine changelog tells a frontend to pass `UINT64_MAX` for a user's explicit
+maximum at or above `HEGEL_MAX_SIZE_DEFAULT`.
+
+Before this change, the gem sent a caller's `max_size` to the engine as
+it is. Measured on linux-amd64 with Ruby 3.4.10 against 0.49.0, without this
+change, 300 cases of `binary(min_size: 200, max_size: 2**64 - 2)` had 200 to
+300 bytes: the engine applied `min_size + 100`. With this change, the same
+draw had 200 to 1465 bytes. A Ruby `Integer` has no upper limit, so a caller
+can also write a maximum above `UINT64_MAX`. Without this change,
+`binary(max_size: 2**70)` raised `RangeError` from the `ffi` gem (measured on
+the same setup).
+
+The Rust frontend declares the constant in
+`frontends/rust/src/ffi/sys/types.rs` at the `libhegel/0.49.0` tag. Its text
+generator, in `frontends/rust/src/generators/strings.rs`, continues to pass
+its own default of 100 (inferred from reading that file).
+
+## Decision
+
+`Hegel::LibHegel.max_size_arg` changes a `max_size` at or above
+`HEGEL_MAX_SIZE_DEFAULT` to `UINT64_MAX`. `Hegel::TestCase#new_collection`,
+`#with_text_generator`, and `#generate_bytes` apply it, so every generator
+that sizes a draw through the engine sends the caller's maximum this way.
+
+The gem continues to compute its own default maximum of text and bytes
+(`Hegel::Generators.default_max_size`) and to send it as a number. It does not
+send the sentinel. The default is the same number, and a reader of the
+generator then sees the default in Ruby.
+
+## Consequences
+
+A maximum at or above `2**64 - 2` means no upper bound. No allocation can
+reach a size of that order, so a caller who writes one gets the meaning
+they wrote. A maximum above `2**64 - 1` also means no upper bound now, where it
+raised `RangeError` before.

data/lib/hegel/lib_hegel/real.rb

@@ -89,6 +89,7 @@ module Hegel
           "hegel_settings_register_profile", [:pointer, StringStruct.by_value, :pointer], :int32
         )
         @hegel_set_default_profile_fn = bind("hegel_set_default_profile", [:pointer, StringStruct.by_value], :int32)
+        @hegel_set_unicode_version_fn = bind("hegel_set_unicode_version", [:pointer, StringStruct.by_value], :int32)
         @hegel_settings_set_test_cases_fn = bind(
           "hegel_settings_set_test_cases", [:pointer, :pointer, :uint64], :int32
         )
@@ -307,7 +308,7 @@ module Hegel
           "hegel_generate_grammar", [:pointer, :pointer, :pointer, :uint64, :pointer], :int32
         )
 
-        LibHegel.with_context(self) { |ctx| LibHegel.warn_on_version_mismatch(self, ctx, io: io) }
+        LibHegel.with_context(self) { |ctx| LibHegel.prepare(self, ctx, io: io) }
       end
 
       # hegel_context_new never returns NULL (guaranteed by the header), so
@@ -382,6 +383,14 @@ module Hegel
         nil
       end
 
+      # Sets the Unicode version for the whole process. "" selects the
+      # engine's newest tables.
+      def set_unicode_version(ctx, version)
+        code = @hegel_set_unicode_version_fn.call(ctx, string_view(version))
+        LibHegel.check!(self, ctx, code)
+        nil
+      end
+
       # No-op when +s+ is nil, matching hegel_settings_free's documented
       # no-op-on-NULL contract; not translated, for the same reason as
       # #context_free: the header documents this call as always returning
@@ -773,7 +782,9 @@ module Hegel
       end
 
       # Closes the most recently opened span. +discard+ true marks it
-      # rejected, so libhegel retries from before the span opened.
+      # rejected, so the shrinker can delete its draws. The engine does not
+      # draw again by itself: the caller does, as Hegel::Generator#filter
+      # does.
       def stop_span(ctx, tc, discard)
         code = @hegel_stop_span_fn.call(ctx, tc, discard)
         LibHegel.check!(self, ctx, code)

data/lib/hegel/lib_hegel.rb

@@ -110,6 +110,14 @@ module Hegel
     # value a 64-bit unsigned integer maxes out at.
     HEGEL_COLLECTION_MAX_SIZE_UNBOUNDED = (2**64) - 1
 
+    # HEGEL_MAX_SIZE_DEFAULT, named from hegel.h's #define of the same name,
+    # UINT64_MAX - 1. Since libhegel 0.49.0, hegel_new_collection,
+    # hegel_string_generator_text, and hegel_generate_bytes read this max_size
+    # as "no maximum given" and apply the default of text and bytes. The header
+    # tells a binding to pass UINT64_MAX for a caller's own maximum at or above
+    # it. See #max_size_arg.
+    HEGEL_MAX_SIZE_DEFAULT = (2**64) - 2
+
     # hegel_generate_float's smallest_nonzero_magnitude must be positive
     # and finite. The header names 5e-324 as the width-64 value that
     # places no restriction on which nonzero magnitudes get drawn.
@@ -121,7 +129,7 @@ module Hegel
     # responds to each name here.
     METHODS = %i[
       context_new context_free context_last_error version
-      settings_new settings_new_for_profile settings_register_profile set_default_profile
+      settings_new settings_new_for_profile settings_register_profile set_default_profile set_unicode_version
       settings_free settings_set_test_cases settings_set_verbosity
       settings_set_seed settings_set_derandomize settings_set_database
       run_start next_test_case run_free test_case_free mark_complete
@@ -212,6 +220,30 @@ module Hegel
       MESSAGE
     end
 
+    # What a freshly loaded engine needs before it builds a generator. Held
+    # here rather than in Real#initialize so the Fake can check it.
+    def prepare(impl, ctx, io: $stderr)
+      warn_on_version_mismatch(impl, ctx, io: io)
+      follow_host_unicode_version(impl, ctx)
+    end
+
+    # Sets the engine's Unicode version to the one Ruby's own Regexp and
+    # String methods follow, so a drawn character falls in the category Ruby
+    # puts it in (docs/adr/0036). The setting is process-wide and read when
+    # a generator is built, so it is made once, when the engine is loaded.
+    def follow_host_unicode_version(impl, ctx)
+      impl.set_unicode_version(ctx, RbConfig::CONFIG.fetch("UNICODE_VERSION"))
+    end
+
+    # The max_size to pass to the engine for a caller's own +max_size+. A
+    # maximum at or above HEGEL_MAX_SIZE_DEFAULT goes over as UINT64_MAX, no
+    # upper bound: otherwise the engine reads UINT64_MAX - 1 as its default of
+    # 100, and a larger value does not fit the u64 argument. No allocation can
+    # reach either size, so "no upper bound" keeps the caller's meaning.
+    def max_size_arg(max_size)
+      (max_size >= HEGEL_MAX_SIZE_DEFAULT) ? HEGEL_COLLECTION_MAX_SIZE_UNBOUNDED : max_size
+    end
+
     # A span label is an opaque u64 that names the generator which opened
     # the span. The engine treats two spans with one label as draws of one
     # generator, and swaps or reorders them when it shrinks. hegel.h defines

data/lib/hegel/libhegel_version.rb

@@ -5,5 +5,5 @@ module Hegel
   # Hegel::VERSION (the gem's own release): hegel-go and hegel-typescript keep
   # the two separate too, so bumping the pinned engine can land as its own
   # commit without also releasing a new gem version.
-  LIBHEGEL_VERSION = "0.48.0"
+  LIBHEGEL_VERSION = "0.49.0"
 end

data/lib/hegel/runner.rb

@@ -202,9 +202,9 @@ module Hegel
     # Pulls test cases from +run+ until hegel_next_test_case reports none
     # left (a nil out-parameter, not an error). Never counts iterations
     # itself: test_cases bounds generation, not how many times shrinking
-    # and rejected cases call the body. Measured against libhegel 0.48.0, a
+    # and rejected cases call the body. Measured against libhegel 0.49.0, a
     # run configured for 20 test cases whose body rejected nearly every case
-    # took 782 to 2047 iterations over 30 runs. +stats+ does its own, different counting
+    # took 806 to 2032 iterations over 30 runs. +stats+ does its own, different counting
     # -- see GenerationStats above.
     def drive(impl, ctx, run, grammars, stats, captures, &block)
       loop do

data/lib/hegel/test_case.rb

@@ -310,7 +310,7 @@ module Hegel
     # hegel_new_collection: Hegel::Generators::ArrayGenerator's own sizing
     # primitive, paired with #collection_more and #collection_free.
     def new_collection(min_size, max_size)
-      @impl.new_collection(@ctx, live_handle, min_size, max_size)
+      @impl.new_collection(@ctx, live_handle, min_size, LibHegel.max_size_arg(max_size))
     end
 
     # hegel_collection_more: whether to draw another element into
@@ -340,8 +340,9 @@ module Hegel
     # read the same way as #with_regex_generator/#with_email_generator/
     # #with_url_generator/#with_domain_generator below, each named for its
     # own hegel_string_generator_* call.
-    def with_text_generator(**kwargs, &block)
-      with_generator_handle(@impl.string_generator_text(@ctx, **kwargs), &block)
+    def with_text_generator(max_size:, **kwargs, &block)
+      handle = @impl.string_generator_text(@ctx, max_size: LibHegel.max_size_arg(max_size), **kwargs)
+      with_generator_handle(handle, &block)
     end
 
     # Runs the block with a regex-matching string generator handle built
@@ -381,7 +382,7 @@ module Hegel
     # hegel_generate_bytes. A future Hegel::Generators::BinaryGenerator's
     # own primitive, the bytes counterpart to #generate_string.
     def generate_bytes(min_size, max_size)
-      @impl.generate_bytes(@ctx, live_handle, min_size, max_size)
+      @impl.generate_bytes(@ctx, live_handle, min_size, LibHegel.max_size_arg(max_size))
     end
 
     # hegel_generate_ipv4, returning the address's 4 raw bytes. Converting

data/lib/hegel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hegel
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/sig/hegel.rbs

@@ -701,12 +701,16 @@ module Hegel
     HEGEL_HC_LARGE_INITIAL_TEST_CASE: Integer
     HEGEL_STATE_MACHINE_DONE: Integer
     HEGEL_COLLECTION_MAX_SIZE_UNBOUNDED: Integer
+    HEGEL_MAX_SIZE_DEFAULT: Integer
     HEGEL_FLOAT64_SMALLEST_NONZERO_MAGNITUDE_UNRESTRICTED: Float
     METHODS: Array[Symbol]
 
     def self.with_context: [R] (untyped impl) { (untyped) -> R } -> R
     def self.check!: (untyped impl, untyped ctx, Integer code) -> void
     def self.warn_on_version_mismatch: (untyped impl, untyped ctx, ?io: untyped) -> void
+    def self.prepare: (untyped impl, untyped ctx, ?io: untyped) -> nil
+    def self.follow_host_unicode_version: (untyped impl, untyped ctx) -> nil
+    def self.max_size_arg: (Integer max_size) -> Integer
     def self.label_from_name: (String name) -> Integer
     def self.label_combine: (Array[Integer] labels) -> Integer
     def self.encode_integer_le: (Integer n) -> String
@@ -722,6 +726,7 @@ module Hegel
       def settings_new_for_profile: (untyped ctx, String name) -> untyped
       def settings_register_profile: (untyped ctx, String name, untyped s) -> nil
       def set_default_profile: (untyped ctx, String name) -> nil
+      def set_unicode_version: (untyped ctx, String version) -> nil
       def settings_free: (untyped ctx, untyped s) -> nil
       def settings_set_test_cases: (untyped ctx, untyped s, Integer n) -> nil
       def settings_set_verbosity: (untyped ctx, untyped s, Integer v) -> nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hegeltest
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: x86_64-linux
 authors:
 - meganemura
@@ -82,6 +82,8 @@ files:
 - docs/adr/0033-cache-compiled-grammars-for-the-length-of-a-run.md
 - docs/adr/0034-repeat-a-test-body-with-a-ruby-side-indent.md
 - docs/adr/0035-defer-concurrent-state-machines-and-the-engine-printer.md
+- docs/adr/0036-follow-rubys-unicode-version.md
+- docs/adr/0037-send-a-maximum-at-the-engine-default-sentinel-as-no-bound.md
 - docs/architecture.md
 - lib/hegel.rb
 - lib/hegel/draw_name.rb