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

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,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,16 +131,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 +149,51 @@ 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_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 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)

lib/rom/environment.rb

@@ -34,6 +34,10 @@ class Gateway
     #    @param [Symbol] adapter The adapter identifier
     defines :adapter
 
+    # @!attribute [r] name
+    #   @return [Object] Gateway's registry identifier
+    attr_reader :name
+
     # @!attribute [r] connection
     #   @return [Object] The gateway's connection object (type varies across adapters)
     attr_reader :connection
@@ -81,25 +85,42 @@ class Gateway
     #
     # @api public
     def self.setup(gateway_or_scheme, *args)
-      case gateway_or_scheme
-      when String
-        raise ArgumentError, <<-STRING.gsub(/^ {10}/, "")
-          URIs without an explicit scheme are not supported anymore.
-          See https://github.com/rom-rb/rom/blob/master/CHANGELOG.md
-        STRING
-      when Symbol
-        klass = class_from_symbol(gateway_or_scheme)
-
-        if klass.instance_method(:initialize).arity.zero?
-          klass.new
+      gateway =
+        case gateway_or_scheme
+        when Gateway
+          unless args.empty?
+            raise ArgumentError, "Can't accept arguments when passing an instance"
+          end
+
+          gateway_or_scheme
+        when String
+          raise ArgumentError, <<-STRING.gsub(/^ {10}/, "")
+            URIs without an explicit scheme are not supported anymore.
+            See https://github.com/rom-rb/rom/blob/master/CHANGELOG.md
+          STRING
+        when Symbol
+          klass = class_from_symbol(gateway_or_scheme)
+
+          if klass.instance_method(:initialize).arity.zero?
+            klass.new
+          else
+            if args.size.equal?(1) && args.first.is_a?(Configurable::Config)
+              if args.first.respond_to?(:args)
+                setup(gateway_or_scheme, *args.first.args)
+              else
+                klass.new(**config)
+              end
+            elsif args.size.equal?(2) && args.last.is_a?(Hash)
+              klass.new(*args[0..-1], **args.last)
+            else
+              klass.new(*args)
+            end
+          end
         else
-          klass.new(*args)
+          gateway_or_scheme
         end
-      else
-        raise ArgumentError, "Can't accept arguments when passing an instance" unless args.empty?
 
-        gateway_or_scheme
-      end
+      gateway
     end
 
     class << self