rom-core 4.0.0.beta1

data/lib/rom/plugin_base.rb

@@ -0,0 +1,45 @@
+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
+
+    # @api private
+    def schema?
+      type == :schema
+    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

@@ -0,0 +1,197 @@
+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
+
+    # Internal registry for schema plugins
+    #
+    # @return [InternalPluginRegistry]
+    #
+    # @api private
+    attr_reader :schemas
+
+    # @api private
+    def initialize
+      @configuration = ConfigurationPluginRegistry.new
+      @mappers = InternalPluginRegistry.new
+      @commands = InternalPluginRegistry.new
+      @relations = InternalPluginRegistry.new
+      @schemas = InternalPluginRegistry.new(SchemaPlugin)
+    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)
+      when :schema        then schemas.adapter(adapter)
+      end
+    end
+  end
+
+  # Abstract registry defining common behaviour
+  #
+  # @api private
+  class PluginRegistryBase < Registry
+    include Dry::Equalizer(:elements, :plugin_type)
+
+    # !@attribute [r] plugin_type
+    #   @return [Class] Typically ROM::PluginBase or its descendant
+    option :plugin_type
+
+    # Retrieve a registered plugin
+    #
+    # @param [Symbol] name The plugin to retrieve
+    #
+    # @return [Plugin]
+    #
+    # @api public
+    def [](name)
+      elements[name]
+    end
+
+    # 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] = plugin_type.new(mod, options)
+    end
+
+    # Returns plugin name by instance
+    #
+    # @return [Symbol] Plugin name
+    #
+    # @api private
+    def plugin_name(plugin)
+     tuple = elements.find { |(_, p)| p.equal?(plugin) }
+     tuple[0] if tuple
+    end
+  end
+
+  # A registry storing environment specific plugins
+  #
+  # @api private
+  class ConfigurationPluginRegistry < PluginRegistryBase
+    # @api private
+    def initialize(*args, **kwargs)
+      super(*args, **kwargs, plugin_type: ConfigurationPlugin)
+    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
+    option :plugin_type, default: -> { Plugin }
+  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(plugin_type = Plugin)
+      @registries = Hash.new { |h, v| h[v] = AdapterPluginRegistry.new({}, plugin_type: plugin_type) }
+    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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,51 @@
+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/registry_reader.rb

@@ -0,0 +1,44 @@
+require 'dry/core/cache'
+require 'rom/constants'
+
+module ROM
+  module Plugins
+    module Relation
+      # Allows relations to access all other relations through registry
+      #
+      # For now this plugin is always enabled
+      #
+      # @api public
+      class RegistryReader < Module
+        extend Dry::Core::Cache
+
+        EMPTY_REGISTRY = RelationRegistry.new(EMPTY_HASH).freeze
+
+        # @api private
+        attr_reader :relations
+
+        # @api private
+        def initialize(relations)
+          @relations = relations
+          define_readers!
+        end
+
+        # @api private
+        def included(klass)
+          super
+          return if klass.instance_methods.include?(:__registry__)
+          klass.option :__registry__, default: -> { EMPTY_REGISTRY }
+        end
+
+        private
+
+        # @api private
+        def define_readers!
+          relations.each do |name|
+            define_method(name) { __registry__[name] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module ROM
+  module Plugins
+    module Schema
+      # A plugin for automatically adding timestamp fields
+      # to the schema definition
+      #
+      # @example
+      #   schema do
+      #     use :timestamps
+      #   end
+      #
+      #   # using non-default names
+      #   schema do
+      #     use :timestamps, attributes: %i(created_on updated_on)
+      #   end
+      #
+      #   # using other types
+      #   schema do
+      #     use :timestamps, type: Types::Date
+      #   end
+      #
+      # @api public
+      module Timestamps
+        DEFAULT_TIMESTAMPS = %i(created_at updated_at).freeze
+
+        # @api private
+        def self.apply(schema, options)
+          type = options.fetch(:type, Types::Time)
+          names = options.fetch(:attributes, DEFAULT_TIMESTAMPS)
+          attributes = names.map { |name| type.meta(name: name, source: schema.name) }
+
+          schema.attributes.concat(
+            schema.class.attributes(attributes, schema.attr_class)
+          )
+        end
+
+        # @api private
+        module DSL
+          # Sets non-default timestamp attributes
+          #
+          # @example
+          #   schema do
+          #     use :timestamps
+          #     timestamps :create_on, :updated_on
+          #   end
+          #
+          # @api public
+          def timestamps(*names)
+            options = plugin_options(:timestamps)
+            options[:attributes] = names unless names.empty?
+
+            self
+          end
+        end
+      end
+    end
+  end
+end