paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/prepared_state_association_reader.rb

@@ -2,71 +2,161 @@
 # rbs_inline: enabled
 
 module PaperTrailDiff
-  # Reads plain direct edges without creating AR records for their members.
+  # Reads plain edges without creating AR records for their members: direct
+  # edges, polymorphic `belongs_to`, and `has_many :through` built from them.
   class PreparedStateAssociationReader
-    #: (PreparedRecordIndex, untyped) -> void
-    def initialize(records, edges)
+    #: (PreparedRecordIndex, untyped, ScopeCondition::Cache) -> void
+    def initialize(records, edges, conditions)
       @records = records
       @edges = edges
+      @conditions = conditions
     end
 
-    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
-    def call(owner, reflection, boundary)
-      return [false, []] unless supported?(reflection)
+    # Unranked, as a part of a has_many through is read, it returns every row
+    # the part's conditions admit, a record reached twice appearing twice.
+    #: (PreparedRecordState, untyped, untyped, ?ranked: bool) -> [bool, Array[PreparedRecordState]]
+    def call(owner, reflection, boundary, ranked: true)
+      return [false, []] unless supported?(reflection, ranked)
+      return through(owner, reflection, boundary, ranked) if reflection.options[:through]
+      return target(owner, reflection, boundary, ranked) if reflection.belongs_to?
 
-      if reflection.belongs_to?
-        id = owner.attributes[reflection.foreign_key.to_s]
-        return [true, []] if id.nil?
-
-        handled, state = @records.snapshot_state_before(reflection.klass, id, boundary)
-        return [handled, state ? [state] : []]
-      end
-      children(owner, reflection, boundary)
+      children(owner, reflection, boundary, ranked)
     end
 
     private
 
     # @rbs @records: PreparedRecordIndex
     # @rbs @edges: untyped
+    # @rbs @conditions: ScopeCondition::Cache
+
+    # A polymorphic target's class is known only once a record names it, so
+    # `target` reads its scope for each record instead.
+    #: (untyped, bool) -> bool
+    def supported?(reflection, ranked)
+      !reflection.foreign_key.is_a?(Array) &&
+        %i[belongs_to has_one has_many].include?(reflection.macro) &&
+        (reflection.polymorphic? || !@conditions.call(reflection, ranked: ranked).nil?)
+    end
+
+    #: (PreparedRecordState, untyped, bool, ?untyped) -> bool
+    def in_scope?(state, reflection, ranked, model_class = reflection.klass)
+      condition = @conditions.call(reflection, model_class, ranked: ranked) #: ScopeCondition
+      condition.matches?(state.attributes)
+    end
+
+    # A type that names no class, or a class whose scope cannot be read as
+    # conditions, is left to the record path, which raises for the first and
+    # reads the second through its association.
+    #: (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def target(owner, reflection, boundary, ranked)
+      id = owner.attributes[reflection.foreign_key.to_s]
+      return [true, []] if id.nil?
+
+      model_class = target_class(owner, reflection)
+      return [false, []] unless model_class &&
+                                @conditions.call(reflection, model_class, ranked: ranked)
 
-    #: (untyped) -> bool
-    def supported?(reflection)
-      !reflection.options[:through] && !reflection.polymorphic? && reflection.scope.nil? &&
-        !reflection.klass.default_scopes? && !reflection.foreign_key.is_a?(Array) &&
-        %i[belongs_to has_one has_many].include?(reflection.macro)
+      handled, state = @records.snapshot_state_before(model_class, id, boundary)
+      [handled, state && in_scope?(state, reflection, ranked, model_class) ? [state] : []]
     end
 
-    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
-    def children(owner, reflection, boundary)
+    #: (PreparedRecordState, untyped) -> untyped
+    def target_class(owner, reflection)
+      return reflection.klass unless reflection.polymorphic?
+
+      AssociationTraversal.named_class(owner.attributes[reflection.foreign_type].to_s)
+    end
+
+    # The members of each join record the owner had at the boundary, as
+    # PreparedHistory#through_records reads them from records. Under
+    # `source_type:`, only join records of that type count. A has_many
+    # through reads its parts unranked, as its query does.
+    #: (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def through(owner, reflection, boundary, ranked)
+      parts_ranked = ranked && !reflection.collection?
+      handled, joins = call(owner, reflection.through_reflection, boundary, ranked: parts_ranked)
+      return [false, []] unless handled
+
+      rows = [] #: Array[PreparedRecordState]
+      joins.each do |join|
+        next unless typed_join?(reflection, join)
+
+        handled, states = call(join, reflection.source_reflection, boundary, ranked: parts_ranked)
+        return [false, []] unless handled
+
+        rows.concat(states)
+      end
+      [true, through_members(reflection, rows, ranked)]
+    end
+
+    # The through's own scope applies after its parts' scopes, to each row,
+    # and a ranked read then keeps a record reached twice as one member.
+    #: (untyped, Array[PreparedRecordState], bool) -> Array[PreparedRecordState]
+    def through_members(reflection, rows, ranked)
+      condition = @conditions.call(reflection, ranked: ranked) #: ScopeCondition
+      members = condition.members(rows)
+      return members unless ranked
+
+      first_if_one(reflection, members.uniq { |state| identity(state) })
+    end
+
+    # A has_one keeps the first of its records.
+    #: (untyped, Array[PreparedRecordState]) -> Array[PreparedRecordState]
+    def first_if_one(reflection, states)
+      reflection.collection? ? states : states.first(1)
+    end
+
+    #: (untyped, PreparedRecordState) -> bool
+    def typed_join?(reflection, join)
+      AssociationTraversal.source_type_member?(reflection, join.attributes[reflection.foreign_type])
+    end
+
+    # A record reached through two join records is one member.
+    #: (PreparedRecordState) -> Array[untyped]
+    def identity(state)
+      model = state.model_class
+      [model.base_class.name, *Array(model.primary_key).map { |key| state.attributes[key].to_s }]
+    end
+
+    #: (PreparedRecordState, untyped, untyped, bool) -> [bool, Array[PreparedRecordState]]
+    def children(owner, reflection, boundary, ranked)
       selected = [] #: Array[PreparedRecordState]
       @edges.call(owner.model_class, reflection).each_value do |group|
         ids_for(group, owner).each do |id|
           handled, child = @records.snapshot_state_before(group.fetch(:model), id, boundary)
           return [false, []] unless handled
 
-          selected << child if child && member?(child, owner, reflection)
+          selected << child if child && member?(child, owner, reflection, ranked)
         end
       end
-      [true, reflection.collection? ? selected : selected.first(1)]
+      return [true, selected] unless ranked
+
+      condition = @conditions.call(reflection) #: ScopeCondition
+      [true, first_if_one(reflection, condition.rank(selected))]
     end
 
     #: (untyped, PreparedRecordState) -> Array[untyped]
     def ids_for(group, owner)
       owners = group[:owners]
-      id = owner.attributes[owner.model_class.primary_key].to_s
       empty = [] #: Array[untyped]
-      owners ? owners.fetch(id, empty) : group.fetch(:ids)
+      owners ? owners.fetch(owner_id(owner), empty) : group.fetch(:ids)
     end
 
-    #: (PreparedRecordState, PreparedRecordState, untyped) -> bool
-    def member?(child, owner, reflection)
-      owner_id = owner.attributes[owner.model_class.primary_key].to_s
-      return false unless child.attributes[reflection.foreign_key.to_s].to_s == owner_id
+    #: (PreparedRecordState, PreparedRecordState, untyped, bool) -> bool
+    def member?(child, owner, reflection, ranked)
+      return false unless child.attributes[reflection.foreign_key.to_s].to_s == owner_id(owner)
+      return false unless AssociationTraversal.sti_member?(reflection.klass, child.attributes)
+      return false unless in_scope?(child, reflection, ranked)
       return true unless reflection.options[:as]
 
       matching_type?(child, owner.model_class, reflection)
     end
 
+    #: (PreparedRecordState) -> String
+    def owner_id(owner)
+      owner.attributes[owner.model_class.primary_key].to_s
+    end
+
     #: (PreparedRecordState, untyped, untyped) -> bool
     def matching_type?(child, model, reflection)
       types = [model.name, model.base_class.name,

data/lib/paper_trail_diff/recorded_changes.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # The changes PaperTrail wrote with one version, typed by the version's model.
+  #
+  # A step's diff compares reconstructed states, so it also holds whatever was
+  # saved without a version before the next one was read. This is the other
+  # account of the same event: only what PaperTrail recorded for it. Comparing
+  # the two is how a caller tells an unrecorded write from the event's own edit.
+  #
+  # PaperTrail's `version.changeset` finds the model through `version.item`,
+  # which is a query per version and nothing at all once the record is deleted.
+  # The version already names its model, so neither is needed here.
+  class RecordedChanges
+    IGNORE_NAMES_REQUIRED = 'ignore: must be an array of strings or symbols; a version ' \
+                            'has no association path for paths: to match'
+    private_constant :IGNORE_NAMES_REQUIRED
+
+    #: (untyped, ignore: untyped) -> Hash[String, ValueChange]?
+    def self.call(version, ignore:)
+      new(version, ignore: ignore).call
+    end
+
+    #: (untyped, ignore: untyped) -> void
+    def initialize(version, ignore:)
+      @version = version
+      @ignore = ignore
+    end
+
+    #: () -> Hash[String, ValueChange]?
+    def call
+      raise InvalidEndpointError, 'expected a PaperTrail version' unless Endpoint.version?(@version)
+
+      ignored = ignored_names
+      return unless recorded?
+
+      model_class = Endpoint.model_class(@version)
+      changes = ActivityEventRecordResolver.new.deserialized_changeset(@version, model_class)
+      return if changes.nil?
+
+      value_changes(changes, Array(model_class.primary_key) + ignored)
+    end
+
+    private
+
+    # @rbs @version: untyped
+    # @rbs @ignore: untyped
+
+    # Validated before anything is read, so a bad option fails the same way
+    # whether or not this version happened to record changes. Subclasses of
+    # Array and String pass, as in other methods' `ignore:`; Symbol has none.
+    #: () -> Array[String]
+    def ignored_names
+      valid = @ignore.is_a?(Array) && @ignore.all? do |name|
+        name.is_a?(String) || name.instance_of?(Symbol)
+      end
+      raise ConfigurationError, IGNORE_NAMES_REQUIRED unless valid
+
+      @ignore.map(&:to_s)
+    end
+
+    # Without the column, or with it left empty for this version, nothing was
+    # recorded. That is not the same answer as a recorded empty changeset.
+    #: () -> bool
+    def recorded?
+      @version.class.column_names.include?('object_changes') && !@version.object_changes.nil?
+    end
+
+    # Primary keys identify the record rather than describe it, as in a diff.
+    #: (untyped, Array[String]) -> Hash[String, ValueChange]
+    def value_changes(changes, excluded)
+      recorded = {} #: Hash[String, ValueChange]
+      changes.each do |name, values|
+        key = name.to_s
+        next if excluded.include?(key)
+
+        recorded[key] = ValueChange.new(from: values.first, to: values.last)
+      end
+      recorded.sort.to_h.freeze
+    end
+  end
+end

data/lib/paper_trail_diff/recorded_class.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # The class a record had at one version, which decides the associations it
+  # can have. Without an `item_subtype` column PaperTrail stores only the base
+  # class, so an STI subclass is read from the stored inheritance column: the
+  # state before the change, or for a create, the value it was created with.
+  # A version that stored neither stays on the base class.
+  module RecordedClass
+    module_function
+
+    #: (untyped) -> untyped
+    def for(version)
+      model = Endpoint.model_class(version)
+      return model unless sti_base?(model)
+
+      type = stored_type(version, model).to_s
+      type.empty? ? model : model.sti_class_for(type)
+    rescue StandardError => e
+      raise unless subclass_not_found?(e)
+
+      raise InvalidEndpointError, "cannot resolve endpoint model: #{type}", cause: e
+    end
+
+    #: (untyped) -> bool
+    def sti_base?(model)
+      model.base_class == model && model.columns_hash.key?(model.inheritance_column.to_s)
+    end
+    private_class_method :sti_base?
+
+    #: (untyped, untyped) -> untyped
+    def stored_type(version, model)
+      column = model.inheritance_column.to_s
+      if version.object
+        attributes = version.object_deserialized
+        return attributes.is_a?(Hash) ? attributes[column] || attributes[column.to_sym] : nil
+      end
+
+      changes = ActivityEventRecordResolver.new.deserialized_changeset(version, model)
+      values = changes[column] if changes.respond_to?(:key?) && changes.key?(column)
+      values.last if values.is_a?(Array)
+    end
+    private_class_method :stored_type
+
+    #: (StandardError) -> bool
+    def subclass_not_found?(error)
+      active_record = Object.const_get(:ActiveRecord) #: untyped
+      error.is_a?(active_record.const_get(:SubclassNotFound))
+    end
+    private_class_method :subclass_not_found?
+  end
+end

data/lib/paper_trail_diff/scope_condition.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # An association scope, or its target's default scope, read as conditions
+  # on stored attributes, so membership at a boundary can be decided from each
+  # record's state there rather than by a query. A limit, offset or has_one
+  # order then ranks the records that meet the conditions (ScopeRanking). It
+  # reads the relation the scope builds once and never runs application code
+  # per record. A scope it cannot read exactly builds no condition, and the
+  # caller keeps its slower path.
+  class ScopeCondition
+    # Relation parts that leave membership to the where clause and the
+    # ranking alone.
+    RELATION_VALUES = %i[where order reordering limit offset readonly strict_loading
+                         extending].freeze
+    # Types whose stored values compare in Ruby as the database compares them,
+    # named rather than referenced so that loading needs no Active Model.
+    VALUE_TYPES = %w[ActiveModel::Type::Integer ActiveModel::Type::Boolean
+                     ActiveModel::Type::ImmutableString].freeze
+    TEXT_TYPE = 'ActiveModel::Type::ImmutableString'
+    ENUM_TYPE = 'ActiveRecord::Enum::EnumType'
+    BIND_PARAM = 'Arel::Nodes::BindParam'
+    ATTRIBUTE = 'Arel::Attributes::Attribute'
+    # Adapters that compare strings exactly by default. MySQL and SQL Server
+    # ignore case and trailing spaces by default, which Ruby cannot follow.
+    EXACT_TEXT_ADAPTERS = %w[sqlite3 postgresql].freeze
+
+    # Raised while reading a node that has no exact plain-Ruby reading.
+    class Unreadable < StandardError; end
+    private_constant :Unreadable
+
+    # Whether the reflection filters its target beyond its keys at all.
+    #: (untyped) -> bool
+    def self.scoped?(reflection)
+      !reflection.scope.nil? || reflection.klass.default_scopes?
+    end
+
+    # A through also filters by the scopes of each reflection it passes.
+    #: (untyped) -> bool
+    def self.scoped_path?(reflection)
+      return !reflection.scope.nil? if reflection.polymorphic?
+      return true if scoped?(reflection)
+      return false unless reflection.through_reflection?
+
+      scoped_path?(reflection.through_reflection) || scoped_path?(reflection.source_reflection)
+    end
+
+    # Returns nil when the scope cannot be read as plain conditions and an
+    # exact ranking. A part of a has_many through is read unranked: the
+    # through's query keeps only its conditions.
+    #: (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+    def self.build(reflection, model_class = reflection.klass, ranked: true)
+      return if ranked && ranked_through?(reflection)
+
+      relation = scoped_relation(reflection, model_class)
+      return unless relation && plain_relation?(relation)
+
+      clause = relation.where_clause - model_class.unscoped.where_clause
+      predicate = Reader.new(model_class).call(clause.ast)
+      new(model_class, predicate, (ranking(relation, reflection, model_class) if ranked))
+    rescue Unreadable
+      nil
+    end
+
+    # nil when the relation picks its members by conditions alone.
+    #: (untyped, untyped, untyped) -> ScopeRanking?
+    def self.ranking(relation, reflection, model_class)
+      return unless ScopeRanking.ranks?(relation, reflection)
+
+      ScopeRanking.build(relation, reflection, model_class) || raise(Unreadable)
+    end
+    private_class_method :ranking
+
+    # A has_one through orders its rows by its own order and then its parts',
+    # and takes the first, so one that passes a ranked part is not read. A
+    # has_many through keeps only its parts' conditions.
+    #: (untyped) -> bool
+    def self.ranked_through?(reflection)
+      return false if reflection.collection?
+
+      ranked_parts?(reflection)
+    end
+
+    # Whether any part of a through, at any depth, has a limit, an offset or
+    # a has_one order.
+    #: (untyped) -> bool
+    def self.ranked_parts?(reflection)
+      return false unless reflection.through_reflection?
+
+      [reflection.through_reflection, reflection.source_reflection].any? do |part|
+        ranked_part?(part) || ranked_parts?(part)
+      end
+    end
+
+    # A polymorphic part's class, and so its scope, is known only per record.
+    #: (untyped) -> bool
+    def self.ranked_part?(part)
+      return false if part.polymorphic?
+
+      relation = scoped_relation(part, part.klass)
+      !relation.nil? && ScopeRanking.ranks?(relation, part)
+    end
+    private_class_method :ranked_part?
+
+    # A scope that takes the owner differs per record, so it is never read.
+    #: (untyped, untyped) -> untyped
+    def self.scoped_relation(reflection, model_class)
+      scope = reflection.scope
+      relation = model_class.default_scoped
+      return relation unless scope
+      return unless scope.arity.zero?
+
+      reflection.scope_for(relation)
+    end
+    private_class_method :scoped_relation
+
+    # Some parts, such as the having clause `or` sets, may be present but
+    # empty.
+    #: (untyped) -> bool
+    def self.plain_relation?(relation)
+      extra = relation.values.except(*RELATION_VALUES).values
+      extra.all? { |value| value.respond_to?(:empty?) && value.empty? }
+    end
+    private_class_method :plain_relation?
+
+    #: (untyped, Array[untyped], ?ScopeRanking?) -> void
+    def initialize(model_class, predicate, ranking = nil)
+      @model_class = model_class
+      @predicate = predicate
+      @ranking = ranking
+      freeze
+    end
+
+    #: (Hash[String, untyped]) -> bool
+    def matches?(attributes)
+      evaluate(@predicate, attributes)
+    end
+
+    # The members among records that are each the owner's by key: those that
+    # meet the conditions, then ranked.
+    #: (Array[untyped]) -> Array[untyped]
+    def members(records)
+      rank(records.select { |record| matches?(record.attributes) })
+    end
+
+    # Records that meet the conditions, as ranked; unchanged without a
+    # ranking.
+    #: (Array[untyped]) -> Array[untyped]
+    def rank(records)
+      ranking = @ranking
+      ranking ? ranking.call(records) : records
+    end
+
+    # SQL compares NULL with nothing, so only an IS NULL test, an equality
+    # with nil, matches it.
+    COMPARISONS = {
+      eq: ->(value, expected) { value == expected },
+      not_eq: ->(value, expected) { !value.nil? && value != expected },
+      in: ->(value, expected) { !value.nil? && expected.include?(value) },
+      not_in: ->(value, expected) { !value.nil? && !expected.include?(value) }
+    }.freeze
+    private_constant :COMPARISONS
+
+    private
+
+    # @rbs @model_class: untyped
+    # @rbs @predicate: Array[untyped]
+    # @rbs @ranking: ScopeRanking?
+
+    #: (Array[untyped], Hash[String, untyped]) -> bool
+    def evaluate(predicate, attributes)
+      operator, first, second = predicate
+      case operator
+      when :and then first.all? { |part| evaluate(part, attributes) }
+      when :or then first.any? { |part| evaluate(part, attributes) }
+      else COMPARISONS.fetch(operator).call(stored(first, attributes), second)
+      end
+    end
+
+    # The form the database holds, as the scope's own values were cast.
+    #: (String, Hash[String, untyped]) -> untyped
+    def stored(name, attributes)
+      @model_class.type_for_attribute(name).serialize(attributes[name])
+    end
+
+    # Builds each reflection's condition once per target class.
+    class Cache
+      #: () -> void
+      def initialize
+        @conditions = {} #: Hash[Array[untyped], ScopeCondition?]
+      end
+
+      # nil when the scope cannot be read from stored attributes.
+      #: (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+      def call(reflection, model_class = reflection.klass, ranked: true)
+        key = [reflection, model_class, ranked]
+        return @conditions.fetch(key) if @conditions.key?(key)
+
+        @conditions[key] = ScopeCondition.build(reflection, model_class, ranked: ranked)
+      end
+
+      # The records the reflection's scope admits, as it ranks them. Its
+      # condition must exist.
+      #: (untyped, Array[untyped], ?untyped, ranked: bool) -> Array[untyped]
+      def select(reflection, records, model_class = reflection.klass, ranked:)
+        condition = call(reflection, model_class, ranked: ranked) #: ScopeCondition
+        condition.members(records)
+      end
+
+      # @rbs @conditions: Hash[Array[untyped], ScopeCondition?]
+    end
+
+    # Compiles a where clause into nested arrays of plain comparisons.
+    class Reader
+      #: (untyped) -> void
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      #: (untyped) -> Array[untyped]
+      def call(node)
+        case node.class.name
+        when 'Arel::Nodes::And' then [:and, node.children.map { |child| call(child) }]
+        when 'Arel::Nodes::Or' then [:or, either(node).map { |child| call(child) }]
+        when 'Arel::Nodes::Grouping' then call(node.expr)
+        else comparison(node)
+        end
+      end
+
+      private
+
+      # @rbs @model_class: untyped
+
+      # An Or is binary before Rails 7.2 and n-ary from it.
+      #: (untyped) -> Array[untyped]
+      def either(node)
+        node.respond_to?(:children) ? node.children : [node.left, node.right]
+      end
+
+      #: (untyped) -> Array[untyped]
+      def comparison(node)
+        case node.class.name
+        when 'Arel::Nodes::Equality' then binary(:eq, node)
+        when 'Arel::Nodes::NotEqual' then binary(:not_eq, node)
+        when 'Arel::Nodes::HomogeneousIn' then homogeneous_in(node)
+        when 'Arel::Nodes::In' then list(:in, node.left, values(node.right))
+        when 'Arel::Nodes::NotIn' then list(:not_in, node.left, values(node.right))
+        else raise Unreadable
+        end
+      end
+
+      #: (Symbol, untyped) -> Array[untyped]
+      def binary(operator, node)
+        [operator, column(node.left), value(node.right)]
+      end
+
+      #: (untyped) -> Array[untyped]
+      def homogeneous_in(node)
+        list(node.type == :in ? :in : :not_in, node.attribute, node.casted_values)
+      end
+
+      # Active Record writes an empty NOT IN as a condition that is always
+      # true, and a NOT IN list holding NULL matches no row.
+      #: (Symbol, untyped, Array[untyped]) -> Array[untyped]
+      def list(operator, attribute, expected)
+        name = column(attribute)
+        return [operator, name, expected] if operator == :in
+        return [:and, []] if expected.empty?
+
+        expected.include?(nil) ? [:or, []] : [operator, name, expected]
+      end
+
+      # Ruby comparison stands in for SQL only on the record's own column of
+      # a type both compare alike.
+      #: (untyped) -> String
+      def column(attribute)
+        raise Unreadable unless ATTRIBUTE.eql?(attribute.class.name)
+
+        table = attribute.relation
+        raise Unreadable unless table.name == @model_class.table_name && table.table_alias.nil?
+
+        name = attribute.name
+        raise Unreadable unless comparable?(name)
+
+        name
+      end
+
+      #: (String) -> bool
+      def comparable?(name)
+        column = @model_class.columns_hash[name]
+        kinds = value_type(@model_class.type_for_attribute(name)).class.ancestors.map(&:name)
+        return false unless column && VALUE_TYPES.intersect?(kinds)
+        return true unless kinds.include?(TEXT_TYPE)
+
+        EXACT_TEXT_ADAPTERS.include?(@model_class.connection_db_config.adapter) &&
+          column.collation.nil?
+      end
+
+      # An enum compares the values it stores, which its subtype describes. A
+      # wrapper such as a serialized or encrypted type is none of these.
+      #: (untyped) -> untyped
+      def value_type(type)
+        ENUM_TYPE.eql?(type.class.name) ? type.subtype : type
+      end
+
+      # A list that is not plain values, such as a subquery, is unreadable.
+      #: (untyped) -> Array[untyped]
+      def values(nodes)
+        raise Unreadable unless nodes.instance_of?(Array)
+
+        nodes.map { |node| value(node) }
+      end
+
+      # A value out of the column's range makes Active Record write a
+      # constant condition instead, so it is left unread. Active Record
+      # writes IS NULL for a value that is nil before casting, but `= NULL`,
+      # which matches nothing, for one that only casts to nil.
+      #: (untyped) -> untyped
+      def value(node)
+        node = node.value if BIND_PARAM.eql?(node.class.name)
+        raise Unreadable unless node.respond_to?(:value_for_database)
+        raise Unreadable if node.respond_to?(:unboundable?) && node.unboundable?
+        return if node.nil?
+
+        node.value_for_database.tap { |value| raise Unreadable if value.nil? }
+      end
+    end
+    private_constant :Reader
+  end
+end