errgonomic 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b7d451a7e98b347baa9556bf72fd22d3825278bf03afddb9a4fdb0e7c325b03
-  data.tar.gz: b336d798fc24356fc0a340ac24d5c562d10d242d5507a71444daa881831ecb27
+  metadata.gz: 4e2e41e94d099dc04ef7a03ce86060c8d991fb8df5ac0f0faf864e25e49082dd
+  data.tar.gz: 0de70e5eebd4319f18579a8bfb4c64597af07f8963d64cdb9ba357c5aec751e8
 SHA512:
-  metadata.gz: 3967b76933831abb7750f253f345a8845c4bd00a172db427d99cd22c5fd3f41d9d18b36a7a44f4f915b04acca72009f52e4927ec8dfa60d98bea80eda82e1a2c
-  data.tar.gz: 2a7ef8d3aa5dbd1e9777e8a653a48c5d3eafbf1b8514e26a483e3056b5139dce643ace35542062512da59b2fa0c9d4b5ab915754e83e747196dabe65f6af91f8
+  metadata.gz: 2a46187771e5ec92b4229dd4f89de9467358e73b2302400cf54093d12e3db5b303333aea1f3d1a21ddc88e4bfbcc5d205ca5913f84799d16ed706222376f1c9c
+  data.tar.gz: 0d72126a463307e8d40c1d9f4a905fbc4b0f52bb3a791fca7a523c8c124a974f935e3ab0f296ffa59722c869b85f1335bfea81b127ae34131af5a84389bdad2c

data/.rubocop.yml

@@ -18,6 +18,7 @@ Metrics/ClassLength:
   Exclude:
     - lib/errgonomic/option.rb
     - lib/errgonomic/result.rb
+    - test/**/*
 
 # core_ext vendors ActiveSupport's blank?/present? patches; the reopened core
 # classes there are explained by the file header, not per class. Test
@@ -26,3 +27,23 @@ Style/Documentation:
   Exclude:
     - lib/errgonomic/core_ext/**/*
     - test/**/*
+
+# A test states one behavior end to end, and splitting one to satisfy a size
+# metric hides the behavior it was written to name. A cop that names its own
+# Exclude replaces this one, so Metrics/ClassLength repeats the path above.
+Metrics:
+  Exclude:
+    - test/**/*
+
+# The ActiveRecord hooks in the optional concern are one subject — where a
+# reader may come from and what leaves it alone — and reading them together is
+# the point. The generated reader is a heredoc, which the length cops count as
+# if it were code.
+Metrics/BlockLength:
+  Exclude:
+    - lib/errgonomic/rails/active_record_optional.rb
+    - test/**/*
+Metrics/MethodLength:
+  Exclude:
+    - lib/errgonomic/rails/active_record_optional.rb
+    - test/**/*

data/README.md

@@ -107,12 +107,14 @@ in Errgonomic::Option::None
 end
 ```
 
-An unhandled Option refuses to leak into your output: `to_s` and `to_json` raise `Errgonomic::SerializeError`, so you handle the inner value deliberately rather than shipping `#<Errgonomic::Option::Some...>` to a user.
+An unhandled Option refuses to leak into your output: `to_s`, `to_json`, and `as_json` raise `Errgonomic::SerializeError`, so you handle the inner value deliberately rather than shipping `#<Errgonomic::Option::Some...>` to a user. The refusal covers `as_json` because Hash and Array serialization recurses through that method, and an Option nested in a payload would otherwise serialize as `{"value": ...}`.
 
 `unwrap!` and `expect!` are for tests and consoles, not application code: they raise on `None`, which is exactly the ambiguous failure the type exists to prevent. Application code should always have a combinator or pattern match that handles the `None` branch explicitly; if none fits, that is a gap worth an issue rather than a reason to unwrap.
 
 Presence follows the discriminant, as in Rust: `Some` is `present?` and `None` is `blank?`, regardless of the wrapped value. So `Some(false).present?` and `Some(nil).present?` are both `true`. If you care about the inner value's own presence, unwrap it first.
 
+The presence helpers are soft-deprecated on Options in favor of the combinators. The present side unwraps, where on any other object it returns the receiver — `Some(v).present_or_raise!(msg)`, `present_or(default)`, `present_or_else { }`, and `presence` all yield `v`, and `None` raises, substitutes, or answers `nil` — and each call prints a one-line stderr nudge naming the combinator to use instead (`expect!`, `unwrap_or`, `unwrap_or_else`, `unwrap_or(nil)`). The blank side (`blank_or*`) raises `UnwrappedAccessError` outright: an Option's blankness is its discriminant, so test it with `none?`.
+
 Equality is between Options only: `Some(5) == Some(5)`, but `Some(5) == 5` and `None() == nil` are `false`. That is quiet, never an error, matching how every Ruby object compares across types. Rust rejects `Some(5) == 5` at compile time; Ruby cannot, so guard the idiom in review and tests: compare against a wrapped value (`opt == Some(5)`) or test the inner value (`opt.some_and? { |v| v == 5 }`).
 
 ### Result
@@ -146,7 +148,7 @@ in Errgonomic::Result::Err, Exception => e
 end
 ```
 
-Like Options, unwrapped Results refuse `to_s` and `to_json`. And `Object#result?` / `Object#assert_result!` help enforce at runtime that a value is a Result.
+Like Options, unwrapped Results refuse `to_s`, `to_json`, and `as_json`. And `Object#result?` / `Object#assert_result!` help enforce at runtime that a value is a Result.
 
 ### Optional collections
 
@@ -199,21 +201,69 @@ end
 
 When `Rails::Railtie` is defined, Errgonomic installs a Railtie with two opt-in integrations for ActiveRecord:
 
-- `include Errgonomic::Rails::ActiveRecordOptional` in a model makes its nullable attributes and `optional: true` associations return `Some(value)` or `None()` instead of a value-or-nil. This is all-or-nothing per model: every nullable column and optional association is wrapped, with no per-attribute opt-in.
+- `include Errgonomic::Rails::ActiveRecordOptional` in a model makes its nullable attributes and `optional: true` associations return `Some(value)` or `None()` instead of a value-or-nil. Every nullable column and optional association is wrapped, with no per-attribute opt-in. Two kinds of attribute stay unwrapped: those declared with `encrypts`, whose surrounding machinery reads the raw value, and those named by `errgonomic_optional_except`.
+
+```ruby
+class Credential < ApplicationRecord
+  errgonomic_optional_except :legacy_token
+  include Errgonomic::Rails::ActiveRecordOptional
+
+  encrypts :access_secret   # also left unwrapped, declared either side of the include
+end
+```
+
+**Where the include goes.** A model that includes the concern converts itself, and only itself. The include may sit at the top of the model with the other concerns, which is where Rails convention puts one. An `optional: true` association declared below it is wrapped as it is declared, rather than only the associations the class happened to declare above it.
+
+```ruby
+class Book < ApplicationRecord
+  include Errgonomic::Rails::ActiveRecordOptional
+
+  belongs_to :author, optional: true   # Some(author) or None()
+end
+```
+
+On an application's own base class, the same include reaches every model below it, and no model mentions errgonomic again:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+  include Errgonomic::Rails::ActiveRecordOptional
+end
+```
+
+Converting one model or all of them is therefore where the include goes, not a setting to choose. The association macros wrap as each model declares them, and a model's nullable columns are wrapped when ActiveRecord loads its schema, so no class body needs a database while it loads.
+
+An application's own base class is the useful place for it. Engine and gem models such as `ActiveStorage::Blob` and `PaperTrail::Version` descend straight from `ActiveRecord::Base`, and their own code reads their attributes knowing nothing about an Option. Including it on `ActiveRecord::Base` reaches those too, which is rarely what anyone wants.
+
+Two ways out, both readable in a model with no include of its own to point at:
+
+```ruby
+class LegacyImport < ApplicationRecord
+  errgonomic_optional_off                     # this model keeps value-or-nil throughout
+end
+
+class Credential < ApplicationRecord
+  errgonomic_optional_except :legacy_token    # this attribute does
+end
+```
+
+`Model.errgonomic_optionals` reports which readers a model wrapped, which is how to check that a conversion did what it meant to.
+
 - `delegate_optional :name, to: :association` (available on all models) delegates through an optional association, returning an Option instead of raising on nil.
 
 `Object#to_option` is also available in Rails to lift any value into an Option (`nil.to_option # => None()`).
 
 #### ActiveRecord compromises
 
-ActiveRecord assumes things about accessors that a strict Rust Option cannot satisfy, so the integration carries four deliberate compromises. Everywhere else, treat a departure from Rust's `Option` semantics as a bug; these four are intended:
+ActiveRecord assumes things about accessors that a strict Rust Option cannot satisfy, so the integration carries five deliberate compromises. Everywhere else, treat a departure from Rust's `Option` semantics as a bug; these five are intended:
 
 1. `None#nil?` answers `true`, so ActiveRecord internals and ordinary `.nil?` checks treat an absent value as absent. Equality does not follow suit: `None() == nil` is still `false`.
 2. `Some` delegates `persisted?`, `marked_for_destruction?`, and `touch_later` to its record, so a `Some` can stand in for its record during persistence.
-3. Quoting is patched so an `Option` passed into `where`/`quote` is unwrapped at the SQL boundary.
+3. Quoting and the predicate builder are patched so an `Option` passed into `where`/`quote` is unwrapped at the SQL boundary: `Some(v)` binds exactly as `v`, and `None()` as `nil`, so a hash condition asks for `IS NULL`. An array of Options unwraps too. An Option interpolated into raw SQL (`where("id = ?", opt)`) still raises, as it should.
 4. `SomeValidator` provides a presence-style validation for Option attributes.
+5. Attributes declared with `encrypts` are never wrapped: ActiveRecord Encryption's own machinery (a length validator it registers outside `Model.validators`) reads the raw value and cannot survive an Option.
 
-The set is closed. If a future integration appears to need a fifth compromise, that is a signal ActiveRecord is pushing back somewhere unmapped, and it warrants a design discussion rather than a quiet patch.
+The set is closed. If a future integration appears to need a sixth compromise, that is a signal ActiveRecord is pushing back somewhere unmapped, and it warrants a design discussion rather than a quiet patch. `errgonomic_optional_except` is deliberately not on the list: it is configuration, an escape hatch that softens the all-or-nothing include for whatever conflict shows up next, rather than a semantic exception.
 
 ## Development
 

data/lib/errgonomic/option.rb

@@ -194,6 +194,114 @@ module Errgonomic
         none?
       end
 
+      # The presence helpers on Object keep their receiver; on an Option that
+      # would hand back the wrapper where the caller asked for a value. Here
+      # the present side unwraps instead, so a name that reads like an
+      # accessor behaves like one. The whole family is soft-deprecated on
+      # Options in favor of the combinators, so each call nudges via stderr,
+      # and the blank side, which has no working call sites to preserve,
+      # teaches rather than guesses at semantics.
+
+      # Returns the inner value of a Some, and raises on a None. Presence
+      # follows the discriminant, so Some(nil) yields nil.
+      #
+      # @param message [String] The error message to raise on a None.
+      # @return [Object] The inner value of a Some.
+      #
+      # @example
+      #   Some("secret").present_or_raise!("no secret") # => "secret"
+      #   Some(nil).present_or_raise!("no secret") # => nil
+      #   None().present_or_raise!("no secret") # => raise Errgonomic::NotPresentError, "no secret"
+      def present_or_raise!(message)
+        presence_nudge('present_or_raise', 'expect!')
+        raise Errgonomic::NotPresentError, message if none?
+
+        value
+      end
+
+      alias present_or_raise present_or_raise!
+
+      # Returns the inner value of a Some, and the given default on a None.
+      # No pedantic type check on the default: this family is deprecated on
+      # Options, and unwrap_or, which the nudge points to, has none either.
+      #
+      # @param default [Object] The value to return on a None.
+      # @return [Object] The inner value of a Some, otherwise the default.
+      #
+      # @example
+      #   Some("secret").present_or("fallback") # => "secret"
+      #   None().present_or("fallback") # => "fallback"
+      def present_or(default)
+        presence_nudge('present_or', 'unwrap_or')
+        return default if none?
+
+        value
+      end
+
+      # Returns the inner value of a Some, and the result of the block on a
+      # None.
+      #
+      # @param block [Proc] The block to call on a None.
+      # @return [Object] The inner value of a Some, otherwise the block's value.
+      #
+      # @example
+      #   Some("secret").present_or_else { "fallback" } # => "secret"
+      #   None().present_or_else { "fallback" } # => "fallback"
+      def present_or_else(&block)
+        presence_nudge('present_or_else', 'unwrap_or_else')
+        return block.call if none?
+
+        value
+      end
+
+      # Returns the inner value of a Some, and nil on a None, so the Rails
+      # +presence || default+ idiom reaches the value rather than the wrapper.
+      #
+      # @return [Object, nil] The inner value of a Some, otherwise nil.
+      #
+      # @example
+      #   Some("secret").presence # => "secret"
+      #   None().presence # => nil
+      #   None().presence || "fallback" # => "fallback"
+      def presence
+        presence_nudge('presence', 'unwrap_or(nil)')
+        return nil if none?
+
+        value
+      end
+
+      # @example the blank side of the presence family teaches the combinators
+      #   begin
+      #     None().blank_or("x")
+      #   rescue NoMethodError => e
+      #     e.class
+      #   end # => Errgonomic::UnwrappedAccessError
+      def blank_or(_default)
+        raise_blank_side_teaching(:blank_or)
+      end
+
+      # @example
+      #   begin
+      #     Some(1).blank_or_else { :x }
+      #   rescue NoMethodError => e
+      #     e.class
+      #   end # => Errgonomic::UnwrappedAccessError
+      def blank_or_else(&_block)
+        raise_blank_side_teaching(:blank_or_else)
+      end
+
+      # @example
+      #   begin
+      #     None().blank_or_raise!("msg")
+      #   rescue NoMethodError => e
+      #     e.class
+      #   end # => Errgonomic::UnwrappedAccessError
+      def blank_or_raise!(_message)
+        raise_blank_side_teaching(:blank_or_raise!)
+      end
+
+      alias blank_or_raise blank_or_raise!
+
       # return an Array with the contained value, if any
       # @example
       #   Some(1).to_a # => [1]
@@ -448,6 +556,15 @@ module Errgonomic
         raise Errgonomic::SerializeError, 'cannot serialize an unwrapped Option'
       end
 
+      # ActiveSupport's Hash#as_json and Array#as_json recurse through their
+      # members with as_json rather than to_json, so an Option nested in a
+      # payload reaches Object#as_json and serializes as its instance
+      # variables. Refuse there too, and the guard holds wherever an Option
+      # travels.
+      def as_json(*_args)
+        raise Errgonomic::SerializeError, 'cannot serialize an unwrapped Option'
+      end
+
       # pp uses its own object dump unless told otherwise; keep it consistent
       # with inspect.
       def pretty_print(pp)
@@ -502,6 +619,21 @@ module Errgonomic
         None()
       end
 
+      private
+
+      def presence_nudge(from, to)
+        warn "Errgonomic: `#{from}` on an Option is soft-deprecated; prefer `#{to}`."
+      end
+
+      def raise_blank_side_teaching(name)
+        raise Errgonomic::UnwrappedAccessError.new(<<~MSG, name)
+          `#{name}` is not supported on an Option, whose blankness is its discriminant.
+          Test it with none?, or supply a fallback with unwrap_or / unwrap_or_else.
+        MSG
+      end
+
+      public
+
       # Rust's mutating combinators (insert, get_or_insert, take, replace)
       # are deliberately omitted: an Option here is a value, not a slot.
     end

data/lib/errgonomic/rails/active_record_delegate_optional.rb

@@ -9,6 +9,22 @@ module Errgonomic
       extend ActiveSupport::Concern
 
       class_methods do
+        # Names attributes that ActiveRecordOptional must leave alone. It has to
+        # be callable before the include, which is what starts the wrapping for
+        # a model that converts itself, so it lives here rather than in the
+        # concern. Where the concern is included on a base class there is no
+        # before, so it also takes back a reader already wrapped.
+        def errgonomic_optional_except(*names)
+          @errgonomic_optional_exceptions = errgonomic_optional_exceptions + names.map(&:to_s)
+          errgonomic_unwrap_optionals(*names) if respond_to?(:errgonomic_unwrap_optionals)
+          @errgonomic_optional_exceptions
+        end
+
+        def errgonomic_optional_exceptions
+          @errgonomic_optional_exceptions ||=
+            superclass.respond_to?(:errgonomic_optional_exceptions) ? superclass.errgonomic_optional_exceptions.dup : []
+        end
+
         def delegate_optional(*methods, to: nil, prefix: nil, private: nil)
           return if to.nil?
 

data/lib/errgonomic/rails/active_record_optional.rb

@@ -4,9 +4,9 @@ module Errgonomic
   module Rails
     # Concern to make ActiveRecord optional attributes and associations return an Option.
     #
-    # Four pragmatic compromises below satisfy ActiveRecord's assumptions
+    # Five pragmatic compromises below satisfy ActiveRecord's assumptions
     # about how accessors behave. They are deliberate exceptions to "Option
-    # behaves like Rust's Option", and the set is closed: a fifth would be a
+    # behaves like Rust's Option", and the set is closed: a sixth would be a
     # signal that ActiveRecord is pushing back somewhere unmapped, deserving
     # a design discussion rather than a quiet patch.
     #
@@ -15,22 +15,131 @@ module Errgonomic
     #    None() == nil stays false.
     # 2. Some delegates persisted?, marked_for_destruction?, and touch_later
     #    to its record, so a Some can stand in for it during persistence.
-    # 3. Two quoting prepends unwrap Options at the SQL boundary, so an
-    #    Option can be passed to where/quote.
+    # 3. Quoting and predicate-building prepends unwrap Options at the SQL
+    #    boundary, so an Option can be passed to where/quote.
     # 4. SomeValidator provides a presence-style validation for Option
     #    attributes.
+    # 5. Attributes declared with encrypts are never wrapped: ActiveRecord
+    #    Encryption registers a length validator outside Model.validators
+    #    that reads the raw value and cannot survive an Option.
+    #
+    # errgonomic_optional_except is not on the list: it is configuration, an
+    # escape hatch for whatever conflict shows up next, not a semantic
+    # exception.
     module ActiveRecordOptional
       extend ActiveSupport::Concern
 
       included do
-        # ::Rails.logger.debug('ActiveRecordOptional')
-        optional_associations = reflect_on_all_associations(:belongs_to)
-                                .select { |r| r.options[:optional] }
-                                .map(&:name)
-        optional_attributes = column_names
-                              .select { |n| column_for_attribute(n).null }
-        @errgonomic_optionals = (optional_attributes + optional_associations)
-        @errgonomic_optionals.each do |name|
+        reflect_on_all_associations(:belongs_to)
+          .select { |r| r.options[:optional] }
+          .each { |r| errgonomic_wrap_optional(r.name) }
+      end
+
+      class_methods do
+        # What a model wrapped is the signal that a conversion did what it
+        # meant to, and the columns are not wrapped until the schema loads, so
+        # asking loads it.
+        def errgonomic_optionals
+          load_schema
+          errgonomic_optional_names
+        end
+
+        # The set as it stands, for the wrapping itself: reaching for the
+        # schema from here would ask the schema to load while it is loading.
+        def errgonomic_optional_names
+          @errgonomic_optional_names ||= []
+        end
+
+        # Read when a reader is about to be wrapped rather than snapshotted at
+        # include time, so an exclusion works on either side of the include.
+        # That is what an include on a base class needs: there is no "before"
+        # for a model to declare anything in.
+        def errgonomic_optional_exclusions
+          inherited = if superclass.respond_to?(:errgonomic_optional_exclusions)
+                        superclass.errgonomic_optional_exclusions
+                      else
+                        []
+                      end
+
+          inherited | Array(encrypted_attributes).map(&:to_s) | Array(try(:errgonomic_optional_exceptions)).map(&:to_s)
+        end
+
+        # A model that keeps value-or-nil throughout, for whatever the
+        # application knows about it that the concern does not. Where the
+        # concern is included on a base class, this is how a model leaves.
+        def errgonomic_optional_off
+          @errgonomic_optional_off = true
+          errgonomic_unwrap_optionals(*errgonomic_optional_names.dup)
+        end
+
+        def errgonomic_optional_off?
+          return true if defined?(@errgonomic_optional_off) && @errgonomic_optional_off
+
+          superclass.respond_to?(:errgonomic_optional_off?) && superclass.errgonomic_optional_off?
+        end
+
+        # A reader wrapped by an ancestor is already an Option; a subclass
+        # that wrapped it again would nest it.
+        def errgonomic_optional?(name)
+          return true if errgonomic_optional_names.include?(name)
+
+          superclass.respond_to?(:errgonomic_optional?) && superclass.errgonomic_optional?(name)
+        end
+
+        # ActiveRecord defines its attribute methods the first time a model
+        # needs its schema, not when the class body runs. Wrapping nullable
+        # columns from the same seam keeps a database out of class loading.
+        def load_schema!
+          super
+          errgonomic_wrap_nullable_columns
+        end
+
+        # A subclass loads its own schema, so whichever of the two is touched
+        # first wraps the shared columns first, and a subclass that got there
+        # first would wrap its parent's readers a second time. Walk the chain
+        # from the top down instead, so an ancestor's readers always exist
+        # before a subclass considers the same name.
+        def errgonomic_wrap_nullable_columns
+          superclass.errgonomic_wrap_nullable_columns if superclass.respond_to?(:errgonomic_wrap_nullable_columns)
+          # An abstract class has no table, and asking one for its columns
+          # raises. The concern belongs on an abstract class all the same: that
+          # is where an application puts behaviour every model should have.
+          return if abstract_class? || table_name.nil?
+
+          column_names.each { |name| errgonomic_wrap_optional(name) if column_for_attribute(name).null }
+        end
+
+        # A concern belongs at the top of a model, above its associations, so
+        # an optional belongs_to is routinely declared after the include.
+        # Wrap it when it arrives, or the conversion is silently partial.
+        def belongs_to(name, scope = nil, **options)
+          super.tap { errgonomic_wrap_optional(name) if options[:optional] }
+        end
+
+        # Encryption surrounds an attribute with machinery that reads the raw
+        # value, including a length validator that calls to_s on it, so a
+        # wrapped encrypted attribute cannot be saved. Declaring encrypts
+        # after the include is the ordinary spelling, and the exclusion is read
+        # from ActiveRecord's own register when a reader is about to be
+        # wrapped, so this only has to take back a reader already wrapped.
+        def encrypts(*names, **options)
+          super.tap { errgonomic_unwrap_optionals(*names) }
+        end
+
+        def errgonomic_unwrap_optionals(*names)
+          names.map(&:to_s).each do |name|
+            next unless errgonomic_optional_names.delete(name)
+
+            remove_method(name)
+          end
+        end
+
+        def errgonomic_wrap_optional(name)
+          name = name.to_s
+          return if errgonomic_optional_off?
+          return if errgonomic_optional_exclusions.include?(name) || errgonomic_optional?(name)
+
+          errgonomic_optional_names << name
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}
               reads = Thread.current[:errgonomic_optional_reads] ||= {}
@@ -51,12 +160,6 @@ module Errgonomic
           RUBY
         end
       end
-
-      class_methods do
-        def errgonomic_optionals
-          @errgonomic_optionals
-        end
-      end
     end
   end
 end
@@ -136,3 +239,33 @@ module Errgonomic
 end
 
 ActiveRecord::ConnectionAdapters::Quoting.prepend(Errgonomic::Rails::ActiveRecordQuoting)
+
+module Errgonomic
+  module Rails
+    # A hash condition never reaches the quoting layer as its raw value: the
+    # predicate builder hands it to a bind attribute, which serializes it
+    # through the column type and casts an unrecognized object to nil. Unwrap
+    # one step earlier, where every hash condition passes, so a Some binds as
+    # its inner value and a None as nil, which Arel renders as IS NULL.
+    module ActiveRecordPredicateBuilder
+      def build(attribute, value, *args)
+        super(attribute, Errgonomic::Rails.unwrap_options(value), *args)
+      end
+    end
+
+    # Unwrap Options in a query condition, reaching one level into an array
+    # so a list of Options binds like a list of values.
+    def self.unwrap_options(value)
+      case value
+      when Errgonomic::Option::Any
+        value.unwrap_or(nil)
+      when Array
+        value.any? { |v| v.is_a?(Errgonomic::Option::Any) } ? value.map { |v| unwrap_options(v) } : value
+      else
+        value
+      end
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder.prepend(Errgonomic::Rails::ActiveRecordPredicateBuilder)

data/lib/errgonomic/result.rb

@@ -369,6 +369,15 @@ module Errgonomic
         raise Errgonomic::SerializeError, 'cannot serialize an unwrapped Result'
       end
 
+      # ActiveSupport's Hash#as_json and Array#as_json recurse through their
+      # members with as_json rather than to_json, so a Result nested in a
+      # payload reaches Object#as_json and serializes as its instance
+      # variables. Refuse there too, and the guard holds wherever a Result
+      # travels.
+      def as_json(*_args)
+        raise Errgonomic::SerializeError, 'cannot serialize an unwrapped Result'
+      end
+
       # pp uses its own object dump unless told otherwise; keep it consistent
       # with inspect.
       def pretty_print(pp)

data/lib/errgonomic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Errgonomic
-  VERSION = '0.8.0'
+  VERSION = '0.8.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: errgonomic
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Nick Zadrozny
 bindir: exe
 cert_chain: []
-date: 1980-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby