Refactor setup/configuration/finalization code

  - Use components directly in the loader
  - Use components when finalizing schemas
  - Use components when finalizing relations
  - Use components when finalizing commands
  - Use components when finalizing mappers
  - Remove usage for *_classes methods
  - Components => Components::Registry
  - Introduce Components::Relation
  - Drastically simplify handling of environment and notifications
  - Remove unused environment config from finalize
  - Remove unused repo_adapter
  - Use configuration in Finalize instead of options
  - Remove redundant configuration.finalize
  - Move setting default command registry to relation class method

Author: solnic

lib/rom/compat/setup.rb

@@ -21,10 +21,25 @@ class Setup
     # @api public
     def auto_registration(directory, **options)
       auto_registration = AutoRegistration.new(directory, inflector: inflector, **options)
-      auto_registration.relations.map { |r| register_relation(r) }
-      auto_registration.commands.map { |r| register_command(r) }
-      auto_registration.mappers.map { |r| register_mapper(r) }
+      auto_registration.relations.each { |r| register_relation(r) }
+      auto_registration.commands.each { |r| register_command(r) }
+      auto_registration.mappers.each { |r| register_mapper(r) }
       self
     end
+
+    # @api public
+    def relation_classes
+      components.relations.map(&:constant)
+    end
+
+    # @api public
+    def command_classes
+      components.commands.map(&:constant)
+    end
+
+    # @api public
+    def mapper_classes
+      components.mappers.map(&:constant)
+    end
   end
 end

lib/rom/components.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rom/constants"
+require "rom/components/schema"
+require "rom/components/command"
+require "rom/components/relation"
+require "rom/components/mapper"
+
+module ROM
+  # Setup objects collect component classes during setup/finalization process
+  #
+  # @api public
+  module Components
+    CORE_TYPES = %i[schemas relations commands mappers].freeze
+
+    HANDLERS = {
+      relations: Relation,
+      commands: Command,
+      mappers: Mapper,
+      schemas: Schema
+    }.freeze
+
+    # @api public
+    def components
+      @components ||= Registry.new
+    end
+
+    class Registry
+      # @api private
+      attr_reader :types
+
+      # @api private
+      attr_reader :store
+
+      # @api private
+      attr_reader :handlers
+
+      # @api private
+      def initialize(types: CORE_TYPES.dup, handlers: HANDLERS)
+        @types = types
+        @store = types.map { |type| [type, EMPTY_ARRAY.dup] }.to_h
+        @handlers = handlers
+      end
+
+      # @api private
+      def [](type)
+        store[type]
+      end
+
+      # @api private
+      def update(other)
+        store.each { |type, items| items.concat(other[type]) }
+        self
+      end
+
+      # @api private
+      def add(type, **options)
+        component = handlers.fetch(type).new(**options)
+
+        if component.respond_to?(:id) && store[type].map(&:id).include?(component.id)
+          case type
+          when :mappers
+            raise MapperAlreadyDefinedError, "+#{component.id}+ is already defined"
+          when :relations
+            raise RelationAlreadyDefinedError, "+#{component.id}+ is already defined"
+          end
+        end
+
+        # TODO: this needs a nicer abstraction
+        # TODO: respond_to? is only needed because auto_register specs use POROs :(
+        update(component.constant.components) if component.constant.respond_to?(:components)
+
+        store[type] << component
+
+        component
+      end
+
+      CORE_TYPES.each do |type|
+        define_method(type) { self[type] }
+      end
+    end
+  end
+end

lib/rom/components/command.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Command < Core
+      id :command
+
+      # @!attribute [r] relation_name
+      #   @return [Symbol] The relation identifier
+      #   @api public
+      option :relation_name, type: Types.Instance(Symbol), default: -> {
+        # TODO: another workaround for auto_register specs not using actual rom classes
+        constant.respond_to?(:relation) ? constant.relation : constant.name.to_sym
+      }
+
+      # @api public
+      def build(relation:)
+        trigger(
+          "commands.class.before_build",
+          command: constant,
+          gateway: gateways[relation.gateway],
+          dataset: relation.dataset,
+          adapter: relation.adapter
+        )
+
+        constant.extend_for_relation(relation) if constant.restrictable
+
+        constant.build(relation)
+      end
+    end
+  end
+end

lib/rom/components/core.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "dry/effects"
+require "dry/core/class_attributes"
+
+require "rom/constants"
+require "rom/initializer"
+require "rom/types"
+
+module ROM
+  module Components
+    # Abstract component class
+    #
+    # @api public
+    class Core
+      extend Initializer
+      extend Dry::Core::ClassAttributes
+
+      include Dry::Effects.Reader(:configuration)
+
+      defines :id
+
+      # @!attribute [r] constant
+      #   @return [Class] Component's target class
+      #   @api public
+      option :constant, optional: true, type: Types.Interface(:new)
+      alias_method :relation, :constant
+
+      # This method is meant to return a run-time component instance
+      #
+      # @api public
+      def build(**)
+        raise NotImplementedError
+      end
+
+      # @api public
+      def trigger(event, payload)
+        notifications.trigger("configuration.#{event}", payload)
+      end
+
+      # @api public
+      def relations
+        configuration.relations
+      end
+
+      # @api public
+      def command_compiler
+        configuration.command_compiler
+      end
+
+      # @api public
+      def notifications
+        configuration.notifications
+      end
+
+      # @api public
+      def gateways
+        configuration.gateways
+      end
+
+      # @api public
+      def components
+        configuration.components
+      end
+
+      # @api public
+      def apply_plugins
+        plugins.each do |plugin|
+          plugin.apply_to(constant)
+        end
+      end
+
+      # @api public
+      def plugins
+        configuration.plugins.select { |plugin| plugin.type == self.class.id }
+      end
+
+      # @api public
+      def plugin_options
+        plugins.map(&:config).map(&:to_hash).reduce(:merge) || EMPTY_HASH
+      end
+
+      private
+
+      # @api private
+      def gateway
+        gateways.fetch(relation.gateway) do
+          raise "+#{constant}+ gateway not found #{constant.gateway.inspect}"
+        end
+      end
+    end
+  end
+end

lib/rom/components/mapper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Mapper < Core
+      id :mapper
+
+      # @!attribute [r] key
+      #   @return [Symbol] The mapper identifier
+      #   @api public
+      option :key, type: Types.Instance(Symbol), default: -> {
+        # TODO: another workaround for auto_register specs not using actual rom classes
+        constant.respond_to?(:register_as) ?
+          (constant.register_as || constant.relation) : constant.name.to_sym
+      }
+
+      # @!attribute [r] base_relation
+      #   @return [Symbol] The base relation identifier
+      #   @api public
+      option :base_relation, type: Types.Instance(Symbol), default: -> {
+        # TODO: another workaround for auto_register specs not using actual rom classes
+        constant.respond_to?(:base_relation) ? constant.base_relation : constant.name.to_sym
+      }
+
+      # @!attribute [r] object
+      #   @return [Class] Pre-initialize object that should be used instead of the constant
+      #   @api public
+      option :object, optional: true
+
+      # @api public
+      def id
+        "#{base_relation}.#{key}"
+      end
+
+      # @api public
+      def build
+        object || constant.build
+      end
+    end
+  end
+end

lib/rom/components/relation.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Relation < Core
+      id :relation
+
+      # @!attribute [r] key
+      #   @return [Symbol] The relation identifier
+      #   @api public
+      option :key, type: Types.Instance(Symbol), default: -> {
+        # TODO: another workaround for auto_register specs not using actual rom classes
+        constant.respond_to?(:relation_name) ? constant.relation_name.to_sym : constant.name.to_sym
+      }
+      alias_method :id, :key
+
+      # @api public
+      def adapter
+        constant.adapter
+      end
+
+      # @return [ROM::Relation]
+      #
+      # @api public
+      def build
+        unless adapter
+          raise MissingAdapterIdentifierError,
+                "Relation class +#{constant}+ is missing the adapter identifier"
+        end
+
+        relation_names = components.relations.map(&:key)
+
+        # TODO: this should become a built-in feature, no neeed to use a plugin
+        constant.use(:registry_reader, relations: relation_names)
+
+        trigger("relations.class.ready", relation: constant, adapter: adapter)
+
+        schema = finalize_schema
+
+        apply_plugins
+
+        dataset = gateway.dataset(schema.name.dataset).instance_exec(constant, &constant.dataset)
+
+        trigger("relations.dataset.allocated", dataset: dataset, relation: constant, adapter: adapter)
+
+        # TODO: this will be removed once mapper registry is lazy-by-default
+        mappers = finalize_mappers
+
+        options = {
+          __registry__: relations,
+          mappers: mappers,
+          schema: schema,
+          inflector: configuration.inflector,
+          **plugin_options
+        }
+
+        relation = constant.new(dataset, **options)
+
+        # TODO: this will be removed once command registry is lazy-by-default
+        finalize_commands(relation)
+
+        relation
+      end
+
+      private
+
+      # @api private
+      def finalize_schema
+        components.schemas
+          .select { |schema| schema.relation == constant }
+          .last # TODO: relation DSL auto-defines an empty schema so this is a workaround
+          .build
+      end
+
+      # @api private
+      def finalize_mappers
+        mappers = components[:mappers]
+          .map { |mapper| [mapper.key, mapper.build] if mapper.base_relation == key }
+          .compact
+          .to_h
+
+        constant.mapper_registry(cache: configuration.cache).merge(mappers)
+      end
+
+      # @api private
+      def finalize_commands(relation)
+        commands = components.commands
+          .select { |command| command.relation_name == constant.relation_name.relation }
+          .map { |command| command.build(relation: relation) }
+
+        commands.each do |command|
+          identifier = command.class.register_as || command.class.default_name
+          relation.commands.elements[identifier] = command
+        end
+
+        command_compiler.commands.elements[constant.relation_name.relation] = relation.commands
+
+        relation.commands.set_compiler(command_compiler)
+        relation.commands.set_mappers(relation.mappers)
+      end
+    end
+  end
+end