lean_struct 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c69420c8618e8f1c8790b3923ec0fbc4d48d1ccb31f79e9698f6d42a11956c84
+  data.tar.gz: 82c6ef9e2c793451238f9d5b18ddda1585133df61dc08cf192596e351c51e504
+SHA512:
+  metadata.gz: 1d01b4790df22732776874ef6a11a752193322e5e4b534467f84e1a56eb15176e5a5d61c7a20612076f7ac9c769804b08c53db4ddeedc3ad389289fc025ad14c
+  data.tar.gz: d1aa29de2d9d1c397319a264498e361dda9029130369bef2d1cb8d8f0f8b034be332bb34d35a26bc0b8e5dd451bbcfd13b066f516d3cdc53819a64cffc953737

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-30
+
+- Initial release: `LeanStruct.define` DSL with `attribute` / `attribute?`, `nullable:`, nested structs,
+  arrays of nested structs, `class_name:`, `sensitive:`, `LeanStruct::Bool`, immutable instances, recursive `to_h` / `to_hash`.
+- Errors for non-Hash input show only the input's class, not its value.
+
+[Unreleased]: https://github.com/Ripchanskiy/lean_struct/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/Ripchanskiy/lean_struct/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Serhii Ripchanskyi
+
+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,271 @@
+# LeanStruct
+
+Immutable, type-checked `Struct` classes with a tiny DSL and **zero runtime dependencies**.
+
+LeanStruct covers the part of [Dry::Struct](https://dry-rb.org/gems/dry-struct/) most apps use for
+simple entities: strict type checks, optional and nullable attributes, nested structs, arrays of
+nested structs and a recursive `to_h`. The result is a plain Ruby `Struct`, roughly 2–3× faster than
+Dry::Struct (see [Performance](#performance)).
+
+```ruby
+User = LeanStruct.define do
+  attribute :id, Integer
+  attribute :name, String, nullable: true    # key required, value may be nil
+  attribute? :email, String                  # key may be omitted
+  attribute :active, LeanStruct::Bool
+  attribute :address do                      # nested struct => User::Address
+    attribute :city, String
+  end
+  attribute :roles, Array do                 # array of nested structs => User::Roles
+    attribute :code, String
+  end
+end
+
+user = User.new(id: 1, name: nil, active: true, address: { city: "Kyiv" }, roles: [{ code: "admin" }])
+user.address.city # => "Kyiv"
+user.to_h
+# => { id: 1, name: nil, active: true, address: { city: "Kyiv" }, roles: [{ code: "admin" }] }
+
+User.new(id: "1", name: nil, active: true, address: { city: "Kyiv" }, roles: [])
+# => LeanStruct::Error: [User.new] "1" (String) has invalid type for :id
+```
+
+## Installation
+
+```ruby
+# Gemfile
+gem "lean_struct"
+```
+
+Requires Ruby 3.1+.
+
+## Usage
+
+### Defining attributes
+
+| DSL                                          | key        | `nil`     |
+|----------------------------------------------|------------|-----------|
+| `attribute :code, String`                    | required   | rejected  |
+| `attribute :code, String, nullable: true`    | required   | accepted  |
+| `attribute? :code, String`                   | may be omitted | rejected  |
+| `attribute? :code, String, nullable: true`   | may be omitted | accepted  |
+
+Any attribute also takes `sensitive: true` to hide its value in errors and `#inspect`
+(see [Sensitive attributes](#sensitive-attributes)).
+
+`attribute?` only allows the key to be **left out**. It does not allow `nil`. Use `nullable: true` for that.
+
+```ruby
+Tag = LeanStruct.define { attribute? :code, String }
+
+Tag.new({})          # => ok, to_h == {}
+Tag.new(code: "a")   # => ok
+Tag.new(code: nil)   # => LeanStruct::Error
+```
+
+### Types
+
+A type is anything that responds to `===`, checked as `type === value`. No coercion is done: `"1"` is not an `Integer`.
+Any class works: `String`, `Float`, `Symbol`, `Hash`, `Time`, your own classes.
+
+```ruby
+LeanStruct.define do
+  attribute :id, Integer                                      # class: value.is_a?(Integer)
+  attribute :active, LeanStruct::Bool                         # true or false only
+  attribute :age, 0..150                                      # Range
+  attribute :country, /\A[A-Z]{2}\z/                          # Regexp
+  attribute :even, ->(value) { value.is_a?(Integer) && value.even? } # lambda
+  attribute :tags, Array                                      # any Array, items are not checked
+end
+```
+
+### Nested structs
+
+A block defines a nested struct. The nested class is named after the attribute (`User::Address`),
+or after `class_name:` when given:
+
+```ruby
+Order = LeanStruct.define do
+  attribute :customer do
+    attribute :name, String
+  end
+  attribute :items, Array, class_name: "Item" do   # Array + block = array of nested structs
+    attribute :sku, String
+    attribute :quantity, Integer
+  end
+end
+
+order = Order.new(customer: { name: "Ann" }, items: [{ sku: "A-1", quantity: 2 }])
+order.items.first # => #<struct Order::Item sku="A-1", quantity=2>
+```
+
+- A nested value may be a `Hash` or an already built instance of the nested class.
+- `nil` for a nested attribute is treated as `{}`. This is valid only when every nested key is optional (`attribute?`).
+  Use `nullable: true` to keep `nil` as is.
+
+### Input rules
+
+- Keys must be **symbols**. `{ "id" => 1 }` fails with `:id is missing in Hash input`.
+- **Unknown keys are ignored.**
+- Both a hash and keyword arguments work: `User.new(hash)`, `User.new(**hash)`, `User.call(hash)`, `User[hash]`.
+- `User.new(user)` returns the same `user` object, so `.call` is safe in pipelines that may already hold an entity.
+
+### Reading
+
+Instances are regular `Struct`s: readers, `[]`, `==`, `members`, `to_a`, `each`, `deconstruct` and
+`deconstruct_keys` (pattern matching) all work.
+
+```ruby
+case user
+in { id: Integer => id, address: { city: } } then [id, city]
+end
+```
+
+`to_h` (aliases `to_hash` and `attributes`) is recursive and returns keys in declaration order.
+**Keys omitted on input are left out**, so "not given" and "given as `nil`" stay distinguishable:
+
+```ruby
+Tag.new({}).to_h            # => {}
+{ **user }                  # works thanks to to_hash
+user.to_h { |k, v| [k.to_s, v] } # block form, like Hash#to_h
+```
+
+### Immutability
+
+Writers are removed: `user.id = 2` and `user[:id] = 2` raise `NoMethodError`.
+
+Immutability is shallow, as in Dry::Struct. Neither instances nor their values are frozen:
+
+- `user.tags << "admin"` changes the struct (so does `user.name << "x"`, if the string is not frozen);
+- a plain `Array` attribute keeps the caller's array, so changing it outside changes the struct too;
+- arrays of nested structs are built anew, but you can still append items to them.
+
+If you need deep immutability, freeze the input data before building the struct.
+
+### Errors
+
+Every validation failure raises `LeanStruct::Error`, a subclass of `ArgumentError`:
+
+```
+[User.new] :id is missing in Hash input
+[User.new] "1" (String) has invalid type for :id
+[User.new] Array has invalid type (Hash expected)
+[User::Address.new] 1 (Integer) has invalid type for :city
+```
+
+Messages include the `inspect` of the rejected value, which helps when an upstream API changes a type.
+Two exceptions keep data out of logs and error trackers:
+
+- When the input is not a Hash, only its class is shown, so `Config.new(ENV)` or a raw HTTP response never
+  ends up in the message.
+- Values of `sensitive: true` attributes are replaced with `[FILTERED]` (see below).
+
+### Sensitive attributes
+
+Mark secrets with `sensitive: true`, which is useful for configs built from ENV or YAML:
+
+```ruby
+Config = LeanStruct.define do
+  attribute :host, String
+  attribute :password, String, sensitive: true
+  attribute :api_key, /\A[a-f0-9]{32}\z/, sensitive: true
+end
+
+Config.new(host: "db", password: 123456, api_key: key)
+# => LeanStruct::Error: [Config.new] [FILTERED] (Integer) has invalid type for :password
+
+config = Config.new(host: "db", password: "s3cret", api_key: key)
+config.inspect   # => #<struct Config host="db", password=[FILTERED], api_key=[FILTERED]>
+config.password  # => "s3cret"
+config.to_h      # => { host: "db", password: "s3cret", api_key: "..." }
+```
+
+- The value is hidden in error messages, `#inspect`, `#to_s` and `pp`. The class is still shown in errors,
+  so you can see that YAML turned `123456` into an `Integer`.
+- `nil` is shown as is: "not set" is not a secret.
+- Readers and `#to_h` return real values: `to_h` is data, not a log line.
+- It applies to the attribute's own value. For a nested struct, mark the nested attributes themselves.
+- Structs without sensitive attributes keep the standard `Struct#inspect`.
+
+### Class API
+
+```ruby
+User.attribute_names       # => [:id, :name, :email, :active, :address, :roles]
+User.schema[:email]        # => #<struct LeanStruct::Field name=:email, type=String, nullable=false, omittable=true, ...>
+```
+
+## Comparison with Dry::Struct
+
+### DSL
+
+| Dry::Struct                                       | LeanStruct                                        |
+|---------------------------------------------------|---------------------------------------------------|
+| `class User < Dry::Struct`                        | `User = LeanStruct.define do ... end`             |
+| `attribute :id, Types::Integer`                   | `attribute :id, Integer`                          |
+| `attribute :name, Types::String.optional`         | `attribute :name, String, nullable: true`         |
+| `attribute? :code, Types::String`                 | `attribute? :code, String`                        |
+| `attribute? :code, Types::String.optional`        | `attribute? :code, String, nullable: true`        |
+| `attribute :active, Types::Bool`                  | `attribute :active, LeanStruct::Bool`             |
+| `attribute :address do ... end`                   | `attribute :address do ... end`                   |
+| `attribute :roles, Types::Array do ... end`       | `attribute :roles, Array do ... end`              |
+
+### Same behaviour
+
+Compared with Dry::Struct using the strict `Dry.Types()` types:
+
+| input                                           | result (both)                         |
+|-------------------------------------------------|---------------------------------------|
+| unknown key                                     | ignored                               |
+| string keys                                     | error: key is missing                 |
+| missing required key                            | error                                 |
+| omitted `attribute?`                            | ok, key left out of `to_h`            |
+| `nil` for a non-optional / non-nullable key     | error                                 |
+| `"1"` for an `Integer` attribute                | error, no coercion                    |
+| `nil` for a nested struct with only `attribute?` keys | `{}`                            |
+| non-array for an array attribute                | error                                 |
+| input is not a Hash                             | error                                 |
+| `Klass.new(instance)`                           | returns the same instance             |
+| `to_h` / `to_hash`                              | recursive hash                        |
+| writers                                         | none                                  |
+| `==`                                            | by value                              |
+
+### Differences
+
+| aspect                          | Dry::Struct                                          | LeanStruct                                  |
+|---------------------------------|------------------------------------------------------|---------------------------------------------|
+| base class                      | `Dry::Struct`                                        | Ruby `Struct`                               |
+| dependencies                    | dry-struct, dry-types, dry-core, dry-logic, dry-inflector, ... | none                              |
+| error class                     | `Dry::Struct::Error`                                 | `LeanStruct::Error < ArgumentError`         |
+| error message                   | `... has invalid type for :id violates constraints (type?(Integer, "1") failed)` | `... has invalid type for :id` |
+| secrets in errors / `#inspect`  | shown                                                | hidden with `sensitive: true`; non-Hash input shows only its class |
+| array item class name           | singularized: `roles` → `User::Role`                 | as the attribute: `User::Roles`, or `class_name:` |
+| `Struct` API (`to_a`, `each`, `members`) | no (`attribute_names`, `schema`)            | yes, plus `attribute_names` and `schema`   |
+| `entity.new(changes)` (copy with changes) | yes                                        | no                                          |
+| defaults, coercion, constraints, `transform_keys`, custom constructors | yes           | no                                          |
+| inheritance (`class Admin < User`) | yes                                               | no                                          |
+
+If you need coercion, defaults or composable types, use Dry::Struct. If your entities are
+"validate a hash from an API and serialize it back", LeanStruct does that with less overhead.
+
+### Performance
+
+Ruby 3.4.10, dry-struct 1.8.1, Apple Silicon, 50 000 iterations, median of 5 runs.
+*Flat*: 5 scalar attributes, one of them omitted. *Nested*: 3 nested structs, an array of 2 nested structs and a bool.
+
+| operation       | Dry::Struct, ms | LeanStruct, ms | LeanStruct faster by |
+|-----------------|----------------:|---------------:|---------------------:|
+| flat `.new`     | 135.2           | 59.1           | 2.3×                 |
+| flat `#to_h`    | 96.5            | 44.0           | 2.2×                 |
+| nested `.new`   | 511.1           | 274.0          | 1.9×                 |
+| nested `#to_h`  | 490.8           | 166.1          | 3.0×                 |
+
+## Development
+
+```sh
+bundle install
+bundle exec rake        # specs + rubocop
+```
+
+## License
+
+[MIT](LICENSE.txt)

data/lib/lean_struct/class_methods.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LeanStruct
+  # Prepended to the struct's singleton class, so it wraps Struct's own .new and .[]
+  module ClassMethods
+    attr_reader :schema
+
+    # Kept in one piece on purpose: hot path, no extra method calls per field
+    def new(attrs = EMPTY_HASH) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      return attrs if attrs.is_a?(self)
+
+      LeanStruct.not_hash!(self, attrs) unless attrs.is_a?(Hash)
+
+      omitted = 0 # bitmask of omitted keys: no allocation per instance
+      bit = 1
+      values = @fields.map do |field|
+        value = attrs.fetch(field.name, UNDEFINED)
+        if UNDEFINED.equal?(value)
+          LeanStruct.missing!(self, field) unless field.omittable
+          omitted |= bit
+          value = nil
+        elsif field.many || !(field.type === value) # rubocop:disable Style/CaseEquality
+          value = LeanStruct.cast(self, field, value)
+        end
+        bit <<= 1
+        value
+      end
+
+      instance = super(*values)
+      instance.instance_variable_set(:@__omitted__, omitted) unless omitted.zero?
+      instance
+    end
+
+    alias call new
+    alias [] new
+
+    def attribute_names
+      members
+    end
+  end
+end

data/lib/lean_struct/filtered_inspect.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LeanStruct
+  # Included only into structs that have sensitive: true attributes.
+  # Masks their values in #inspect, #to_s and pp (nil stays visible: "not set" is not a secret).
+  # #to_h and readers still return real values.
+  module FilteredInspect
+    def inspect
+      schema = self.class.schema
+      pairs = each_pair.map do |name, value|
+        "#{name}=#{LeanStruct.filter(schema[name], value)}"
+      end
+      ["#<struct", self.class.name, pairs.join(", ")].compact.join(" ").concat(">")
+    end
+
+    alias to_s inspect
+
+    def pretty_print(printer)
+      printer.text(inspect)
+    end
+  end
+end

data/lib/lean_struct/instance_methods.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LeanStruct
+  # Included (not prepended), so attribute readers with the same names still win
+  module InstanceMethods
+    # Recursive hash; keys omitted on input are left out
+    def to_h(&block) # rubocop:disable Metrics/MethodLength
+      omitted = @__omitted__
+      hash = {}
+      if omitted
+        bit = 1
+        each_pair do |name, value|
+          hash[name] = LeanStruct.dump(value) if omitted.nobits?(bit)
+          bit <<= 1
+        end
+      else
+        each_pair { |name, value| hash[name] = LeanStruct.dump(value) }
+      end
+      block ? hash.to_h(&block) : hash
+    end
+
+    alias to_hash to_h
+    alias attributes to_h
+  end
+end

data/lib/lean_struct/schema.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LeanStruct
+  # DSL evaluated inside LeanStruct.define
+  class Schema
+    def self.build(&)
+      schema = new
+      schema.instance_eval(&)
+      schema.fields
+    end
+
+    attr_reader :fields
+
+    def initialize
+      @fields = []
+    end
+
+    # attribute :id, Integer
+    # attribute :name, String, nullable: true
+    # attribute :address do ... end
+    # attribute :roles, Array, class_name: "Role" do ... end
+    # attribute :token, String, sensitive: true
+    def attribute(name, type = nil, nullable: false, omittable: false, class_name: nil, sensitive: false, &block) # rubocop:disable Metrics/ParameterLists
+      name = name.to_sym
+      validate!(name, type, block)
+      nested = LeanStruct.define(&block) if block
+      @fields << Field.new(name:, type: nested || type, nullable:, omittable:, class_name:, sensitive:,
+                           many: !nested.nil? && type == Array, nested: !nested.nil?)
+    end
+
+    # Same as #attribute, but the key may be omitted from input
+    def attribute?(name, type = nil, **opts, &)
+      attribute(name, type, **opts, omittable: true, &)
+    end
+
+    private
+
+    def validate!(name, type, block)
+      raise Error, "attribute :#{name} is already defined" if @fields.any? { |field| field.name == name }
+      raise Error, "attribute :#{name} requires a type or a block" if type.nil? && block.nil?
+    end
+  end
+end

data/lib/lean_struct/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LeanStruct
+  VERSION = "0.1.0"
+end

data/lib/lean_struct.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "lean_struct/version"
+require_relative "lean_struct/schema"
+require_relative "lean_struct/class_methods"
+require_relative "lean_struct/instance_methods"
+require_relative "lean_struct/filtered_inspect"
+
+# Builds immutable Struct classes with type checks on construction.
+#
+#   User = LeanStruct.define do
+#     attribute :id, Integer
+#     attribute :name, String, nullable: true   # key required, value may be nil
+#     attribute? :email, String                 # key may be omitted
+#     attribute :token, String, sensitive: true # value hidden in errors and #inspect
+#     attribute :address do                     # nested struct => User::Address
+#       attribute :city, String
+#     end
+#     attribute :roles, Array do                # array of nested structs => User::Roles
+#       attribute :code, String
+#     end
+#   end
+#
+#   User.new(id: 1, name: nil, address: { city: "Kyiv" }, roles: [])
+module LeanStruct
+  class Error < ArgumentError; end
+
+  # Type matcher for true/false (Ruby has no Boolean class)
+  module Bool
+    def self.===(value)
+      value.equal?(true) || value.equal?(false)
+    end
+  end
+
+  Field = Struct.new(:name, :type, :nullable, :omittable, :many, :nested, :class_name, :sensitive,
+                     keyword_init: true)
+
+  FILTERED = "[FILTERED]"
+  EMPTY_HASH = {}.freeze
+  UNDEFINED = Object.new.freeze
+  private_constant :UNDEFINED
+
+  class << self
+    def define(&block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      raise Error, "LeanStruct.define requires a block" unless block
+
+      fields = Schema.build(&block)
+      raise Error, "LeanStruct.define requires at least one attribute" if fields.empty?
+
+      klass = Struct.new(*fields.map(&:name), keyword_init: false)
+      klass.instance_variable_set(:@fields, fields.freeze)
+      klass.instance_variable_set(:@schema, fields.to_h { |field| [field.name, field] }.freeze)
+      name_nested(klass, fields)
+      make_immutable(klass, fields)
+      klass.singleton_class.prepend(ClassMethods)
+      klass.include(InstanceMethods)
+      klass.include(FilteredInspect) if fields.any?(&:sensitive)
+      klass
+    end
+
+    # @api private
+    def cast(klass, field, value)
+      return value if value.nil? && field.nullable
+      return cast_one(klass, field, value) unless field.many
+      return value.map { |item| cast_one(klass, field, item) } if value.is_a?(Array)
+
+      invalid!(klass, field, value)
+    end
+
+    # @api private
+    def dump(value)
+      case value
+      when Struct then value.to_h
+      when Array then value.map { |item| dump(item) }
+      else value
+      end
+    end
+
+    # @api private
+    def missing!(klass, field)
+      raise Error, "[#{klass}.new] :#{field.name} is missing in Hash input"
+    end
+
+    # @api private
+    def invalid!(klass, field, value)
+      raise Error, "[#{klass}.new] #{filter(field, value)} (#{value.class}) has invalid type for :#{field.name}"
+    end
+
+    # @api private
+    def filter(field, value)
+      field.sensitive && !value.nil? ? FILTERED : value.inspect
+    end
+
+    # @api private
+    # Only the class: the whole input (e.g. ENV) must never end up in the message
+    def not_hash!(klass, value)
+      raise Error, "[#{klass}.new] #{value.class} has invalid type (Hash expected)"
+    end
+
+    private
+
+    def cast_one(klass, field, value)
+      return value if field.type === value # rubocop:disable Style/CaseEquality
+      # nil nested input is treated as {} (valid when all nested keys are omittable)
+      return field.type.new(value || EMPTY_HASH) if field.nested && (value.nil? || value.is_a?(Hash))
+
+      invalid!(klass, field, value)
+    end
+
+    # User::Address, User::Roles, or the explicit class_name: option
+    def name_nested(klass, fields)
+      fields.select(&:nested).each do |field|
+        klass.const_set(field.class_name || camelize(field.name), field.type)
+      end
+    end
+
+    def camelize(name)
+      name.to_s.split("_").map(&:capitalize).join
+    end
+
+    def make_immutable(klass, fields)
+      klass.send(:undef_method, :[]=)
+      fields.each { |field| klass.send(:undef_method, :"#{field.name}=") }
+    end
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: lean_struct
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Serhii Ripchanskyi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: LeanStruct builds plain Ruby Struct classes with type checks, optional
+  and nullable attributes, nested structs and recursive to_h. A lightweight, dependency-free
+  alternative to Dry::Struct for simple entities.
+email:
+- sergeyripchanskiy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/lean_struct.rb
+- lib/lean_struct/class_methods.rb
+- lib/lean_struct/filtered_inspect.rb
+- lib/lean_struct/instance_methods.rb
+- lib/lean_struct/schema.rb
+- lib/lean_struct/version.rb
+homepage: https://github.com/Ripchanskiy/lean_struct
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/Ripchanskiy/lean_struct
+  changelog_uri: https://github.com/Ripchanskiy/lean_struct/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Ripchanskiy/lean_struct/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Immutable, type-checked Struct classes with a small DSL and zero dependencies.
+test_files: []