rom-core 4.0.0.beta1

data/lib/rom/environment.rb

@@ -0,0 +1,70 @@
+require 'rom/support/configurable'
+require 'rom/gateway'
+
+module ROM
+  # Core gateway configuration interface
+  #
+  # @api public
+  class Environment
+    include Configurable
+
+    attr_reader :gateways, :gateways_map
+
+    # @api public
+    def initialize(*args)
+      @gateways = {}
+      @gateways_map = {}
+
+      configure_gateways(*args) unless args.empty?
+    end
+
+    private
+
+    def configure_gateways(*args)
+      normalized_gateway_args = normalize_gateway_args(*args)
+      normalized_gateways = normalize_gateways(normalized_gateway_args)
+
+      @gateways, @gateways_map = normalized_gateways.values_at(:gateways, :map)
+
+      normalized_gateway_args.each_with_object(config) do |(name, gateway_config), config|
+        options = gateway_config.is_a?(Array) && gateway_config.last
+        load_config(config.gateways[name], options) if options.is_a?(Hash)
+      end
+    end
+
+
+    # @api private
+    def normalize_gateway_args(*args)
+      args.first.is_a?(Hash) ? args.first : { default: args }
+    end
+
+    # Build gateways using the setup interface
+    #
+    # @api private
+    def normalize_gateways(gateways_config)
+      gateways_config.each_with_object(map: {}, gateways: {}) do |(name, spec), hash|
+        identifier, *args = Array(spec)
+
+        if identifier.is_a?(Gateway)
+          gateway = identifier
+        else
+          gateway = Gateway.setup(identifier, *args.flatten)
+        end
+
+        hash[:map][gateway] = name
+        hash[:gateways][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
+  end
+end

data/lib/rom/gateway.rb

@@ -0,0 +1,184 @@
+require 'dry/core/class_attributes'
+
+require 'rom/transaction'
+require 'rom/support/notifications'
+
+module ROM
+  # Abstract gateway class
+  #
+  # Every adapter needs to inherit from this class and implement
+  # required interface
+  #
+  # @abstract
+  #
+  # @api public
+  class Gateway
+    extend Dry::Core::ClassAttributes
+    extend Notifications::Listener
+
+    defines :adapter
+
+    # @!attribute [r] connection
+    #   @return [Object] The gateway's connection object (type varies across adapters)
+    attr_reader :connection
+
+    # Set up a gateway
+    #
+    # @overload setup(type, *args)
+    #   Sets up a single-gateway given a gateway type.
+    #   For custom gateways, create an instance and pass it directly.
+    #
+    #   @example
+    #     module SuperDB
+    #       class Gateway < ROM::Gateway
+    #         def initialize(options)
+    #         end
+    #       end
+    #     end
+    #
+    #     ROM.register_adapter(:super_db, SuperDB)
+    #
+    #     Gateway.setup(:super_db, some: 'options')
+    #     # SuperDB::Gateway.new(some: 'options') is called
+    #
+    #   @param [Symbol] type Registered gateway identifier
+    #   @param [Array] args Additional gateway options
+    #
+    # @overload setup(gateway)
+    #   Set up a gateway instance
+    #
+    #   @example
+    #     module SuperDB
+    #       class Gateway < ROM::Gateway
+    #         def initialize(options)
+    #         end
+    #       end
+    #     end
+    #
+    #     ROM.register_adapter(:super_db, SuperDB)
+    #
+    #     Gateway.setup(SuperDB::Gateway.new(some: 'options'))
+    #
+    #   @param [Gateway] gateway
+    #
+    # @return [Gateway] a specific gateway subclass
+    #
+    # @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 == 0
+          klass.new
+        else
+          klass.new(*args)
+        end
+      else
+        if args.empty?
+          gateway_or_scheme
+        else
+          raise ArgumentError, "Can't accept arguments when passing an instance"
+        end
+      end
+    end
+
+    # Get gateway subclass for a specific adapter
+    #
+    # @param [Symbol] type Adapter identifier
+    #
+    # @return [Class]
+    #
+    # @api private
+    def self.class_from_symbol(type)
+      adapter = ROM.adapters.fetch(type) {
+        begin
+          require "rom/#{type}"
+        rescue LoadError
+          raise AdapterLoadError, "Failed to load adapter rom/#{type}"
+        end
+
+        ROM.adapters.fetch(type)
+      }
+
+      adapter.const_get(:Gateway)
+    end
+
+    # Returns the adapter, defined for the class
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def adapter
+      self.class.adapter || raise(
+        MissingAdapterIdentifierError,
+        "gateway class +#{self}+ is missing the adapter identifier"
+      )
+    end
+
+    # A generic interface for setting up a logger
+    #
+    # This is not a required interface, it's a no-op by default
+    #
+    # @abstract
+    #
+    # @api public
+    def use_logger(*)
+      # noop
+    end
+
+    # A generic interface for returning default logger
+    #
+    # Adapters should implement this method as handling loggers is different
+    # across adapters. This is a no-op by default and returns nil.
+    #
+    # @return [NilClass]
+    #
+    # @api public
+    def logger
+      # noop
+    end
+
+    # Schema inference hook
+    #
+    # Every gateway that supports schema inference should implement this method
+    #
+    # @return [Array] An array with dataset names
+    #
+    # @api private
+    def schema
+      []
+    end
+
+    # Disconnect is optional and it's a no-op by default
+    #
+    # @api public
+    def disconnect
+      # noop
+    end
+
+    # Runs a block inside a transaction. The underlying transaction engine
+    # is adapter-specific
+    #
+    # @param [Hash] Transaction options
+    # @return The result of yielding the block or +nil+ if
+    #         the transaction was rolled back
+    #
+    # @api public
+    def transaction(opts = EMPTY_HASH, &block)
+      transaction_runner(opts).run(opts, &block)
+    end
+
+    private
+
+    # @api private
+    def transaction_runner(_)
+      Transaction::NoOp
+    end
+  end
+end

data/lib/rom/global.rb

@@ -0,0 +1,58 @@
+require 'rom/plugin_registry'
+require 'rom/global/plugin_dsl'
+
+module ROM
+  # Globally accessible public interface exposed via ROM module
+  #
+  # @api public
+  module Global
+    # Set base global registries in ROM constant
+    #
+    # @api private
+    def self.extended(rom)
+      super
+
+      rom.instance_variable_set('@adapters', {})
+      rom.instance_variable_set('@plugin_registry', PluginRegistry.new)
+    end
+
+    # An internal adapter identifier => adapter module map used by setup
+    #
+    # @return [Hash<Symbol=>Module>]
+    #
+    # @api private
+    attr_reader :adapters
+
+    # An internal identifier => plugin map used by the setup
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :plugin_registry
+
+    # Global plugin setup DSL
+    #
+    # @example
+    #   ROM.plugins do
+    #     register :publisher, Plugin::Publisher, type: :command
+    #   end
+    #
+    # @example
+    def plugins(*args, &block)
+      PluginDSL.new(plugin_registry, *args, &block)
+    end
+
+    # Register adapter namespace under a specified identifier
+    #
+    # @param [Symbol] identifier
+    # @param [Class,Module] adapter
+    #
+    # @return [self]
+    #
+    # @api private
+    def register_adapter(identifier, adapter)
+      adapters[identifier] = adapter
+      self
+    end
+  end
+end

data/lib/rom/global/plugin_dsl.rb

@@ -0,0 +1,47 @@
+module ROM
+  module Global
+    # plugin registration DSL
+    #
+    # @private
+    class PluginDSL
+      # Default options passed to plugin registration
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :defaults
+
+      # Plugin registry
+      #
+      # @return [PluginRegistry]
+      #
+      # @api private
+      attr_reader :registry
+
+      # @api private
+      def initialize(registry, defaults = EMPTY_HASH, &block)
+        @registry = registry
+        @defaults = defaults
+        instance_exec(&block)
+      end
+
+      # Register a plugin
+      #
+      # @param [Symbol] name of the plugin
+      # @param [Module] mod to include
+      # @param [Hash] options
+      #
+      # @api public
+      def register(name, mod, options = EMPTY_HASH)
+        registry.register(name, mod, defaults.merge(options))
+      end
+
+      # Register plugins for a specific adapter
+      #
+      # @param [Symbol] adapter type
+      def adapter(type, &block)
+        self.class.new(registry, adapter: type, &block)
+      end
+    end
+  end
+end

data/lib/rom/initializer.rb

@@ -0,0 +1,64 @@
+require 'dry-initializer'
+
+module ROM
+
+  # @api private
+  module Initializer
+    # @api private
+    module DefineWithHook
+      def param(*)
+        super
+
+        __define_with__
+      end
+
+      def option(*)
+        super
+
+        __define_with__ unless method_defined?(:with)
+      end
+
+      def __define_with__
+        seq_names = __initializer_mixin__.
+                      instance_method(:__initialize__).
+                      parameters.
+                      select { |type, _| type == :req }.
+                      map { |_, name| name }.
+                      join(', ')
+
+        seq_names << ', ' unless seq_names.empty?
+
+        undef_method(:with) if method_defined?(:with)
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def with(new_options = EMPTY_HASH)
+            if new_options.empty?
+              self
+            else
+              self.class.new(#{ seq_names }options.merge(new_options))
+            end
+          end
+        RUBY
+      end
+    end
+
+    # @api private
+    def self.extended(base)
+      base.extend(Dry::Initializer[undefined: false])
+      base.extend(DefineWithHook)
+      base.include(InstanceMethods)
+    end
+
+    # @api private
+    module InstanceMethods
+      # Instance options
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def options
+        @__options__
+      end
+    end
+  end
+end

data/lib/rom/lint/enumerable_dataset.rb

@@ -0,0 +1,54 @@
+require 'rom/lint/linter'
+
+module ROM
+  module Lint
+    # Ensures that a [ROM::EnumerableDataset] extension correctly yields
+    # arrays and tuples
+    #
+    # @api public
+    class EnumerableDataset < ROM::Lint::Linter
+      # The linted subject
+      #
+      # @api public
+      attr_reader :dataset
+
+      # The expected data
+      #
+      # @api public
+      attr_reader :data
+
+      # Create a linter for EnumerableDataset
+      #
+      # @param [EnumerableDataset] dataset the linted subject
+      # @param [Object] data the expected data
+      #
+      # @api public
+      def initialize(dataset, data)
+        @dataset = dataset
+        @data = data
+      end
+
+      # Lint: Ensure that +dataset+ yield tuples via +each+
+      #
+      # @api public
+      def lint_each
+        result = []
+        dataset.each do |tuple|
+          result << tuple
+        end
+        return if result == data
+
+        complain "#{dataset.class}#each must yield tuples"
+      end
+
+      # Lint: Ensure that +dataset+'s array equals to expected +data+
+      #
+      # @api public
+      def lint_to_a
+        return if dataset.to_a == data
+
+        complain "#{dataset.class}#to_a must cast dataset to an array"
+      end
+    end
+  end
+end