schema-model 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f4f7d2224dda7f2a0ced1da41e8597e6374df27a22fd739c1bd86a0b02441c3
-  data.tar.gz: 4ff7d3bcf5f8e80d241d7e85b25c84f0a7f651c1e43beeafe923537eeb3aa880
+  metadata.gz: d02407b3970af8db7c2bde92ebe9bb6e557e9f6415b503dbee29961938d15144
+  data.tar.gz: d475d956180eabe9455e40c482f44735217ddcff04d1d121e5e86de3a4071686
 SHA512:
-  metadata.gz: c113bc5af055eae0d038c42113fade624505848db7945576fd642845e7071791bf041db388e8ef8ff8b076a27a82b2de94beb8cf91ec80d8f02b478152d7ce4d
-  data.tar.gz: 77f0728d85424f45a5cf5c034f4b7a7510a54357a0e55bebfdd95a4f1c3da7a32517e4bc5d33d86d776d0d5245581fea71c2d163ff419da53d41d12b1ae8c6a2
+  metadata.gz: 0df082a47d8e30b845f36fd72c35dd73164a365a5cf67e76f7bfcb0d97000d4ef1f9581b46377ec7129a9253c3aa39984a7e28a068a8137d0a229eda427556cd
+  data.tar.gz: fda0a963a0e4b5de8800977b85d90c981ed16885b6659d620bbef5360d0c5f72ebd8e0ed34d764f9ca9e07b915a9bb7674fba2c891cac9cefd0245fe60045a03

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.12.0](https://github.com/dougyouch/schema/compare/v0.11.0...v0.12.0) (2026-10-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* with Schema::All, a parsing error's type is now the code symbol (e.g. :invalid) instead of the message string; messages are unchanged.
+
+### Features
+
+* decimal type, datetime alias, association was_set? and parsing error codes ([e93e683](https://github.com/dougyouch/schema/commit/e93e6836e98efcdf01da656818f70ec305f59871))
+
 ## [0.11.0](https://github.com/dougyouch/schema/compare/v0.10.0...v0.11.0) (2026-10-05)
 
 

data/README.md

@@ -181,7 +181,7 @@ def update
 end
 ```
 
-Associations in `set_attribute_values` are schema models; call `as_json` on them if the record expects hashes. For a single attribute, `input.name_was_set?` answers the same question.
+Associations in `set_attribute_values` are schema models; call `as_json` on them if the record expects hashes. For a single attribute or association, `input.name_was_set?` answers the same question.
 
 For nested input, `as_json(only_set: true)` keeps only the fields that were sent, at every level, so it can be merged into a JSON column without wiping fields the client left out:
 
@@ -201,18 +201,22 @@ record.data = record.data.deep_merge(input.as_json(only_set: true).deep_stringif
 attribute :name, :string              # String values
 attribute :count, :integer            # Integer values (parses "123", " 123 " and "0123" to 123)
 attribute :price, :float              # Float values (parses "9.99" to 9.99, also "1e+5")
+attribute :total, :decimal            # BigDecimal (parses "9.99" exactly); with Schema::All
 attribute :active, :boolean           # see below
 attribute :notes, :string_or_nil      # String, but nil when empty or whitespace-only
 ```
 
 Booleans accept `1, t, true, on, y, yes` as `true` and `0, f, false, off, n, no` as `false` (any case). Any other string is an `invalid` parsing error, and numbers are `true` unless they're 0.
 
-For `:integer`, `:float`, `:boolean`, `:date`, `:time`, `:american_date` and `:american_time`, strings are stripped first and a blank string parses to `nil` without an error, so empty CSV cells don't count as bad input.
+`:decimal` needs the `bigdecimal` gem on Ruby 3.4+; ActiveModel already depends on it.
+
+For `:integer`, `:float`, `:decimal`, `:boolean`, `:date`, `:time`, `:american_date` and `:american_time`, strings are stripped first and a blank string parses to `nil` without an error, so empty CSV cells don't count as bad input.
 
 ### Date and Time Types
 
 ```ruby
 attribute :created_at, :time          # ISO 8601 date and time (Time.xmlschema)
+attribute :updated_at, :datetime      # same as :time, matching ActiveRecord's type name
 attribute :birth_date, :date          # ISO 8601 (Date.iso8601), e.g. "2024-01-31"; free text like "May 1" is invalid
 attribute :us_date, :american_date    # MM/DD/YYYY format
 attribute :us_time, :american_time    # MM/DD/YYYY HH:MM:SS format
@@ -255,7 +259,7 @@ Each read of a default returns a fresh copy (frozen values are shared), so mutat
 
 ### Checking If Attribute Was Set
 
-Every attribute generates a `_was_set?` predicate method:
+Every attribute and association generates a `_was_set?` predicate method:
 
 ```ruby
 user = UserSchema.from_hash(name: 'John')
@@ -462,6 +466,8 @@ user.parsing_errors.full_messages  # => ["Age is invalid"]
 | `unknown_attribute` | is an unknown attribute | `schema.parsing_errors.unknown_attribute` |
 | `unhandled_type` | is an unhandled type | `schema.parsing_errors.unhandled_type` |
 
+The code is kept as each error's type, so `user.parsing_errors.details # => { age: [{ error: :invalid }] }`. Register codes for your own parsers with `Schema::ActiveModelParsingErrors.add_message(:read_only, 'is read only')`; other strings added to `parsing_errors` are kept as messages.
+
 A plain `Schema::Model` uses `Schema::Errors`, which stores the codes themselves (`user.parsing_errors[:age] # => ["invalid"]`).
 
 ### Checking Everything at Once

data/lib/schema/active_model_parsing_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module Schema
+  # One parsing error in {ActiveModelParsingErrors}: its type is the code (e.g. :invalid) and its
+  # message is resolved when it's added. A plain ActiveModel::Error would resolve the message by
+  # reading the attribute, which unknown keys and nested markers ("items:0") don't have.
+  class ActiveModelParsingError < ActiveModel::Error
+    # @return [String]
+    def message
+      options[:message]
+    end
+  end
+end

data/lib/schema/active_model_parsing_errors.rb

@@ -3,10 +3,12 @@
 require 'active_model'
 
 module Schema
-  # Schema::ActiveModelParsingErrors turns parsing error codes into readable messages,
-  # e.g. "Age is invalid" instead of "Age invalid". Override them with I18n keys under schema.parsing_errors.
+  # Schema::ActiveModelParsingErrors gives parsing errors readable messages, e.g. "Age is invalid"
+  # instead of "Age invalid", while keeping the code as the error's type, so
+  # `parsing_errors.details` reports `{ error: :invalid }`. Override messages with I18n keys under
+  # schema.parsing_errors, and register more codes with {.add_message}.
   class ActiveModelParsingErrors < ActiveModel::Errors
-    # Default English message for each parsing error code.
+    # Default English message for each built-in parsing error code.
     MESSAGES = {
       ::Schema::ParsingErrors::INVALID => 'is invalid',
       ::Schema::ParsingErrors::INCOMPATIBLE => 'is an incompatible type',
@@ -15,18 +17,37 @@ module Schema
       ::Schema::ParsingErrors::UNHANDLED_TYPE => 'is an unhandled type'
     }.freeze
 
-    # parsing error keys (e.g. "items:0" or an unknown key) often aren't attributes on the model,
-    # so codes are added as message strings rather than ActiveModel error types
+    # @return [Hash{String => String}] every known code and its default message
+    def self.messages
+      @messages ||= MESSAGES.dup
+    end
+
+    # Registers a parsing error code, e.g. for a custom parser.
+    # @example
+    #   Schema::ActiveModelParsingErrors.add_message(:read_only, 'is read only')
+    #   model.parsing_errors.add(:id, :read_only) # => "Id is read only", details { error: :read_only }
+    # @param code [Symbol, String]
+    # @param message [String] default message; an I18n key schema.parsing_errors.<code> overrides it
+    # @return [void]
+    def self.add_message(code, message)
+      messages[code.to_s] = message
+    end
+
+    # Known codes are stored as the error's type with a readable message. Anything else is kept
+    # as a message string, since parsing error keys (e.g. "items:0") often aren't model attributes.
     def add(attribute, type = :invalid, **)
-      super(attribute, message_for(type), **)
+      code = type.to_s
+      return super unless self.class.messages.key?(code)
+
+      error = ActiveModelParsingError.new(@base, attribute, code.to_sym, message: message_for(code))
+      @errors.append(error)
+      error
     end
 
     private
 
-    def message_for(type)
-      return type unless MESSAGES.key?(type)
-
-      I18n.t("schema.parsing_errors.#{type}", default: MESSAGES[type])
+    def message_for(code)
+      I18n.t("schema.parsing_errors.#{code}", default: self.class.messages[code])
     end
   end
 end

data/lib/schema/all.rb

@@ -15,6 +15,7 @@ module Schema
       # parsers
       base.schema_include ::Schema::Parsers::American
       base.schema_include ::Schema::Parsers::Array
+      base.schema_include ::Schema::Parsers::Decimal
       base.schema_include ::Schema::Parsers::Hash
       base.schema_include ::Schema::Parsers::Json
 

data/lib/schema/associations/has_many.rb

@@ -26,6 +26,10 @@ module Schema
     #{options[:instance_variable]}
   end
 
+  def #{options[:getter]}_was_set?
+    instance_variable_defined?(:#{options[:instance_variable]})
+  end
+
   def #{name}_schema_creator
     @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
   end

data/lib/schema/associations/has_one.rb

@@ -25,6 +25,10 @@ module Schema
     #{options[:instance_variable]}
   end
 
+  def #{options[:getter]}_was_set?
+    instance_variable_defined?(:#{options[:instance_variable]})
+  end
+
   def #{name}_schema_creator
     @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
   end

data/lib/schema/parsers/common.rb

@@ -119,6 +119,11 @@ module Schema
         end
       end
 
+      # @!method parse_datetime(field_name, parsing_errors, value)
+      #   Same as {#parse_time}, so `attribute :created_at, :datetime` matches ActiveRecord's type name.
+      #   @return [Time, nil]
+      alias parse_datetime parse_time
+
       # Parses ISO 8601 dates (Date.iso8601).
       # @return [Date, nil]
       def parse_date(field_name, parsing_errors, value)

data/lib/schema/parsers/decimal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Schema
+  module Parsers
+    # Schema::Parsers::Decimal parses :decimal attributes into BigDecimal, for money and other
+    # exact values. Included by Schema::All. On Ruby 3.4+ bigdecimal is a bundled gem; ActiveModel
+    # already depends on it, otherwise add it to your Gemfile.
+    module Decimal
+      include StringValue
+
+      # Accepted decimal strings, e.g. "12", "-0.50", "1.5e3".
+      DECIMAL_REGEX = /\A[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?\z/
+
+      # Parses decimals from strings and numbers; hashes and arrays are incompatible.
+      # @return [BigDecimal, nil]
+      def parse_decimal(field_name, parsing_errors, value)
+        case value
+        when BigDecimal then value
+        when Integer, Rational then BigDecimal(value, 0)
+        when Float then parse_float_as_decimal(field_name, parsing_errors, value)
+        when String
+          parse_string_value(field_name, parsing_errors, value) { |str| BigDecimal(str) if DECIMAL_REGEX.match?(str) }
+        when nil then nil
+        when ::Hash, ::Array then add_decimal_error(field_name, parsing_errors, ::Schema::ParsingErrors::INCOMPATIBLE)
+        else add_decimal_error(field_name, parsing_errors, ::Schema::ParsingErrors::UNHANDLED_TYPE)
+        end
+      end
+
+      private
+
+      # floats go through their shortest string form, so 1.1 becomes 1.1 and not 1.100000000000000088...
+      def parse_float_as_decimal(field_name, parsing_errors, value)
+        return add_decimal_error(field_name, parsing_errors, ::Schema::ParsingErrors::INCOMPATIBLE) unless value.finite?
+
+        BigDecimal(value.to_s)
+      end
+
+      def add_decimal_error(field_name, parsing_errors, code)
+        parsing_errors.add(field_name, code)
+        nil
+      end
+    end
+  end
+end

data/lib/schema/version.rb

@@ -2,5 +2,5 @@
 
 module Schema
   # Gem version, bumped by release-please
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
 end

data/lib/schema-model.rb

@@ -26,6 +26,7 @@ module Schema
 
   autoload :ActiveModelValidations, 'schema/active_model_validations'
   autoload :All, 'schema/all'
+  autoload :ActiveModelParsingError, 'schema/active_model_parsing_error'
   autoload :ActiveModelParsingErrors, 'schema/active_model_parsing_errors'
   autoload :ArrayHeaders, 'schema/array_headers'
   autoload :Arrays, 'schema/arrays'
@@ -43,6 +44,7 @@ module Schema
     autoload :American, 'schema/parsers/american'
     autoload :Array, 'schema/parsers/array'
     autoload :Common, 'schema/parsers/common'
+    autoload :Decimal, 'schema/parsers/decimal'
     autoload :Hash, 'schema/parsers/hash'
     autoload :Json, 'schema/parsers/json'
     autoload :StringValue, 'schema/parsers/string_value'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Doug Youch
@@ -45,6 +45,7 @@ files:
 - README.md
 - bin/schema-json2csv
 - lib/schema-model.rb
+- lib/schema/active_model_parsing_error.rb
 - lib/schema/active_model_parsing_errors.rb
 - lib/schema/active_model_validations.rb
 - lib/schema/all.rb
@@ -63,6 +64,7 @@ files:
 - lib/schema/parsers/american.rb
 - lib/schema/parsers/array.rb
 - lib/schema/parsers/common.rb
+- lib/schema/parsers/decimal.rb
 - lib/schema/parsers/hash.rb
 - lib/schema/parsers/json.rb
 - lib/schema/parsers/string_value.rb