philiprehberger-struct_kit 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b55b47cb37e7ebf99690da52df447bbd35570f3d025047fd37bb5be1f15cbb0
-  data.tar.gz: 03a1b60f04e75e455389020bbdf34d2ec028651fe7c14abeb0038a6c33937068
+  metadata.gz: fb334ab4e4fec14463ca38a07eecad0e085d8b9abf0d8414d0efd8a525040bdc
+  data.tar.gz: 026bf5453a47902dd2aaf27bb903c0a23d514f4d25ef8f76ea59c0c7248bc61f
 SHA512:
-  metadata.gz: 8efe14b43443a8ce8fca842f2ae3ae70a8cb511c753319883fba1454c0fd45f8839945ebfebd282242291b51ea28148ef213756c8ca6cbb55e142c51d3ef7851
-  data.tar.gz: 668b1b75f73a814b437c6647019afbbbc78e566817de8f11a650a7cb8fa6ef7bab695e0417f0b0255dc7175cb2b1b118d6fdef9f507b971e67ea7f157408966d
+  metadata.gz: 68319362763b7797c3805a41a425cdf7b4a534382f8c48911fb80021c5b88775fb5e66b8a7400dcf0b41cfbf6575d22e33cc784cebb51040893e5e58e7f60c58
+  data.tar.gz: 615483affddbec4813f6f794edf904a5c5c4e04d70f66d0cd19703edd59239e5ac7f9424a9c7d247b298fe7c7a7f1a5075d4af757fe93bdd3719796d09b5f70c

data/CHANGELOG.md

@@ -2,21 +2,39 @@
 
 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).
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this gem adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-## [0.1.0] - 2026-03-21
+## [0.1.2] - 2026-03-22
+
+### Fixed
+
+- Fix CHANGELOG header wording
+- Add bug_tracker_uri to gemspec
+
+## [0.1.1] - 2026-03-22
+
+### Changed
+- Improve source code, tests, and rubocop compliance
+
+## [0.1.0] - 2026-03-22
 
 ### Added
+
 - Initial release
 - DSL-based struct definition with `StructKit.define`
-- Typed fields with runtime type checking
+- Typed fields with runtime type checking (single class or array of classes)
 - 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`
+- Validation rules (range, format regex, custom blocks)
+- Immutable instances by default (frozen after initialization)
+- Mutable variant with `StructKit.define(mutable: true)`
+- `#to_h` and `.from_h` for hash serialization (string keys accepted)
+- `#to_json` for JSON serialization
+- Pattern matching support via `#deconstruct_keys`
+- Value equality via `#==`
+- Keyword-only constructor
+
+[Unreleased]: https://github.com/philiprehberger/rb-struct-kit/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/philiprehberger/rb-struct-kit/releases/tag/v0.1.0

data/README.md

@@ -1,10 +1,9 @@
 # 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)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-struct_kit.svg)](https://badge.fury.io/rb/philiprehberger-struct_kit)
+[![CI](https://github.com/philiprehberger/rb-struct-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-struct-kit/actions/workflows/ci.yml)
 
-Enhanced struct builder with typed fields, defaults, validation, and pattern matching
+Enhanced struct builder with typed fields, defaults, validation, and pattern matching.
 
 ## Requirements
 
@@ -20,7 +19,7 @@ gem 'philiprehberger-struct_kit'
 
 Or install directly:
 
-```bash
+```sh
 gem install philiprehberger-struct_kit
 ```
 
@@ -39,66 +38,67 @@ end
 user = User.new(name: 'Alice', age: 30)
 user.name   # => "Alice"
 user.age    # => 30
-user.role   # => :user
+user.frozen? # => true
 ```
 
-### Defaults
+### Type Checking
 
 ```ruby
-Config = Philiprehberger::StructKit.define do
-  field :timeout, Integer, default: 30
-  field :tags, Array, default: -> { [] }
+Point = Philiprehberger::StructKit.define do
+  field :x, Integer
+  field :y, Integer
+  field :active, [TrueClass, FalseClass], default: true
 end
 
-config = Config.new
-config.timeout  # => 30
-config.tags     # => []
+Point.new(x: 1, y: 2)            # OK
+Point.new(x: 'a', y: 2)          # TypeError!
+Point.new(x: 1, y: 2, active: 0) # TypeError!
 ```
 
-### Type Coercion
+### Default Values
 
 ```ruby
-Record = Philiprehberger::StructKit.define do
-  field :count, Integer, default: 0, coerce: ->(v) { v.to_i }
+Config = Philiprehberger::StructKit.define do
+  field :timeout, Integer, default: 30
+  field :tags, Array, default: -> { [] }  # lambda for mutable defaults
 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"]
+Email = Philiprehberger::StructKit.define do
+  field :address, String
+  validate :address, format: /@/
+end
 ```
 
-### Immutability
+### Mutable Structs
 
 ```ruby
-user = User.new(name: 'Alice')
-user.frozen?  # => true
+MutableUser = Philiprehberger::StructKit.define(mutable: true) do
+  field :name, String
+  field :age, Integer, default: 0
+end
 
-updated = user.merge(age: 31)  # returns new instance
-updated.age  # => 31
-user.age     # => 0 (unchanged)
+user = MutableUser.new(name: 'Alice')
+user.name = 'Bob'  # OK, not frozen
 ```
 
-### Hash Serialization
+### 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 })
+user.to_h    # => { name: "Alice", age: 30, role: :user }
+user.to_json # => '{"name":"Alice","age":30,"role":"user"}'
+
+User.from_h({ 'name' => 'Bob', 'age' => 25 })  # string keys OK
 ```
 
 ### Pattern Matching
 
 ```ruby
-user = User.new(name: 'Alice', role: :admin)
-
 case user
 in { role: :admin }
   puts 'Admin user'
@@ -109,43 +109,41 @@ end
 
 ## API
 
-### `Philiprehberger::StructKit`
+### `Philiprehberger::StructKit.define(mutable: false, &block)`
 
-| Method | Description |
-|--------|-------------|
-| `.define { block }` | Define a new struct class with the DSL |
+Define a new struct class. Evaluates the block in DSL context.
 
-### DSL (inside `define` block)
+### DSL Methods
 
 | 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 |
+| `field(name, type = nil, default: UNSET)` | Declare a typed field with optional default |
+| `validate(name, range: nil, format: nil, &block)` | Add validation rule 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 |
+| `#to_json` | Convert to JSON string |
 | `#deconstruct_keys(keys)` | Pattern matching support |
+| `#==` | Value equality |
+| `#inspect` | Human-readable string representation |
 
 ### Class Methods
 
 | Method | Description |
 |--------|-------------|
-| `.from_h(hash)` | Construct from a hash (string or symbol keys) |
+| `.from_h(hash)` | Construct from hash (string or symbol keys) |
 
 ## Development
 
-```bash
+```sh
 bundle install
-bundle exec rspec      # Run tests
-bundle exec rubocop    # Check code style
+bundle exec rspec
+bundle exec rubocop
 ```
 
 ## License
 
-MIT
+MIT License. See [LICENSE](LICENSE) for details.

data/lib/philiprehberger/struct_kit/definition.rb

@@ -1,87 +1,94 @@
 # frozen_string_literal: true
 
 require_relative 'field'
-require_relative 'validation'
 
 module Philiprehberger
   module StructKit
     class Definition
-      def initialize
+      def initialize(mutable: false)
         @fields = {}
         @validations = {}
+        @mutable = mutable
       end
 
-      def field(name, type = nil, default: :__no_default__, coerce: nil)
-        @fields[name] = Field.new(name, type, default: default, coerce: coerce)
+      def field(name, type = nil, default: Field::UNSET)
+        @fields[name] = Field.new(name, type, default: default)
       end
 
-      def validate(name, **rules, &block)
-        @validations[name] ||= []
-        @validations[name] << rules unless rules.empty?
-        @validations[name] << block if block
+      def validate(field_name, range: nil, format: nil, &block)
+        @validations[field_name] ||= []
+        rules = {}
+        rules[:range] = range if range
+        rules[:format] = format if format
+        @validations[field_name] << rules unless rules.empty?
+        @validations[field_name] << block if block
       end
 
       def build
-        fields = @fields
-        validations = @validations
+        fields = @fields.dup
+        mutable = @mutable
 
-        validations.each do |name, rules|
+        # Attach validations to fields
+        @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
+            attr_accessor :_fields, :_mutable
           end
 
-          fields.each do |name, _field|
-            attr_reader name
+          fields.each_key do |fname|
+            attr_reader fname
           end
 
           define_method(:initialize) do |**kwargs|
-            self.class._fields.each do |name, f|
-              value = if kwargs.key?(name)
-                        kwargs[name]
+            self.class._fields.each do |fname, f|
+              value = if kwargs.key?(fname)
+                        kwargs[fname]
                       elsif f.has_default?
                         f.resolve_default
                       else
-                        raise ArgumentError, "missing keyword: #{name}"
+                        raise ArgumentError, "missing keyword: #{fname}"
                       end
 
-              value = f.coerce_value(value)
-
-              unless f.validate_type(value)
-                raise TypeError, "#{name} must be a #{f.type}, got #{value.class}"
+              unless f.type_valid?(value)
+                expected = f.type.is_a?(Array) ? f.type.map(&:name).join(' or ') : f.type.name
+                raise TypeError, "#{fname} must be #{expected}, got #{value.class}"
               end
 
-              instance_variable_set(:"@#{name}", value)
+              # Run validations
+              validation_errors = f.validate_value(value)
+              raise ArgumentError, validation_errors.join(', ') unless validation_errors.empty?
+
+              instance_variable_set(:"@#{fname}", value)
             end
 
-            freeze
+            freeze unless self.class._mutable
           end
 
-          define_method(:to_h) do
-            self.class._fields.each_with_object({}) do |(name, _), hash|
-              hash[name] = instance_variable_get(:"@#{name}")
+          if mutable
+            fields.each_key do |fname|
+              attr_writer fname
             end
           end
 
-          define_method(:merge) do |**attrs|
-            self.class.new(**to_h.merge(attrs))
+          define_method(:to_h) do
+            self.class._fields.each_with_object({}) do |(fname, _), hash|
+              hash[fname] = instance_variable_get(:"@#{fname}")
+            end
           end
 
-          define_method(:==) do |other|
-            other.is_a?(self.class) && to_h == other.to_h
+          define_method(:to_json) do |*args|
+            require 'json'
+            to_h.to_json(*args)
           end
 
-          define_method(:hash) do
-            to_h.hash
+          define_singleton_method(:from_h) do |hash|
+            sym_hash = hash.transform_keys(&:to_sym)
+            new(**sym_hash)
           end
 
           define_method(:deconstruct_keys) do |keys|
@@ -89,20 +96,24 @@ module Philiprehberger
             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}>"
+          define_method(:==) do |other|
+            other.is_a?(self.class) && to_h == other.to_h
           end
 
-          define_method(:inspect) { to_s }
+          define_method(:hash) do
+            to_h.hash
+          end
 
-          define_singleton_method(:from_h) do |hash|
-            sym_hash = hash.transform_keys(&:to_sym)
-            new(**sym_hash)
+          define_method(:inspect) do
+            fields_str = to_h.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+            "#<#{self.class.name || 'StructKit'} #{fields_str}>"
           end
+
+          alias_method :to_s, :inspect
         end
 
         klass._fields = fields
+        klass._mutable = mutable
         klass
       end
     end

data/lib/philiprehberger/struct_kit/field.rb

@@ -3,37 +3,33 @@
 module Philiprehberger
   module StructKit
     class Field
-      attr_reader :name, :type, :default, :coerce, :validations
+      UNSET = Object.new.freeze
 
-      def initialize(name, type = nil, default: :__no_default__, coerce: nil)
+      attr_reader :name, :type, :validations
+
+      def initialize(name, type = nil, default: UNSET)
         @name = name
         @type = type
         @default = default
-        @coerce = coerce
         @validations = []
       end
 
       def has_default?
-        @default != :__no_default__
+        @default != UNSET
       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)
+      def type_valid?(value)
         return true if @type.nil?
-        return true if value.nil? && has_default?
 
-        value.is_a?(@type)
+        if @type.is_a?(Array)
+          @type.any? { |t| value.is_a?(t) }
+        else
+          value.is_a?(@type)
+        end
       end
 
       def add_validation(rule)
@@ -43,19 +39,11 @@ module Philiprehberger
       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
+            errors << "#{@name} must be in range #{rule[:range]}" if rule[:range] && !rule[:range].include?(value)
+            errors << "#{@name} does not match required format" if rule[:format] && !rule[:format].match?(value.to_s)
           when Proc
             msg = rule.call(value)
             errors << msg if msg.is_a?(String)

data/lib/philiprehberger/struct_kit/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module StructKit
-    VERSION = '0.1.0'
+    VERSION = '0.1.2'
   end
 end

data/lib/philiprehberger/struct_kit.rb

@@ -2,13 +2,12 @@
 
 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
+    def self.define(mutable: false, &block)
+      defn = Definition.new(mutable: mutable)
       defn.instance_eval(&block)
       defn.build
     end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-struct_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
-- Philip Rehberger
+- philiprehberger
 autorequire:
 bindir: bin
 cert_chain: []
@@ -14,7 +14,7 @@ description: Define data classes with typed fields, default values, validation r
   and pattern matching support. Immutable by default with keyword-only construction,
   JSON/Hash serialization, and runtime type checking.
 email:
-- me@philiprehberger.com
+- philiprehberger@users.noreply.github.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -25,7 +25,6 @@ files:
 - 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:
@@ -44,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/philiprehberger/struct_kit/validation.rb

@@ -1,20 +0,0 @@
-# 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