hegeltest 0.1.0

data/sig/hegel.rbs

@@ -0,0 +1,563 @@
+module Hegel
+  VERSION: String
+  LIBHEGEL_VERSION: String
+  FATAL_EXCEPTIONS: Array[singleton(Exception)]
+
+  class Error < StandardError
+  end
+
+  class StopTest < Exception
+  end
+
+  class AssumeFailed < Exception
+  end
+
+  def self.test: (?test_cases: Integer?, ?seed: Integer?, ?derandomize: bool?, ?verbosity: Symbol?, ?database: String?, ?database_key: String?, ?phases: Array[Symbol]?, ?suppress_health_check: Array[Symbol]?, ?report_multiple_failures: bool, ?stateful_step_count: Integer?, ?output: untyped, ?reproduce_failure: String?, ?impl: untyped) { (TestCase) -> void } -> nil
+  def self.default_impl: () -> untyped
+
+  class TestCase
+    DEFAULT_DRAW_NAME: String
+    DRAW_CALLER_DEPTH: Integer
+
+    def initialize: (untyped impl, untyped ctx, untyped handle, ?record: bool) -> void
+    def entries: () -> Array[[:draw, String, untyped] | [:note, untyped]]?
+    def draw_integer: (Integer min_value, Integer max_value, ?label: String?) -> Integer
+    def draw_boolean: (?Float p, ?label: String?) -> bool
+    def draw: (Generator generator, ?label: String?) -> untyped
+    def assume: (boolish condition) -> void
+    def reject: () -> bot
+    def note: (?untyped? message) ?{ () -> untyped } -> void
+    def generate_integer: (Integer min_value, Integer max_value) -> Integer
+    def generate_integer_big: (Integer min_value, Integer max_value) -> Integer
+    def generate_boolean: (?Float p) -> bool
+    def generate_float: (Integer width, Float min_value, Float max_value, allow_nan: bool, allow_infinity: bool, exclude_min: bool, exclude_max: bool, smallest_nonzero_magnitude: Float) -> Float
+    def target: (Numeric value, ?label: String) -> nil
+    def start_span: (Integer label) -> untyped
+    def stop_span: (?discard: bool) -> untyped
+    def new_collection: (Integer min_size, Integer max_size) -> untyped
+    def collection_more: (untyped collection) -> bool
+    def collection_reject: (untyped collection, ?why: String?) -> untyped
+    def collection_free: (untyped collection) -> untyped
+    def with_text_generator: [R] (min_size: Integer, max_size: Integer, ?codec: String?, ?min_codepoint: Integer, ?max_codepoint: Integer) { (untyped) -> R } -> R
+    def with_regex_generator: [R] (String pattern, fullmatch: bool) { (untyped) -> R } -> R
+    def with_email_generator: [R] () { (untyped) -> R } -> R
+    def with_url_generator: [R] () { (untyped) -> R } -> R
+    def with_domain_generator: [R] (max_length: Integer) { (untyped) -> R } -> R
+    def generate_string: (untyped generator) -> String
+    def generate_bytes: (Integer min_size, Integer max_size) -> String
+    def generate_ipv4: () -> String
+    def generate_ipv6: () -> String
+    def generate_uuid: (Integer version, bool has_version) -> String
+    def string_generator_regex: (String pattern, bool fullmatch, ?untyped alphabet) -> untyped
+    def string_generator_email: () -> untyped
+    def string_generator_url: () -> untyped
+    def string_generator_domain: (Integer max_length) -> untyped
+    def string_generator_free: (untyped generator) -> nil
+    def generate_date: (Array[Integer] min_value, Array[Integer] max_value) -> Array[Integer]
+    def generate_time: (Array[Integer] min_value, Array[Integer] max_value) -> Array[Integer]
+    def generate_datetime: (Array[Integer] min_date, Array[Integer] min_time, Array[Integer] max_date, Array[Integer] max_time) -> [Array[Integer], Array[Integer]]
+    def new_pool: () -> untyped
+    def pool_add: (untyped pool) -> Integer
+    def pool_generate: (untyped pool, bool consume) -> Integer
+    def pool_free: (untyped pool) -> nil
+    def free_pools: () -> void
+    def new_state_machine: (Array[String] rule_names, Array[String] invariant_names) -> untyped
+    def state_machine_next_rule: (untyped state_machine) -> Integer
+    def state_machine_rule_rejected: (untyped state_machine) -> nil
+    def state_machine_free: (untyped state_machine) -> nil
+  end
+
+  class Generator
+    def do_draw: (untyped tc) -> untyped
+    def map: () { (untyped) -> untyped } -> Generator
+    def filter: () { (untyped) -> boolish } -> Generator
+
+    class Mapped < Generator
+      def initialize: (Generator source, Proc block) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class Filtered < Generator
+      MAX_ATTEMPTS: Integer
+
+      def initialize: (Generator source, Proc block) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+  end
+
+  module Generators
+    class BooleanGenerator < Generator
+      def initialize: (p: Float) -> void
+      def do_draw: (untyped tc) -> bool
+    end
+
+    class IntegerGenerator < Generator
+      INT64_MIN: Integer
+      INT64_MAX: Integer
+
+      def initialize: (min_value: Integer?, max_value: Integer?) -> void
+      def do_draw: (untyped tc) -> Integer
+    end
+
+    class FloatGenerator < Generator
+      WIDTH: Integer
+
+      def initialize: (min_value: Float?, max_value: Float?, allow_nan: bool, allow_infinity: bool, exclude_min: bool, exclude_max: bool) -> void
+      def do_draw: (untyped tc) -> Float
+    end
+
+    class TextGenerator < Generator
+      def initialize: (min_size: Integer, max_size: Integer?, codec: String?, min_codepoint: Integer?, max_codepoint: Integer?) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class ArrayGenerator < Generator
+      def initialize: (Generator elements, min_size: Integer, max_size: Integer?) -> void
+      def do_draw: (untyped tc) -> Array[untyped]
+
+      private
+
+      def draw_elements: (untyped tc, Integer max_size) -> Array[untyped]
+      def draw_element: (untyped tc) -> untyped
+    end
+
+    class JustGenerator < Generator
+      def initialize: (untyped value) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class SampledFromGenerator < Generator
+      def initialize: (untyped collection) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class OneOfGenerator < Generator
+      def initialize: (Array[Generator] generators) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class OptionalGenerator < Generator
+      def initialize: (Generator generator) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class TupleGenerator < Generator
+      def initialize: (Array[Generator] generators) -> void
+      def do_draw: (untyped tc) -> Array[untyped]
+    end
+
+    class SetGenerator < Generator
+      def initialize: (Generator elements, min_size: Integer, max_size: Integer?) -> void
+      def do_draw: (untyped tc) -> Set[untyped]
+
+      private
+
+      def draw_elements: (untyped tc, Integer max_size) -> Set[untyped]
+      def draw_element: (untyped tc) -> untyped
+    end
+
+    class HashGenerator < Generator
+      def initialize: (Generator keys, Generator values, min_size: Integer, max_size: Integer?) -> void
+      def do_draw: (untyped tc) -> Hash[untyped, untyped]
+
+      private
+
+      def draw_entries: (untyped tc, Integer max_size) -> Hash[untyped, untyped]
+      def draw_entry: (untyped tc) -> [untyped, untyped]
+    end
+
+    class CharactersGenerator < Generator
+      def initialize: (codec: String?, min_codepoint: Integer?, max_codepoint: Integer?) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class BinaryGenerator < Generator
+      def initialize: (min_size: Integer, max_size: Integer?) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class FromRegexGenerator < Generator
+      def initialize: (untyped pattern, fullmatch: bool) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class EmailsGenerator < Generator
+      def do_draw: (untyped tc) -> String
+    end
+
+    class UrlsGenerator < Generator
+      def do_draw: (untyped tc) -> String
+    end
+
+    class DomainsGenerator < Generator
+      def initialize: (max_length: Integer) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class IpAddressesGenerator < Generator
+      def initialize: (v4: bool, v6: bool) -> void
+      def do_draw: (untyped tc) -> untyped
+
+      private
+
+      def draw_address: (untyped tc) -> untyped
+    end
+
+    class UuidsGenerator < Generator
+      def initialize: (version: Integer?) -> void
+      def do_draw: (untyped tc) -> String
+    end
+
+    class DatesGenerator < Generator
+      MIN_DATE: untyped
+      MAX_DATE: untyped
+
+      def initialize: (min_value: untyped, max_value: untyped) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    class TimesGenerator < Generator
+      MIDNIGHT: String
+      LAST_MICROSECOND: String
+      FORMAT: Regexp
+
+      def initialize: (min_value: String?, max_value: String?) -> void
+      def do_draw: (untyped tc) -> String
+
+      private
+
+      def parse: (untyped value, String name) -> Array[Integer]
+    end
+
+    class DatetimesGenerator < Generator
+      MIN_DATETIME: Time
+      MAX_DATETIME: Time
+
+      def initialize: (min_value: Time?, max_value: Time?) -> void
+      def do_draw: (untyped tc) -> Time
+    end
+
+    class CompositeGenerator < Generator
+      def initialize: () { (CompositeGenerator::BlockTestCase) -> untyped } -> void
+      def do_draw: (untyped tc) -> untyped
+
+      class BlockTestCase
+        def initialize: (untyped tc) -> void
+        def draw: (Generator generator) -> untyped
+        def draw_integer: (Integer min_value, Integer max_value) -> Integer
+        def draw_boolean: (?Float p) -> bool
+      end
+    end
+
+    class DeferredGenerator < Generator
+      def initialize: () -> void
+      def set: (Generator generator) -> void
+      def do_draw: (untyped tc) -> untyped
+    end
+
+    extend Syntax::Methods
+  end
+
+  class StateMachine
+    include Syntax::Methods
+
+    def self.rule: (Symbol | String name) { (TestCase) -> untyped } -> void
+    def self.invariant: (Symbol | String name) { (TestCase) -> untyped } -> void
+    def self.rule_definitions: () -> Hash[String, Proc]
+    def self.invariant_definitions: () -> Hash[String, Proc]
+  end
+
+  module Stateful
+    def self.run: (StateMachine machine, TestCase tc) -> void
+    def self.drive: (StateMachine machine, Hash[String, Proc] rules, Array[String] rule_names, Hash[String, Proc] invariants, untyped state_machine, TestCase tc) -> void
+    def self.apply_rule: (StateMachine machine, Proc block, Hash[String, Proc] invariants, untyped state_machine, TestCase tc) -> void
+    def self.run_invariants: (StateMachine machine, Hash[String, Proc] invariants, TestCase tc) -> void
+
+    class Pool
+      def initialize: (TestCase tc) -> void
+      def size: () -> Integer
+      def empty?: () -> bool
+      def add: (untyped value) -> Pool
+      def values_reusable: () -> ValuesReusable
+      def values_consumed: () -> ValuesConsumed
+
+      class ValuesReusable < Generator
+        def initialize: (untyped pool, Hash[Integer, untyped] values) -> void
+        def do_draw: (untyped tc) -> untyped
+      end
+
+      class ValuesConsumed < Generator
+        def initialize: (untyped pool, Hash[Integer, untyped] values) -> void
+        def do_draw: (untyped tc) -> untyped
+      end
+    end
+  end
+
+  module Syntax
+    module Methods
+      def booleans: (?p: Float) -> Generators::BooleanGenerator
+      def integers: (?min_value: Integer?, ?max_value: Integer?) -> Generators::IntegerGenerator
+      def floats: (?min_value: Float?, ?max_value: Float?, ?allow_nan: bool, ?allow_infinity: bool, ?exclude_min: bool, ?exclude_max: bool) -> Generators::FloatGenerator
+      def text: (?min_size: Integer, ?max_size: Integer?, ?codec: String?, ?min_codepoint: Integer?, ?max_codepoint: Integer?) -> Generators::TextGenerator
+      def arrays: (Generator elements, ?min_size: Integer, ?max_size: Integer?) -> Generators::ArrayGenerator
+      def just: (untyped value) -> Generators::JustGenerator
+      def sampled_from: (untyped collection) -> Generators::SampledFromGenerator
+      def one_of: (*Generator generators) -> Generators::OneOfGenerator
+      def optional: (Generator generator) -> Generators::OptionalGenerator
+      def tuples: (*Generator generators) -> Generators::TupleGenerator
+      def sets: (Generator elements, ?min_size: Integer, ?max_size: Integer?) -> Generators::SetGenerator
+      def hashes: (Generator keys, Generator values, ?min_size: Integer, ?max_size: Integer?) -> Generators::HashGenerator
+      def characters: (?codec: String?, ?min_codepoint: Integer?, ?max_codepoint: Integer?) -> Generators::CharactersGenerator
+      def binary: (?min_size: Integer, ?max_size: Integer?) -> Generators::BinaryGenerator
+      def from_regex: (untyped pattern, ?fullmatch: bool) -> Generators::FromRegexGenerator
+      def emails: () -> Generators::EmailsGenerator
+      def urls: () -> Generators::UrlsGenerator
+      def domains: (?max_length: Integer) -> Generators::DomainsGenerator
+      def ip_addresses: (?v4: bool, ?v6: bool) -> Generators::IpAddressesGenerator
+      def uuids: (?version: Integer?) -> Generators::UuidsGenerator
+      def dates: (?min_value: untyped, ?max_value: untyped) -> Generators::DatesGenerator
+      def times: (?min_value: String?, ?max_value: String?) -> Generators::TimesGenerator
+      def datetimes: (?min_value: Time?, ?max_value: Time?) -> Generators::DatetimesGenerator
+      def composite: () { (Generators::CompositeGenerator::BlockTestCase) -> untyped } -> Generators::CompositeGenerator
+      def deferred: () -> Generators::DeferredGenerator
+    end
+  end
+
+  module DrawName
+    ASSIGNMENT_NODE_TYPES: Array[untyped]
+
+    def self.for: (String path, Integer lineno) -> String?
+    def self.reset_cache: () -> void
+    def self.parse: (String path) -> untyped
+    def self.cache: () -> Hash[String, untyped]
+    def self.read_and_parse: (String path) -> untyped
+    def self.assignment_nodes: (untyped node, ?Array[untyped] matches) -> Array[untyped]
+    def self.covers?: (untyped location, Integer lineno) -> bool
+  end
+
+  module Report
+    class Failure
+      def initialize: (test_cases: Integer, discarded: Integer, entries: Array[[:draw, String, untyped] | [:note, untyped]], blob: String) -> void
+      def test_cases: () -> Integer
+      def discarded: () -> Integer
+      def entries: () -> Array[[:draw, String, untyped] | [:note, untyped]]
+      def blob: () -> String
+    end
+
+    def self.assign_names: (Array[[:draw, String, untyped] | [:note, untyped]] entries) -> Array[[:draw, String, untyped] | [:note, untyped]]
+    def self.render_failure: (Failure failure) -> String
+    def self.render: (Array[Failure] failures) -> String
+  end
+
+  module Settings
+    VERBOSITY_CODES: Hash[Symbol, Integer]
+    PHASE_CODES: Hash[Symbol, Integer]
+    HEALTH_CHECK_CODES: Hash[Symbol, Integer]
+
+    def self.apply: (untyped impl, untyped ctx, untyped settings, test_cases: Integer?, seed: Integer?, derandomize: bool?, verbosity: Symbol?, database: String?, database_key: String?, phases: Array[Symbol]?, suppress_health_check: Array[Symbol]?, report_multiple_failures: bool, stateful_step_count: Integer?) -> void
+    def self.apply_verbosity: (untyped impl, untyped ctx, untyped settings, Symbol verbosity) -> void
+    def self.apply_database: (untyped impl, untyped ctx, untyped settings, database: String?, database_key: String?) -> void
+    def self.apply_phases: (untyped impl, untyped ctx, untyped settings, Array[Symbol] phases) -> void
+    def self.apply_suppress_health_check: (untyped impl, untyped ctx, untyped settings, Array[Symbol] checks) -> void
+    def self.mask_for: (Array[Symbol] values, Hash[Symbol, Integer] codes) -> Integer
+  end
+
+  module Runner
+
+    UNKNOWN_ORIGIN: String
+    UNKNOWN_RUN_ERROR_MESSAGE: String
+    LIBRARY_DIR: String
+    INSTALLED_GEM_DIRS: Array[String]
+    STDLIB_DIR: String
+
+    class GenerationStats
+      def initialize: () -> void
+      def record: (Integer status, String? origin) -> void
+      def for: (String? origin) -> [Integer, Integer]
+    end
+
+    def self.run: (impl: untyped, ?test_cases: Integer?, ?seed: Integer?, ?derandomize: bool?, ?verbosity: Symbol?, ?database: String?, ?database_key: String?, ?phases: Array[Symbol]?, ?suppress_health_check: Array[Symbol]?, ?report_multiple_failures: bool, ?stateful_step_count: Integer?, ?output: untyped, ?reproduce_failure: String?) { (TestCase) -> void } -> nil
+    def self.run_and_finish: (untyped impl, untyped ctx, untyped settings, quiet: bool, output: untyped) { (TestCase) -> void } -> nil
+    def self.drive: (untyped impl, untyped ctx, untyped run, GenerationStats stats) { (TestCase) -> void } -> void
+    def self.with_test_case: [R] (untyped impl, untyped ctx, untyped tc, ?record: bool) { (TestCase) -> R } -> R
+    def self.run_case: (untyped impl, untyped ctx, untyped tc, GenerationStats stats) { (TestCase) -> void } -> void
+    def self.finish: (untyped impl, untyped ctx, untyped settings, untyped result, GenerationStats stats, quiet: bool, output: untyped) { (TestCase) -> void } -> nil
+    def self.replay: (untyped impl, untyped ctx, untyped settings, untyped result, GenerationStats stats, quiet: bool, output: untyped) { (TestCase) -> void } -> bot
+    def self.replay_failure: (untyped impl, untyped ctx, untyped settings, untyped failure, Integer index, GenerationStats stats) { (TestCase) -> void } -> [Exception, Report::Failure]
+    def self.reproduce: (untyped impl, untyped ctx, untyped settings, String blob, quiet: bool, output: untyped) { (TestCase) -> void } -> bot
+    def self.classify: (TestCase test_case) { (TestCase) -> void } -> [Integer, String?, Exception?, Array[[:draw, String, untyped] | [:note, untyped]]?]
+    def self.origin_for: (Exception exception) -> String
+    def self.infrastructure?: (String path) -> bool
+    def self.flaky_message: () -> String
+    def self.multiple_failures_message: (Integer count) -> String
+  end
+
+  module Locate
+    LIBRARY_PATH_ENV: String
+    ASSET_NAMES: Hash[String, String]
+    GEM_LIBHEGEL_DIR: String
+    DEFAULT_FINDER: ^(String, String) -> String?
+
+    def self.resolve: (?env: untyped, ?host_cpu: String, ?host_os: String, ?gem_dir: String, ?finder: ^(String, String) -> String?) -> String
+    def self.asset_name: (host_cpu: String, host_os: String) -> String
+    def self.from_env: (untyped, String, String) -> String?
+    def self.find_override: (String, String, String) -> String
+    def self.override_candidate_names: (String, String) -> Array[String]
+    def self.release_asset_name: (String, String) -> String?
+    def self.host_id: (String, String) -> String
+    def self.normalize_os: (String) -> String
+    def self.normalize_cpu: (String, String) -> String
+    def self.ext_of_os: (String) -> String
+    def self.unsupported_host_message: (String, String) -> String
+    def self.missing_bundle_message: (String, String) -> String
+    def self.missing_override_message: (String, Array[String]) -> String
+  end
+
+  module LibHegel
+    HEGEL_OK: Integer
+    HEGEL_E_STOP_TEST: Integer
+    HEGEL_E_ASSUME: Integer
+    HEGEL_E_BACKEND: Integer
+    HEGEL_E_INVALID_HANDLE: Integer
+    HEGEL_E_INVALID_ARG: Integer
+    HEGEL_E_ALREADY_COMPLETE: Integer
+    HEGEL_E_NOT_COMPLETE: Integer
+    HEGEL_E_INTERNAL: Integer
+    HEGEL_E_CONCURRENT_USE: Integer
+    CODE_NAMES: Hash[Integer, String]
+    HEGEL_STATUS_VALID: Integer
+    HEGEL_STATUS_INVALID: Integer
+    HEGEL_STATUS_OVERRUN: Integer
+    HEGEL_STATUS_INTERESTING: Integer
+    HEGEL_RUN_STATUS_PASSED: Integer
+    HEGEL_RUN_STATUS_FAILED: Integer
+    HEGEL_RUN_STATUS_ERROR: Integer
+    HEGEL_VERBOSITY_QUIET: Integer
+    HEGEL_VERBOSITY_NORMAL: Integer
+    HEGEL_VERBOSITY_VERBOSE: Integer
+    HEGEL_VERBOSITY_DEBUG: Integer
+    HEGEL_PHASE_EXPLICIT: Integer
+    HEGEL_PHASE_REUSE: Integer
+    HEGEL_PHASE_GENERATE: Integer
+    HEGEL_PHASE_TARGET: Integer
+    HEGEL_PHASE_SHRINK: Integer
+    HEGEL_PHASE_ALL: Integer
+    HEGEL_HC_FILTER_TOO_MUCH: Integer
+    HEGEL_HC_TOO_SLOW: Integer
+    HEGEL_HC_TEST_CASES_TOO_LARGE: Integer
+    HEGEL_HC_LARGE_INITIAL_TEST_CASE: Integer
+    HEGEL_LABEL_LIST: Integer
+    HEGEL_LABEL_LIST_ELEMENT: Integer
+    HEGEL_LABEL_SET: Integer
+    HEGEL_LABEL_SET_ELEMENT: Integer
+    HEGEL_LABEL_MAP: Integer
+    HEGEL_LABEL_MAP_ENTRY: Integer
+    HEGEL_LABEL_TUPLE: Integer
+    HEGEL_LABEL_ONE_OF: Integer
+    HEGEL_LABEL_OPTIONAL: Integer
+    HEGEL_LABEL_FIXED_DICT: Integer
+    HEGEL_LABEL_FLAT_MAP: Integer
+    HEGEL_LABEL_FILTER: Integer
+    HEGEL_LABEL_MAPPED: Integer
+    HEGEL_LABEL_SAMPLED_FROM: Integer
+    HEGEL_LABEL_ENUM_VARIANT: Integer
+    HEGEL_LABEL_FEATURE_FLAG: Integer
+    HEGEL_LABEL_REGEX: Integer
+    HEGEL_LABEL_EMAIL: Integer
+    HEGEL_LABEL_URL: Integer
+    HEGEL_LABEL_DOMAIN: Integer
+    HEGEL_LABEL_DATE: Integer
+    HEGEL_LABEL_TIME: Integer
+    HEGEL_LABEL_DATETIME: Integer
+    HEGEL_LABEL_UUID: Integer
+    HEGEL_LABEL_IP_ADDRESS: Integer
+    HEGEL_LABEL_INTEGER: Integer
+    HEGEL_LABEL_FLOAT: Integer
+    HEGEL_LABEL_BOOLEAN: Integer
+    HEGEL_LABEL_BYTES: Integer
+    HEGEL_LABEL_STRING: Integer
+    HEGEL_LABEL_STATEFUL_RULE: Integer
+    HEGEL_LABEL_FRESH_ID: Integer
+    HEGEL_LABEL_SET_CHOICE: Integer
+    HEGEL_STATE_MACHINE_DONE: Integer
+    HEGEL_COLLECTION_MAX_SIZE_UNBOUNDED: 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.encode_integer_le: (Integer n) -> String
+    def self.decode_integer_le: (String bytes) -> Integer
+
+    class Real
+      def initialize: (?String path, ?io: untyped) -> void
+      def context_new: () -> untyped
+      def context_free: (untyped ctx) -> nil
+      def context_last_error: (untyped ctx) -> String
+      def version: (untyped ctx) -> String
+      def settings_new: (untyped ctx) -> untyped
+      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
+      def settings_set_seed: (untyped ctx, untyped s, Integer seed, bool has_seed) -> nil
+      def settings_set_derandomize: (untyped ctx, untyped s, bool derandomize) -> nil
+      def settings_set_database: (untyped ctx, untyped s, String? database) -> nil
+      def settings_set_stateful_step_count: (untyped ctx, untyped s, Integer n) -> nil
+      def settings_set_report_multiple_failures: (untyped ctx, untyped s, bool yes) -> nil
+      def settings_set_database_key: (untyped ctx, untyped s, String? key) -> nil
+      def settings_set_phases: (untyped ctx, untyped s, Integer phases) -> nil
+      def settings_set_suppress_health_check: (untyped ctx, untyped s, Integer checks) -> nil
+      def run_start: (untyped ctx, untyped settings) -> untyped
+      def next_test_case: (untyped ctx, untyped run) -> untyped?
+      def run_free: (untyped ctx, untyped run) -> nil
+      def test_case_free: (untyped ctx, untyped tc) -> nil
+      def mark_complete: (untyped ctx, untyped tc, Integer status, String? origin) -> nil
+      def target: (untyped ctx, untyped tc, Float value, String label) -> nil
+      def generate_boolean: (untyped ctx, untyped tc, Float p, bool forced, bool has_forced) -> bool
+      def generate_integer: (untyped ctx, untyped tc, Integer min_value, Integer max_value) -> Integer
+      def generate_integer_big: (untyped ctx, untyped tc, Integer min_value, Integer max_value) -> Integer
+      def run_result: (untyped ctx, untyped run) -> untyped
+      def run_result_free: (untyped ctx, untyped r) -> nil
+      def run_result_status: (untyped ctx, untyped r) -> Integer
+      def run_result_error: (untyped ctx, untyped r) -> String?
+      def run_result_failure_count: (untyped ctx, untyped r) -> Integer
+      def run_result_failure: (untyped ctx, untyped r, Integer index) -> untyped
+      def failure_free: (untyped ctx, untyped f) -> nil
+      def failure_origin: (untyped ctx, untyped f) -> String
+      def failure_reproduction_blob: (untyped ctx, untyped f) -> String?
+      def test_case_from_blob: (untyped ctx, untyped settings, String blob) -> untyped
+      def start_span: (untyped ctx, untyped tc, Integer label) -> nil
+      def stop_span: (untyped ctx, untyped tc, bool discard) -> nil
+      def new_collection: (untyped ctx, untyped tc, Integer min_size, Integer max_size) -> untyped
+      def collection_more: (untyped ctx, untyped tc, untyped collection) -> bool
+      def collection_reject: (untyped ctx, untyped tc, untyped collection, ?String? why) -> nil
+      def collection_free: (untyped ctx, untyped collection) -> nil
+      def new_pool: (untyped ctx, untyped tc) -> untyped
+      def pool_add: (untyped ctx, untyped tc, untyped pool) -> Integer
+      def pool_generate: (untyped ctx, untyped tc, untyped pool, bool consume) -> Integer
+      def pool_free: (untyped ctx, untyped pool) -> nil
+      def new_state_machine: (untyped ctx, untyped tc, Array[String] rule_names, Array[String] invariant_names) -> untyped
+      def state_machine_next_rule: (untyped ctx, untyped tc, untyped state_machine) -> Integer
+      def state_machine_rule_rejected: (untyped ctx, untyped tc, untyped state_machine) -> nil
+      def state_machine_free: (untyped ctx, untyped state_machine) -> nil
+      def generate_float: (untyped ctx, untyped tc, Integer width, Float min_value, Float max_value, bool allow_nan, bool allow_infinity, bool exclude_min, bool exclude_max, Float smallest_nonzero_magnitude) -> Float
+      def string_generator_text: (untyped ctx, min_size: Integer, max_size: Integer, ?codec: String?, ?min_codepoint: Integer, ?max_codepoint: Integer) -> untyped
+      def string_generator_free: (untyped ctx, untyped generator) -> nil
+      def generate_string: (untyped ctx, untyped tc, untyped generator) -> String
+      def generate_string_result_free: (untyped ctx, untyped result) -> nil
+      def generate_bytes: (untyped ctx, untyped tc, Integer min_size, Integer max_size) -> String
+      def generate_bytes_result_free: (untyped ctx, untyped result) -> nil
+      def string_generator_regex: (untyped ctx, String pattern, bool fullmatch, ?untyped alphabet) -> untyped
+      def string_generator_email: (untyped ctx) -> untyped
+      def string_generator_url: (untyped ctx) -> untyped
+      def string_generator_domain: (untyped ctx, Integer max_length) -> untyped
+      def generate_ipv4: (untyped ctx, untyped tc) -> String
+      def generate_ipv6: (untyped ctx, untyped tc) -> String
+      def generate_uuid: (untyped ctx, untyped tc, Integer version, bool has_version) -> String
+      def generate_date: (untyped ctx, untyped tc, Array[Integer] min_value, Array[Integer] max_value) -> Array[Integer]
+      def generate_time: (untyped ctx, untyped tc, Array[Integer] min_value, Array[Integer] max_value) -> Array[Integer]
+      def generate_datetime: (untyped ctx, untyped tc, Array[Integer] min_date, Array[Integer] min_time, Array[Integer] max_date, Array[Integer] max_time) -> [Array[Integer], Array[Integer]]
+    end
+  end
+end

data/skills/hegel-ruby/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: hegel-ruby
+description: >
+  Write property-based tests using Hegel in Ruby projects, with RSpec,
+  Minitest, or any other test runner. Use this skill whenever the user asks
+  to write tests, add test coverage, or improve testing for Ruby functions,
+  modules, or classes. It applies especially when the code has properties
+  like round-trips, invariants, or contracts that hold across many inputs.
+  Also triggers on: "property-based tests", "PBT", "hegel", "generative tests",
+  "randomized testing", "test with random inputs", "shrinking", or when
+  existing tests use rantly, prop_check, rubycheck, pbt, or propr.
+---
+
+# Hegel: Property-Based Testing for Ruby
+
+This skill covers the Ruby API of Hegel, driven by the `hegeltest` gem (an
+unofficial, third-party binding to `libhegel`, unaffiliated with the
+`hegeldev` organization). It does not carry Hegel's methodology: how to find
+a property worth testing, how to keep a generator from being
+over-constrained, and the catalogue of property patterns. That methodology
+lives in the upstream
+[hegel-skill](https://github.com/hegeldev/hegel-skill), and applies to Ruby
+the same way it applies to Rust, Go, C++, TypeScript, Java, and OCaml. Load
+that skill first for the workflow and the property catalogue, then come back
+here for the Ruby-specific API.
+
+Before writing a Ruby property-based test, load
+`references/ruby/reference.md` for the exact API: `Hegel.test`, settings,
+`TestCase` methods, every generator and its options, stateful testing with
+`Hegel::StateMachine`, the combinator methods, and Ruby-specific gotchas.