actionable-rb 1.9.0

data/lib/actionable/rbs.rb

@@ -0,0 +1,502 @@
+# frozen_string_literal: true
+
+module Actionable
+  # Generates RBS for a *user* action class — track 2 of the RBS strategy
+  # (decision D13). Sord covers the library's static classes, but it can't see
+  # +CreateInvoice.run(amount:)+ or +result.invoice+: those depend on the
+  # action's declared +input+/+output+ schemas. This walks those schemas (via
+  # FieldStruct's metadata and +FieldStruct::RBS.type_for+) and emits:
+  #
+  # * a typed +.run+ signature from the input schema (or +(*untyped)+ when
+  #   free-form), with an overload taking a built input struct;
+  # * for a fixed +input+ schema, a nested +InputSchema+ struct and a typed
+  #   +#input+ reader returning it. Like +Output+ and +Result+ it exists only
+  #   in RBS, so generation raises +ArgumentError+ when Ruby already resolves
+  #   +Action::InputSchema+;
+  # * a nullable instance variable per output field (+@total: ::Integer?+),
+  #   so steps that assign it type-check. The generated RBS owns these: a
+  #   host sig must not declare them again, since RBS rejects an instance
+  #   variable declared twice;
+  # * a nested +Output+ struct with a typed accessor per output field;
+  # * a nested +Result+ with +output+ and the convenience-delegation readers,
+  #   which +.run+ returns;
+  # * when the action declares failures with +fails+, a +failure_code+ type
+  #   alias listing every code it can fail with: the declared ones, then the
+  #   {Action::GEM_FAILURE_CODES} (decision D20);
+  # * when the action declares skips with +skips+, a +skip_code+ type alias
+  #   listing every code it can skip with (decision D21). The gem emits no skip
+  #   codes of its own, so the alias holds the declared ones only.
+  #
+  # Under typed outcomes (decision D23) +.run+ returns the action's own
+  # +Success | Skipped | Failure+ instead, each typed with its +code+ and an
+  # +output+ that names what the outcome can carry: a nested class per code
+  # that declares an output schema (+AlreadyActiveSkipOutput+,
+  # +InvalidFailureOutput+), and a Hash for a code without one. A failure's
+  # output also admits every skip schema and +Output+, since a broken one ends
+  # the run as +invalid_output+ carrying it.
+  #
+  #   class CreateInvoice < Actionable::Action
+  #     input  { required :amount, :integer }
+  #     output { required :invoice, :string }
+  #   end
+  #
+  #   puts Actionable::RBS.generate(CreateInvoice)
+  #   # class CreateInvoice < ::Actionable::Action
+  #   #   def self.run: (amount: ::Integer) -> Result
+  #   #               | (InputSchema input) -> Result
+  #   #   def input: () -> InputSchema
+  #   #   @invoice: ::String?
+  #   #   class InputSchema < ::FieldStruct::Base ... end
+  #   #   class Output < ::FieldStruct::Base ... end
+  #   #   class Result < ::Actionable::Result ... end
+  #   # end
+  #
+  # The action names its real superclass, and every named ancestor up to
+  # {Actionable::Action} is declared before it, member-less, so the output
+  # resolves without the host generating its abstract bases.
+  #
+  # The emitted +Result+/+Output+/+InputSchema+ are generated type aids: at
+  # runtime +.run+ returns a {Success}/{Failure}/{Skipped} that responds to
+  # these via output delegation, and the schemas are anonymous classes. Field
+  # types come from +FieldStruct::RBS.type_for+, so they match FieldStruct's own
+  # generator, and describe a valid instance. Referenced field types appear as
+  # qualified names (+::Invoice+) — generate RBS for those (e.g. via
+  # +FieldStruct::RBS+) so they resolve.
+  module RBS
+    # Generate RBS source for a user action class.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [String] RBS for the action, wrapped in its module nesting
+    # @raise [ArgumentError] when +klass+ is not a named {Actionable::Action}
+    #   subclass, or declares a fixed +input+ schema while Ruby already
+    #   resolves +klass::InputSchema+
+    def self.generate(klass)
+      unless klass.is_a?(::Class) && klass < Actionable::Action
+        raise ArgumentError, "Actionable::RBS.generate expects an Actionable::Action subclass, got #{klass.inspect}"
+      end
+      raise ArgumentError, 'cannot generate RBS for an anonymous action' unless klass.name
+
+      check_input_schema_name!(klass)
+      ancestor_blocks(klass) + wrap_namespace(klass.name, class_block(klass))
+    end
+
+    # The generated input type is named +InputSchema+, nested in the action.
+    # It exists only in RBS, so a Ruby constant that +klass::InputSchema+
+    # already resolves to (on the action, an ancestor class or an included
+    # module; +Object+'s top-level constants don't resolve through +klass::+)
+    # would make the RBS name lie.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [void]
+    # @raise [ArgumentError] when +klass+ has a fixed input schema and Ruby
+    #   already resolves +klass::InputSchema+
+    def self.check_input_schema_name!(klass)
+      return unless input_schema_class?(klass)
+
+      owner = klass.ancestors.take_while { |mod| mod != ::Object }.find { |mod| mod.const_defined?(:InputSchema, false) }
+      return unless owner
+
+      raise ArgumentError,
+        "#{klass.name}::InputSchema is already defined (in #{owner.name || owner.inspect}); " \
+        'Actionable::RBS.generate names the generated input type InputSchema, so rename that constant'
+    end
+    private_class_method :check_input_schema_name!
+
+    # @param klass [Class<Actionable::Action>]
+    # @return [Boolean] whether the generated RBS declares +InputSchema+: for a
+    #   fixed +input+ schema, not a discriminated +input_for+ one
+    def self.input_schema_class?(klass)
+      !klass.input_schema.nil? && klass.input_dispatch.nil?
+    end
+    private_class_method :input_schema_class?
+
+    # Declares every named ancestor between +klass+ and {Actionable::Action},
+    # so the action's superclass resolves on its own: a host often never
+    # generates its abstract base actions. Each is member-less, except that a
+    # typed ancestor also declares its result classes empty, for a typed
+    # subclass's result classes to subclass. Being empty, each declaration
+    # merges with the ancestor's full signature when that is generated too, and
+    # repeats byte-identically across the subclasses of one base, which RBS
+    # accepts across files.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [String] one namespaced block per ancestor, outermost first
+    def self.ancestor_blocks(klass)
+      named_ancestors(klass).reverse.map { |ancestor| "#{wrap_namespace(ancestor.name, ancestor_block(ancestor))}\n" }.join
+    end
+    private_class_method :ancestor_blocks
+
+    # @param ancestor [Class<Actionable::Action>]
+    # @return [String] the ancestor's member-less class block
+    def self.ancestor_block(ancestor)
+      head = class_head(ancestor)
+      return "#{head}\nend" unless typed_parent?(ancestor)
+
+      lines = %w[Success Skipped Failure].map { |name| "class #{name} < #{outcome_base(ancestor.superclass, name)}\nend" }
+      "#{head}\n#{indent(lines.join("\n"))}\nend"
+    end
+    private_class_method :ancestor_block
+
+    # @param klass [Class<Actionable::Action>]
+    # @return [Array<Class<Actionable::Action>>] the named classes strictly
+    #   between +klass+ and {Actionable::Action}, nearest first
+    def self.named_ancestors(klass)
+      chain = []
+      parent = klass.superclass
+      while parent && parent != Actionable::Action
+        chain << parent if parent.name
+        parent = parent.superclass
+      end
+      chain
+    end
+    private_class_method :named_ancestors
+
+    # @param klass [Class<Actionable::Action>]
+    # @return [String] +class Name < ::Superclass+, naming the nearest named
+    #   superclass (anonymous ones have no RBS name)
+    def self.class_head(klass)
+      parent = named_ancestors(klass).first || Actionable::Action
+      "class #{klass.name.split("::").last} < ::#{parent.name}"
+    end
+    private_class_method :class_head
+
+    # @param parent [Class]
+    # @return [Boolean] whether a subclass's result classes subclass +parent+'s
+    def self.typed_parent?(parent)
+      parent.respond_to?(:typed_outcomes?) && parent.typed_outcomes? && !parent.name.nil?
+    end
+    private_class_method :typed_parent?
+
+    # @param klass [Class<Actionable::Action>]
+    # @return [String]
+    def self.class_block(klass)
+      return typed_class_block(klass) if klass.typed_outcomes?
+
+      sections = leading_sections(klass, klass.output_schema ? 'Result' : '::Actionable::Result')
+      if (schema = klass.output_schema)
+        sections << output_block(schema)
+        sections << result_block(schema)
+      end
+      "#{class_head(klass)}\n#{indent(sections.join("\n\n"))}\nend"
+    end
+    private_class_method :class_block
+
+    # The class block of an action with typed outcomes (decision D23).
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [String]
+    def self.typed_class_block(klass)
+      sections = leading_sections(klass, '(Success | Skipped | Failure)')
+      sections << output_block(klass.output_schema) if klass.output_schema
+      outcome_schemas(klass).each { |name, schema| sections << output_block(schema, name) }
+      sections.concat(outcome_blocks(klass))
+      "#{class_head(klass)}\n#{indent(sections.join("\n\n"))}\nend"
+    end
+    private_class_method :typed_class_block
+
+    # The sections every action's class block opens with: the code aliases,
+    # +.run+, the typed +#input+ reader, the output instance variables, and the
+    # +InputSchema+ class.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @param return_type [String] what +.run+ returns
+    # @return [Array<String>]
+    def self.leading_sections(klass, return_type)
+      aliases = []
+      aliases << failure_code_alias(klass) unless klass.declared_failures.empty?
+      aliases << skip_code_alias(klass) unless klass.declared_skips.empty?
+      sections = []
+      sections << aliases.join("\n") unless aliases.empty?
+      sections << "def self.run: #{run_signature(klass, return_type: return_type)}"
+      sections << 'def input: () -> InputSchema' if input_schema_class?(klass)
+      sections << output_ivar_lines(klass.output_schema).join("\n") if klass.output_schema&.metadata&.any?
+      sections << output_block(klass.input_schema, 'InputSchema') if input_schema_class?(klass)
+      sections
+    end
+    private_class_method :leading_sections
+
+    # One instance variable per output field, which steps assign and the
+    # {Runner} captures into the output. Each is nullable: it is unset until a
+    # step assigns it. The generator owns these declarations, since RBS rejects
+    # the same instance variable declared in two files.
+    #
+    # @param schema [Class<FieldStruct::Base>] the success output schema
+    # @return [Array<String>]
+    def self.output_ivar_lines(schema)
+      schema.metadata.map { |field| "@#{field.name}: #{FieldStruct::RBS.type_for(field, nullable: true)}" }
+    end
+    private_class_method :output_ivar_lines
+
+    # The nested output class of every skip, then every failure, code that
+    # declares an output schema, named after the code.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [Array<Array(String, Class<FieldStruct::Base>)>] name, schema
+    def self.outcome_schemas(klass)
+      skips = klass.skip_declarations.keys.filter_map do |code|
+        schema = klass.skip_output_schema(code)
+        [code, "#{camelize(code)}SkipOutput", schema] if schema
+      end
+      failures = klass.failure_declarations.keys.filter_map do |code|
+        schema = klass.failure_output_schema(code)
+        [code, "#{camelize(code)}FailureOutput", schema] if schema
+      end
+      check_outcome_names!(klass, 'skip', skips)
+      check_outcome_names!(klass, 'failure', failures)
+      (skips + failures).map { |_, name, schema| [name, schema] }
+    end
+    private_class_method :outcome_schemas
+
+    # Every output class name must be an RBS class name, and unique: two codes
+    # that camelize alike (+:ready+ / +:ready_+, +:expired?+ /
+    # +:expired_predicate+) would otherwise emit one class for two schemas.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @param kind [String] +skip+ or +failure+
+    # @param entries [Array<Array(Symbol, String, Class<FieldStruct::Base>)>]
+    #   code, class name, schema
+    # @return [void]
+    # @raise [ArgumentError] on an invalid or a shared class name
+    def self.check_outcome_names!(klass, kind, entries)
+      entries.each do |code, name, _|
+        next if CONSTANT_NAME.match?(name)
+
+        raise ArgumentError, "#{klass.name}: #{kind} code #{code.inspect} gives #{name}, which is not a valid " \
+                             'RBS class name (it must start with an ASCII capital); rename the code'
+      end
+      entries.group_by { |_, name, _| name }.each_value do |same|
+        next if same.size == 1
+
+        codes = same.map { |code, _, _| code.inspect }.join(' and ')
+        raise ArgumentError, "#{klass.name}: #{kind} codes #{codes} both name #{same.first[1]} in the " \
+                             'generated RBS; rename one of the codes'
+      end
+    end
+    private_class_method :check_outcome_names!
+
+    # The +Success+, +Skipped+ and +Failure+ blocks of a typed action.
+    #
+    # @param klass [Class<Actionable::Action>]
+    # @return [Array<String>]
+    def self.outcome_blocks(klass)
+      skips = outcome_schemas(klass).select { |name, _| name.end_with?('SkipOutput') }
+      failures = outcome_schemas(klass).select { |name, _| name.end_with?('FailureOutput') }
+      failures += skips
+      failures << ['Output', klass.output_schema] if klass.output_schema
+      [
+        outcome_block(klass, 'Success', success_lines(klass)),
+        outcome_block(klass, 'Skipped', ["def code: () -> #{code_type(klass.declared_skips, "skip_code")}",
+                                         "def output: () -> #{union(skips.map(&:first))}",
+                                         *delegator_lines(skips.map(&:last))]),
+        outcome_block(klass, 'Failure', ["def code: () -> #{code_type(klass.declared_failures, "failure_code")}",
+                                         "def output: () -> #{union(failures.map(&:first))}",
+                                         *delegator_lines(failures.map(&:last), nullable: true)])
+      ]
+    end
+    private_class_method :outcome_blocks
+
+    # The readers a result delegates to its output struct, one per field any
+    # of +schemas+ declares. A field several declare types as the union of
+    # their types, nullable when any declares it optional, or when +nullable+.
+    # A failure's readers are all nullable: an +invalid_output+ failure carries
+    # the output that broke its schema, so a required field can be missing.
+    #
+    # @param schemas [Array<Class<FieldStruct::Base>>]
+    # @param nullable [Boolean] make every reader nullable
+    # @return [Array<String>]
+    def self.delegator_lines(schemas, nullable: false)
+      fields = Hash.new { |hash, name| hash[name] = [] }
+      schemas.each { |schema| schema.metadata.each { |field| fields[field.name] << field } }
+      fields.map do |name, declared|
+        types = declared.map { |field| rbs_type(field, nullable: false) }.uniq
+        type = if types.include?('untyped') then 'untyped'
+               elsif types.one? then types.first
+               else "(#{types.join(" | ")})"
+               end
+        type = nullable(type) if nullable || declared.any? { |field| !field.required? }
+        "def #{name}: () -> #{type}"
+      end
+    end
+    private_class_method :delegator_lines
+
+    # @param klass [Class<Actionable::Action>]
+    # @return [Array<String>] the +Success+ block's signatures
+    def self.success_lines(klass)
+      schema = klass.output_schema
+      lines = ['def code: () -> :success', "def output: () -> #{schema ? "Output" : HASH_OUTPUT}"]
+      schema&.metadata&.each { |field| lines << "def #{field.name}: () -> #{rbs_type(field)}" }
+      lines
+    end
+    private_class_method :success_lines
+
+    # @param declared [Hash] the declared codes
+    # @param name [String] the alias naming them
+    # @return [String] the alias, or +::Symbol+ when none are declared
+    def self.code_type(declared, name)
+      declared.empty? ? '::Symbol' : name
+    end
+    private_class_method :code_type
+
+    # @return [String]
+    HASH_OUTPUT = '::Hash[::Symbol, untyped]'
+    private_constant :HASH_OUTPUT
+
+    # @return [Regexp] what RBS accepts as a class name
+    CONSTANT_NAME = /\A[A-Z][A-Za-z0-9_]*\z/
+    private_constant :CONSTANT_NAME
+
+    # @param types [Array<String>] the output classes an outcome can carry
+    # @return [String] them and a Hash, as one RBS type
+    def self.union(types)
+      types.empty? ? HASH_OUTPUT : "(#{(types + [HASH_OUTPUT]).join(" | ")})"
+    end
+    private_class_method :union
+
+    # @param klass [Class<Actionable::Action>]
+    # @param name [String] +Success+, +Skipped+ or +Failure+
+    # @param lines [Array<String>] the block's method signatures
+    # @return [String] the class block, subclassing the parent action's own
+    #   result class when the parent has typed outcomes, else the gem's
+    def self.outcome_block(klass, name, lines)
+      "class #{name} < #{outcome_base(klass.superclass, name)}\n#{indent(lines.join("\n"))}\nend"
+    end
+    private_class_method :outcome_block
+
+    # @param parent [Class] the superclass of the action being generated
+    # @param name [String] +Success+, +Skipped+ or +Failure+
+    # @return [String] the parent's result class when it has typed outcomes,
+    #   else the gem's
+    def self.outcome_base(parent, name)
+      typed_parent?(parent) ? "::#{parent.name}::#{name}" : "::Actionable::#{name}"
+    end
+    private_class_method :outcome_base
+
+    # A code's trailing +?+ / +!+ becomes +Predicate+ / +Bang+, since neither
+    # may appear in a constant; +:x+ and +:x?+ get different names.
+    #
+    # @param code [Symbol]
+    # @return [String] +:already_active+ as +AlreadyActive+, +:expired?+ as
+    #   +ExpiredPredicate+, +:done!+ as +DoneBang+
+    def self.camelize(code)
+      base = code.to_s.split('_').map(&:capitalize).join
+      base.sub(/\?\z/, 'Predicate').sub(/!\z/, 'Bang')
+    end
+    private_class_method :camelize
+
+    # @param klass [Class<Actionable::Action>]
+    # @param return_type [String] what +.run+ returns
+    # @return [String] the +.run+ signature: typed kwargs from the input schema
+    #   (or +(*untyped)+ free-form), plus an overload taking a built
+    #   +InputSchema+ instance, which +.run+ passes through
+    def self.run_signature(klass, return_type:)
+      # An input_for dispatch decides the input at run time, even under a
+      # fixed input schema, so its keywords can't be listed.
+      schema = klass.input_schema if klass.input_dispatch.nil?
+      params = schema ? schema.metadata.map { |field| run_param(field) }.join(', ') : '*untyped'
+      signature = "(#{params}) -> #{return_type}"
+      return signature unless input_schema_class?(klass)
+
+      "#{signature}\n            | (InputSchema input) -> #{return_type}"
+    end
+    private_class_method :run_signature
+
+    # @param klass [Class<Actionable::Action>] an action that declares failures
+    # @return [String] the +failure_code+ alias: a union of the declared codes
+    #   and the codes the gem emits itself, as Symbol literal types
+    def self.failure_code_alias(klass)
+      codes = (klass.declared_failures.keys + Actionable::Action::GEM_FAILURE_CODES).uniq
+      "type failure_code = #{codes.map(&:inspect).join(" | ")}"
+    end
+    private_class_method :failure_code_alias
+
+    # @param klass [Class<Actionable::Action>] an action that declares skips
+    # @return [String] the +skip_code+ alias: a union of the declared skip codes
+    #   as Symbol literal types
+    def self.skip_code_alias(klass)
+      "type skip_code = #{klass.declared_skips.keys.map(&:inspect).join(" | ")}"
+    end
+    private_class_method :skip_code_alias
+
+    # @param field [FieldStruct::Field]
+    # @return [String] +name: Type+ (required), +?name: Type+ (required with a
+    #   default, so it may be omitted) or +?name: Type?+ (optional: it may be
+    #   omitted or passed +nil+; +run(note: nil)+ succeeds).
+    def self.run_param(field)
+      omittable = !field.required? || !field.default.nil?
+      "#{"?" if omittable}#{field.name}: #{rbs_type(field)}"
+    end
+    private_class_method :run_param
+
+    # A nested struct class with FieldStruct's reader and writer shape: the
+    # reader nullable when optional, the writer +(T? value) -> T?+.
+    #
+    # @param schema [Class<FieldStruct::Base>] an output or input schema
+    # @param name [String] the nested class name
+    # @return [String] the nested class block
+    def self.output_block(schema, name = 'Output')
+      lines = ["class #{name} < ::FieldStruct::Base"]
+      schema.metadata.each do |field|
+        writer = rbs_type(field, nullable: true)
+        lines << "  attr_reader #{field.name}: #{rbs_type(field)}"
+        lines << "  def #{field.name}=: (#{writer} value) -> #{writer}"
+      end
+      lines << 'end'
+      lines.join("\n")
+    end
+    private_class_method :output_block
+
+    # @param schema [Class<FieldStruct::Base>] the output schema
+    # @return [String] the nested +Result+ class block with output delegation
+    def self.result_block(schema)
+      lines = ['class Result < ::Actionable::Result', '  def output: () -> Output']
+      schema.metadata.each { |field| lines << "  def #{field.name}: () -> #{rbs_type(field)}" }
+      lines << 'end'
+      lines.join("\n")
+    end
+    private_class_method :result_block
+
+    # The field's RBS type, as FieldStruct's own generator emits it: made
+    # nullable when optional, or as +nullable+ says (D13).
+    #
+    # @param field [FieldStruct::Field]
+    # @param nullable [Boolean, nil] +nil+ follows the field's optionality
+    # @return [String]
+    def self.rbs_type(field, nullable: nil)
+      FieldStruct::RBS.type_for(field, nullable: nullable)
+    end
+    private_class_method :rbs_type
+
+    # @param type [String] an RBS type expression
+    # @return [String] +type+ made nullable, unless it already admits +nil+
+    def self.nullable(type)
+      type == 'untyped' || type.end_with?('?') ? type : "#{type}?"
+    end
+    private_class_method :nullable
+
+    # Wrap a class block in the nesting implied by its qualified name,
+    # indenting two spaces per level. A namespace that is a class opens as
+    # +class+ (no superclass, so it merges with the class's own declaration),
+    # since RBS rejects a class and a module of the same name.
+    #
+    # @param full_name [String]
+    # @param inner [String]
+    # @return [String] RBS source ending in a trailing newline
+    def self.wrap_namespace(full_name, inner)
+      parts = full_name.split('::')[0...-1]
+      block = inner
+      parts.each_index.reverse_each do |i|
+        keyword = Object.const_get(parts[0..i].join('::')).is_a?(::Class) ? 'class' : 'module'
+        block = "#{keyword} #{parts[i]}\n#{indent(block)}\nend"
+      end
+      "#{block}\n"
+    end
+    private_class_method :wrap_namespace
+
+    # @param text [String]
+    # @return [String] +text+ with every non-blank line indented two spaces
+    def self.indent(text)
+      text.split("\n", -1).map { |line| line.empty? ? line : "  #{line}" }.join("\n")
+    end
+    private_class_method :indent
+  end
+end

data/lib/actionable/registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Actionable
+  # A read-only map of every named action class, keyed by class name (decision
+  # D11). {Action} registers each subclass through its +inherited+ hook;
+  # anonymous subclasses (which have no name) are skipped. Used for discovery
+  # and tooling — e.g. sweeping all actions to generate RBS.
+  class Registry
+    def initialize
+      @map = {}
+    end
+
+    # Register an action class under its name. No-op for anonymous classes.
+    #
+    # @param klass [Class] the action subclass
+    # @return [self]
+    def register(klass)
+      name = klass.name
+      @map[name] = klass unless name.nil?
+      self
+    end
+
+    # @param name [String, Symbol] an action class name
+    # @return [Class, nil] the registered class, or +nil+
+    def [](name)
+      @map[name.to_s]
+    end
+
+    # @yieldparam name [String]
+    # @yieldparam klass [Class]
+    # @return [Enumerator, self]
+    def each(&)
+      return @map.each unless block_given?
+
+      @map.each(&)
+      self
+    end
+
+    # @return [Array<String>] the registered class names
+    def keys
+      @map.keys
+    end
+
+    # @return [Array<Class>] the registered classes
+    def values
+      @map.values
+    end
+
+    # @return [Integer] the number of registered classes
+    def size
+      @map.size
+    end
+
+    # @return [Boolean] whether nothing is registered
+    def empty?
+      @map.empty?
+    end
+  end
+
+  # @return [Registry] the process-wide action registry
+  def self.registry
+    @registry ||= Registry.new
+  end
+end