permission_forge 0.14.1

data/lib/permission_forge/operators/registry.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module PermissionForge
+  # @api private
+  module Operators
+    # Strategy Pattern registry mapping operator names to query-building callables.
+    #
+    # Each operator receives (query, sanitized_column, rule, value) and returns
+    # an ActiveRecord::Relation. The value arrives typed for the column it is
+    # compared with (see {ValueTyping}): one value for the comparisons and the
+    # text of a LIKE pattern, an Array for `in` / `not_in` (the list) and
+    # `between` (the two bounds). To add a new operator, register it in
+    # {.strategies} and define the corresponding class method.
+    #
+    # @example Fetching and calling an operator
+    #   strategy = PermissionForge::Operators::Registry.fetch('equal')
+    #   strategy.call(query, '"customers"."status"', rule, 'active')
+    #
+    # @api public
+    module Registry
+      module_function
+
+      # @param name [String] operator constant from PermissionSetRule (e.g., 'equal')
+      # @return [#call] callable strategy
+      # @raise [ArgumentError] if operator is unknown
+      def fetch(name)
+        strategies.fetch(name) { raise ArgumentError, "Unknown operator: #{name}" }
+      end
+
+      # @return [Hash<String, #call>] frozen operator lookup table
+      def strategies
+        @strategies ||= build_strategies.freeze
+      end
+
+      # Resets the memoized strategies hash. Useful in tests after defining custom operators.
+      def reset!
+        @strategies = nil
+      end
+
+      # Wraps a pre-quoted column reference in Arel.sql so that downstream
+      # .where calls treat it as a trusted SQL literal. The column has already
+      # been quoted with the connection's real identifier quoting
+      # (quote_table_name / quote_column_name) in
+      # PermissionForge::Services::PermissionRuleApplier before reaching the
+      # Registry — values are still bound as parameters, never interpolated.
+      #
+      # @param col [String] already-quoted column (e.g. '"table"."column"')
+      # @return [Arel::Nodes::SqlLiteral]
+      def arel_col(col)
+        Arel.sql(col)
+      end
+
+      # Wraps a bare Equality predicate in Grouping. Required for default_scope
+      # compatibility: Model.new/create runs scope_for_create, whose
+      # WhereClause#to_h(equality_only: true) dereferences `.relation` on
+      # top-level Equality nodes — our left operand is a SqlLiteral (no
+      # `.relation`), which would raise NoMethodError on every create for a
+      # scoped user. `to_h` skips Grouping nodes, so wrapping makes the
+      # predicate invisible to create-attribute inference while leaving the
+      # read-path SQL semantically identical: (("t"."col" = ?)).
+      #
+      # @param predicate [Arel::Nodes::Equality]
+      # @return [Arel::Nodes::Grouping]
+      def grouped(predicate)
+        Arel::Nodes::Grouping.new(predicate)
+      end
+
+      # --- Operator implementations ---
+
+      def op_equal(query, col, rule, val)
+        column = arel_col(col)
+        return query.where(column.eq(val).or(column.eq(nil))) if rule[:include_nulls]
+
+        query.where(grouped(column.eq(val)))
+      end
+
+      # The `not_equal` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_not_equal(query, col, rule, val)
+        column = arel_col(col)
+        base = query.where(column.not_eq(val))
+        return base.or(query.where(column.eq(nil))) if rule[:include_nulls]
+
+        base
+      end
+
+      # The `in` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_in(query, col, rule, val)
+        column = arel_col(col)
+        values = list_values(rule, val)
+        return query.where(column.in(values).or(column.eq(nil))) if rule[:include_nulls]
+
+        query.where(column.in(values))
+      end
+
+      # The `not_in` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_not_in(query, col, rule, val)
+        column = arel_col(col)
+        values = list_values(rule, val)
+        return query.where(column.not_in(values).or(column.eq(nil))) if rule[:include_nulls]
+
+        query.where(column.not_in(values))
+      end
+
+      # The `contains` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_contains(query, col, _rule, val)
+        column = arel_col(col)
+        query.where(column.matches("%#{sanitize_like(val)}%", LIKE_ESCAPE))
+      end
+
+      # The `not_contains` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_not_contains(query, col, _rule, val)
+        column = arel_col(col)
+        query.where(column.does_not_match("%#{sanitize_like(val)}%", LIKE_ESCAPE))
+      end
+
+      # The `starts_with` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_starts_with(query, col, _rule, val)
+        column = arel_col(col)
+        query.where(column.matches("#{sanitize_like(val)}%", LIKE_ESCAPE))
+      end
+
+      # The `ends_with` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_ends_with(query, col, _rule, val)
+        column = arel_col(col)
+        query.where(column.matches("%#{sanitize_like(val)}", LIKE_ESCAPE))
+      end
+
+      # The node is built here, not from a Ruby Range: the bounds are already
+      # typed, and not every pair of them makes a Range (two booleans do not).
+      def op_between(query, col, rule, val)
+        bounds = range_values(rule, val).map { |bound| Arel::Nodes.build_quoted(bound) }
+        query.where(Arel::Nodes::Between.new(arel_col(col), Arel::Nodes::And.new(bounds)))
+      end
+
+      # The `less_than` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_less_than(query, col, _rule, val)
+        query.where(arel_col(col).lt(val))
+      end
+
+      # The `greater_than` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_greater_than(query, col, _rule, val)
+        query.where(arel_col(col).gt(val))
+      end
+
+      # The `less_than_or_equal` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_less_than_or_equal(query, col, _rule, val)
+        query.where(arel_col(col).lteq(val))
+      end
+
+      # The `greater_than_or_equal` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_greater_than_or_equal(query, col, _rule, val)
+        query.where(arel_col(col).gteq(val))
+      end
+
+      # The `is_null` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_is_null(query, col, _rule, _val)
+        query.where(grouped(arel_col(col).eq(nil)))
+      end
+
+      # The `is_not_null` operator strategy: `(query, col, rule, val)` returning a relation.
+      # @return [ActiveRecord::Relation]
+      # @api private
+      def op_is_not_null(query, col, _rule, _val)
+        query.where(arel_col(col).not_eq(nil))
+      end
+
+      # --- Helpers ---
+
+      def parse_list_value(rule)
+        rule[:field_value].to_s.split(',').map(&:strip)
+      end
+
+      # The list as PermissionRuleApplier typed it for the column. A strategy
+      # called directly with anything else reads the rule's own text, as it
+      # did before values were typed.
+      def list_values(rule, val)
+        val.is_a?(Array) ? val : parse_list_value(rule)
+      end
+
+      # The two bounds, likewise.
+      def range_values(rule, val)
+        return val if val.is_a?(Array)
+
+        lower, upper = parse_list_value(rule)
+        coerce_between_values(lower, upper)
+      end
+
+      # `%`, `_` and the escape character itself match literally. The pattern
+      # only means that with an ESCAPE clause: SQLite has no default escape
+      # character, and neither has MySQL under NO_BACKSLASH_ESCAPES. The
+      # adapter quotes the clause, which is what keeps it one backslash there
+      # (trilogy does; the mysql2 driver cannot quote any text in that mode).
+      LIKE_ESCAPE = '\\'
+
+      # Escapes `%`, `_` and the escape character so a value is matched literally by LIKE.
+      # @return [String]
+      # @api private
+      def sanitize_like(value)
+        value.to_s.gsub(/[%_\\]/) { |char| "#{LIKE_ESCAPE}#{char}" }
+      end
+
+      INTEGER_PATTERN = /\A-?\d+\z/
+      FLOAT_PATTERN = /\A-?\d+\.\d+\z/
+      DATE_PATTERN = /\A\d{4}-\d{2}-\d{2}\z/
+
+      COERCION_RULES = [
+        [INTEGER_PATTERN, lambda(&:to_i)],
+        [FLOAT_PATTERN,   lambda(&:to_f)],
+        [DATE_PATTERN,    ->(v) { Date.parse(v) }]
+      ].freeze
+
+      # Types the two bounds of a `between` rule the same way (dates, times, numbers).
+      # @return [Array]
+      # @api private
+      def coerce_between_values(lower, upper)
+        COERCION_RULES.each do |pattern, coercer|
+          next unless lower.match?(pattern) && upper.match?(pattern)
+
+          return [coercer.call(lower), coercer.call(upper)]
+        end
+        [lower, upper]
+      rescue Date::Error
+        [lower, upper]
+      end
+
+      # Builds the operator-to-strategy mapping by merging categorized sub-groups.
+      def build_strategies
+        comparison_operators.merge(set_operators).merge(string_operators).merge(range_and_null_operators)
+      end
+
+      # @return [Hash{String => Method}] the equality and ordering operators
+      # @api private
+      def comparison_operators
+        psr = PermissionForge::PermissionSetRule
+        {
+          psr::EQUAL => method(:op_equal),
+          psr::NOT_EQUAL => method(:op_not_equal),
+          psr::LESS_THAN => method(:op_less_than),
+          psr::GREATER_THAN => method(:op_greater_than),
+          psr::LESS_THAN_OR_EQUAL => method(:op_less_than_or_equal),
+          psr::GREATER_THAN_OR_EQUAL => method(:op_greater_than_or_equal)
+        }
+      end
+
+      # @return [Hash{String => Method}] `in` and `not_in`
+      # @api private
+      def set_operators
+        psr = PermissionForge::PermissionSetRule
+        { psr::IN => method(:op_in), psr::NOT_IN => method(:op_not_in) }
+      end
+
+      # @return [Hash{String => Method}] `contains`, `not_contains`, `starts_with` and `ends_with`
+      # @api private
+      def string_operators
+        psr = PermissionForge::PermissionSetRule
+        {
+          psr::CONTAINS => method(:op_contains),
+          psr::NOT_CONTAINS => method(:op_not_contains),
+          psr::STARTS_WITH => method(:op_starts_with),
+          psr::ENDS_WITH => method(:op_ends_with)
+        }
+      end
+
+      # @return [Hash{String => Method}] `between`, `is_null` and `is_not_null`
+      # @api private
+      def range_and_null_operators
+        psr = PermissionForge::PermissionSetRule
+        {
+          psr::BETWEEN => method(:op_between),
+          psr::IS_NULL => method(:op_is_null),
+          psr::IS_NOT_NULL => method(:op_is_not_null)
+        }
+      end
+    end
+  end
+end

data/lib/permission_forge/operators/rule_column.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module PermissionForge
+  module Operators
+    # The model column a rule's field_name names, as far as it can be told:
+    # what {ValueTyping} goes by to give the rule's value that column's type.
+    #
+    # A plain name is a column of the model the rule ends on — its own, or the
+    # last one on its association path. A dotted name (`customers.supplier_id`,
+    # `public.customers.supplier_id`) says which table: the rule's own or one
+    # along the path; a schema or database before it is not looked at. The
+    # column is looked up the way the database resolves the name: among the
+    # table's columns (a model's `ignored_columns` are still columns), and
+    # without regard to case where the database has none ({EXACT_NAMES}) — a
+    # name the database resolves has to be typed, or its value is compared as
+    # text after all. A lookup that is more generous than the database costs
+    # nothing: the database then rejects the name itself.
+    #
+    # When the table is none of the rule's, or has no such column, nothing is
+    # known and the value is left as it is. A field_name that is not a name
+    # ({.name?}) is {#malformed?}: such a rule matches nothing.
+    class RuleColumn
+      # Adapters whose database compares a quoted name as it is written. On
+      # every other one — MySQL, SQLite — `Flag` is the column `flag`.
+      EXACT_NAMES = %w[PostgreSQL PostGIS].freeze
+
+      # @return [ActiveRecord::ConnectionAdapters::Column, nil]
+      attr_reader :column
+      # @return [Hash, nil] label => stored value, when the model declares the column an enum
+      attr_reader :enum
+
+      class << self
+        # A field name is one name, or several joined by dots. An empty one
+        # among them — a leading, trailing or doubled dot, or nothing at all —
+        # makes it no name: quoted segment by segment it would be another
+        # name than the one that was written.
+        def name?(field_name)
+          segments = field_name.to_s.split('.', -1)
+          segments.any? && segments.none?(&:empty?)
+        end
+
+        # @param field_name [String] the rule's field_name
+        # @param models [Array<Class>] the rule's model, then the model of each
+        #   association on its path (see {.models_along})
+        # @return [RuleColumn]
+        def find(field_name, models)
+          return MALFORMED unless name?(field_name)
+
+          *qualifier, name = field_name.to_s.split('.')
+          model = table_model(qualifier.last, models)
+          model ? on(model, name) : UNKNOWN
+        end
+
+        # The rule's own model, then the model of each association on its path;
+        # a plain field_name is a column of the last one.
+        #
+        # @param model [Class] the rule's model
+        # @param association_chain [Array<String>] the rule's field_accessor_path, split
+        # @return [Array<Class>] empty when the path cannot be followed
+        def models_along(model, association_chain)
+          association_chain.reduce([model]) do |models, assoc|
+            joined = models.last.reflect_on_association(assoc.to_sym)&.klass
+            break [] unless joined
+
+            models << joined
+          end
+        end
+
+        private
+
+        # The model a table name stands for; without one, the model the rule ends on.
+        def table_model(table, models)
+          return models.last unless table
+
+          models.find { |model| same_name?(model.table_name.to_s.split('.').last, table, exact_names?(model)) }
+        end
+
+        def on(model, name)
+          connection = model.connection
+          column = column_named(connection.schema_cache.columns_hash(model.table_name), name, exact_names?(model))
+          new(column, column && model.defined_enums[column.name], connection.adapter_name)
+        end
+
+        def column_named(columns, name, exact)
+          columns[name] || columns.each_value.find { |column| same_name?(column.name, name, exact) }
+        end
+
+        def same_name?(own, written, exact)
+          own == written || (!exact && own.casecmp?(written))
+        end
+
+        def exact_names?(model)
+          EXACT_NAMES.include?(model.connection.adapter_name)
+        end
+      end
+
+      def initialize(column, enum, adapter_name)
+        @column = column
+        @enum = enum
+        @adapter_name = adapter_name
+      end
+
+      # Nothing is known about the column: no table of the rule, or no such column.
+      UNKNOWN = new(nil, nil, nil).freeze
+      # The rule's field_name is not a name.
+      MALFORMED = new(nil, nil, nil).freeze
+
+      def malformed?
+        equal?(MALFORMED)
+      end
+
+      # The caster for the column's type, on the database it is in.
+      #
+      # @return [#call] see ValueCasters.for
+      def caster
+        ValueCasters.for(column, @adapter_name)
+      end
+    end
+  end
+end

data/lib/permission_forge/operators/validations.rb

@@ -0,0 +1,111 @@
+module PermissionForge
+  module Operators
+    # Operator-specific checks of a rule's `field_value` (`between` takes exactly two values, `in` at least one).
+    # Add a check with one entry in `VALIDATORS`.
+    #
+    # @api public
+    module Validations
+      VALUE_REQUIRED_MESSAGE = lambda {
+        I18n.t('permission_forge.validations.permission_set_rule.value_required',
+               default: 'must not be blank for this operator')
+      }
+
+      NUMERIC_REQUIRED_MESSAGE = lambda {
+        I18n.t('permission_forge.validations.permission_set_rule.numeric_or_date_required',
+               default: 'must be a numeric or date value for comparison operators')
+      }
+
+      VALUE_NOT_EXPECTED_MESSAGE = lambda {
+        I18n.t('permission_forge.validations.permission_set_rule.value_not_expected',
+               default: 'does not require a value for this operator')
+      }
+
+      SINGLE_VALUE_VALIDATOR = lambda { |values|
+        return unless values.empty?
+
+        { field: :field_value, message: VALUE_REQUIRED_MESSAGE.call }
+      }
+
+      NUMERIC_VALIDATOR = lambda { |values|
+        return if values.empty?
+        return if values.all? { |v| v.match?(/\A-?\d+(\.\d+)?\z/) || parseable_date?(v) }
+
+        { field: :field_value, message: NUMERIC_REQUIRED_MESSAGE.call }
+      }
+
+      NULL_OPERATOR_VALIDATOR = lambda { |values|
+        return if values.empty?
+
+        { field: :field_value, message: VALUE_NOT_EXPECTED_MESSAGE.call }
+      }
+
+      VALIDATORS = {
+        'between' => lambda { |values|
+          return if values.size == 2
+
+          { field: :field_value,
+            message: I18n.t('permission_forge.validations.permission_set_rule.between_requires_two_values',
+                            default: 'must contain exactly 2 comma-separated values for between operator') }
+        },
+        'in' => lambda { |values|
+          return unless values.empty?
+
+          { field: :field_value,
+            message: I18n.t('permission_forge.validations.permission_set_rule.in_requires_values',
+                            default: 'must contain at least 1 comma-separated value') }
+        },
+        'not_in' => lambda { |values|
+          return unless values.empty?
+
+          { field: :field_value,
+            message: I18n.t('permission_forge.validations.permission_set_rule.in_requires_values',
+                            default: 'must contain at least 1 comma-separated value') }
+        },
+        'equal' => SINGLE_VALUE_VALIDATOR,
+        'not_equal' => SINGLE_VALUE_VALIDATOR,
+        'contains' => SINGLE_VALUE_VALIDATOR,
+        'not_contains' => SINGLE_VALUE_VALIDATOR,
+        'starts_with' => SINGLE_VALUE_VALIDATOR,
+        'ends_with' => SINGLE_VALUE_VALIDATOR,
+        'greater_than' => NUMERIC_VALIDATOR,
+        'less_than' => NUMERIC_VALIDATOR,
+        'greater_than_or_equal' => NUMERIC_VALIDATOR,
+        'less_than_or_equal' => NUMERIC_VALIDATOR,
+        'is_null' => NULL_OPERATOR_VALIDATOR,
+        'is_not_null' => NULL_OPERATOR_VALIDATOR
+      }.freeze
+
+      # The operators that take no value (the null checks): the ones whose
+      # validator refuses any value.
+      VALUELESS = VALIDATORS.select { |_, validator| validator.equal?(NULL_OPERATOR_VALIDATOR) }.keys.freeze
+
+      # @return [Boolean] whether `operator` takes no value
+      def self.valueless?(operator)
+        VALUELESS.include?(operator.to_s)
+      end
+
+      # @param operator [String] an operator of PermissionSetRule
+      # @param field_value [String] the rule's value
+      # @return [Hash, nil] `{ field:, message: }` when the value is invalid for the operator, else nil
+      def self.validate(operator, field_value)
+        return if operator.blank? || field_value.blank?
+        # 'current_user' is a special substitution token valid for all operators
+        return if field_value.to_s.strip == 'current_user'
+
+        validator = VALIDATORS[operator]
+        return unless validator
+
+        parsed = field_value.to_s.split(',').map(&:strip).reject(&:blank?)
+        validator.call(parsed)
+      end
+
+      def self.parseable_date?(value)
+        Date.parse(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
+      private_class_method :parseable_date?
+    end
+  end
+end

data/lib/permission_forge/operators/value_casters/number.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module PermissionForge
+  module Operators
+    module ValueCasters
+      # Casts the text of a number for an integer, decimal or float column.
+      module Number
+        # A plain decimal, or one in scientific notation (`1e3`): every
+        # database reads both.
+        FORMAT = /\A[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d{1,3})?\z/
+        BIGINT = (-(2**63)..((2**63) - 1))
+        # Past the range of a double the databases part ways again: PostgreSQL
+        # raises on a float column, MySQL and SQLite round a tiny number to zero.
+        DOUBLE = (Float::MIN..Float::MAX)
+        # What a single-precision float holds, a little short of both ends.
+        SINGLE = (1.1754944e-38..3.4028234e38)
+
+        # A whole number that fits 64 bits is an Integer, however it is written
+        # (`50`, `50.0`, `5e1`): compared with an integer column it can use the
+        # column's index, where a decimal makes PostgreSQL cast every row. Any
+        # other number — a fraction, one past that range — is a BigDecimal,
+        # which every adapter writes as an exact numeric literal: the database
+        # compares numbers (`supplier_id < 5.5`, `supplier_id <
+        # 99999999999999999999`) and never casts text to the column's type.
+        EXACT = lambda do |value|
+          text = value.to_s.strip
+          next UNUSABLE unless text.match?(FORMAT)
+
+          decimal = BigDecimal(text)
+          next decimal.to_i if decimal.frac.zero? && BIGINT.cover?(decimal)
+
+          decimal.zero? || DOUBLE.cover?(decimal.abs) ? decimal : UNUSABLE
+        end
+
+        # For a PostgreSQL `real` column. PostgreSQL compares it with a number
+        # in double precision, where 0.1 is not the 0.1 the column stores; text
+        # it reads as a `real`. So the rule's text is handed over as the text
+        # of the number it was checked to be, and compared in single precision
+        # — as it was before values were typed. Two things stay numbers: the
+        # id `current_user` stands for, and a number no `real` can hold, which
+        # equals none and on which PostgreSQL would raise as text. MySQL
+        # compares a FLOAT in double precision whatever it gets, and SQLite
+        # has doubles only: there the number goes as a number (EXACT).
+        SINGLE_PRECISION = lambda do |value|
+          number = EXACT.call(value)
+          next number unless value.is_a?(String) && !number.equal?(UNUSABLE)
+          next number unless number.zero? || SINGLE.cover?(number.abs)
+
+          number.is_a?(Integer) ? number.to_s : number.to_s('F')
+        end
+
+        # The two bounds of `between` on a PostgreSQL `real` column, likewise
+        # as they always were: two plain integers or two plain decimals went
+        # to PostgreSQL as numbers (the reading still made where nothing is
+        # known about a column), any other pair as text.
+        SINGLE_PRECISION_BOUNDS = lambda do |bounds|
+          numbers = bounds.map { |bound| EXACT.call(bound) }
+          next UNUSABLE if numbers.include?(UNUSABLE)
+
+          plain = Registry.coerce_between_values(*bounds).first.is_a?(Numeric)
+          plain ? numbers : bounds.map { |bound| SINGLE_PRECISION.call(bound) }
+        end
+      end
+    end
+  end
+end

data/lib/permission_forge/operators/value_casters/temporal.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PermissionForge
+  module Operators
+    module ValueCasters
+      # Casts ISO 8601 text for a date, time or datetime column.
+      #
+      # The text is checked here (the notation, a real calendar day) and cast by
+      # the ActiveRecord type of the column, so the adapter quotes the result the
+      # way it stores that column: a date-time without an offset is read in the
+      # database's time zone (`ActiveRecord.default_timezone`), one with an
+      # offset is converted to it, and SQLite gets the text it compares with.
+      # A date column takes the day of a date-time, a time column the time of
+      # day. Anything else — another notation, `now`, `tomorrow`, the id that
+      # `current_user` stands for — is UNUSABLE, unless the caster is the one
+      # for a database that reads such text itself ({#as_written}).
+      class Temporal
+        DAY = /(?<year>\d{4})-(?<month>\d\d?)-(?<day>\d\d?)/
+        CLOCK = /(?:[01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?/
+        OFFSET = /Z|[+-]\d\d(?::?\d\d)?/
+        DAY_AND_CLOCK = /\A#{DAY}(?:[T ]#{CLOCK}(?: ?#{OFFSET})?)?\z/
+        CLOCK_ONLY = /\A(?:\d{4}-\d\d-\d\d[T ])?#{CLOCK}\z/
+
+        # @param format [Regexp] what the text has to look like
+        # @param type [ActiveModel::Type::Value] casts the text and serializes the result
+        # @param as_written [Boolean] hand text of another notation over as it is
+        def initialize(format, type, as_written: false)
+          @format = format
+          @type = type
+          @as_written = as_written
+        end
+
+        def call(value)
+          return UNUSABLE unless value.is_a?(String)
+
+          recognised(value.strip) || (@as_written ? value : UNUSABLE)
+        end
+
+        # The same caster for a database that reads date and time text itself
+        # and raises on what it cannot read (PostgreSQL). Text this caster does
+        # not recognise is handed over as it is written, as it was before
+        # values were typed: `today`, a date in a local notation. What is not
+        # text stays UNUSABLE.
+        #
+        # @return [Temporal]
+        def as_written
+          self.class.new(@format, @type, as_written: true)
+        end
+
+        DATE = new(DAY_AND_CLOCK, ActiveRecord::Type::Date.new)
+        DATETIME = new(DAY_AND_CLOCK, ActiveRecord::Type::DateTime.new)
+        TIME = new(CLOCK_ONLY, ActiveRecord::Type::Time.new)
+
+        private
+
+        def recognised(text)
+          parts = @format.match(text)
+          @type.serialize(@type.cast(text)) if parts && real_day?(parts)
+        end
+
+        # A time of day names no day; a date has to be one of the calendar.
+        def real_day?(parts)
+          year, month, day = parts.named_captures.values_at('year', 'month', 'day')
+          year.nil? || Date.valid_date?(year.to_i, month.to_i, day.to_i)
+        end
+      end
+    end
+  end
+end