standard_ledger 0.5.1 → 0.6.0

data/lib/standard_ledger/projector.rb

@@ -1,638 +0,0 @@
-require "active_support/concern"
-require "active_support/core_ext/class/attribute"
-
-module StandardLedger
-  # Adds the `projects_onto` DSL to an Entry class. Each `projects_onto`
-  # declaration registers a single (target_association, mode, projector)
-  # tuple; multi-target fan-out is two declarations.
-  #
-  # @example block form
-  #   class VoucherRecord < ApplicationRecord
-  #     include StandardLedger::Entry
-  #     include StandardLedger::Projector
-  #
-  #     ledger_entry kind: :action, idempotency_key: :serial_no, scope: :organisation_id
-  #
-  #     projects_onto :voucher_scheme, mode: :inline do
-  #       on(:grant)    { |scheme, _| scheme.increment(:granted_vouchers_count) }
-  #       on(:redeem)   { |scheme, _| scheme.increment(:redeemed_vouchers_count) }
-  #       on(:consume)  { |scheme, _| scheme.increment(:consumed_vouchers_count) }
-  #       on(:clawback) { |scheme, _| scheme.increment(:clawed_back_vouchers_count) }
-  #     end
-  #   end
-  #
-  # @example class form
-  #   projects_onto :order, mode: :async, via: Orders::FulfillableProjector
-  module Projector
-    extend ActiveSupport::Concern
-
-    # Captures the per-projection configuration declared by `projects_onto`.
-    # Stored on the entry class so `StandardLedger.post` and
-    # `StandardLedger.rebuild!` can iterate over them at runtime.
-    #
-    # `:view` and `:refresh_options` are populated only for `:matview`-mode
-    # projections; they're `nil` for every other mode.
-    Definition = Struct.new(
-      :target_association, :mode, :projector_class, :handlers, :guard, :lock, :permissive,
-      :recompute_sql, :trigger_name, :view, :refresh_options, :options,
-      keyword_init: true
-    )
-
-    class_methods do
-      # Declare a projection from this entry onto a single target.
-      #
-      # @param target_association [Symbol] the `belongs_to` association name on
-      #   this entry pointing at the projection target.
-      # @param mode [Symbol] one of `:inline`, `:async`, `:sql`, `:trigger`,
-      #   `:matview`. See the design doc §5.3 for selection guidance.
-      # @param via [Class, nil] optional `Projection` subclass; required for
-      #   `:async`/`:trigger`/`:sql` modes when the projector is non-trivial,
-      #   optional for `:inline` when a block is given.
-      # @param if [Proc, nil] optional guard; the projection is skipped when
-      #   the proc (evaluated in the entry's instance context) returns false.
-      # @param lock [Symbol, nil] `:pessimistic` to wrap inline updates in
-      #   `target.with_lock { ... }`. Default: `nil` (optimistic).
-      # @param permissive [Boolean] when true, an entry with a kind not
-      #   handled by `on(:kind)` is silently skipped instead of raising
-      #   `UnhandledKind`. Default: false.
-      # @param view [String, Symbol, nil] for `mode: :matview` only — the name
-      #   of the host-owned materialized view. Required when mode is
-      #   `:matview`; ignored otherwise.
-      # @param refresh [Hash, nil] for `mode: :matview` only — refresh
-      #   metadata, e.g. `{ every: 5.minutes, concurrently: true }`. The
-      #   gem records this on the Definition for hosts to read when wiring
-      #   their scheduler; the gem does NOT auto-schedule.
-      # @param trigger_name [String, Symbol, nil] for `mode: :trigger` only —
-      #   the name of the host-owned database trigger. Required when mode is
-      #   `:trigger`; ignored otherwise. The gem does NOT create or manage
-      #   the trigger; it records the name so `standard_ledger:doctor` can
-      #   verify the trigger's presence in the connected schema.
-      # @yield optional block-DSL form: register per-kind handlers via
-      #   `on(:kind) { |target, entry| ... }`. Not allowed for `mode: :matview`.
-      # @return [Definition] the registered projection.
-      def projects_onto(target_association, mode:, via: nil, if: nil, lock: nil, permissive: false,
-                        view: nil, refresh: nil, trigger_name: nil, counters: nil,
-                        rebuild_sql: nil, **options, &block)
-        guard = binding.local_variable_get(:if) # `if:` is a reserved keyword
-
-        # `counters:` is sugar for the most common :inline shape — a hash
-        # mapping `kind => column` that synthesises one
-        # `on(kind) { |t, _| t.class.increment_counter(col, t.id) }` per
-        # entry. Direct UPDATE (the class-method form) is intentional: it
-        # invalidates the SQL query cache for the target table on each
-        # call, which keeps multiple sibling-entry creates in a single
-        # transaction (e.g. via `accepts_nested_attributes_for`) from
-        # losing updates against stale cached reads. Block form remains
-        # available for non-counter projections.
-        if counters
-          if mode != :inline
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `counters:` with mode: #{mode.inspect}; " \
-                  "the counters shortcut is :inline-only — counter caches don't fit the async/sql/" \
-                  "trigger/matview contracts"
-          end
-          if block || via
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `counters:` together with a block or `via:`; " \
-                  "the counters shortcut synthesises handlers automatically — use one form or the other"
-          end
-          unless counters.is_a?(Hash) && counters.all? { |k, v| k.is_a?(Symbol) && v.is_a?(Symbol) }
-            raise ArgumentError,
-                  "projects_onto :#{target_association} `counters:` must be a Hash of Symbol kind => Symbol column"
-          end
-
-          block = ->(*) {
-            counters.each do |kind, column|
-              on(kind) { |target, _| target.class.increment_counter(column, target.id) }
-            end
-          }
-        end
-
-        # `rebuild_sql:` keyword form for `:trigger` mode — equivalent to
-        # the legacy block-DSL `rebuild_sql "..."` clause but doesn't
-        # require a block. The block-DSL form is still supported.
-        if rebuild_sql && mode == :trigger
-          if block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got both `rebuild_sql:` and a block — " \
-                  "use one form or the other"
-          end
-          # Capture the parameter value into a local before building the
-          # block: when the synthesised block is `instance_eval`'d on
-          # `TriggerDsl`, the bare name `rebuild_sql` resolves to
-          # `TriggerDsl#rebuild_sql` (the writer), not the keyword
-          # parameter we want to pass in.
-          rebuild_sql_value = rebuild_sql
-          block = ->(*) { rebuild_sql(rebuild_sql_value) }
-        end
-
-        if mode == :manual
-          # `:manual` records the projection contract (target + projector
-          # class) without installing any callback. Use this when the
-          # entry's interesting lifecycle event is not the create itself
-          # — typically an AASM/state-machine model where the projection
-          # should fire on a transition (e.g. `validate_disbursement!`)
-          # rather than `after_create`. Hosts invoke the projector
-          # explicitly from operation code; the gem's role is to make
-          # the contract introspectable (via `standard_ledger_projections`)
-          # and to give `StandardLedger.rebuild!` a class handle for log
-          # replay.
-          if block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :manual does not accept a block — " \
-                  "the entry's lifecycle is owned by the host, so per-kind handlers can't fire " \
-                  "automatically. Use `via: ProjectorClass` and invoke the projector explicitly " \
-                  "from the operation that drives the lifecycle event."
-          end
-
-          if via.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :manual requires `via: ProjectorClass` " \
-                  "whose `apply(target, entry)` is invoked explicitly by host code on the lifecycle " \
-                  "event the gem cannot observe (e.g. an AASM transition)."
-          end
-
-          unless lock.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `lock:` with mode: :manual; " \
-                  "the host owns the dispatch boundary and is responsible for any locking it needs."
-          end
-
-          if permissive
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `permissive: true` with mode: :manual; " \
-                  "`permissive:` is only meaningful with the block form."
-          end
-
-          definition = Definition.new(
-            target_association: target_association,
-            mode: mode,
-            projector_class: via,
-            handlers: {},
-            guard: guard,
-            lock: lock,
-            permissive: permissive,
-            recompute_sql: nil,
-            trigger_name: nil,
-            view: nil,
-            refresh_options: nil,
-            options: options
-          )
-
-          self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-          # No `install_mode_callbacks_for` — the host owns the dispatch.
-          return definition
-        end
-
-        if mode == :async
-          if block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :async does not accept a block — " \
-                  "use `via: ProjectorClass` whose `apply(target, entry)` recomputes from the log " \
-                  "inside `with_lock` for retry-safety. Block-form per-kind handlers aren't safe " \
-                  "under async retry."
-          end
-
-          if via.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :async requires `via: ProjectorClass` " \
-                  "(class-form only — see the registration error message for block-form for the why)"
-          end
-
-          unless lock.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `lock:` with mode: :async; " \
-                  ":async always wraps the projector in `target.with_lock` for retry-safety, " \
-                  "so the option is redundant. Drop it."
-          end
-
-          if permissive
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `permissive: true` with mode: :async; " \
-                  "`permissive:` is only meaningful with the block form, and `:async` mode rejects " \
-                  "block-form for retry-safety reasons"
-          end
-
-          definition = Definition.new(
-            target_association: target_association,
-            mode: mode,
-            projector_class: via,
-            handlers: {},
-            guard: guard,
-            lock: lock,
-            permissive: permissive,
-            recompute_sql: nil,
-            trigger_name: nil,
-            view: nil,
-            refresh_options: nil,
-            options: options
-          )
-
-          self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-          install_mode_callbacks_for(definition)
-          return definition
-        end
-
-        if mode == :trigger
-          if via
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `via:` with mode: :trigger; " \
-                  "the trigger is the contract — there is no projector class. The host " \
-                  "owns the trigger via a Rails migration; the gem only records the " \
-                  "trigger's name and rebuild SQL"
-          end
-
-          unless lock.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `lock:` with mode: :trigger; " \
-                  "`lock:` is not supported by :trigger mode — the database trigger handles " \
-                  "concurrency atomically"
-          end
-
-          if permissive
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `permissive:` with mode: :trigger; " \
-                  "`permissive:` is not supported by :trigger mode — the trigger doesn't " \
-                  "dispatch through per-kind handlers"
-          end
-
-          if guard
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `if:` with mode: :trigger; " \
-                  "`if:` is not supported by :trigger mode — the database trigger fires " \
-                  "unconditionally from the DB on INSERT, so a Ruby-side guard would " \
-                  "silently never run"
-          end
-
-          if trigger_name.nil? || trigger_name.to_s.empty?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} requires `trigger_name: \"...\"` for mode: :trigger; " \
-                  "the gem records the trigger's name so `standard_ledger:doctor` can verify its presence"
-          end
-
-          unless block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} requires a block with `rebuild_sql \"...\"` for mode: :trigger"
-          end
-
-          dsl = TriggerDsl.new
-          dsl.instance_eval(&block)
-
-          if dsl.rebuild_sql_text.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} block is empty; mode: :trigger requires a `rebuild_sql \"...\"` clause"
-          end
-
-          unless dsl.rebuild_sql_text.include?(":target_id")
-            raise ArgumentError,
-                  "projects_onto :#{target_association} rebuild SQL must include the `:target_id` placeholder; " \
-                  "it's bound to each target's id when `StandardLedger.rebuild!` walks the log"
-          end
-
-          definition = Definition.new(
-            target_association: target_association,
-            mode: mode,
-            projector_class: nil,
-            handlers: {},
-            guard: guard,
-            lock: lock,
-            permissive: permissive,
-            recompute_sql: dsl.rebuild_sql_text,
-            trigger_name: trigger_name.to_s,
-            view: nil,
-            refresh_options: nil,
-            options: options
-          )
-
-          self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-          install_mode_callbacks_for(definition)
-          return definition
-        end
-
-        if mode == :sql
-          if via
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `via:` with mode: :sql; " \
-                  "`:sql` mode's contract is the recompute SQL itself, declared via `recompute \"...\"` " \
-                  "in the block — use a different mode if you want a `via:` projector class"
-          end
-
-          unless lock.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `lock:` with mode: :sql; " \
-                  "`lock:` is not supported by :sql mode — recompute SQL doesn't dispatch through " \
-                  "with_lock; use :inline mode if you need pessimistic locking"
-          end
-
-          if permissive
-            raise ArgumentError,
-                  "projects_onto :#{target_association} got `permissive:` with mode: :sql; " \
-                  "`permissive:` is not supported by :sql mode — recompute SQL doesn't dispatch " \
-                  "through per-kind handlers; use :inline mode if you need permissive dispatch"
-          end
-
-          unless block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} requires a block with `recompute \"...\"` for mode: :sql"
-          end
-
-          dsl = SqlDsl.new
-          dsl.instance_eval(&block)
-
-          if dsl.recompute_sql.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} block is empty; mode: :sql requires a `recompute \"...\"` clause"
-          end
-
-          unless dsl.recompute_sql.include?(":target_id")
-            raise ArgumentError,
-                  "projects_onto :#{target_association} recompute SQL must include the `:target_id` placeholder; " \
-                  "it's bound to the entry's foreign key for this projection's target"
-          end
-
-          definition = Definition.new(
-            target_association: target_association,
-            mode: mode,
-            projector_class: nil,
-            handlers: {},
-            guard: guard,
-            lock: lock,
-            permissive: permissive,
-            recompute_sql: dsl.recompute_sql,
-            trigger_name: nil,
-            view: nil,
-            refresh_options: nil,
-            options: options
-          )
-
-          self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-          install_mode_callbacks_for(definition)
-          return definition
-        end
-
-        if mode == :matview
-          if block
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :matview does not accept a block; " \
-                  "matview projections have no per-kind handlers — they refresh on a schedule"
-          end
-
-          if view.nil?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} mode: :matview requires `view: \"name\"` " \
-                  "(the materialized view name to refresh)"
-          end
-
-          definition = Definition.new(
-            target_association: target_association,
-            mode: mode,
-            projector_class: nil,
-            handlers: {},
-            guard: guard,
-            lock: lock,
-            permissive: permissive,
-            recompute_sql: nil,
-            trigger_name: nil,
-            view: view.to_s,
-            refresh_options: refresh || {},
-            options: options
-          )
-
-          self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-          install_mode_callbacks_for(definition)
-          return definition
-        end
-
-        if block && via
-          raise ArgumentError,
-                "projects_onto :#{target_association} got both a block and `via:`; the two forms are mutually exclusive"
-        end
-
-        unless block || via
-          raise ArgumentError,
-                "projects_onto :#{target_association} requires either a block of `on(:kind) { ... }` handlers or `via: ProjectorClass`"
-        end
-
-        if via && permissive
-          raise ArgumentError,
-                "projects_onto :#{target_association} got `permissive: true` with `via:`; " \
-                "`permissive:` is only meaningful with the block form, where it falls back " \
-                "to the `:_` wildcard handler when no specific-kind handler matches. Class " \
-                "form (`via: ProjectorClass`) runs `apply(target, entry)` unconditionally, " \
-                "so there's nothing to be permissive about."
-        end
-
-        handlers = {}
-        if block
-          dsl = HandlerDsl.new
-          dsl.instance_eval(&block)
-          handlers = dsl.handlers
-
-          if handlers.empty?
-            raise ArgumentError,
-                  "projects_onto :#{target_association} block is empty; at least one `on(:kind) { ... }` handler is required"
-          end
-        end
-
-        definition = Definition.new(
-          target_association: target_association,
-          mode: mode,
-          projector_class: via,
-          handlers: handlers,
-          guard: guard,
-          lock: lock,
-          permissive: permissive,
-          recompute_sql: nil,
-          trigger_name: nil,
-          view: nil,
-          refresh_options: nil,
-          options: options
-        )
-
-        self.standard_ledger_projections = standard_ledger_projections + [ definition ]
-        install_mode_callbacks_for(definition)
-        definition
-      end
-
-      # Delegate per-mode callback installation to the matching strategy
-      # class. Keeps `Modes::*` from reaching into `Projector`'s internals
-      # — each strategy gets a chance to wire up `after_create`,
-      # `after_create_commit`, or whatever lifecycle hook it needs the first
-      # time a projection of its mode is registered on this class.
-      #
-      # @param definition [Definition]
-      # @return [void]
-      def install_mode_callbacks_for(definition)
-        case definition.mode
-        when :inline
-          StandardLedger::Modes::Inline.install!(self)
-        when :async
-          StandardLedger::Modes::Async.install!(self)
-        when :sql
-          StandardLedger::Modes::Sql.install!(self)
-        when :matview
-          StandardLedger::Modes::Matview.install!(self)
-        when :trigger
-          StandardLedger::Modes::Trigger.install!(self)
-        end
-      end
-
-      # Filter the registered projections by mode. Used by the per-mode
-      # strategy classes (`Modes::Inline`, `Modes::Async`, ...) to discover
-      # which projections they own for a given entry class.
-      #
-      # @param mode [Symbol] one of `:inline`, `:async`, `:sql`, `:trigger`,
-      #   `:matview`.
-      # @return [Array<Definition>] the matching definitions, in declared order.
-      def standard_ledger_projections_for(mode)
-        standard_ledger_projections.select { |definition| definition.mode == mode }
-      end
-    end
-
-    included do
-      class_attribute :standard_ledger_projections, instance_writer: false
-      self.standard_ledger_projections = []
-    end
-
-    # Apply a single projection definition to this entry. Resolves the
-    # target association, evaluates the optional `if:` guard, looks up the
-    # per-kind handler (or falls back to the projector class), and invokes
-    # it.
-    #
-    # `lock:` is interpreted by the mode strategies (`Modes::Inline`, ...)
-    # — not here. The inline strategy needs the lock to span both the
-    # handler invocation *and* the coalesced `target.save!`, so it wraps
-    # an entire per-target group rather than a single `apply_projection!`
-    # call. See `Modes::Inline#call` for the lock-spans-save guarantee.
-    #
-    # The mode strategies call this method; hosts typically do not call it
-    # directly.
-    #
-    # @param definition [Definition] one of the entry class's registered
-    #   projections.
-    # @return [Boolean] `true` when the handler (or projector class) ran;
-    #   `false` when the projection short-circuited (guard returned false,
-    #   target was nil, or permissive mode found no matching handler).
-    # @raise [StandardLedger::Error] when the entry's kind column is nil.
-    # @raise [StandardLedger::UnhandledKind] when no handler matches and
-    #   `permissive: false`.
-    def apply_projection!(definition)
-      if definition.mode == :sql
-        raise Error,
-              "apply_projection! is not supported for mode: :sql; " \
-              "the recompute SQL runs through `Modes::Sql#call` directly with no per-kind dispatch"
-      end
-
-      if definition.mode == :trigger
-        raise Error,
-              "apply_projection! is not supported for mode: :trigger; " \
-              "the database trigger fires from the DB on INSERT, not from Ruby"
-      end
-
-      return false if definition.guard && !instance_exec(&definition.guard)
-
-      target = public_send(definition.target_association)
-      return false if target.nil?
-
-      if definition.projector_class
-        definition.projector_class.new.apply(target, self)
-        return true
-      end
-
-      kind = resolve_kind!
-      handler = definition.handlers[kind.to_sym]
-
-      if handler.nil?
-        if definition.permissive
-          handler = definition.handlers[:_]
-          return false if handler.nil?
-        else
-          raise UnhandledKind,
-                "#{self.class.name} has no handler for kind=#{kind.inspect} on projection :#{definition.target_association}"
-        end
-      end
-
-      handler.call(target, self)
-      true
-    end
-
-    private
-
-    def resolve_kind!
-      unless self.class.respond_to?(:standard_ledger_entry_config)
-        raise Error,
-              "#{self.class.name} includes Projector but not Entry; " \
-              "`ledger_entry` must be called before apply_projection! can dispatch"
-      end
-
-      kind_column = self.class.standard_ledger_entry_config&.[](:kind) || :kind
-      kind = public_send(kind_column)
-      if kind.nil?
-        raise Error,
-              "#{self.class.name} entry has nil kind (column #{kind_column.inspect}); cannot dispatch projection"
-      end
-      kind
-    end
-
-    # Internal collector for the block-DSL form. Captures `on(:kind)` calls
-    # into a hash keyed by kind. Wildcard `on(:_)` is reserved as a catch-all
-    # — its handler runs only when no specific-kind handler matched.
-    class HandlerDsl
-      attr_reader :handlers
-
-      def initialize
-        @handlers = {}
-      end
-
-      def on(kind, &block)
-        raise ArgumentError, "on(:#{kind}) requires a block" unless block
-        @handlers[kind.to_sym] = block
-      end
-    end
-
-    # Internal collector for the `:sql`-mode block-DSL form. Captures the
-    # `recompute "..."` clause's SQL string. Unlike `HandlerDsl` there are
-    # no per-kind handlers — the recompute SQL is the entire contract: it
-    # must be expressible as a single statement with `:target_id` bound
-    # from the entry's foreign key, and it serves both the after-create
-    # path and `StandardLedger.rebuild!`.
-    class SqlDsl
-      attr_reader :recompute_sql
-
-      def recompute(sql)
-        unless sql.is_a?(String)
-          raise ArgumentError, "recompute requires a SQL string; got #{sql.class}"
-        end
-        unless @recompute_sql.nil?
-          raise ArgumentError,
-                "recompute called more than once in the same projects_onto block; " \
-                ":sql mode supports exactly one recompute clause per projection"
-        end
-        @recompute_sql = sql
-      end
-    end
-
-    # Internal collector for the `:trigger`-mode block-DSL form. Captures
-    # the `rebuild_sql "..."` clause's SQL string. The trigger itself is
-    # owned by the host (created in a Rails migration); the gem only
-    # records this rebuild SQL so `StandardLedger.rebuild!` can recompute
-    # the projection from the log when invoked. Like `:sql` mode, the SQL
-    # must be expressible as a single statement with `:target_id` bound
-    # from each target's id at rebuild time.
-    class TriggerDsl
-      attr_reader :rebuild_sql_text
-
-      def rebuild_sql(sql)
-        unless sql.is_a?(String)
-          raise ArgumentError, "rebuild_sql requires a SQL string; got #{sql.class}"
-        end
-        unless @rebuild_sql_text.nil?
-          raise ArgumentError,
-                "rebuild_sql called more than once in the same projects_onto block; " \
-                ":trigger mode supports exactly one rebuild_sql clause per projection"
-        end
-        @rebuild_sql_text = sql
-      end
-    end
-  end
-end

data/lib/standard_ledger/rspec/helpers.rb

@@ -1,15 +0,0 @@
-module StandardLedger
-  module RSpec
-    # Convenience methods auto-included into every RSpec example group when
-    # the host loads `require "standard_ledger/rspec"`. The actual override
-    # map lives on `StandardLedger` itself so non-RSpec callers (e.g. a
-    # background job spec running outside RSpec) can use the same API.
-    module Helpers
-      # Forwards to `StandardLedger.with_modes` so specs can write
-      # `with_modes(...) { ... }` instead of the fully-qualified form.
-      def with_modes(overrides, &block)
-        StandardLedger.with_modes(overrides, &block)
-      end
-    end
-  end
-end