Improve gateway setup (#638)

In summary:

  - Separate loading adapters from loading gateways
  - Simplify gateway handling
  - Simplify configuring gateways
  - Add Gateway#name
  - Add Gateway#config (which is *the config* that was used to create a gateway instance)
  - Move config stuff from gateways environment to Configuration
  - Move loading of gateways to Setup
  - Stop memoizing plugins in components
  - Turn Environment into a standard registry with gateways
  - Move Configuration#relation_classes to rom/compat

Author: solnic

lib/rom/compat.rb

@@ -5,5 +5,24 @@
 module ROM
   class Configuration
     def_delegators :@setup, :auto_registration
+    def_delegators :@gateways, :gateways_map
+
+    alias_method :environment, :gateways
+
+    # @api private
+    def relation_classes(gateway = nil)
+      classes = setup.components.relations.map(&:constant)
+
+      return classes unless gateway
+
+      gw_name = gateway.is_a?(Symbol) ? gateway : gateways_map[gateway]
+      classes.select { |rel| rel.gateway == gw_name }
+    end
+
+    # @api private
+    # @deprecated
+    def gateways_map
+      @gateways_map ||= gateways.to_a.map(&:reverse).to_h
+    end
   end
 end

lib/rom/components/core.rb

@@ -80,12 +80,12 @@ def apply_plugins
       end
 
       # @api public
-      memoize def plugins
+      def plugins
         configuration.plugins.select { |plugin| plugin.type == self.class.id }
       end
 
       # @api public
-      memoize def plugin_options
+      def plugin_options
         plugins.map(&:config).map(&:to_hash).reduce(:merge) || EMPTY_HASH
       end
 

lib/rom/configuration.rb

@@ -3,11 +3,10 @@
 require "forwardable"
 
 require "rom/support/notifications"
-require "rom/environment"
 require "rom/setup"
 require "rom/configuration_dsl"
+require "rom/support/configurable"
 require "rom/support/inflector"
-require "rom/relation_registry"
 
 module ROM
   class Configuration
@@ -23,68 +22,75 @@ class Configuration
     register_event("configuration.commands.class.before_build")
 
     include ROM::ConfigurationDSL
+    include Configurable
 
     NoDefaultAdapterError = Class.new(StandardError)
 
-    # @!attribute [r] environment
-    #   @return [Environment] Environment object with gateways
-    attr_reader :environment
-
     # @!attribute [r] setup
-    #   @return [Setup] Setup object which collects component classes and plugins
+    #   @return [Setup] Setup object which manages component and plugins
     attr_reader :setup
 
     # @!attribute [r] notifications
     #   @return [Notifications] Notification bus instance
     attr_reader :notifications
 
-    # @!attribute [r] cache
-    #   @return [Notifications] Cache
-    attr_reader :cache
-
-    # @!attribute [r] relations
-    #   @return [ROM::RelationRegistry] relations
-    attr_reader :relations
-
-    def_delegators :@setup, :register_relation, :register_command,
-                   :register_mapper, :register_plugin, :auto_register,
-                   :inflector, :inflector=, :components, :plugins
-
-    def_delegators :@environment, :gateways, :gateways_map, :configure, :config
+    def_delegators :@setup, :cache, :relations, :gateways,
+      :register_relation, :register_command, :register_mapper,
+      :register_plugin, :auto_register, :inflector, :inflector=,
+      :components, :plugins
 
     # Initialize a new configuration
     #
-    # @see Environment#initialize
-    #
     # @return [Configuration]
     #
     # @api private
     def initialize(*args, &block)
-      @environment = Environment.new(*args)
-      @setup = Setup.new
       @notifications = Notifications.event_bus(:configuration)
-      @cache = Cache.new
 
-      @relations = RelationRegistry.build
+      config.gateways = Config.new
+      @setup = Setup.new(config: config.gateways)
 
-      block&.call(self)
+      configure(*args, &block)
     end
 
-    # @api private
-    def finalize
-      setup.finalize
+    # @api public
+    def configure(*args)
+      unless args.empty?
+        gateways_config = args.first.is_a?(Hash) ? args.first : {default: args}
+
+        gateways_config.each do |name, value|
+          args = Array(value)
+
+          adapter, *rest = args
+
+          if rest.size > 1 && rest.last.is_a?(Hash)
+            load_config(config.gateways[name], {adapter: adapter, args: rest[0..-1], **rest.last})
+          else
+            options = rest.first.is_a?(Hash) ? rest.first : {args: rest.flatten(1)}
+            load_config(config.gateways[name], {adapter: adapter, **options})
+          end
+        end
+      end
+
+      # Load adapters explicitly here to ensure their plugins are present already
+      # while setup loads components and then triggers finalization
+      setup.load_adapters
+
+      yield(self) if block_given?
+
+      # No more changes allowed
+      config.freeze
+
+      # Load gateways after yielding config because gateways *need finalized config*
+      setup.load_gateways
+
       self
     end
 
     # @api private
-    def command_compiler
-      @command_compiler ||= CommandCompiler.new(
-        gateways,
-        relations,
-        Registry.new,
-        notifications,
-        inflector: inflector
-      )
+    def finalize
+      setup.finalize
+      self
     end
 
     # Apply a plugin to the configuration
@@ -96,10 +102,9 @@ def command_compiler
     #
     # @api public
     def use(plugin, options = {})
-      if plugin.is_a?(Array)
-        plugin.each { |p| use(p) }
-      elsif plugin.is_a?(Hash)
-        plugin.to_a.each { |p| use(*p) }
+      case plugin
+      when Array then plugin.each { |p| use(p) }
+      when Hash then plugin.to_a.each { |p| use(*p) }
       else
         ROM.plugin_registry[:configuration].fetch(plugin).apply_to(self, options)
       end
@@ -116,16 +121,14 @@ def [](name)
       gateways.fetch(name)
     end
 
-    # Hook for respond_to? used internally
-    #
     # @api private
-    def respond_to?(name, include_all = false)
-      gateways.key?(name) || super
+    def default_gateway
+      @default_gateway ||= gateways[:default] if gateways.key?(:default)
     end
 
     # @api private
-    def default_gateway
-      @default_gateway ||= gateways[:default]
+    def default_adapter
+      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
     end
 
     # @api private
@@ -136,22 +139,34 @@ def adapter_for_gateway(gateway)
     end
 
     # @api private
-    def relation_classes(gateway = nil)
-      classes = setup.components.relations.map(&:constant)
-
-      return classes unless gateway
-
-      gw_name = gateway.is_a?(Symbol) ? gateway : gateways_map[gateway]
-      classes.select { |rel| rel.gateway == gw_name }
+    def command_compiler
+      @command_compiler ||= CommandCompiler.new(
+        gateways,
+        relations,
+        Registry.new,
+        notifications,
+        inflector: inflector
+      )
     end
 
     # @api private
-    def default_adapter
-      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
+    def respond_to_missing?(name, include_all = false)
+      gateways.key?(name) || super
     end
 
     private
 
+    # @api private
+    def load_config(config, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          load_config(config[key], value)
+        else
+          config.send("#{key}=", value)
+        end
+      end
+    end
+
     # Returns gateway if method is a name of a registered gateway
     #
     # @return [Gateway]

lib/rom/constants.rb

@@ -20,6 +20,7 @@ def initialize(adapter, component)
   end
 
   EnvAlreadyFinalizedError = Class.new(StandardError)
+  GatewayAlreadyDefinedError = Class.new(StandardError)
   RelationAlreadyDefinedError = Class.new(StandardError)
   CommandAlreadyDefinedError = Class.new(StandardError)
   MapperAlreadyDefinedError = Class.new(StandardError)