rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/plugins/dsl.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rom/constants"
+
+module ROM
+  module Plugins
+    # Plugin registration DSL
+    #
+    # @private
+    class DSL
+      # 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 Name of a plugin
+      # @param [Module] mod Plugin module
+      # @param [Hash] options
+      #
+      # @api public
+      def register(name, mod, options = EMPTY_HASH)
+        registry.register(name, mod: mod, **defaults, **options)
+      end
+
+      # Register plugins for a specific adapter
+      #
+      # @param [Symbol] type The adapter identifier
+      #
+      # @api public
+      def adapter(type, &block)
+        self.class.new(registry, adapter: type, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "rom/changeset"
+require "rom/changeset/extensions/relation"
+
+module ROM
+  module Plugins
+    module Relation
+      # Relation plugin which adds `Relation#changeset` method
+      #
+      # @api public
+      module Changeset
+        TYPES = {
+          create: ROM::Changeset::Create,
+          update: ROM::Changeset::Update,
+          delete: ROM::Changeset::Delete
+        }.freeze
+
+        # @api private
+        def self.apply(target, **)
+          target.include(InstanceMethods)
+        end
+
+        # Relation instance methods provided by the Changeset plugin
+        #
+        # @api public
+        module InstanceMethods
+          # Create a changeset for a relation
+          #
+          # @overload changeset(type, data)
+          #   Create a changeset of one of predefined types
+          #
+          #   @example creating a record
+          #     users.
+          #       changeset(:create, name: 'Jane').
+          #       commit
+          #     # => #<ROM::Struct::User id=1 name="Jane">
+          #
+          #   @example updating a record
+          #     users.
+          #       by_pk(1).
+          #       changeset(:update, name: 'Jack').
+          #       commit
+          #     # => #<ROM::Struct::User id=1 name="Jane">
+          #
+          #   @example providing data as a separate step
+          #     changeset = users.changeset(:create)
+          #     jack = changeset.data(name: 'Jack').commit
+          #     jane = changeset.data(name: 'Jane').commit
+          #
+          #   @example using a command graph
+          #     users.
+          #       changeset(
+          #         :create,
+          #         name: "Jane",
+          #         posts: [{ title: "Something about aliens" }]
+          #       )
+          #
+          #   @param [Symbol] type The changeset type
+          #   @param [Hash] data
+          #   @return [Changeset]
+          #
+          # @overload changeset(changeset_class, data)
+          #   @example using a custom changeset class
+          #     class NewUser < ROM::Changeset::Create
+          #       map do |tuple|
+          #         { **tuple, name: tuple.values_at(:first_name, :last_name).join(' ') }
+          #       end
+          #     end
+          #
+          #     users.changeset(NewUser, first_name: 'John', last_name: 'Doe').commit
+          #
+          #   @param [Class] changeset_class A custom changeset class
+          #   @return [Changeset]
+          #
+          # @api public
+          def changeset(type, data = EMPTY_HASH)
+            klass = type.is_a?(Symbol) ? TYPES.fetch(type) : type
+
+            unless klass < ROM::Changeset
+              raise ArgumentError, "+#{type.name}+ must be a Changeset descendant"
+            end
+
+            if klass < ROM::Changeset::Stateful
+              klass.new(self, __data__: data)
+            else
+              klass.new(self)
+            end
+          rescue KeyError
+            raise ArgumentError,
+                  "+#{type.inspect}+ is not a valid changeset type. Must be one of: #{TYPES.keys.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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
+
+        # Instrumentation extension for relation classes
+        #
+        # @api private
+        module ClassInterface
+          # Configure provided methods for instrumentation
+          #
+          # @param [Array<Symbol>] methods A list of method names
+          #
+          # @api public
+          def instrument(*methods)
+            (methods - Instrumentation.mixin.instance_methods).each do |meth|
+              Instrumentation.mixin.send(:define_method, meth) do
+                instrument { super() }
+              end
+            end
+          end
+        end
+
+        # Execute a block using instrumentation
+        #
+        # @api public
+        def instrument(&block)
+          notifications.instrument(
+            config.component.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,36 @@
+# frozen_string_literal: true
+
+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
+        EMPTY_REGISTRY = EMPTY_HASH
+
+        # @api private
+        attr_reader :relations
+
+        # @api private
+        def initialize(relations:)
+          @relations = relations
+          define_readers!
+        end
+
+        private
+
+        # @api private
+        def define_readers!
+          relations.each do |name|
+            define_method(name) { registry.relations[name] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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
+        DEFAULT_TYPE = ROM::Types::Time
+
+        # @api private
+        def self.apply(schema, **options)
+          attributes = options.fetch(:attributes, DEFAULT_TIMESTAMPS)
+          attrs_type = options.fetch(:type, DEFAULT_TYPE)
+
+          attributes.each do |name|
+            schema.attribute(name, attrs_type)
+          end
+
+          schema
+        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)
+            plugin(:timestamps, attributes: names).apply
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/plugins.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "dry/container"
+
+require "rom/constants"
+require "rom/plugin"
+
+require "rom/plugins/dsl"
+require "rom/plugins/relation/registry_reader"
+require "rom/plugins/relation/instrumentation"
+require "rom/plugins/relation/changeset"
+require "rom/plugins/command/schema"
+require "rom/plugins/command/timestamps"
+require "rom/plugins/schema/timestamps"
+
+module ROM
+  # Registry of all known plugins
+  #
+  # @api public
+  module Plugins
+    extend Dry::Container::Mixin
+    extend Enumerable
+
+    module_function
+
+    def dsl(*args, &block)
+      Plugins::DSL.new(self, *args, &block)
+    end
+
+    # @api private
+    def register(name, type:, **options)
+      Plugin.new(name: name, type: type, **options).tap do |plugin|
+        super(plugin.key, plugin)
+      end
+    end
+
+    # @api private
+    def each
+      keys.each { |key| yield(self[key]) }
+    end
+
+    # @api private
+    def resolve(key)
+      super
+    rescue Dry::Container::Error
+      raise ROM::UnknownPluginError, "+#{key}+ plugin was not found"
+    end
+
+    # TODO: move to rom/compat
+    # @api private
+    class Resolver
+      attr_reader :container, :type, :_adapter
+
+      # @api private
+      def initialize(container, type:, adapter: nil)
+        @container = container
+        @type = type
+        @_adapter = adapter
+      end
+
+      # @api private
+      def adapter(name)
+        self.class.new(container, type: type, adapter: name)
+      end
+
+      # @api private
+      def fetch(name, adapter = nil)
+        if adapter
+          key = [adapter, type, name].compact.join(".")
+
+          if container.key?(key)
+            container.resolve(key)
+          else
+            fetch(name)
+          end
+        elsif _adapter && key?(name)
+          fetch(name, _adapter)
+        else
+          key = "#{type}.#{name}"
+          container.resolve(key)
+        end
+      end
+      alias_method :[], :fetch
+
+      # @api private
+      def key?(name)
+        container.key?([_adapter, type, name].compact.join("."))
+      end
+    end
+
+    # @api private
+    def [](key)
+      if key?(key)
+        super
+      else
+        Resolver.new(self, type: key)
+      end
+    end
+  end
+end

data/lib/rom/processor/composer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ROM
+  class Processor
+    # @api private
+    module Composer
+      # @api private
+      class Factory
+        attr_reader :fns, :default
+
+        # @api private
+        def initialize(default = nil)
+          @fns = []
+          @default = default
+        end
+
+        # @api private
+        def <<(other)
+          fns.concat(Array(other).compact)
+          self
+        end
+
+        # @api private
+        def to_fn
+          fns.reduce(:+) || default
+        end
+      end
+
+      # @api private
+      def compose(default = nil)
+        factory = Factory.new(default)
+        yield(factory)
+        factory.to_fn
+      end
+    end
+  end
+end