philiprehberger-struct_kit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8b55b47cb37e7ebf99690da52df447bbd35570f3d025047fd37bb5be1f15cbb0
+  data.tar.gz: 03a1b60f04e75e455389020bbdf34d2ec028651fe7c14abeb0038a6c33937068
+SHA512:
+  metadata.gz: 8efe14b43443a8ce8fca842f2ae3ae70a8cb511c753319883fba1454c0fd45f8839945ebfebd282242291b51ea28148ef213756c8ca6cbb55e142c51d3ef7851
+  data.tar.gz: 668b1b75f73a814b437c6647019afbbbc78e566817de8f11a650a7cb8fa6ef7bab695e0417f0b0255dc7175cb2b1b118d6fdef9f507b971e67ea7f157408966d

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-21
+
+### Added
+- Initial release
+- DSL-based struct definition with `StructKit.define`
+- Typed fields with runtime type checking
+- Default values (static and lambda)
+- Value coercion via `coerce:` option
+- Validation rules (range, format, custom blocks)
+- Immutable instances (frozen by default)
+- `#to_h` and `.from_h` for hash serialization
+- `#merge` for creating modified copies
+- Pattern matching support via `deconstruct_keys`

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 philiprehberger
+
+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,151 @@
+# philiprehberger-struct_kit
+
+[![Tests](https://github.com/philiprehberger/rb-struct-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-struct-kit/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-struct_kit.svg)](https://rubygems.org/gems/philiprehberger-struct_kit)
+[![License](https://img.shields.io/github/license/philiprehberger/rb-struct-kit)](LICENSE)
+
+Enhanced struct builder with typed fields, defaults, validation, and pattern matching
+
+## Requirements
+
+- Ruby >= 3.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'philiprehberger-struct_kit'
+```
+
+Or install directly:
+
+```bash
+gem install philiprehberger-struct_kit
+```
+
+## Usage
+
+```ruby
+require 'philiprehberger/struct_kit'
+
+User = Philiprehberger::StructKit.define do
+  field :name, String
+  field :age, Integer, default: 0
+  field :role, Symbol, default: :user
+  validate :age, range: 0..150
+end
+
+user = User.new(name: 'Alice', age: 30)
+user.name   # => "Alice"
+user.age    # => 30
+user.role   # => :user
+```
+
+### Defaults
+
+```ruby
+Config = Philiprehberger::StructKit.define do
+  field :timeout, Integer, default: 30
+  field :tags, Array, default: -> { [] }
+end
+
+config = Config.new
+config.timeout  # => 30
+config.tags     # => []
+```
+
+### Type Coercion
+
+```ruby
+Record = Philiprehberger::StructKit.define do
+  field :count, Integer, default: 0, coerce: ->(v) { v.to_i }
+end
+
+record = Record.new(count: '42')
+record.count  # => 42
+```
+
+### Validation
+
+```ruby
+user = User.new(name: 'Alice', age: 200)
+user.valid?   # => false
+user.errors   # => ["age must be in range 0..150"]
+```
+
+### Immutability
+
+```ruby
+user = User.new(name: 'Alice')
+user.frozen?  # => true
+
+updated = user.merge(age: 31)  # returns new instance
+updated.age  # => 31
+user.age     # => 0 (unchanged)
+```
+
+### Hash Serialization
+
+```ruby
+user = User.new(name: 'Alice', age: 30)
+user.to_h  # => { name: "Alice", age: 30, role: :user }
+
+User.from_h({ name: 'Bob', age: 25 })
+```
+
+### Pattern Matching
+
+```ruby
+user = User.new(name: 'Alice', role: :admin)
+
+case user
+in { role: :admin }
+  puts 'Admin user'
+in { role: :user }
+  puts 'Regular user'
+end
+```
+
+## API
+
+### `Philiprehberger::StructKit`
+
+| Method | Description |
+|--------|-------------|
+| `.define { block }` | Define a new struct class with the DSL |
+
+### DSL (inside `define` block)
+
+| Method | Description |
+|--------|-------------|
+| `field :name, Type, default:, coerce:` | Define a typed field with optional default and coercion |
+| `validate :name, range:, format:` | Add validation rules to a field |
+
+### Instance Methods
+
+| Method | Description |
+|--------|-------------|
+| `#to_h` | Convert to a plain hash |
+| `#merge(**attrs)` | Return a new instance with merged attributes |
+| `#valid?` | Whether all validations pass |
+| `#errors` | Array of validation error messages |
+| `#deconstruct_keys(keys)` | Pattern matching support |
+
+### Class Methods
+
+| Method | Description |
+|--------|-------------|
+| `.from_h(hash)` | Construct from a hash (string or symbol keys) |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec      # Run tests
+bundle exec rubocop    # Check code style
+```
+
+## License
+
+MIT

data/lib/philiprehberger/struct_kit/definition.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'field'
+require_relative 'validation'
+
+module Philiprehberger
+  module StructKit
+    class Definition
+      def initialize
+        @fields = {}
+        @validations = {}
+      end
+
+      def field(name, type = nil, default: :__no_default__, coerce: nil)
+        @fields[name] = Field.new(name, type, default: default, coerce: coerce)
+      end
+
+      def validate(name, **rules, &block)
+        @validations[name] ||= []
+        @validations[name] << rules unless rules.empty?
+        @validations[name] << block if block
+      end
+
+      def build
+        fields = @fields
+        validations = @validations
+
+        validations.each do |name, rules|
+          next unless fields[name]
+
+          rules.each { |rule| fields[name].add_validation(rule) }
+        end
+
+        klass = Class.new do
+          include Validation
+
+          define_method(:_fields_data) { fields }
+
+          class << self
+            attr_accessor :_fields
+          end
+
+          fields.each do |name, _field|
+            attr_reader name
+          end
+
+          define_method(:initialize) do |**kwargs|
+            self.class._fields.each do |name, f|
+              value = if kwargs.key?(name)
+                        kwargs[name]
+                      elsif f.has_default?
+                        f.resolve_default
+                      else
+                        raise ArgumentError, "missing keyword: #{name}"
+                      end
+
+              value = f.coerce_value(value)
+
+              unless f.validate_type(value)
+                raise TypeError, "#{name} must be a #{f.type}, got #{value.class}"
+              end
+
+              instance_variable_set(:"@#{name}", value)
+            end
+
+            freeze
+          end
+
+          define_method(:to_h) do
+            self.class._fields.each_with_object({}) do |(name, _), hash|
+              hash[name] = instance_variable_get(:"@#{name}")
+            end
+          end
+
+          define_method(:merge) do |**attrs|
+            self.class.new(**to_h.merge(attrs))
+          end
+
+          define_method(:==) do |other|
+            other.is_a?(self.class) && to_h == other.to_h
+          end
+
+          define_method(:hash) do
+            to_h.hash
+          end
+
+          define_method(:deconstruct_keys) do |keys|
+            h = to_h
+            keys ? h.slice(*keys) : h
+          end
+
+          define_method(:to_s) do
+            fields_str = to_h.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+            "#<#{self.class.name || 'StructKit'} #{fields_str}>"
+          end
+
+          define_method(:inspect) { to_s }
+
+          define_singleton_method(:from_h) do |hash|
+            sym_hash = hash.transform_keys(&:to_sym)
+            new(**sym_hash)
+          end
+        end
+
+        klass._fields = fields
+        klass
+      end
+    end
+  end
+end

data/lib/philiprehberger/struct_kit/field.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module StructKit
+    class Field
+      attr_reader :name, :type, :default, :coerce, :validations
+
+      def initialize(name, type = nil, default: :__no_default__, coerce: nil)
+        @name = name
+        @type = type
+        @default = default
+        @coerce = coerce
+        @validations = []
+      end
+
+      def has_default?
+        @default != :__no_default__
+      end
+
+      def resolve_default
+        return nil unless has_default?
+
+        @default.respond_to?(:call) ? @default.call : @default
+      end
+
+      def coerce_value(value)
+        return value unless @coerce
+
+        @coerce.call(value)
+      end
+
+      def validate_type(value)
+        return true if @type.nil?
+        return true if value.nil? && has_default?
+
+        value.is_a?(@type)
+      end
+
+      def add_validation(rule)
+        @validations << rule
+      end
+
+      def validate_value(value)
+        errors = []
+
+        unless validate_type(value)
+          errors << "#{@name} must be a #{@type}, got #{value.class}"
+        end
+
+        @validations.each do |rule|
+          case rule
+          when Hash
+            if rule[:range] && !rule[:range].include?(value)
+              errors << "#{@name} must be in range #{rule[:range]}"
+            end
+            if rule[:format] && !rule[:format].match?(value.to_s)
+              errors << "#{@name} does not match required format"
+            end
+          when Proc
+            msg = rule.call(value)
+            errors << msg if msg.is_a?(String)
+          end
+        end
+
+        errors
+      end
+    end
+  end
+end

data/lib/philiprehberger/struct_kit/validation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module StructKit
+    module Validation
+      def valid?
+        errors.empty?
+      end
+
+      def errors
+        errs = []
+        self.class._fields.each do |name, field|
+          value = instance_variable_get(:"@#{name}")
+          errs.concat(field.validate_value(value))
+        end
+        errs
+      end
+    end
+  end
+end

data/lib/philiprehberger/struct_kit/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module StructKit
+    VERSION = '0.1.0'
+  end
+end

data/lib/philiprehberger/struct_kit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'struct_kit/version'
+require_relative 'struct_kit/field'
+require_relative 'struct_kit/validation'
+require_relative 'struct_kit/definition'
+
+module Philiprehberger
+  module StructKit
+    def self.define(&block)
+      defn = Definition.new
+      defn.instance_eval(&block)
+      defn.build
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: philiprehberger-struct_kit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Philip Rehberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Define data classes with typed fields, default values, validation rules,
+  and pattern matching support. Immutable by default with keyword-only construction,
+  JSON/Hash serialization, and runtime type checking.
+email:
+- me@philiprehberger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/philiprehberger/struct_kit.rb
+- lib/philiprehberger/struct_kit/definition.rb
+- lib/philiprehberger/struct_kit/field.rb
+- lib/philiprehberger/struct_kit/validation.rb
+- lib/philiprehberger/struct_kit/version.rb
+homepage: https://github.com/philiprehberger/rb-struct-kit
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/philiprehberger/rb-struct-kit
+  source_code_uri: https://github.com/philiprehberger/rb-struct-kit
+  changelog_uri: https://github.com/philiprehberger/rb-struct-kit/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/philiprehberger/rb-struct-kit/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Enhanced struct builder with typed fields, defaults, validation, and pattern
+  matching
+test_files: []