textus 0.54.2 → 0.55.2

data/lib/textus/action/rule_list.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class RuleList < Base
-      extend Textus::Contract::DSL
-
-      verb :rule_list
-      summary "List every rule block in the manifest."
-      surfaces :cli
-      cli "rule list"
-      view(:cli) { |policies| { "verb" => "rule_list", "policies" => policies } }
-
-      def call(container:, **)
-        manifest = container.manifest
-        manifest.rules.blocks.map do |block|
-          row = { "match" => block.match }
-          self.class::LIST_FIELDS.each do |field|
-            value = block.public_send(field)
-            row[field.to_s] = serialize(field, value) unless value.nil?
-          end
-          row
-        end
-      end
-
-      LIST_FIELDS = Textus::Manifest::Schema::FIELD_REGISTRY.select { |_, m| m[:in_rule_list] }.keys.freeze
-
-      private
-
-      def serialize(field, value)
-        case field
-        when :retention
-          { "ttl_seconds" => value.ttl_seconds, "action" => value.action.to_s }
-        when :react
-          value.to_h
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/textus/action/schema_envelope.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class SchemaEnvelope < Base
-      extend Textus::Contract::DSL
-
-      verb :schema_show
-      summary "Return the schema (field shape) for an entry's family, by key."
-      surfaces :cli, :mcp
-      cli "schema show"
-      arg :key, String, required: true, positional: true,
-                        description: "any key in the family whose schema you want; returns required/optional fields and their types"
-
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, **)
-        manifest = container.manifest
-        schemas = container.schemas
-        mentry = manifest.resolver.resolve(@key).entry
-        schema = schemas.fetch_or_nil(mentry.schema)
-        { "protocol" => PROTOCOL, "key" => @key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
-      end
-    end
-  end
-end

data/lib/textus/action/uid.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Uid < Base
-      extend Textus::Contract::DSL
-
-      verb :uid
-      summary "Return the stable UID of an entry without reading its body."
-      surfaces :cli
-      cli "key uid"
-      arg :key, String, required: true, positional: true, description: "entry key"
-      view(:cli) { |uid, inputs| { "key" => inputs[:key], "uid" => uid } }
-
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, call:)
-        Textus::Action::Get.new(key: @key).call(container: container, call: call).uid
-      end
-
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
-      end
-    end
-  end
-end

data/lib/textus/action/where.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class Where < Base
-      extend Textus::Contract::DSL
-
-      verb :where
-      summary "Resolve a key to its zone, owner, and path without reading the body."
-      surfaces :cli, :mcp
-      arg :key, String, required: true, positional: true,
-                        description: "dotted key to locate (returns zone, owner, path; does not read content)"
-
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def call(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
-        manifest = container.manifest
-        res = manifest.resolver.resolve(@key)
-        mentry = res.entry
-        path = res.path
-        { "protocol" => PROTOCOL, "key" => @key, "lane" => mentry.lane, "owner" => mentry.owner, "path" => path }
-      end
-
-      def self.new(*args, **kwargs)
-        return super(**kwargs) unless args.any?
-
-        positional = instance_method(:initialize).parameters.slice(:keyreq, :key).map(&:last)
-        mapped = positional.zip(args).to_h
-        super(**mapped.merge(kwargs))
-      end
-    end
-  end
-end

data/lib/textus/action/write_verb.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Action
-    class WriteVerb < Base
-      private
-
-      def auth(container)
-        Textus::Gate::Auth.new(container)
-      end
-
-      def writer(container, call)
-        Textus::Envelope::Writer.from(container: container, call: call)
-      end
-
-      def reader(container)
-        Textus::Envelope::Reader.from(container: container)
-      end
-
-      def run_with_cascade(target_key, container:, call:)
-        result = yield
-        cascade_to_rdeps(target_key, container, call) if target_key
-        result
-      end
-
-      def cascade_to_rdeps(key, container, call)
-        rdeps = Textus::Action::Rdeps.new(key: key).call(container: container, call: call).fetch("rdeps", [])
-        producible = rdeps.select { |dep_key| producible?(dep_key, container) }
-        return if producible.empty?
-
-        producible.each do |dep_key|
-          Textus::Jobs::Materialize.new(key: dep_key).call(container:, call:)
-        end
-      end
-
-      def producible?(key, container)
-        entry = container.manifest.resolver.resolve(key).entry
-        !entry.publish_tree.nil?
-      rescue Textus::Error
-        false
-      end
-    end
-  end
-end

data/lib/textus/call.rb

@@ -1,28 +0,0 @@
-require "securerandom"
-
-module Textus
-  # Immutable per-invocation value. Carries who is acting (role), the
-  # request correlation id, the wall clock, and the dry_run flag — the
-  # bits Use Cases need that are not part of the Container.
-  Call = Data.define(:role, :correlation_id, :now, :dry_run) do
-    def self.build(role:, correlation_id: nil, now: nil, dry_run: false)
-      new(
-        role: role.to_s,
-        correlation_id: correlation_id || SecureRandom.uuid,
-        now: now || Textus::Ports::Clock.new.now,
-        dry_run: dry_run,
-      )
-    end
-
-    def dry_run? = dry_run
-
-    def with_role(new_role)
-      self.class.new(
-        role: new_role.to_s,
-        correlation_id: correlation_id,
-        now: now,
-        dry_run: dry_run,
-      )
-    end
-  end
-end

data/lib/textus/command.rb

@@ -1,41 +0,0 @@
-module Textus
-  module Command
-    Get             = Data.define(:key, :role)
-    Put             = Data.define(:key, :meta, :body, :content, :if_etag, :role)
-    Propose         = Data.define(:key, :meta, :body, :content, :role, :pending_key) do
-      def initialize(key:, role:, meta: nil, body: nil, content: nil, pending_key: nil)
-        super
-      end
-    end
-    KeyDelete       = Data.define(:key, :if_etag, :role)
-    KeyMv           = Data.define(:old_key, :new_key, :dry_run, :role)
-    Accept          = Data.define(:pending_key, :role)
-    Reject          = Data.define(:pending_key, :role)
-    Enqueue         = Data.define(:type, :args, :role)
-    Ingest          = Data.define(:kind, :slug, :url, :path, :zone, :label, :role) do
-      def initialize(kind:, slug:, role:, url: nil, path: nil, zone: nil, label: nil)
-        super
-      end
-    end
-    List            = Data.define(:prefix, :lane, :role)
-    Where           = Data.define(:key, :role)
-    Uid             = Data.define(:key, :role)
-    Blame           = Data.define(:key, :limit, :role)
-    Audit           = Data.define(:key, :lane, :verb, :since, :seq_since, :correlation_id, :limit, :role)
-    Deps            = Data.define(:key, :role)
-    Rdeps           = Data.define(:key, :role)
-    Pulse           = Data.define(:since, :role)
-    RuleExplain     = Data.define(:key, :detail, :role)
-    RuleList        = Data.define(:role)
-    RuleLint        = Data.define(:candidate_yaml, :role)
-    Published       = Data.define(:role)
-    SchemaShow      = Data.define(:key, :role)
-    Doctor          = Data.define(:checks, :role)
-    Boot            = Data.define(:role)
-    Jobs            = Data.define(:state, :action, :job_id, :role)
-    DataMv          = Data.define(:from, :to, :dry_run, :role)
-    KeyMvPrefix     = Data.define(:from_prefix, :to_prefix, :dry_run, :role)
-    KeyDeletePrefix = Data.define(:prefix, :dry_run, :role)
-    Drain           = Data.define(:prefix, :lane, :role)
-  end
-end

data/lib/textus/container.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "dry-struct"
-
-module Textus
-  # Single capability record handed to every use case. Replaces the
-  # ReadCaps/WriteCaps/HookCaps trio from 0.26.x. Built once per Store
-  # (see Store#initialize); Store delegates its readers to this record,
-  # so this struct is the single source of truth for the field set.
-  class Container < Dry::Struct
-    attribute :manifest,   Types::Any
-    attribute :file_store, Types::Any
-    attribute :schemas,    Types::Any
-    attribute :root,       Types::String
-    attribute :audit_log,  Types::Any
-    attribute :workflows,  Types::Any
-    attribute :gate,       Types::Any
-
-    def with(**attrs) = self.class.new(to_h.merge(attrs))
-
-    def initialize(*)
-      super
-      freeze
-    end
-  end
-end

data/lib/textus/contract/around.rb

@@ -1,29 +0,0 @@
-module Textus
-  module Contract
-    # Registry of named, stateful wrappers a verb may declare via `around :name`.
-    # A resource implements
-    #   `wrap(scope:, inputs:, session:) { |effective_inputs| ... }`:
-    # it may adjust the inputs before the call and post-process the result after
-    # — exactly what build's lock and pulse's cursor need, without a hand-authored
-    # CLI class (ADR 0068). `session:` is the dispatching session (nil for the
-    # sessionless CLI/Ruby surfaces, present for MCP), so a session-aware resource
-    # like the cursor can defer to the session's own state instead of its file.
-    module Around
-      @registry = {}
-
-      module_function
-
-      def register(name, resource)
-        @registry[name] = resource
-      end
-
-      def fetch(name)
-        @registry.fetch(name) { raise "no around resource registered: #{name.inspect}" }
-      end
-
-      def with(name, scope:, inputs:, session: nil, &call)
-        fetch(name).wrap(scope: scope, inputs: inputs, session: session, &call)
-      end
-    end
-  end
-end

data/lib/textus/contract/binder.rb

@@ -1,88 +0,0 @@
-module Textus
-  module Contract
-    # Raised when a required arg is absent from the bound input. Surface
-    # adapters translate this to their native error (MCP ToolError, CLI
-    # UsageError); a direct Ruby call lets it surface as-is.
-    class MissingArgs < Textus::Error
-      attr_reader :spec, :missing
-
-      def initialize(spec, missing)
-        @spec = spec
-        @missing = missing
-        super("missing_args", "#{spec.verb}: missing #{missing.map(&:wire).join(", ")}")
-      end
-    end
-
-    # The single argument binder for every surface (spike: collapses the three
-    # historical implementations — MCP::Catalog.map_args, CLI::Runner.call_args,
-    # and RoleScope's default-injection loop — into one algorithm).
-    #
-    # Input is a uniform `inputs` hash keyed by arg NAME (the use-case kwarg
-    # name, never the wire name): each surface normalizes its own raw transport
-    # shape (MCP JSON keyed by wire-name, CLI argv+flags, Ruby args+kwargs) into
-    # this hash. Binder owns the shared algorithm and nothing transport-specific:
-    #
-    #   1. validate every required arg is present in `inputs`;
-    #   2. for absentees, fall back to session_default (when a session is given)
-    #      then to the literal default; otherwise omit the arg entirely;
-    #   3. split into the (positional, keyword) pair to splat into the use-case,
-    #      routing by `arg.positional`.
-    #
-    # Returns `[positional_array, keyword_hash]` — exactly what
-    # `RoleScope#<verb>(*pos, **kw)` expects.
-    module Binder
-      module_function
-
-      # Validation is unconditional: a `required:` arg absent from `inputs` is a
-      # contract violation on every surface (ADR 0069). `required:` is now an
-      # honest contract invariant, not a surface policy — args the use-case
-      # treats as optional (e.g. `meta`, whose real requiredness lives in schema
-      # validation downstream) are declared `required: false`, so this check
-      # never fires spuriously and never needs an opt-out.
-      def bind(spec, inputs, session: nil)
-        missing = spec.required_args.reject { |a| inputs.key?(a.name) }
-        raise MissingArgs.new(spec, missing) unless missing.empty?
-
-        pos = []
-        kw  = {}
-        spec.args.each do |a|
-          if inputs.key?(a.name)
-            value = inputs[a.name]
-          elsif a.session_default && session
-            value = session.public_send(a.session_default)
-          elsif !a.default.nil?
-            value = a.default
-          else
-            next
-          end
-
-          if a.positional
-            pos << value
-          else
-            kw[a.name] = value
-          end
-        end
-        [pos, kw]
-      end
-
-      # Normalize an ordered positional list + a by-name keyword hash (the shape
-      # CLI argv+flags and Ruby args+kwargs both arrive in) into the uniform
-      # by-name `inputs` hash bind expects. Positionals beyond what was supplied
-      # are dropped so bind's required-check sees them as absent.
-      def inputs_from_ordered(spec, ordered_positionals, by_name_keywords)
-        names = spec.args.select(&:positional).map(&:name)
-        names.zip(ordered_positionals).to_h.compact.merge(by_name_keywords)
-      end
-
-      # Normalize a raw transport hash keyed by WIRE name (the shape MCP JSON
-      # arrives in) into the uniform by-name `inputs` hash bind expects. Keys
-      # not declared on the contract are ignored.
-      def inputs_from_wire(spec, raw)
-        raw ||= {}
-        spec.args.each_with_object({}) do |a, h|
-          h[a.name] = raw[a.wire.to_s] if raw.key?(a.wire.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/textus/contract/resources/build_lock.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Contract
-    module Resources
-      # Serializes builds across every surface (CLI, MCP, Ruby). Previously the
-      # CLI verb wrapped each build in a BuildLock by hand; lifting it into the
-      # contract means the MCP surface inherits the single-writer guarantee and
-      # cannot collide with a concurrent CLI or background build.
-      class BuildLock
-        def wrap(scope:, inputs:, session: nil) # rubocop:disable Lint/UnusedMethodArgument
-          Textus::Ports::BuildLock.with(root: scope.container.root) { yield(inputs) }
-        end
-      end
-    end
-  end
-end
-
-Textus::Contract::Around.register(:build_lock, Textus::Contract::Resources::BuildLock.new)

data/lib/textus/contract/resources/cursor.rb

@@ -1,26 +0,0 @@
-module Textus
-  module Contract
-    module Resources
-      # Reads the persisted file cursor as the `since` default when the caller
-      # did not supply one, runs pulse, then persists the returned cursor.
-      # Replaces CLI::Verb::Pulse's hand-coded CursorStore read/write (ADR 0068).
-      #
-      # A session-bearing surface (MCP) carries its own cursor via the contract's
-      # `session_default: :cursor`, so this defers entirely when a session is
-      # present — it is the sessionless CLI/Ruby surfaces that need the file.
-      class Cursor
-        def wrap(scope:, inputs:, session:)
-          return yield(inputs) if session
-
-          store = Textus::CursorStore.new(root: scope.container.root, role: scope.role)
-          effective = inputs.key?(:since) ? inputs : inputs.merge(since: store.read)
-          result = yield(effective)
-          store.write(result["cursor"]) if result.is_a?(Hash) && result["cursor"]
-          result
-        end
-      end
-    end
-  end
-end
-
-Textus::Contract::Around.register(:cursor, Textus::Contract::Resources::Cursor.new)

data/lib/textus/contract/sources.rb

@@ -1,39 +0,0 @@
-require "json"
-
-module Textus
-  module Contract
-    # CLI-only input acquisition. Transforms entries of the uniform `inputs`
-    # hash that declare a `source:`/`coerce:`, and builds `inputs` from a
-    # `cli_stdin` envelope — so put/propose/migrate/rule_lint/audit need no
-    # hand-authored CLI class (ADR 0068). MCP receives typed JSON, so these
-    # never run there.
-    module Sources
-      module_function
-
-      # Apply per-arg :file sources (value is a path -> file contents) and
-      # :coerce callables to a by-name inputs hash. Returns a new hash.
-      def acquire(spec, inputs)
-        spec.args.each_with_object(inputs.dup) do |a, h|
-          next unless h.key?(a.name)
-
-          h[a.name] = File.read(h[a.name]) if a.source == :file
-          h[a.name] = a.coerce.call(h[a.name]) if a.coerce
-        end
-      end
-
-      # Parse a cli_stdin :json envelope into a by-name inputs hash, mapping
-      # envelope keys (wire-names) to arg names.
-      def from_stdin(spec, stream)
-        return {} unless spec.cli_stdin == :json
-
-        raw = stream.read.to_s
-        return {} if raw.strip.empty? # no envelope piped -> required args surface as missing
-
-        envelope = JSON.parse(raw)
-        spec.args.each_with_object({}) do |a, h|
-          h[a.name] = envelope[a.wire.to_s] if envelope.key?(a.wire.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/textus/contract/view.rb

@@ -1,15 +0,0 @@
-module Textus
-  module Contract
-    # Renders a use-case result for a surface, using the verb's declared view
-    # (falling back to the default). The single replacement for the old
-    # response/cli_response split and the Proc#arity sniff: views are always
-    # called as (result, inputs); a one-parameter view ignores inputs.
-    module View
-      module_function
-
-      def render(spec, surface, result, inputs)
-        spec.view(surface).call(result, inputs)
-      end
-    end
-  end
-end

data/lib/textus/contract.rb

@@ -1,174 +0,0 @@
-module Textus
-  # Declarative, co-located interface contract for a verb. One source of truth
-  # for the agent-facing summary, the argument schema, which transports expose
-  # the verb, and how the return value is shaped for the wire. CLI/Ruby/MCP and
-  # boot project from this; the MCP catalog is fully derived from it (ADR 0039).
-  module Contract
-    # One argument of a verb. `positional: true` means it is passed to the
-    # use-case as a positional (e.g. `get(key)`); otherwise as a keyword.
-    # `session_default` names a zero-arg method on `Textus::Session` (Symbol)
-    # that supplies the value when the wire arg is absent; `nil` means no default.
-    # `wire_name` is the name the arg carries on the wire (MCP JSON property / CLI
-    # envelope key) when it must differ from the use-case kwarg `name` — e.g. `put`
-    # takes the `meta:` kwarg but exposes `_meta` on the wire to match what `get`
-    # returns and what the CLI `--stdin` envelope already speaks (ADR 0057).
-    # `source: :file` (CLI only) reads the arg's value as a path -> file
-    # contents; `coerce:` is a callable applied to the raw value (CLI only);
-    # `cli_default:` supplies a CLI-specific default that diverges from the
-    # contract `default` the agent surfaces use (`:__unset` sentinel = none).
-    Arg = Data.define(
-      :name, :type, :required, :positional, :session_default,
-      :description, :wire_name, :default, :source, :coerce, :cli_default
-    ) do
-      # The name used on the wire (defaults to the kwarg name).
-      def wire = wire_name || name
-    end
-
-    JSON_TYPES = {
-      String => "string", Integer => "integer", Hash => "object",
-      Array => "array", :boolean => "boolean"
-    }.freeze
-
-    def self.json_type(type)
-      JSON_TYPES.fetch(type) { raise ArgumentError.new("no JSON type mapping for #{type.inspect}") }
-    end
-
-    Spec = Data.define(:verb, :summary, :args, :surfaces, :views, :cli, :around, :cli_stdin) do
-      def mcp? = surfaces.include?(:mcp)
-      def cli? = surfaces.include?(:cli)
-
-      # The output shaper for a surface; falls back to the default view. Every
-      # view is invoked uniformly as `view.call(result, inputs)` — a view that
-      # declares one parameter ignores `inputs` (procs tolerate extra args).
-      def view(surface = :default) = views[surface] || views.fetch(:default)
-
-      # Operator-facing command path. Defaults to the verb token; grouped verbs
-      # declare e.g. `cli "schema show"`.
-      def cli_path = cli || verb.to_s
-      def cli_words = cli_path.split
-      def cli_group = cli_words.size > 1 ? cli_words.first : nil
-      def cli_leaf  = cli_words.last
-
-      def required_args = args.select(&:required)
-
-      # JSON-Schema object for MCP tools/list inputSchema.
-      # Outer keys (:type, :properties, :required) are symbols; inner property
-      # keys are strings — matches the MCP/JSON wire shape expected by clients.
-      def input_schema
-        props = args.to_h do |a|
-          h = { "type" => Contract.json_type(a.type) }
-          h["description"] = a.description if a.description
-          [a.wire.to_s, h]
-        end
-        { type: "object", properties: props, required: required_args.map { |a| a.wire.to_s } }
-      end
-    end
-
-    # Mixed onto a use-case class via `extend`. Calls accumulate into ivars,
-    # frozen into a Spec on first read of `.contract`.
-    module DSL
-      def verb(name = nil)
-        if name
-          raise "contract already built; declare verb before reading .contract" if defined?(@__contract) && @__contract
-
-          @__verb = name
-        else
-          @__verb
-        end
-      end
-
-      def summary(text = nil)
-        if text
-          raise "contract already built; declare summary before reading .contract" if defined?(@__contract) && @__contract
-
-          @__summary = text
-        else
-          @__summary
-        end
-      end
-
-      def surfaces(*list)
-        if list.empty?
-          @__surfaces ||= []
-        else
-          raise "contract already built; declare surfaces before reading .contract" if defined?(@__contract) && @__contract
-
-          @__surfaces = list
-        end
-      end
-
-      def cli(path = nil)
-        if path
-          raise "contract already built; declare cli before reading .contract" if defined?(@__contract) && @__contract
-
-          @__cli = path.to_s
-        else
-          @__cli
-        end
-      end
-
-      # Declare a stateful wrapper resource (Contract::Around) to run around
-      # dispatch — e.g. `around :cursor` (pulse) or `around :build_lock` (build).
-      def around(name = nil)
-        return @__around unless name
-
-        raise "contract already built; declare around before reading .contract" if defined?(@__contract) && @__contract
-
-        @__around = name
-      end
-
-      def arg(name, type, required: false, positional: false, session_default: nil, description: nil, wire_name: nil, default: nil, source: nil, coerce: nil, cli_default: :__unset) # rubocop:disable Metrics/ParameterLists,Layout/LineLength
-        raise "contract already built; declare args before reading .contract" if defined?(@__contract) && @__contract
-
-        (@__args ||= []) << Arg.new(
-          name: name, type: type, required: required,
-          positional: positional, session_default: session_default,
-          description: description, wire_name: wire_name, default: default,
-          source: source, coerce: coerce, cli_default: cli_default
-        )
-      end
-
-      # Verb-level: the CLI reads its inputs from a stdin envelope of this mode.
-      # `:json` parses stdin as a JSON object and distributes its keys to args
-      # by wire-name. nil means no stdin acquisition.
-      def cli_stdin(mode = :__read)
-        return @__cli_stdin if mode == :__read
-
-        raise "contract already built; declare cli_stdin before reading .contract" if defined?(@__contract) && @__contract
-
-        @__cli_stdin = mode
-      end
-
-      # Declare an output shaper. `view { ... }` is the default (MCP + Ruby);
-      # `view(:cli) { ... }` overrides for the CLI. Both receive (result, inputs).
-      def view(surface = :default, &blk)
-        return (@__views ||= {})[surface] unless blk
-
-        raise "contract already built; declare view before reading .contract" if defined?(@__contract) && @__contract
-
-        (@__views ||= {})[surface] = blk
-      end
-
-      def contract?
-        !@__verb.nil?
-      end
-
-      # rubocop:disable Naming/MemoizedInstanceVariableName
-      # @__contract uses double-underscore to match the other accumulator ivars
-      # (@__verb, @__args, etc.) and avoid name collision with user-defined `@contract`.
-      def contract
-        @__contract ||= Spec.new(
-          verb: @__verb,
-          summary: @__summary,
-          args: (@__args || []).freeze,
-          surfaces: (@__surfaces || []).freeze,
-          views: ((@__views ||= {})[:default] ||= ->(v, _i) { v }) && @__views,
-          cli: @__cli,
-          around: @__around,
-          cli_stdin: @__cli_stdin,
-        )
-      end
-      # rubocop:enable Naming/MemoizedInstanceVariableName
-    end
-  end
-end