Improve and simplify gateway config and setup

This makes gateway setup more inline with how components are handled.
It'll make it easier to extend configuration with support for global
defaults and simplify handling of gateways at runtime, because they
now have a name under which they are registered + all config and opts
associated with a gateway instance are stored within the gateway registry
which makes it easily accessible.

It didn't make sense to improve Gateway abstract class because making it
backward compatible would be too much work and breaking API would be even
more work, considering all the adapters that would have to be updated.

In summary:

  - Simplify gateway handling
  - Simplify configuring gateways
  - Add Gateway#name
  - Move config stuff from gateways environment to Configuration
  - Stop memoizing plugins in components
  - Turn Environment into a standard registry with gateways
  - Move Configuration#relation_classes to rom/compat
  - Move Configuration#adapter_for_gateway to rom/compat

Author: solnic

lib/rom/compat.rb

@@ -5,5 +5,32 @@
 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
+
+    # @api private
+    # @deprecated
+    def adapter_for_gateway(gateway)
+      ROM.adapters.select do |_key, value|
+        value.const_defined?(:Gateway) && gateway.is_a?(value.const_get(:Gateway))
+      end.keys.first
+    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,10 +3,11 @@
 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/gateway_registry"
 require "rom/relation_registry"
 
 module ROM
@@ -23,12 +24,13 @@ 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] gateways
+    #   @return [GatewayRegistry] Configured runtime gateways
+    attr_reader :gateways
 
     # @!attribute [r] setup
     #   @return [Setup] Setup object which collects component classes and plugins
@@ -50,24 +52,49 @@ class Configuration
                    :register_mapper, :register_plugin, :auto_register,
                    :inflector, :inflector=, :components, :plugins
 
-    def_delegators :@environment, :gateways, :gateways_map, :configure, :config
-
     # 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)
+
+      @setup = Setup.new
       @cache = Cache.new
 
+      config.gateways = Config.new
+      @gateways = GatewayRegistry.new({}, cache: cache, config: config.gateways)
+
+      configure(*args, &block)
+
       @relations = RelationRegistry.build
+    end
+
+    # @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_gateways
+
+      yield(self) if block_given?
 
-      block&.call(self)
+      self
     end
 
     # @api private
@@ -76,17 +103,6 @@ def finalize
       self
     end
 
-    # @api private
-    def command_compiler
-      @command_compiler ||= CommandCompiler.new(
-        gateways,
-        relations,
-        Registry.new,
-        notifications,
-        inflector: inflector
-      )
-    end
-
     # Apply a plugin to the configuration
     #
     # @param [Mixed] plugin The plugin identifier, usually a Symbol
@@ -96,10 +112,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,42 +131,62 @@ 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
-    def adapter_for_gateway(gateway)
-      ROM.adapters.select do |_key, value|
-        value.const_defined?(:Gateway) && gateway.is_a?(value.const_get(:Gateway))
-      end.keys.first
+    def command_compiler
+      @command_compiler ||= CommandCompiler.new(
+        gateways,
+        relations,
+        Registry.new,
+        notifications,
+        inflector: inflector
+      )
     end
 
     # @api private
-    def relation_classes(gateway = nil)
-      classes = setup.components.relations.map(&:constant)
+    def respond_to_missing?(name, include_all = false)
+      gateways.key?(name) || super
+    end
 
-      return classes unless gateway
+    private
 
-      gw_name = gateway.is_a?(Symbol) ? gateway : gateways_map[gateway]
-      classes.select { |rel| rel.gateway == gw_name }
+    # @api private
+    def load_gateways
+      config.gateways.each do |name, gateway_config|
+        gateway =
+          if gateway_config.adapter.is_a?(Gateway)
+            gateway_config.adapter
+          else
+            Gateway.setup(gateway_config.adapter, gateway_config)
+          end
+
+        # TODO: this is here to keep backward compatibility
+        gateway.instance_variable_set(:"@name", name)
+
+        gateways.add(name, gateway)
+      end
     end
 
     # @api private
-    def default_adapter
-      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
+    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
 
-    private
-
     # 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)