typed_model 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b1bfb6a568683689e6333d52789ba54cecb6582f107c44398f86001a90168cd
-  data.tar.gz: 220086f68dbb3033a6e9e91f562fe59c0709c7694d2ca79494b8452f722bd647
+  metadata.gz: e073e121645ca98973bfdccf4eec35d7b22280d57ffae982dd82adc5277200d6
+  data.tar.gz: 7dec738ef8f379ef9aef9640e1c7ffc40ae8eacbdc019d35fd53a861967abcc4
 SHA512:
-  metadata.gz: 6461a2b3a7e02a68bffeb6e2d330b17b562be0e1598ce35fe514f1a4c3fde0e1980e61fa23cacda63eedac2f40d2c802b46954172be4d7e9b11a8e2c370f068b
-  data.tar.gz: c939e41dd3c7e727f311e5ae9bede19ce4e1e9e1e1d9d2d790ddb055566982d1c735e573dcca198fb2ced894a0a79f08d9b1b169874113ebb328c7dbcdf106c1
+  metadata.gz: 07a337998fc5a7a9c4e7f3e48682ea3687dce65ee40c65d1c0b839ce10cb4755ca9ff40d0331ba8a21b5dd0cf1b0d980b9261cc44adfa2ba58d204875568293f
+  data.tar.gz: 6fd6b7833075e1860f923f1efd3bf4a610348ce6fe127a7eb8250034cfe350fff987e4a7e09b2937ccd844e29548d79ba8d77009377bcb3ef8b917eaf4c0f9a6

data/.ruby-version

@@ -0,0 +1 @@
+3.1.4

data/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## 1.0.0
+
+### Bug Fixes
+
+- `valid?` now resets errors between calls — previously errors accumulated across invocations
+- `typecast` no longer swallows `false` return values (used `|| value` which treated `false` as nil)
+- `instantiate_type` returns nil for nil input instead of raising NoMethodError
+- `validate_recognized_types` uses `!value.nil?` instead of `value != nil` to avoid ActiveSupport DateTime comparison bug
+
+### Breaking Changes
+
+- `assert_not_blank` is now a distinct validation from `assert_required` — checks for non-whitespace (`/\S/`) rather than just empty/nil
+- Removed deprecated `Fixnum` from `PRIMITIVE_CLASSES`
+
+### Additions
+
+- `Errors#to_h` added for accessing the underlying error hash
+- Mapping key attribute assignment now works bidirectionally (set via name or mapping_key)
+
+### Code Quality
+
+- Modern Ruby syntax: safe navigation, guard clauses, `rescue StandardError`, symbol method names
+- Extracted `build_validators`, `build_seq_of`, `build_map_of` helpers in `TypeDef`
+- Extracted `recognized_scalar_type?` and `merge_value_errors` in `TypeDef`
+- `Errors#each_error` uses `yield` instead of `blk.call`
+- `ModelValidations#each_error` uses anonymous block forwarding (`&`)
+- Added `# frozen_string_literal: true` to `type_def.rb`
+
+### Tests
+
+- Expanded `assert_not_blank` coverage (nil, empty, whitespace, non-blank, leading/trailing whitespace)
+- `valid?` error reset between calls
+- Boolean typecast with falsey values
+- `instantiate_type` nil handling
+- DateTime `<=>` nil edge case in validate
+- Mapping key bidirectional assignment
+- Nested association messages with mapping key

data/README.md

@@ -1,13 +1,13 @@
 # TypedModel
 
-A Ruby library for defining data schemas via classes with 
-typed fields and built in hydration and serialization
-
-* data mapping (data -> object -> data)
-* declared types
-* declared validations
-* Nested models
-    
+A lightweight attribute declaration, validation, and type-coercion framework for Ruby. Include `TypedModel::ModelBase` in a class to get:
+
+- **`attribute`** declarations with type and validation options
+- **`initialize(values)`** — construct from a hash
+- **`attributes=`** — bulk-assign from a hash
+- **`valid?`** / **`errors`** — run validations and inspect failures
+- **`to_data`** — serialize to a plain hash
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,76 +24,217 @@ Or install it yourself as:
 
     $ gem install typed_model
 
-## Usage
-
-    Employee
-      include ModelBase
-
-      attribute :a_boolean, type: :boolean
-      attribute :an_integer, type: :integer
-      attribute :a_timestamp, type: :timestamp
-      attribute :widget1, type: :map
-      attribute :address, type: a_c
-      attribute :addresses, seq_of: a_c
-      attribute :colors, type: :seq
-    end
-        
-### Sequences
-    
-      # non-empty/nil sequence
-      attribute :a_seq, type: :seq, :validations [:required]
-      
-      attribute :a_seq, seq_of: :string
-      
-      attribute :a_seq, seq_of: Address
-      
-      # sequence of string -> integer maps
-      attribute :a_Seq, seq_of: [:string, :integer]
-      
-      attribute :a_seq, seq_of: { type: Adress, :validations [:some_validation] }
-        
-### Maps
-
-      # string -> string
-      attribute :a_map, :map_of [:string, :integer]
-      
-      attribute :a_map, type: :map, validations: [:required]
-      
-      # map of maps
-      attribute :map_of_maps, :map_of [:string, [:string, :integer]]
-      
-      # map of maps
-      attribute :a_map, :map_of [{type: :string, validators: [:some_check]},
-                                 {type: Address, validators: [:required]},
-                        :validators [:required]
-
-### Validations
-
-Primitive types (e.g. :string, :integer, :timestamp, :boolean, etc) are 
-automatically validated.
-
-##### Custom validations
-
-Via :keyword or `Validator instance`
- 
-        class Employee
-            ...
-            attribute :name, validations: [:my_validation]
-
-            def assert_my_validation(attr)
-              add_error(attr, 'some error')
-            end
-         end
-         
-
-        validator = Validator.new(:foo) do
-           ['some error']
-        end
-        
-        class Employee
-           ...
-           attribute :name, validations: [validator]
+## Built-in Types
+
+`:string`, `:integer`, `:boolean`, `:timestamp`, `:map`, `:seq`
+
+## Basic Example
+
+```ruby
+class Employee
+  include TypedModel::ModelBase
+
+  attribute :name
+  attribute :a_boolean, type: :boolean
+  attribute :an_integer, type: :integer
+  attribute :a_timestamp, type: :timestamp
+  attribute :widget1, type: :map
+  attribute :address, type: Address
+  attribute :addresses, seq_of: Address
+  attribute :colors, type: :seq
+end
+```
+
+## Sequences
+
+```ruby
+# non-empty/nil sequence
+attribute :a_seq, type: :seq, validations: [:required]
+
+# typed sequence of strings
+attribute :a_seq, seq_of: :string
+
+# sequence of Address models
+attribute :a_seq, seq_of: Address
+
+# sequence of [string, integer] pairs
+attribute :a_seq, seq_of: [:string, :integer]
+
+# sequence with nested type and validations
+attribute :a_seq, seq_of: { type: Address, validations: [:some_validation] }
+```
+
+## Maps
+
+```ruby
+# string -> integer
+attribute :a_map, map_of: [:string, :integer]
+
+# required map
+attribute :a_map, type: :map, validations: [:required]
+
+# map of maps
+attribute :map_of_maps, map_of: [:string, [:string, :integer]]
+```
+
+## Validations
+
+Primitive types (`:string`, `:integer`, `:timestamp`, `:boolean`, etc.) are automatically validated. Supply built-in or custom validators via the `validations:` option on `attribute`:
+
+```ruby
+attribute :name, type: :string, validations: [:required]
+attribute :email, type: :string, validations: [:not_blank]
+attribute :started_at, type: :timestamp, validations: [:required]
+```
+
+### Built-in Validators
+
+| Keyword       | Fails when                                      | Error key  |
+| ------------- | ----------------------------------------------- | ---------- |
+| `:required`   | value is `nil` or empty                         | `:required` |
+| `:not_blank`  | value has no non-whitespace characters           | `:required` |
+| `:not_nil`    | value is `nil` (empty is OK)                    | `:required_not_nil` |
+| `:timestamp`  | value cannot be parsed as a `Time`              | `:invalid`  |
+| `:integer`    | value cannot be coerced to `Integer`            | `:invalid`  |
+| `:string`     | value cannot be coerced to `String`             | `:invalid`  |
+
+### Custom Validations
+
+Via `:keyword` — define an `assert_<name>` method:
+
+```ruby
+class Employee
+  include TypedModel::ModelBase
+
+  attribute :name, validations: [:required, :my_validation]
+
+  def assert_my_validation(attr)
+    add_error(attr, 'some error')
+  end
+end
+```
+
+Via `Validator` instance:
+
+```ruby
+validator = TypedModel::Validator.new(:foo) do
+  ['some error']
+end
+
+class Employee
+  include TypedModel::ModelBase
+
+  attribute :name, validations: [validator]
+end
+```
+
+### Before-Validation Callbacks
+
+Register methods that run before the main `validate` pass. Callbacks are inherited and run in ancestor order (parent -> child):
 
+```ruby
+class Employee
+  include TypedModel::ModelBase
+
+  before_validation :normalize_name
+
+  attribute :name, type: :string
+
+  def normalize_name
+    self.name = name&.strip
+    add_error(:name, :required) if name.to_s.empty?
+  end
+end
+```
+
+## Validating Payloads and Reporting Errors
+
+Data models are commonly used to validate API request and response payloads. The standard pattern is:
+
+1. Instantiate the model from the payload hash
+2. Call `valid?` — returns `true`/`false` and populates `errors`
+3. If invalid, report the problems using `errors.inspect`
+
+### The `errors` Object
+
+`errors` is an instance of `TypedModel::Errors` — a hash of attribute names to arrays of error symbols/messages:
+
+```ruby
+model.errors[:name]              # => [:required]
+model.errors['address/street']   # => [:required]  (nested path)
+model.errors['addresses/1/type'] # => [:required]  (array index in path)
+model.errors.empty?              # => true/false
+```
+
+Iterate all errors:
+
+```ruby
+model.each_error { |key, msg| puts "#{key}: #{msg}" }
+```
+
+### Validating Inbound Requests
+
+Validate input before processing. Return or raise with `errors.inspect` to convey what's wrong:
+
+```ruby
+def process_request(params)
+  request = MyRequest.new(params)
+  raise "Invalid request: #{request.errors.inspect}" unless request.valid?
+
+  handle(request)
+end
+```
+
+In a Rails controller, render the errors directly as JSON:
+
+```ruby
+def create
+  response = MyResponse.new(response_params)
+
+  unless response.valid?
+    render json: response.errors.to_h, status: :bad_request
+    return
+  end
+
+  process(response)
+  render json: response, status: :created
+end
+```
+
+### Validating Outbound Responses
+
+Validate data received from external APIs to catch unexpected payloads early:
+
+```ruby
+def build_response(klass, data)
+  response = klass.new(data)
+
+  unless response.valid?
+    raise InvalidResponse, "Invalid #{klass}: #{response.errors.inspect}"
+  end
+
+  response
+end
+```
+
+Avoid logging raw payload data — it may contain sensitive information. When logging `errors.inspect`, ensure your error messages do not embed raw field values or other sensitive data, and prefer structured or otherwise sanitized error formats where possible.
+
+### Soft vs Hard Failure
+
+Choose the error-handling strategy that fits the context:
+
+```ruby
+# Soft — log and return a fallback (caller can continue)
+unless request.valid?
+  logger.info("Invalid request: #{request.errors.inspect}")
+  return empty_response(errors: request.errors, invalid_request: true)
+end
+
+# Hard — raise so the caller knows something is fundamentally wrong
+unless request.valid?
+  raise "Invalid request: #{request.errors.inspect}"
+end
+```
 
 ## Development
 
@@ -103,7 +244,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/typed_model.
+Bug reports and pull requests are welcome on GitHub at https://github.com/lenny/typed_model.
 
 ## License
 

data/lib/typed_model/attribute_definition.rb

@@ -7,7 +7,8 @@ module TypedModel
     attr_reader :name, :spec, :model_validations, :mapping_key
 
     def initialize(name:, type: nil, seq_of: nil, map_of: nil, validations: [], mapping_key: nil)
-      @name, @mapping_key = name, mapping_key
+      @name = name
+      @mapping_key = mapping_key
       @model_validations = []
       spec_validations = []
       validations.each do |v|
@@ -32,12 +33,9 @@ module TypedModel
       value = attr_value(model)
       spec.validate(value, model.errors, name)
       model_validations.each do |v|
-        method_name = "assert_#{v}"
-        if model.respond_to?(method_name)
-          model.send(method_name, name)
-        else
-          raise "Unrecognized validation '#{v}'"
-        end
+        method_name = :"assert_#{v}"
+        raise "Unrecognized validation '#{v}'" unless model.respond_to?(method_name)
+        model.send(method_name, name)
       end
     end
 

data/lib/typed_model/errors.rb

@@ -16,12 +16,16 @@ module TypedModel
       end
     end
 
-    def each_error(&blk)
+    def each_error
       @errors.each do |(k, msgs)|
-        msgs.each { |m| blk.call(k, m) }
+        msgs.each { |m| yield(k, m) }
       end
     end
 
+    def to_h
+      @errors.to_h
+    end
+
     def [](k)
       @errors[k]
     end

data/lib/typed_model/map_of.rb

@@ -8,10 +8,8 @@ module TypedModel
     end
 
     def typecast_value(values)
-      unless values.nil?
-        values.each_with_object({}) do |(k, v), h|
-          h[key_spec.typecast_value(k)] = value_spec.typecast_value(v)
-        end
+      values&.each_with_object({}) do |(k, v), h|
+        h[key_spec.typecast_value(k)] = value_spec.typecast_value(v)
       end
     end
 
@@ -22,11 +20,9 @@ module TypedModel
     end
 
     def validate(value, errors, key_prefix)
-      unless value.nil?
-        value.each_pair do |k, v|
-          key_spec.validate(k, errors, "#{key_prefix}/keys/#{k}")
-          value_spec.validate(v, errors, "#{key_prefix}/#{k}")
-        end
+      value&.each_pair do |k, v|
+        key_spec.validate(k, errors, "#{key_prefix}/keys/#{k}")
+        value_spec.validate(v, errors, "#{key_prefix}/#{k}")
       end
     end
   end

data/lib/typed_model/model_base.rb

@@ -32,12 +32,11 @@ module TypedModel
         class << self
           def attribute(name, opts = {})
             @declared_attributes ||= {}
-            attribute_def = AttributeDefinition.new(opts.merge(name: name))
+            attribute_def = AttributeDefinition.new(**opts, name: name)
             @declared_attributes[name.to_sym] = attribute_def
-            @declared_attributes[attribute_def.mapping_key.to_sym] = attribute_def
             attr_reader name
-            define_method "#{name}=" do |v|
-              instance_variable_set("@#{name}", attribute_def.typecast_value(v))
+            define_method :"#{name}=" do |v|
+              instance_variable_set(:"@#{name}", attribute_def.typecast_value(v))
             end
           end
 
@@ -46,6 +45,13 @@ module TypedModel
               attributes.merge!(c.instance_variable_get(:@declared_attributes) || {})
             end
           end
+
+          def declared_attributes_with_alternates
+            declared_attributes.each_with_object({}) do |(name, attr_def), h|
+              h[name] = attr_def
+              h[attr_def.mapping_key.to_sym] = attr_def
+            end
+          end
         end
       end
     end
@@ -57,9 +63,10 @@ module TypedModel
     def attributes=(values = {})
       return if values.nil?
 
+      attrs_with_alternates = self.class.declared_attributes_with_alternates
       values.each_pair do |k, v|
-        if (attr_def = self.class.declared_attributes[k.to_sym])
-          setter = "#{attr_def.name}="
+        if (attr_def = attrs_with_alternates[k.to_sym])
+          setter = :"#{attr_def.name}="
           send(setter, v) if respond_to?(setter)
         end
       end

data/lib/typed_model/model_validations.rb

@@ -38,22 +38,21 @@ module TypedModel
 
     def assert_not_blank(field)
       v = send(field)
-      add_error(field, :required) unless v.to_s.match(/\S+/)
+      add_error(field, :required) unless v.to_s.match?(/\S/)
     end
 
     def assert_timestamp(field)
       v = send(field)
-      if !v.is_a?(Time)
+      unless v.is_a?(Time)
         s = v.to_s
-        if s.match(/\S/)
-          send("#{field}=", Time.parse(s))
-        end
+        send(:"#{field}=", Time.parse(s)) if s.match?(/\S/)
       end
-    rescue
+    rescue StandardError
       add_error(field, :invalid)
     end
 
     def valid?
+      @errors = Errors.new
       self.class.before_validation_callbacks.each do |fname|
         send(fname)
       end

data/lib/typed_model/seq_of.rb

@@ -15,10 +15,8 @@ module TypedModel
     end
 
     def validate(value, errors, key_prefix)
-      unless value.nil?
-        value.each_with_index do |v, index|
-          spec.validate(v, errors, "#{key_prefix}/#{index}")
-        end
+      value&.each_with_index do |v, index|
+        spec.validate(v, errors, "#{key_prefix}/#{index}")
       end
     end
   end

data/lib/typed_model/type_def.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'typed_model/seq_of'
 require 'typed_model/map_of'
 require 'typed_model/types'
@@ -11,26 +13,37 @@ module TypedModel
 
         t, seq_of, map_of, validations = spec_map.values_at(:type, :seq_of, :map_of, :validations)
 
-        validators = (validations || []).map do |v|
-          Validator.build(v)
-        end
-
+        validators = build_validators(validations)
         spec_opts = { type: t, validators: validators }
 
         if seq_of
-          seq_spec = build(seq_of)
-          new(spec_opts.merge(type: SeqOf.new(seq_spec)))
+          build_seq_of(spec_opts, seq_of)
         elsif map_of
-          key_spec_opts, val_spec_opts = map_of
-          if val_spec_opts.is_a?(Array)
-            val_spec_opts = { type: :map, map_of: val_spec_opts }
-          end
-          map_of = MapOf.new(build(key_spec_opts), build(val_spec_opts))
-          new(spec_opts.merge(type: map_of))
+          build_map_of(spec_opts, map_of)
         else
           new(spec_opts)
         end
       end
+
+      private
+
+      def build_validators(validations)
+        (validations || []).map { |v| Validator.build(v) }
+      end
+
+      def build_seq_of(spec_opts, seq_of)
+        seq_spec = build(seq_of)
+        new(spec_opts.merge(type: SeqOf.new(seq_spec)))
+      end
+
+      def build_map_of(spec_opts, map_of)
+        key_spec_opts, val_spec_opts = map_of
+        if val_spec_opts.is_a?(Array)
+          val_spec_opts = { type: :map, map_of: val_spec_opts }
+        end
+        map_of = MapOf.new(build(key_spec_opts), build(val_spec_opts))
+        new(spec_opts.merge(type: map_of))
+      end
     end
 
     attr_accessor :value_type, :validators
@@ -41,18 +54,16 @@ module TypedModel
     end
 
     def typecast_value(v)
-      if value_type
-        if value_type.respond_to?(:typecast_value)
-          value_type.typecast_value(v)
-        elsif value_type.is_a?(Symbol) && Types.recognized?(value_type)
-          Types.typecast(value_type, v)
-        elsif value_type.is_a?(Class)
-          instantiate_type(v)
-        else
-          raise "unrecognized type '#{value_type.inspect}'"
-        end
+      return v unless value_type
+
+      if value_type.respond_to?(:typecast_value)
+        value_type.typecast_value(v)
+      elsif recognized_scalar_type?
+        Types.typecast(value_type, v)
+      elsif value_type.is_a?(Class)
+        instantiate_type(v)
       else
-        v
+        raise "unrecognized type '#{value_type.inspect}'"
       end
     end
 
@@ -65,9 +76,7 @@ module TypedModel
         value_type.validate(value, errors, key_prefix)
       end
 
-      if value.respond_to?(:valid?) && value.respond_to?(:errors) && !value.valid?
-        errors.merge!(value.errors, key_prefix)
-      end
+      merge_value_errors(value, errors, key_prefix)
     end
 
     def to_data(value)
@@ -82,8 +91,12 @@ module TypedModel
 
     private
 
+    def recognized_scalar_type?
+      value_type.is_a?(Symbol) && Types.recognized?(value_type)
+    end
+
     def execute_validators(errors, key_prefix, value)
-      validators.each_with_object(errors) do |v, errors|
+      validators.each do |v|
         (v.validate(value) || []).each do |s|
           errors.add(key_prefix, s)
         end
@@ -91,14 +104,22 @@ module TypedModel
     end
 
     def validate_recognized_types(errors, key_prefix, value)
-      if value_type.is_a?(Symbol) && Types.recognized?(value_type)
-        if value != nil && Types.send(value_type, value).nil?
+      if recognized_scalar_type?
+        if !value.nil? && Types.send(value_type, value).nil?
           errors.add(key_prefix, :invalid)
         end
       end
     end
 
+    def merge_value_errors(value, errors, key_prefix)
+      if value.respond_to?(:valid?) && value.respond_to?(:errors) && !value.valid?
+        errors.merge!(value.errors, key_prefix)
+      end
+    end
+
     def instantiate_type(v)
+      return nil if v.nil?
+
       if v.is_a?(value_type)
         v
       else
@@ -108,5 +129,3 @@ module TypedModel
     end
   end
 end
-
-

data/lib/typed_model/types.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module TypedModel
 
   # Supported Types/Type coercion
@@ -11,7 +13,7 @@ module TypedModel
   #
   #
   class Types
-    PRIMITIVE_CLASSES = Set.new([String, TrueClass, FalseClass, Integer, Float, Fixnum])
+    PRIMITIVE_CLASSES = Set.new([String, TrueClass, FalseClass, Integer, Float])
 
     class << self
       def recognized?(t)
@@ -19,7 +21,8 @@ module TypedModel
       end
 
       def typecast(sym, value)
-        send(sym, value) || value
+        type_casted = send(sym, value)
+        type_casted.nil? ? value : type_casted
       end
 
       def timestamp(v)
@@ -28,24 +31,22 @@ module TypedModel
         else
           Time.parse(v)
         end
-      rescue
+      rescue StandardError
         nil
       end
 
       def boolean(v)
         case v
-        when "true", true then
+        when 'true', true
           true
-        when "false", false then
+        when 'false', false
           false
-        else
-          nil
         end
       end
 
       def integer(v)
         Integer(v)
-      rescue
+      rescue StandardError
         nil
       end
 

data/lib/typed_model/validator.rb

@@ -4,24 +4,16 @@ module TypedModel
   class Validator
     class << self
       def build(arg)
-        if arg.respond_to?(:validate) && arg.respond_to?(:name)
-          return arg
-        end
-        if arg.is_a?(Symbol)
-          if Validators.recognized?(arg)
-            new_builtin_validator(arg)
-          else
-            raise "Unrecognized validation '#{arg}'"
-          end
-        else
-          raise "failed to create validator from '#{arg}'"
-        end
+        return arg if arg.respond_to?(:validate) && arg.respond_to?(:name)
+        raise "failed to create validator from '#{arg}'" unless arg.is_a?(Symbol)
+        raise "Unrecognized validation '#{arg}'" unless Validators.recognized?(arg)
+        new_builtin_validator(arg)
       end
 
       def from_primitive(t)
         new(t) do |v|
           errors = []
-          if v != nil && (msg = send("assert_#{t}", v))
+          if !v.nil? && (msg = send(:"assert_#{t}", v))
             errors << msg
           end
           errors

data/lib/typed_model/validators.rb

@@ -5,47 +5,39 @@ module TypedModel
     module_function
 
     def recognized?(sym)
-      respond_to?("assert_#{sym}")
+      respond_to?(:"assert_#{sym}")
     end
 
     def validate(sym, value)
-      method_name = "assert_#{sym}"
-      unless respond_to?(method_name)
-        raise "Unrecognized validation '#{sym}'"
-      end
+      method_name = :"assert_#{sym}"
+      raise "Unrecognized validation '#{sym}'" unless respond_to?(method_name)
       send(method_name, value)
     end
 
     def assert_timestamp(v)
-      if Types.timestamp(v).nil?
-        :invalid
-      end
+      :invalid if Types.timestamp(v).nil?
     end
 
     def assert_required(v)
-      if v.nil? || (v.respond_to?(:empty?) && v.empty?)
-        :required
-      end
+      :required if v.nil? || (v.respond_to?(:empty?) && v.empty?)
     end
 
-    alias assert_not_blank assert_required
+    # Checks that value contains at least one non-whitespace character.
+    # Semantically different from assert_required which only checks empty/nil.
+    def assert_not_blank(v)
+      :required unless /\S/.match?(v.to_s)
+    end
 
     def assert_not_nil(v)
-      if v.nil?
-        :required_not_nil
-      end
+      :required_not_nil if v.nil?
     end
 
     def assert_string(v)
-      if Types.string(v).nil?
-        :invalid
-      end
+      :invalid if Types.string(v).nil?
     end
 
     def assert_integer(v)
-      if Types.integer(v).nil?
-        :invalid
-      end
+      :invalid if Types.integer(v).nil?
     end
   end
 end

data/lib/typed_model/version.rb

@@ -1,3 +1,3 @@
 module TypedModel
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/typed_model.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: typed_model
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Lenny Marks
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-08-10 00:00:00.000000000 Z
+date: 2026-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -62,7 +62,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - LICENSE.txt
@@ -91,7 +93,7 @@ metadata:
   homepage_uri: https://github.com/lenny/typed_model
   source_code_uri: https://github.com/lenny/typed_model
   changelog_uri: https://github.com/lenny/typed_model/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,9 +108,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: A Ruby library for defining data schemas via classes with typed fields and
   built in hydration and serialization