strict 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b15e13a3f628809ea9410898b170658979f5e4c5a69b03a1ef4dcccad35e947f
-  data.tar.gz: b37173fddebaa55c744c20230548a80832a38c86e6bb4879f39d54a105fb5ddb
+  metadata.gz: f7a4d9b33782e029a5bdaf97e300a83ccb21fc76629e92d9dbbf3d12c373eaa4
+  data.tar.gz: 715e362a7bb394c4f18d6eb46d828d5c5dbfe0090f85ed971a89369981254532
 SHA512:
-  metadata.gz: 25bb591ed6df44c60f6e2c01f977f4fcb881b022e62af11adbcd32e4d15dd83bfbfd34a1f20139aa64b0de0e8447e8cdc9e73d6ff5ac5331ea1ef9cab81f1f7e
-  data.tar.gz: 46ddcaa771d227162e762d6bb424382c0efc3451d540340ad70a888842669ad8fb5969af11302d49ff5c5f5334852d44201be20253c399156373d9fd5d4c7ae8
+  metadata.gz: 696e79a02adafa97c27575b5b3ac787aeb4923d07753d3149efbdf283a5357a0c74ccea46367cd6d0d8d49996e45e668418c203652738aa2a0efcc5ec24dbdf0
+  data.tar.gz: 751a0ebdc18322f456ebc834ec7a215dc28b0de66dc010be82bcb03a5cbfdfa4c160a66110d0b60e22c056cfe34d0827b2e13533ee580c1761987c570939a4be

data/.agents/resume

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+printf 'No services require resume steps.\n'

data/.agents/setup

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$repo_root"
+
+run_step() {
+  local description="$1"
+  shift
+  local started_at="$SECONDS"
+
+  printf '\n==> %s\n' "$description"
+  "$@"
+  printf '<== Finished in %ss\n' "$((SECONDS - started_at))"
+}
+
+install_system_packages() {
+  local packages=(
+    autoconf
+    bison
+    build-essential
+    ca-certificates
+    curl
+    libdb-dev
+    libffi-dev
+    libgdbm-compat-dev
+    libgdbm-dev
+    libncurses-dev
+    libreadline-dev
+    libssl-dev
+    libyaml-dev
+    patch
+    uuid-dev
+    zlib1g-dev
+  )
+  local missing_packages=()
+  local package
+
+  for package in "${packages[@]}"; do
+    if ! dpkg-query -W -f='${Status}' "$package" 2>/dev/null | grep -Fq 'install ok installed'; then
+      missing_packages+=("$package")
+    fi
+  done
+
+  if ((${#missing_packages[@]} == 0)); then
+    printf 'All system packages are already installed.\n'
+    return
+  fi
+
+  local apt=(apt-get)
+  if ((EUID != 0)); then
+    apt=(sudo apt-get)
+  fi
+
+  "${apt[@]}" update
+  DEBIAN_FRONTEND=noninteractive "${apt[@]}" install -y "${missing_packages[@]}"
+}
+
+install_mise() {
+  if [[ -x "$HOME/.local/bin/mise" ]]; then
+    printf 'mise is already installed.\n'
+    return
+  fi
+
+  curl --fail --location --silent --show-error https://mise.run | sh
+}
+
+configure_login_shell() {
+  local profile="$HOME/.bash_profile"
+  local marker='# strict mise toolchain'
+
+  touch "$profile"
+  if grep -Fqx "$marker" "$profile"; then
+    printf 'The login-shell toolchain path is already configured.\n'
+    return
+  fi
+
+  cat >> "$profile" <<'EOF'
+
+# strict mise toolchain
+case ":$PATH:" in
+  *":$HOME/.local/bin:"*) ;;
+  *) export PATH="$HOME/.local/bin:$PATH" ;;
+esac
+case ":$PATH:" in
+  *":$HOME/.local/share/mise/shims:"*) ;;
+  *) export PATH="$HOME/.local/share/mise/shims:$PATH" ;;
+esac
+EOF
+}
+
+run_step 'Install system packages' install_system_packages
+run_step 'Install mise' install_mise
+
+export PATH="$HOME/.local/bin:$PATH"
+
+run_step 'Configure login-shell toolchain access' configure_login_shell
+run_step 'Install the pinned Ruby toolchain' mise install
+
+bundler_version="$(awk '/^BUNDLED WITH$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/, ""); print}' Gemfile.lock)"
+if ! mise exec -- ruby -e 'exit Gem::Specification.find_all_by_name("bundler", ARGV.fetch(0)).empty? ? 1 : 0' "$bundler_version"; then
+  run_step "Install Bundler $bundler_version" mise exec -- gem install bundler --version "$bundler_version" --no-document
+fi
+
+run_step 'Install gem dependencies' mise exec -- ./bin/setup

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format progress

data/.rubocop.yml

@@ -1,10 +1,11 @@
-require:
-  - rubocop-minitest
+plugins:
+  - rubocop-factory_bot
   - rubocop-rake
+  - rubocop-rspec
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0.0
+  TargetRubyVersion: 3.3
 
 Style/CaseEquality:
   Enabled: false
@@ -15,7 +16,16 @@ Style/Documentation:
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
+Style/SymbolProc:
+  Enabled: false
+
 Metrics/BlockLength:
    Exclude:
-    - "test/**/*"
+    - "spec/**/*"
     - "*.gemspec"
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false

data/.tool-versions

@@ -1 +1 @@
-ruby 3.0.0
+ruby 3.3.12

data/API.md

@@ -0,0 +1,335 @@
+# Supported API
+
+This document defines the compatibility boundary for Strict 2.0. Code inside this boundary is public API. Other reachable Ruby constants, methods, generated modules, and reflection details are implementation details unless this document identifies them as public.
+
+## Capabilities
+
+Bring each Strict capability into a class with `include`:
+
+```ruby
+include Strict::Value
+include Strict::Object
+include Strict::Method
+include Strict::Interface
+include Strict::Union
+```
+
+The former `extend Strict::Method` and `extend Strict::Interface` forms are not part of this major-version API.
+
+### Values and objects
+
+`Strict::Value` and `Strict::Object` add an `attributes` declaration block. Each declaration accepts an attribute name, an optional validator, `coerce:`, and one of `default:`, `default_value:`, or `default_generator:`.
+
+Attribute names must be strings or symbols in the supported identifier shape: a lowercase ASCII letter or underscore, followed by ASCII letters, digits, or underscores, with one optional trailing `?` or `!`. Use `strict_attribute` when a name is a Ruby reserved word or already resolves to a method inside the declaration block, for example `strict_attribute :if` or `strict_attribute :format`. Empty names, operators, setters, and other method-name forms are rejected. Generated accessors use the conventional backing instance variable formed by removing a trailing `?` or `!` from the attribute name, so `active?` uses `@active`. Class behavior can read this declared state directly; writing it directly bypasses validation and is unsupported. A mutable object's punctuation writer can be called with `public_send`, for example `object.public_send(:"active?=", false)`.
+
+Both capabilities provide:
+
+- keyword initialization that rejects missing, additional, or invalid attributes;
+- declared readers;
+- coercion before validation;
+- `to_h`, with symbol keys in declaration order;
+- a meaningful `inspect` and pretty-print representation, without a fixed formatting contract;
+- class methods `strict_attributes` and `coercer`.
+
+`Strict::Object` also provides validated writers. It retains Ruby's identity equality and does not provide `with`.
+
+`Strict::Value` does not provide writers. It provides:
+
+- `with(**attributes)`, which returns a validated instance of the same class;
+- `deconstruct_keys(keys)`, for Ruby hash and class patterns;
+- `==` and `eql?`, based on exact class and attribute values;
+- `hash`, consistent with `eql?`.
+
+A class can execute at most one `attributes` block, and an empty block counts as that one block. A subclass inherits its parent's attributes and can execute one `attributes` block without changing the parent. A declaration with the exact name of an inherited attribute replaces its validator, coercer, and default in the subclass while retaining its position in the attribute order. A declaration cannot duplicate another declaration in the same block. Attribute names also cannot map to the same backing instance variable, such as `active`, `active?`, and `active!`, including across inherited declarations.
+
+Before it installs generated methods, Strict rejects an attribute whose reader would collide with a public, protected, or private instance method defined directly on the declaring class. It also rejects methods reserved by `BasicObject`, the active Strict capability, or Strict's generated implementation, including `class`, `to_h`, `inspect`, `hash`, `eql?`, `initialize`, `pretty_print`, and `public_send`. `Strict::Object` applies the same checks to its generated writer.
+
+An attribute can override an inherited public, protected, or private method from a superclass or a non-Strict included module. The generated reader or writer is public and replaces the inherited behavior; it does not wrap or validate calls to the inherited method. Strict does not police methods defined after the `attributes` block; later overrides remain unsupported. Same-block duplicate attributes, repeated blocks, prohibited generated-method collisions, and invalid names or declaration options raise `ArgumentError` at declaration time.
+
+#### Attribute introspection
+
+`strict_attributes` is an ordered `Enumerable`. Each yielded descriptor supports:
+
+- `name`
+- `validator`
+- `optional?`
+
+The descriptor's concrete class and other methods are implementation details.
+
+#### Defaults
+
+- `default: value` uses the value directly.
+- `default: callable` calls it for each default.
+- `default_value: value` preserves the value even when it is callable.
+- `default_generator: callable` calls it for each default and requires an object that responds to `call`.
+
+Only one default option can be present on one declaration.
+
+#### Attribute coercion
+
+`coerce:` accepts:
+
+- omission, which uses `validator.coercer` when available and otherwise disables coercion;
+- `false`, which disables coercion inherited from the validator;
+- a callable;
+- a class method name as a symbol;
+- `true`, which calls the class method `coerce_<attribute>`.
+
+Other coercer forms raise `ArgumentError` at declaration time. Strict does not require a class-method coercer selected by a symbol or `true` to exist when the attribute is declared. The receiving class resolves it during initialization or assignment, so a subclass can provide or override it.
+
+The generated class `coercer` returns `nil`, non-hash-like values, and instances of that exact class unchanged. A subclass instance is not an exact-class match: a parent class coercer treats it as hash-like input and creates a new parent instance from the parent's declared attributes. For other hash-like input, the coercer recognizes declared symbol or string keys and initializes the class with those values.
+
+### Discriminated unions
+
+`Strict::Union` defines a closed, discriminated union of generated value-object variants. A union must declare one discriminator before it declares variants:
+
+```ruby
+class PaymentResult
+  include Strict::Union
+
+  discriminator :status
+
+  attributes do
+    request_id String
+  end
+
+  variant :authorized, tag: "payment.authorized" do
+    attributes do
+      authorization_id String
+      amount_in_cents Integer
+    end
+
+    def successful? = true
+  end
+
+  variant :declined do
+    attributes do
+      reason String
+    end
+
+    def successful? = false
+  end
+end
+```
+
+There is no default discriminator. A union can declare zero or one `attributes` block before its variants. Strict shares these attributes across every variant. The declaration can appear before or after the discriminator, but it cannot redeclare the discriminator.
+
+A variant name must be a lower snake-case string or symbol, and Strict generates its PascalCase nested subclass. By default, the discriminator tag is the name's corresponding symbol. The optional `tag:` can assign a different string or symbol. For example, `variant :requires_action, tag: "action-required"` generates `PaymentResult::RequiresAction < PaymentResult` with the tag `"action-required"`.
+
+The variant block configures the generated subclass. It can include modules, define methods, and contain zero or one `attributes` block. Strict combines the discriminator, shared union attributes, and variant attributes in that order. The discriminator is an implicit first attribute with a fixed default value:
+
+```ruby
+PaymentResult::Authorized.new(
+  request_id: "request_123",
+  authorization_id: "auth_123",
+  amount_in_cents: 1_000
+).to_h
+# => { status: "payment.authorized", request_id: "request_123", authorization_id: "auth_123", amount_in_cents: 1_000 }
+```
+
+Variants therefore use the documented `Strict::Value` behavior for initialization, validation, coercion, defaults, copying, equality, hashing, conversion, inspection, pattern matching, and declaration errors. A variant attribute cannot duplicate or share a backing instance variable with the discriminator or a shared union attribute, and generated readers cannot collide with methods defined in the variant block. The union base cannot be instantiated directly.
+
+`PaymentResult === value` is true only when `value` has the exact class of a registered variant. Generated variant classes retain normal Ruby class matching, including matching instances of their subclasses. Union and variant inheritance are outside the compatibility boundary.
+
+The union class `coercer`:
+
+- returns `nil` and non-hash-like values unchanged;
+- returns an existing exact union member unchanged;
+- accepts the discriminator as a symbol or string key;
+- accepts a registered tag as its equivalent symbol or string value and stores its configured form;
+- dispatches hash-like input through the selected variant's value coercer;
+- raises `ArgumentError` when the discriminator is missing or unknown.
+
+A union class can be an attribute or method validator. Declarations use its coercer automatically, so they accept hash-like input unless coercion is disabled:
+
+```ruby
+payment_result PaymentResult
+strict_payment_result PaymentResult, coerce: false
+```
+
+Declaring a discriminator more than once, declaring equivalent duplicate string or symbol tags, using an invalid variant name or tag, replacing an existing generated constant, declaring multiple union or variant attribute blocks, declaring union attributes after a variant, or redeclaring the discriminator raises `ArgumentError`. Declaration return values, generated-class reflection details, and the exact text of declaration and coercion errors are outside the compatibility boundary.
+
+### Signed methods
+
+`Strict::Method` adds `sig`, which applies to the next instance or singleton method definition. A signature supports required and optional positional parameters, `*rest`, required and optional keyword parameters, `**keyrest`, and an optional `returns` declaration. Blocks pass through without validation.
+
+Parameter declaration names must be supported strings or symbols in the identifier shape documented for attributes and must match the signed Ruby method's parameters. `strict_parameter` supports Ruby reserved words that cannot be expressed as ordinary calls in the DSL. Parameter declarations accept a validator, `coerce: false` or a callable coercer, and the three default forms described above. Other coercer forms raise `ArgumentError` at declaration time.
+
+Strict verifies that signature names match the method definition. Calls coerce parameters, validate parameters, invoke the method, and validate its return value. `returns` is validate-only: the exact object produced by the method is the object returned to its caller. It does not accept `coerce:` or any other keyword and never transforms the returned value. A signature with no `returns` declaration accepts any return value.
+
+A signature cannot declare the same parameter more than once or contain more than one `returns` declaration. Invalid names, invalid defaults or coercers, duplicate parameters, repeated returns, and unsupported return options raise `ArgumentError` when the signature is declared. Exact error messages are not fixed.
+
+Inherited signed methods remain validated. A subclass override is unsigned unless the subclass provides a new signature.
+
+The following behavior is outside the compatibility boundary:
+
+- private or protected signed methods;
+- repeated signatures or same-class method redefinition;
+- DSL expression return values;
+- generated wrapper owners, ancestors, parameters, source locations, or other reflection details.
+
+### Interfaces
+
+`Strict::Interface` adds `expose`, `.coercer`, `.implemented_by?`, and `.verify_implementation!`. `expose(name) { ... }` defines a validated, keyword-forwarding instance method.
+
+Constructing an interface requires an implementation. The implementation must respond publicly to every exposed method and accept every keyword declared by that method. It can accept an interface keyword as a required or optional keyword, or through a keyword-rest parameter. Additional required positional or keyword parameters do not conform because they can reject a valid interface call. Additional optional positional or keyword parameters, positional-rest parameters, blocks, and ordinary implementation methods do not affect conformance.
+
+`Interface.implemented_by?(adapter)` returns `true` or `false` without constructing an interface. `Interface.verify_implementation!(adapter)` performs the same check, returns `nil` when the adapter conforms, and otherwise raises `Strict::ImplementationDoesNotConformError` with the structured details described below. Interface construction uses this same check.
+
+Interface instances expose their `implementation`. The class coercer:
+
+- returns `nil` unchanged;
+- returns an instance of that exact interface unchanged;
+- otherwise wraps the value and checks conformance.
+
+When an interface class is an attribute or parameter validator, declarations use this coercer automatically.
+
+Interface subclassing and re-exposing a method are outside the compatibility boundary.
+
+## RSpec integration
+
+Strict provides opt-in integration with RSpec 3.13. RSpec is not a runtime dependency and `require "strict"` does not
+load it. Applications that use the integration must add RSpec to their test bundle and load the adapter from their spec
+helper:
+
+```ruby
+require "strict/rspec"
+```
+
+Loading the adapter registers the `validate` and `conform_to` matchers and adds `strict_double` to RSpec example groups.
+
+### RSpec matchers
+
+`expect(validator).to validate(value)` applies the ordinary `===` validator protocol. For a
+`Strict::DetailedValidator`, it uses `violations(value)` and includes root or nested violation paths when the expectation
+fails. RSpec matcher objects and compatible instance doubles are accepted as test values. Exact failure-message wording
+and formatting are not fixed.
+
+`expect(implementation).to conform_to(interface)` uses `interface.verify_implementation!` to check the same conformance as
+constructing the interface. It does not invoke exposed methods. A failed expectation includes the conformance error's
+details, without a fixed wording or formatting contract.
+
+### RSpec doubles and matcher placeholders
+
+`strict_double(strict_class, stubs = {})` returns an RSpec instance verifying double. For a `Strict::Interface`, every
+exposed method is stubbed to return `nil` unless `stubs` provides another result. Calls through the interface still
+validate parameters and return values, so an omitted stub can cause `Strict::MethodReturnError` when `nil` is not a valid
+return. For other classes, only the supplied methods are stubbed. RSpec rejects stubs for methods that the doubled class
+does not expose.
+
+RSpec instance verifying doubles created by `strict_double` or `instance_double` satisfy a class or module validator
+when an instance of the doubled class would satisfy it. This applies to attributes, signed parameters, return values,
+and values nested inside `ArrayOf`, `HashOf`, or `AllOf`. Plain, non-verifying doubles do not bypass validation.
+
+RSpec matcher objects can stand in for validated test values at those same locations. When an expected `Strict::Value`
+is used in an RSpec argument expectation, RSpec recursively applies matcher objects in its attributes. The expected and
+actual values must have the same exact class. Loading the adapter does not change `Strict::Value#==`, `#eql?`, or `#hash`.
+
+`Strict::RSpec` is the public integration namespace. Its nested constants, singleton methods, generated RSpec matcher
+classes, RSpec proxy metadata, and reflection details are outside the compatibility boundary.
+
+## Validators and coercers
+
+Any object that implements `===` can be a validator. This includes classes, modules, literals, and custom validators. When a validator rejects a value, Strict reports that validator in one `:invalid` violation at the current path.
+
+Attribute and parameter declarations automatically use `validator.coercer` when the validator responds to `coercer`. An explicit `coerce:` value takes precedence, and `coerce: false` disables this automatic coercion.
+
+A custom validator can opt into nested structured failures by including `Strict::DetailedValidator` and implementing `violations(value)`. The method must return an array of `Strict::Violation` records and return an empty array when the value is valid. Each violation path is relative to the validated value; Strict prefixes paths when the validator is nested inside a declaration or a built-in detailed validator. `Strict::DetailedValidator` implements `===` from `violations`, so the custom validator does not need to implement both methods.
+
+```ruby
+class Emails
+  include Strict::DetailedValidator
+
+  def violations(value)
+    unless Array === value
+      return [Strict::Violation.new(path: [], code: :invalid, value: value, validator: Array)]
+    end
+
+    value.each_with_index.filter_map do |email, index|
+      next if String === email
+
+      Strict::Violation.new(path: [index], code: :invalid, value: email, validator: String)
+    end
+  end
+end
+```
+
+`Strict::Violation.new` accepts the four keyword arguments exposed by its readers: `path:`, `code:`, `value:`, and `validator:`. Validators that only implement `===` remain fully supported and do not need to include `Strict::DetailedValidator`.
+
+Attribute and method DSL blocks provide these validator constructors:
+
+- `AllOf(*validators)`
+- `AnyOf(*validators)`
+- `Anything()`
+- `ArrayOf(element_validator)`
+- `Boolean()`
+- `HashOf(key_validator => value_validator)`
+- `RangeOf(element_validator)`
+
+They also provide these coercer constructors:
+
+- `ToArray(with: nil)`
+- `ToHash(with_keys: nil, with_values: nil)`
+
+`ArrayOf` provides a coercer with the same array-like conversion as `ToArray` and uses its element validator's coercer when available. `HashOf` provides the corresponding `ToHash` behavior and uses its key and value validators' coercers when available. This coercion composes recursively, such as for `ArrayOf(ValueClass)` or `HashOf(String => ArrayOf(ValueClass))`.
+
+The other built-in validators do not provide coercers. Their conversions have no single safe default: logical validators cannot unambiguously select or order coercers, ranges have no supported conversion contract, and booleans have no canonical input conversion.
+
+The constructors' validation and conversion results are public. Their concrete `Strict::Validators::*` and `Strict::Coercers::*` classes, metadata readers, and exact string representations are not public API.
+
+## Configuration
+
+Strict provides:
+
+- `Strict.configuration`
+- `Strict.configure { |configuration| ... }`
+- `Strict.with_overrides(**options) { ... }`
+
+The supported configuration options are `random` and `sample_rate`, with readers and writers. `random` must implement `Random::Formatter`. `sample_rate` must be in the inclusive range from `0` through `1`.
+
+Overrides are local to the current execution context (fiber), can be nested, and are restored when a block returns or raises. Neither a newly created fiber nor a new thread inherits an active override. An active override cannot be changed with `Strict.configure`.
+
+Sampling controls validator calls. Attribute and parameter coercion, signature-definition checks, and interface conformance checks still run when validation is sampled out. Return validation can be sampled out, but return coercion never occurs.
+
+Direct construction of `Strict::Configuration`, its `validate?` and `to_h` methods, block return values, and configuration object identity are outside the compatibility boundary.
+
+## Exceptions
+
+These exception classes are public and inherit from `Strict::Error`:
+
+- `Strict::AssignmentError`
+- `Strict::InitializationError`
+- `Strict::ImplementationDoesNotConformError`
+- `Strict::MethodCallError`
+- `Strict::MethodDefinitionError`
+- `Strict::MethodReturnError`
+
+Messages identify the failure but their exact wording and formatting are not fixed. Exception constructor signatures are internal.
+
+Every `Strict::Error` provides `#violations`, which returns an array of `Strict::Violation` records. Assignment, initialization, method-call, and method-return errors report runtime validation and structural input failures. Other errors return an empty array.
+
+Each violation provides:
+
+- `path`: the location of the failure;
+- `code`: `:invalid`, `:missing`, or `:unexpected`;
+- `value`: the rejected or unexpected value, or `nil` for a missing value;
+- `validator`: the validator that rejected or required the value, or `nil` for an unexpected value.
+
+An attribute or parameter name is the first path segment. Array elements use zero-based indices, and hash entries use their actual keys. Unexpected positional arguments use their zero-based argument indices. Return values start at the root, so a simple invalid return has an empty path and a nested return starts with its collection segment. `ArrayOf`, `HashOf`, and `AllOf` preserve nested failure paths. Failure order is not fixed.
+
+The supported readers are:
+
+- `AssignmentError#value`
+- `InitializationError#remaining_attributes` and `#missing_attributes`
+- `ImplementationDoesNotConformError#interface`, `#receiver`, `#missing_methods`, and `#invalid_method_definitions`
+- `MethodCallError#remaining_args`, `#remaining_kwargs`, and `#missing_parameters`
+- `MethodDefinitionError#missing_parameters` and `#additional_parameters`
+- `MethodReturnError#value`
+
+Readers that expose attribute, parameter, or method descriptors are internal.
+
+## Constants and implementation details
+
+`Strict::VERSION`, `Strict::Violation`, and `Strict::DetailedValidator` are public. `Strict::ISSUE_TRACKER` is internal.
+
+`Strict::Attribute`, `Strict::Parameter`, `Strict::Return`, `strict_class_methods`, and `strict_instance_methods` are internal. The `Strict::Accessor`, `Strict::Reader`, `Strict::Attributes`, `Strict::Dsl`, `Strict::Interfaces`, `Strict::Methods`, and `Strict::Unions` namespaces and their contents are also internal.

data/CHANGELOG.md

@@ -1,5 +1,114 @@
 ## [Unreleased]
 
+## [2.0.0] - 2026-08-20
+
+### Added
+
+- Define and characterize the supported 2.0 API in `API.md`, provide RBS signatures for that boundary, validate them in the default checks, and add repeatable timing and allocation benchmark tooling.
+- Add closed discriminated unions whose generated variants use `Strict::Value` for attributes and value behavior.
+- Add inherited value and object attribute declarations and shared union attributes.
+- Add structured validation violations with paths, codes, rejected values, and validators for assignment, initialization, signed method calls, and returns, plus an optional detailed-validator protocol for custom nested failures.
+- Add opt-in RSpec matchers, verifying doubles, and nested matcher placeholders for Strict values and validations.
+- Add `implemented_by?` and `verify_implementation!` to check interface adapters without constructing an interface.
+
+### Breaking changes
+
+- Standardize all four capabilities on `include`: `Strict::Value`, `Strict::Object`, `Strict::Method`, and `Strict::Interface`. The legacy `extend Strict::Method` and `extend Strict::Interface` forms are outside the supported 2.0 API.
+- Make signed method returns validate-only. `returns` rejects coercion options, validates the original result, and preserves its identity for the caller.
+- Reject malformed or same-block duplicate attribute declarations, repeated attribute blocks, duplicate or repeated signatures, and same-class or Strict/core-reserved generated attribute method collisions with `ArgumentError` instead of silently replacing declarations or installing pathological methods.
+
+### Changed
+
+- Require Ruby 3.3 or newer and test against all maintained Ruby releases.
+- Update development dependencies to their latest release lines while retaining Zeitwerk 2.x compatibility from 2.6 onward.
+- Compile signed-method invocation metadata once, reuse unchanged call arguments, and consolidate generated wrappers by owner.
+- Preserve validated explicit keywords when keyrest processing changes a signed call.
+- Forward validated interface calls directly to implementations and compile interface-conformance expectations once per interface definition.
+- Check interface implementation signatures by substitutability: require every exposed keyword and reject only additional parameters that can constrain a valid interface call.
+- Reduce value and object hot-path allocations during initialization, `to_h`, equality, and hashing.
+- Share declaration invariants between attributes and parameters, preserve conventional attribute backing instance variables, and reject attribute names that map to the same storage.
+- Automatically use a validator's coercer for attributes and parameters unless the declaration overrides or disables coercion.
+- Propagate default coercion through `ArrayOf` elements and `HashOf` keys and values.
+- Keep Strict configuration overrides in isolated internal execution-context storage to avoid collisions with application keys.
+- Generate attribute readers and writers through one shared implementation, with mutable writers bound directly to their declarations.
+- Allow generated attribute readers and writers to override inherited public, protected, and private methods while continuing to reject same-class and Strict/core-reserved collisions.
+- Allow value and object subclasses to redefine inherited attributes without changing the parent or attribute order.
+- Return exact `Strict::Value` and `Strict::Object` instances unchanged from their class coercers while continuing to convert subclass instances.
+- Validate declaration names, explicit default generators, and capability-specific coercer forms before installing attributes or signatures.
+
+### Performance
+
+Representative microbenchmarks compared `90ba08a` (before) with `daa388d` (after) on Ruby 3.3.12, with YJIT disabled. Both revisions used the same pinned harness and public workloads. Results are the median of six interleaved process-run medians; each run used 50,000 warmup iterations, 200,000 measured iterations, and nine timing samples. Allocation counts were stable across all six runs.
+
+| Operation | `90ba08a` ns/op | `daa388d` ns/op | Change | Allocations/op |
+| --- | ---: | ---: | ---: | ---: |
+| Value initialization | 4,339 | 2,017 | -54% | 11 → 4 |
+| Mutable assignment | 456 | 431 | -5% | 0 → 0 |
+| Verified method call | 2,118 | 1,981 | -6% | 10 → 6 |
+| Interface construction | 5,054 | 1,145 | -77% | 19 → 4 |
+| Interface call | 3,230 | 2,340 | -28% | 16 → 8 |
+| `to_h` | 1,301 | 852 | -35% | 6 → 2 |
+| Equality | 2,786 | 1,433 | -49% | 12 → 3 |
+| Hashing | 1,847 | 926 | -50% | 6 → 2 |
+
+The equal-weight geometric mean of the eight after/before timing ratios is 0.57, or 43% lower. These microbenchmarks are environment-dependent measurements, not performance guarantees.
+
+## [1.5.0] - 2023-04-12
+
+### Added
+
+- Add global configuration through `Strict.configure` and nested, thread-local overrides through `Strict.with_overrides`.
+- Add configurable validation sampling for attributes, parameters, and return values through `sample_rate` and `random`.
+
+## [1.4.0] - 2022-11-02
+
+### Changed
+
+- Allow interface implementations to use `*args` and `**kwargs` for parameters they do not declare directly, while continuing to validate calls made through the interface.
+
+## [1.3.1] - 2022-10-20
+
+### Fixed
+
+- Support parameterless methods in `Strict::Interface` without generating invalid method syntax.
+
+## [1.3.0] - 2022-10-18
+
+### Added
+
+- Add `.coercer` to classes that extend `Strict::Interface` so they can validate and wrap implementations through the coercion protocol.
+
+## [1.2.0] - 2022-10-14
+
+### Changed
+
+- Support Ruby 3.0 and newer instead of requiring Ruby 3.1 or newer.
+
+## [1.1.0] - 2022-10-14
+
+### Added
+
+- Add `Strict::Interface` for defining validated interfaces and checking that implementations conform to their exposed methods.
+- Add coercers for `Strict::Value` and `Strict::Object` classes and for array and hash values.
+
+## [1.0.0] - 2022-10-12
+
+### Added
+
+- Publish the initial Strict release with immutable `Strict::Value` classes, mutable `Strict::Object` classes, and runtime method-call validation through `Strict::Method`.
+- Add the attribute and method-signature DSLs, built-in validators, coercion, structured errors, value equality and cloning, and object assignment validation.
+
 ## [0.0.0] - 2022-10-01
 
-- Initial release
+- Start initial development.
+
+[Unreleased]: https://github.com/kylekthompson/strict/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/kylekthompson/strict/compare/v1.5.0...v2.0.0
+[1.5.0]: https://github.com/kylekthompson/strict/compare/v1.4.0...v1.5.0
+[1.4.0]: https://github.com/kylekthompson/strict/compare/v1.3.1...v1.4.0
+[1.3.1]: https://github.com/kylekthompson/strict/compare/v1.3.0...v1.3.1
+[1.3.0]: https://github.com/kylekthompson/strict/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/kylekthompson/strict/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/kylekthompson/strict/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/kylekthompson/strict/releases/tag/v1.0.0
+[0.0.0]: https://github.com/kylekthompson/strict/commit/27fbe42e0d0d3c5ce86493e1252cf889f5a746d9

data/Gemfile

@@ -4,3 +4,16 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in strict.gemspec
 gemspec
+
+group :development do
+  gem "debug", "~> 1.11"
+  gem "factory_bot", "~> 6.5"
+  gem "gem-release", "~> 2.2"
+  gem "rake", "~> 13.4"
+  gem "rbs", "~> 4.1"
+  gem "rspec", "~> 3.13"
+  gem "rubocop", "~> 1.89"
+  gem "rubocop-factory_bot", "~> 2.28"
+  gem "rubocop-rake", "~> 0.7"
+  gem "rubocop-rspec", "~> 3.10"
+end