rom 3.3.3 → 4.0.0.beta1

data/lib/rom/pipeline.rb

@@ -1,122 +0,0 @@
-module ROM
-  # Data pipeline common interface
-  #
-  # @api private
-  module Pipeline
-    # Common `>>` operator extension
-    #
-    # @api private
-    module Operator
-      # Compose two relation with a left-to-right composition
-      #
-      # @example
-      #   users.by_name('Jane') >> tasks.for_users
-      #
-      # @param [Relation] other The right relation
-      #
-      # @return [Relation::Composite]
-      #
-      # @api public
-      def >>(other)
-        composite_class.new(self, other)
-      end
-
-      private
-
-      # @api private
-      def composite_class
-        raise NotImplementedError
-      end
-    end
-
-    include Operator
-
-    # Send data through specified mappers
-    #
-    # @return [Relation::Composite]
-    #
-    # @api public
-    def map_with(*names)
-      [self, *names.map { |name| mappers[name] }]
-        .reduce { |a, e| composite_class.new(a, e) }
-    end
-
-    # @api public
-    def as(*names)
-      new_meth = names[0].is_a?(Class) ? 'map_to' : 'map_with'
-
-      msg = <<-STR
-          Relation#as will change behavior in 4.0. Use `#{new_meth}` instead
-            => Called at:
-               #{caller.join("\n")}
-          STR
-
-      Dry::Core::Deprecations.warn(msg)
-
-      map_with(*names)
-    end
-
-    # Forwards messages to the left side of a pipeline
-    #
-    # @api private
-    module Proxy
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        left.respond_to?(name) || super
-      end
-
-      private
-
-      # Check if response from method missing should be decorated
-      #
-      # @api private
-      def decorate?(response)
-        response.is_a?(left.class)
-      end
-
-      # @api private
-      def method_missing(name, *args, &block)
-        if left.respond_to?(name)
-          response = left.__send__(name, *args, &block)
-
-          if decorate?(response)
-            self.class.new(response, right)
-          else
-            response
-          end
-        else
-          super
-        end
-      end
-    end
-
-    # Base composite class with left-to-right pipeline behavior
-    #
-    # @api private
-    class Composite
-      (Kernel.private_instance_methods - %i(respond_to_missing?)).each(&method(:undef_method))
-
-      include Dry::Equalizer(:left, :right)
-      include Proxy
-
-      # @api private
-      attr_reader :left
-
-      # @api private
-      attr_reader :right
-
-      # @api private
-      def initialize(left, right)
-        @left = left
-        @right = right
-      end
-
-      # Compose this composite with another object
-      #
-      # @api public
-      def >>(other)
-        self.class.new(self, other)
-      end
-    end
-  end
-end

data/lib/rom/plugin.rb

@@ -1,20 +0,0 @@
-require 'rom/plugin_base'
-require 'rom/support/configurable'
-
-module ROM
-  # Plugin is a simple object used to store plugin configurations
-  #
-  # @private
-  class Plugin < PluginBase
-    include Configurable
-
-    # Apply this plugin to the provided class
-    #
-    # @param [Class] klass
-    #
-    # @api private
-    def apply_to(klass)
-      klass.send(:include, mod)
-    end
-  end
-end

data/lib/rom/plugin_base.rb

@@ -1,40 +0,0 @@
-module ROM
-  # Abstract plugin base
-  #
-  # @private
-  class PluginBase
-    # @return [Module] a module representing the plugin
-    #
-    # @api private
-    attr_reader :mod
-
-    # @return [Hash] configuration options
-    #
-    # @api private
-    attr_reader :options
-
-    # @api private
-    attr_reader :type
-
-    # @api private
-    def initialize(mod, options)
-      @mod      = mod
-      @options  = options
-      @type = options.fetch(:type)
-    end
-
-    # @api private
-    def relation?
-      type == :relation
-    end
-
-    # Apply this plugin to the provided class
-    #
-    # @param [Mixed] base
-    #
-    # @api private
-    def apply_to(_base)
-      raise NotImplementedError, "#{self.class}#apply_to not implemented"
-    end
-  end
-end

data/lib/rom/plugin_registry.rb

@@ -1,173 +0,0 @@
-require 'rom/registry'
-
-module ROM
-  # Stores all registered plugins
-  #
-  # @api private
-  class PluginRegistry
-    # Internal registry for configuration plugins
-    #
-    # @return [ConfigurationPluginRegistry]
-    #
-    # @api private
-    attr_reader :configuration
-
-    # Internal registry for command plugins
-    #
-    # @return [InternalPluginRegistry]
-    #
-    # @api private
-    attr_reader :commands
-
-    # Internal registry for mapper plugins
-    #
-    # @return [InternalPluginRegistry]
-    #
-    # @api private
-    attr_reader :mappers
-
-    # Internal registry for relation plugins
-    #
-    # @return [InternalPluginRegistry]
-    #
-    # @api private
-    attr_reader :relations
-
-    # @api private
-    def initialize
-      @configuration = ConfigurationPluginRegistry.new
-      @mappers = InternalPluginRegistry.new
-      @commands = InternalPluginRegistry.new
-      @relations = InternalPluginRegistry.new
-    end
-
-    # Register a plugin for future use
-    #
-    # @param [Symbol] name The registration name for the plugin
-    # @param [Module] mod The plugin to register
-    # @param [Hash] options optional configuration data
-    # @option options [Symbol] :type What type of plugin this is (command,
-    # relation or mapper)
-    # @option options [Symbol] :adapter (:default) which adapter this plugin
-    # applies to. Leave blank for all adapters
-    def register(name, mod, options = EMPTY_HASH)
-      type    = options.fetch(:type)
-      adapter = options.fetch(:adapter, :default)
-
-      plugins_for(type, adapter).register(name, mod, options)
-    end
-
-    private
-
-    # Determine which specific registry to use
-    #
-    # @api private
-    def plugins_for(type, adapter)
-      case type
-      when :configuration then configuration
-      when :command       then commands.adapter(adapter)
-      when :mapper        then mappers.adapter(adapter)
-      when :relation      then relations.adapter(adapter)
-      end
-    end
-  end
-  # Abstract registry defining common behaviour
-  #
-  # @api private
-  class PluginRegistryBase < Registry
-    # Retrieve a registered plugin
-    #
-    # @param [Symbol] name The plugin to retrieve
-    #
-    # @return [Plugin]
-    #
-    # @api public
-    def [](name)
-      elements[name]
-    end
-  end
-  # A registry storing environment specific plugins
-  #
-  # @api private
-  class ConfigurationPluginRegistry < PluginRegistryBase
-    # Assign a plugin to this environment registry
-    #
-    # @param [Symbol] name The registered plugin name
-    # @param [Module] mod The plugin to register
-    # @param [Hash] options optional configuration data
-    #
-    # @api private
-    def register(name, mod, options)
-      elements[name] = ConfigurationPlugin.new(mod, options)
-    end
-
-    # Return an environment plugin
-    #
-    # @param [Symbol] name The name of the environment plugin
-    #
-    # @raises [UnknownPluginError] if no plugin is found with the given name
-    #
-    # @api public
-    def fetch(name)
-      self[name] || raise(UnknownPluginError, name)
-    end
-  end
-  # A registry storing adapter specific plugins
-  #
-  # @api private
-  class AdapterPluginRegistry < PluginRegistryBase
-    # Assign a plugin to this adapter registry
-    #
-    # @param [Symbol] name The registered plugin name
-    # @param [Module] mod The plugin to register
-    # @param [Hash] options optional configuration data
-    #
-    # @api private
-    def register(name, mod, options)
-      elements[name] = Plugin.new(mod, options)
-    end
-  end
-
-  # Store a set of registries grouped by adapter
-  #
-  # @api private
-  class InternalPluginRegistry
-    # Return the existing registries
-    #
-    # @return [Hash]
-    #
-    # @api private
-    attr_reader :registries
-
-    # @api private
-    def initialize
-      @registries = Hash.new { |h, v| h[v] = AdapterPluginRegistry.new }
-    end
-
-    # Return the plugin registry for a specific adapter
-    #
-    # @param [Symbol] name The name of the adapter
-    #
-    # @return [AdapterRegistry]
-    #
-    # @api private
-    def adapter(name)
-      registries[name]
-    end
-
-    # Return the plugin for a given adapter
-    #
-    # @param [Symbol] name The name of the plugin
-    # @param [Symbol] adapter_name (:default) The name of the adapter used
-    #
-    # @raises [UnknownPluginError] if no plugin is found with the given name
-    #
-    # @api public
-    def fetch(name, adapter_name = :default)
-      adapter(adapter_name)[name] || adapter(:default)[name] ||
-        raise(UnknownPluginError, name)
-    end
-
-    alias_method :[], :fetch
-  end
-end

data/lib/rom/plugins/command/schema.rb

@@ -1,37 +0,0 @@
-module ROM
-  module Plugins
-    module Command
-      # @api private
-      module Schema
-        def self.included(klass)
-          super
-          klass.extend(ClassInterface)
-        end
-
-        # @api private
-        module ClassInterface
-          # @see Command.build
-          # @api public
-          def build(relation, options = {})
-            if options.key?(:input) || !relation.schema?
-              super
-            else
-              default_input = options.fetch(:input, input)
-
-              input_handler =
-                if default_input != Hash && relation.schema?
-                  -> tuple { relation.input_schema[input[tuple]] }
-                elsif relation.schema?
-                  relation.input_schema
-                else
-                  default_input
-                end
-
-              super(relation, options.merge(input: input_handler))
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rom/plugins/configuration/configuration_dsl.rb

@@ -1,21 +0,0 @@
-require 'rom/configuration_dsl'
-require 'dry/core/deprecations'
-
-module ROM
-  module ConfigurationPlugins
-    # Provides macros for defining relations, mappers and commands
-    #
-    # @api public
-    module ConfigurationDSL
-
-      # @api private
-      def self.apply(configuration, options = {})
-        Dry::Core::Deprecations.announce(
-          :macros,
-          "Calling `use(:macros)` is no longer necessary. Macros are enabled by default.",
-          tag: :rom
-        )
-      end
-    end
-  end
-end

data/lib/rom/plugins/relation/instrumentation.rb

@@ -1,51 +0,0 @@
-require 'dry/core/class_attributes'
-
-module ROM
-  module Plugins
-    module Relation
-      # Experimental plugin for configuring relations with an external
-      # instrumentation system like dry-monitor or ActiveSupport::Notifications
-      #
-      # @api public
-      module Instrumentation
-        extend Dry::Core::ClassAttributes
-
-        # This hooks sets up a relation class with injectible notifications object
-        #
-        # @api private
-        def self.included(klass)
-          super
-          klass.option :notifications
-          klass.extend(ClassInterface)
-          klass.prepend(mixin)
-          klass.instrument(:to_a)
-        end
-
-        defines :mixin
-        mixin Module.new
-
-        module ClassInterface
-          def instrument(*methods)
-            (methods - Instrumentation.mixin.instance_methods).each do |meth|
-              Instrumentation.mixin.send(:define_method, meth) do
-                instrument { super() }
-              end
-            end
-          end
-        end
-
-        # @api public
-        def instrument(&block)
-          notifications.instrument(self.class.adapter, name: name.relation, **notification_payload(self), &block)
-        end
-
-        private
-
-        # @api private
-        def notification_payload(relation)
-          EMPTY_HASH
-        end
-      end
-    end
-  end
-end

data/lib/rom/plugins/relation/key_inference.rb

@@ -1,48 +0,0 @@
-require 'dry/core/inflector'
-
-module ROM
-  module Plugins
-    module Relation
-      module KeyInference
-        # Infer foreign_key name for this relation
-        #
-        # TODO: this should be configurable and handled by an injected policy
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        def foreign_key(other = nil)
-          if other
-            if schema?
-              rel_name = other.respond_to?(:to_sym) ?
-                ROM::Relation::Name[other.to_sym] : other.base_name
-
-              key = schema.foreign_key(rel_name.dataset)
-              key ? key.meta[:name] : __registry__[rel_name].foreign_key
-            else
-              relation = other.respond_to?(:to_sym) ?
-                __registry__[other] : other
-
-              relation.foreign_key
-            end
-          else
-            :"#{Dry::Core::Inflector.singularize(name.dataset)}_id"
-          end
-        end
-
-        # Return base name which defaults to name attribute
-        #
-        # @return [ROM::Relation::Name]
-        #
-        # @api private
-        def base_name
-          name
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  register :key_inference, ROM::Plugins::Relation::KeyInference, type: :relation
-end

data/lib/rom/plugins/relation/registry_reader.rb

@@ -1,33 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      EMPTY_REGISTRY = RelationRegistry.new.freeze
-
-      # Allows relations to access all other relations through registry
-      #
-      # For now this plugin is always enabled
-      #
-      # @api public
-      module RegistryReader
-        # @api private
-        def self.included(klass)
-          super
-          return if klass.instance_methods.include?(:__registry__)
-          klass.option :__registry__, default: -> { EMPTY_REGISTRY }
-        end
-
-        # @api private
-        def respond_to_missing?(name, _include_private = false)
-          __registry__.key?(name) || super
-        end
-
-        private
-
-        # @api private
-        def method_missing(name, *)
-          __registry__.fetch(name) { super }
-        end
-      end
-    end
-  end
-end

data/lib/rom/registry.rb

@@ -1,50 +0,0 @@
-module ROM
-  # @api private
-  class Registry
-    include Enumerable
-    include Dry::Equalizer(:elements)
-
-    class ElementNotFoundError < KeyError
-      def initialize(key, name)
-        super("#{key.inspect} doesn't exist in #{name} registry")
-      end
-    end
-
-    attr_reader :elements, :name
-
-    def initialize(elements = {}, name = self.class.name)
-      @elements = elements
-      @name = name
-    end
-
-    def each(&block)
-      return to_enum unless block
-      elements.each { |element| yield(element) }
-    end
-
-    def key?(name)
-      !name.nil? && elements.key?(name.to_sym)
-    end
-
-    def fetch(key)
-      raise ArgumentError.new('key cannot be nil') if key.nil?
-
-      elements.fetch(key.to_sym) do
-        return yield if block_given?
-
-        raise ElementNotFoundError.new(key, name)
-      end
-    end
-    alias_method :[], :fetch
-
-    def respond_to_missing?(name, include_private = false)
-      elements.key?(name) || super
-    end
-
-    private
-
-    def method_missing(name, *)
-      elements.fetch(name) { super }
-    end
-  end
-end