rom 2.0.2 → 4.2.1

data/lib/rom/pipeline.rb

@@ -1,106 +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
-    alias_method :as, :map_with
-
-    # 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
-      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,17 +0,0 @@
-require 'rom/plugin_base'
-
-module ROM
-  # Plugin is a simple object used to store plugin configurations
-  #
-  # @private
-  class Plugin < PluginBase
-    # 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,31 +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
-    def initialize(mod, options)
-      @mod      = mod
-      @options  = options
-    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/support/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.schema_hash[input[tuple]] }
-                elsif relation.schema?
-                  relation.schema_hash
-                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,17 +0,0 @@
-require 'rom/configuration_dsl'
-require 'rom/support/deprecations'
-
-module ROM
-  module ConfigurationPlugins
-    # Provides macros for defining relations, mappers and commands
-    #
-    # @api public
-    module ConfigurationDSL
-
-      # @api private
-      def self.apply(configuration, options = {})
-        ROM::Deprecations.announce(:macros, "Calling `use(:macros)` is no longer necessary. Macros are enabled by default.")
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-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
-            :"#{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,32 +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
-          klass.option :__registry__, type: RelationRegistry, default: EMPTY_REGISTRY, reader: true
-        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/plugins/relation/view/dsl.rb

@@ -1,32 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      module View
-        class DSL
-          attr_reader :name
-
-          attr_reader :attributes
-
-          attr_reader :relation_block
-
-          def initialize(name, &block)
-            @name = name
-            instance_eval(&block)
-          end
-
-          def header(*args, &block)
-            @attributes = args.size > 0 ? args.first : block
-          end
-
-          def relation(&block)
-            @relation_block = lambda(&block)
-          end
-
-          def call
-            [name, attributes, relation_block]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-require 'rom/plugins/relation/view/dsl'
-
-module ROM
-  module Plugins
-    module Relation
-      module View
-        def self.included(klass)
-          super
-
-          klass.class_eval do
-            extend ClassInterface
-
-            option :view, reader: true
-            option :attributes
-
-            def self.attributes
-              @__attributes__ ||= {}
-            end
-          end
-        end
-
-        # Return column names that will be selected for this relation
-        #
-        # By default we use dataset columns but first we look at configured
-        # attributes by `view` DSL
-        #
-        # @return [Array<Symbol>]
-        #
-        # @api private
-        def attributes(view_name = view)
-          if options.key?(:attributes)
-            options[:attributes]
-          else
-            header = self.class.attributes
-              .fetch(view_name, self.class.attributes.fetch(:base))
-
-            if header.is_a?(Proc)
-              instance_exec(&header)
-            else
-              header
-            end
-          end
-        end
-
-        module ClassInterface
-          # Define a relation view with a specific header
-          #
-          # With headers defined all the mappers will be inferred automatically
-          #
-          # @example
-          #   class Users < ROM::Relation[:sql]
-          #     view(:by_name, [:id, :name]) do |name|
-          #       where(name: name)
-          #     end
-          #
-          #     view(:listing, [:id, :name, :email]) do
-          #       select(:id, :name, :email).order(:name)
-          #     end
-          #   end
-          #
-          # @api public
-          def view(*args, &block)
-            if args.size == 1 && block.arity > 0
-              raise ArgumentError, "header must be set as second argument"
-            end
-
-            name, names, relation_block =
-              if args.size == 1
-                DSL.new(*args, &block).call
-              else
-                [*args, block]
-              end
-
-            attributes[name] = names
-
-            if relation_block.arity > 0
-              auto_curry_guard do
-                define_method(name, &relation_block)
-                auto_curry(name) { with(view: name) }
-              end
-            else
-              define_method(name) do
-                instance_exec(&relation_block).with(view: name)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  register :view, ROM::Plugins::Relation::View, type: :relation
-end