rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/components/provider.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "rom/support/configurable"
+
+require "rom/core"
+require "rom/settings"
+require "rom/registries/root"
+
+require_relative "dsl"
+require_relative "registry"
+
+module ROM
+  # Define a module for component definitions and runtime setup
+  #
+  # @return [Components::Provider]
+  #
+  # @api public
+  def self.Provider(*features, **options)
+    Components::Provider.new(features, **options)
+  end
+
+  # @api private
+  module Components
+    # @api private
+    class Provider < Module
+      attr_reader :provider
+
+      attr_reader :type
+
+      attr_reader :features
+
+      # @api private
+      module InstanceMethods
+        # @api public
+        def components
+          @components ||= Registry.new(provider: self)
+        end
+
+        # @api private
+        def registry(**options)
+          Registries::Root.new(
+            config: config,
+            components: components,
+            notifications: Notifications.event_bus(:configuration),
+            **options
+          )
+        end
+      end
+
+      # @api private
+      module ClassMethods
+        include InstanceMethods
+
+        # @api private
+        def inherited(klass)
+          super
+          klass.components.update(components, abstract: true)
+        end
+      end
+
+      # @api private
+      def initialize(features, type: nil)
+        super()
+        @provider = nil
+        @type = type
+        @features = features
+      end
+
+      # @api private
+      def define_configure_method(type, features)
+        yield Module.new {
+                define_method(:configure) do |*args, &block|
+                  # Inherit global defaults
+                  config.component.inherit!(**ROM.config[type], type: type)
+
+                  # Inherit global defaults for individual features
+                  features.each do |name|
+                    config[name].inherit!(**ROM.config[name]) if ROM.config.key?(name)
+                  end
+
+                  super(*args, &block)
+                end
+              }
+      end
+
+      # @api private
+      def included(provider)
+        super
+        @provider = provider
+        provider.include(mod)
+        provider.include(Configurable)
+        import_settings
+        provider.include(InstanceMethods)
+        define_configure_method(type, features) { |mod|
+          provider.prepend(mod)
+        }
+        freeze
+      end
+
+      # @api private
+      def extended(provider)
+        super
+        @provider = provider
+        provider.extend(mod)
+        provider.extend(Configurable)
+        import_settings
+        provider.extend(ClassMethods)
+        define_configure_method(type, features) { |mod|
+          provider.singleton_class.prepend(mod)
+        }
+        freeze
+      end
+
+      # @api private
+      def mod
+        @mod ||=
+          Module.new.tap do |mod|
+            define_dsl_method(mod, :__dsl__)
+
+            features.each do |type|
+              if ROM.components.key?(type)
+                handler = ROM.components[type]
+
+                [handler.key, handler.namespace]
+                  .select { |name|
+                    DSL.instance_methods.include?(name)
+                  }
+                  .each { |name|
+                    define_dsl_method(mod, name)
+                  }
+              else
+                define_dsl_method(mod, type)
+              end
+            end
+          end
+      end
+
+      # @api private
+      def define_dsl_method(mod, name)
+        mod.define_method(name) { |*args, **opts, &block|
+          DSL.instance_method(name).bind(self).(*args, **opts, &block)
+        }
+      end
+
+      # @api private
+      def import_settings
+        # Import default settings for the provider
+        provider.setting(:component, import: ROM.settings[type])
+
+        # Import default settings for each feature that the provider supports
+        features.each do |name|
+          if ROM.settings.key?(name)
+            # Define the settings
+            provider.setting(name, import: ROM.settings[name])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/registry.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "rom/constants"
+require "rom/core"
+
+module ROM
+  # @api private
+  module Components
+    # @api public
+    class Registry
+      include Enumerable
+
+      # @api private
+      attr_reader :provider
+
+      # @api private
+      attr_reader :handlers
+
+      DUPLICATE_ERRORS = {
+        gateways: GatewayAlreadyDefinedError,
+        datasets: DatasetAlreadyDefinedError,
+        schemas: SchemaAlreadyDefinedError,
+        relations: RelationAlreadyDefinedError,
+        associations: AssociationAlreadyDefinedError,
+        commands: CommandAlreadyDefinedError,
+        mappers: MapperAlreadyDefinedError
+      }.freeze
+
+      # @api private
+      def initialize(provider:, handlers: ROM.components)
+        @provider = provider
+        @handlers = handlers
+      end
+
+      # @api private
+      def store
+        @store ||= handlers.map { |handler| [handler.namespace, EMPTY_ARRAY.dup] }.to_h
+      end
+
+      # @api private
+      def each
+        store.each { |type, components|
+          components.each { |component| yield(type, component) }
+        }
+      end
+
+      # @api private
+      def to_a
+        flat_map { |_, components| components }
+      end
+
+      # @api private
+      def call(key, &fallback)
+        comp = detect { |_, component| component.key == key && !component.abstract? }&.last
+
+        if comp
+          comp.build
+        elsif fallback
+          fallback.()
+        else
+          raise KeyError, "+#{key}+ not found"
+        end
+      end
+
+      # @api private
+      def [](type)
+        store[type]
+      end
+
+      # @api private
+      def get(type, **opts)
+        public_send(type, **opts).first
+      end
+
+      # @api private
+      def add(type, item: nil, **options)
+        component = item || build(type, **options)
+
+        # if include?(type, component)
+        #   other = get(type, key: component.key)
+
+        #   raise(
+        #     DUPLICATE_ERRORS[type],
+        #     "#{provider}: +#{component.key}+ is already defined by #{other.provider}"
+        #   )
+        # end
+
+        store[type] << component
+
+        update(component.local_components)
+
+        component
+      end
+
+      # @api private
+      def replace(type, item: nil, **options)
+        component = item || build(type, **options)
+        delete(type, item) if include?(type, component)
+        store[type] << component
+        component
+      end
+
+      # @api private
+      def delete(type, item)
+        self[type].delete(item)
+        self
+      end
+
+      # @api private
+      def update(other, **options)
+        other.each do |type, component|
+          add(
+            type,
+            item: component.with(provider: provider, config: component.config.join(options, :right))
+          )
+        end
+        self
+      end
+
+      # @api private
+      def build(type, **options)
+        handlers[type].build(**options, provider: provider)
+      end
+
+      # @api private
+      def include?(type, component)
+        !component.abstract? && keys(type).include?(component.key)
+      end
+
+      # @api private
+      def key?(key)
+        keys.include?(key)
+      end
+
+      # @api private
+      def keys(type = nil)
+        if type
+          self[type].map(&:key)
+        else
+          to_a.map(&:key)
+        end
+      end
+
+      CORE_COMPONENTS.each do |type|
+        define_method(type) do |**opts|
+          all = self[type]
+          return all if opts.empty?
+
+          all.select { |el| opts.all? { |key, value| el.public_send(key).eql?(value) } }
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/relation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Relation < Core
+      # @!attribute [r] constant
+      #   @return [.new] Relation instance builder (typically a class)
+      option :constant, type: Types.Interface(:new)
+
+      # @return [ROM::Relation]
+      #
+      # @api public
+      def build
+        constant.use(:changeset)
+        constant.use(:registry_reader, relations: registry.relation_ids)
+
+        # Define view methods if there are any registered view components for this relation
+        local_components.views(relation_id: id).each do |view|
+          view.define(constant)
+        end
+
+        apply_plugins
+
+        constant.new(inflector: inflector, registry: registry, **plugin_options)
+      end
+
+      # @api public
+      def adapter
+        config.adapter
+      end
+
+      # @api private
+      def local_components
+        constant.components
+      end
+    end
+  end
+end

data/lib/rom/components/schema.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "rom/relation/name"
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Schema < Core
+      # @api private
+      option :name, type: Types.Instance(ROM::Relation::Name), default: -> {
+        ROM::Relation::Name[config.relation, config.dataset]
+      }
+
+      # @api public
+      def build
+        if view?
+          registry.schemas[config.relation].instance_eval(&block)
+        else
+          schema = config.constant.define(
+            name, **config, **config.options, inferrer: inferrer, registry: registry
+          )
+
+          if gateway?
+            schema.finalize_attributes!(gateway: gateway)
+          else
+            schema.finalize_attributes!
+          end
+
+          schema.finalize!
+        end
+      end
+
+      # @api private
+      def inferrer
+        config.inferrer.with(enabled: config.infer)
+      end
+
+      # @api private
+      def dataset
+        config.dataset
+      end
+
+      # @api private
+      def adapter
+        config.adapter
+      end
+
+      # @api private
+      def relation
+        config.relation
+      end
+
+      # @api private
+      def view?
+        config.view.equal?(true)
+      end
+    end
+  end
+end

data/lib/rom/components/view.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class View < Core
+      # @!attribute [r] relation_id
+      #   @return [Symbol] Relation runtime identifier
+      #   @api private
+      option :relation_id
+
+      # @!attribute [r] relation_block
+      #   @return [Proc] Block used for view method definition
+      #   @api private
+      option :relation_block
+
+      # @return [ROM::Relation]
+      #
+      # @api private
+      def build
+        registry.relations[relation_id].public_send(config.id)
+      end
+
+      # @return [Symbol]
+      #
+      # @api private
+      def define(constant)
+        _name = config.id
+        _relation_block = relation_block
+
+        if relation_block&.arity&.positive?
+          constant.class_eval do
+            auto_curry_guard do
+              define_method(_name, &_relation_block)
+
+              auto_curry(_name) do
+                schemas[_name].(self)
+              end
+            end
+          end
+        else
+          constant.class_eval do
+            define_method(_name) do
+              schemas[_name].(instance_eval(&_relation_block))
+            end
+          end
+        end
+
+        _name
+      end
+    end
+  end
+end

data/lib/rom/components.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/container"
+
+require_relative "initializer"
+require_relative "types"
+
+module ROM
+  # Registry of all known component handlers
+  #
+  # @api public
+  module Components
+    extend Dry::Container::Mixin
+    extend Enumerable
+
+    module_function
+
+    # @api private
+    class Handler
+      extend Initializer
+
+      option :key, type: Types.Instance(Symbol)
+
+      option :constant, type: Types.Interface(:new)
+
+      option :namespace, type: Types.Instance(Symbol), default: -> { Inflector.namespace(key) }
+
+      # @api private
+      def build(**options)
+        constant.new(**options)
+      end
+    end
+
+    # @see ROM.components
+    #
+    # @return [Components]
+    #
+    # @api public
+    def register(key, constant = nil, **options)
+      Handler.new(key: key, constant: constant, **options).tap do |handler|
+        super(handler.key, handler)
+        # TODO: unify handler access
+        super(handler.namespace, handler)
+      end
+      self
+    end
+
+    # Iterate over all registered component handlers
+    #
+    # @api public
+    def each
+      keys.each { |key| yield(resolve(key)) }
+    end
+  end
+end

data/lib/rom/configuration_dsl.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# TODO: move this to rom/compat
+ROM::ConfigurationDSL = ROM::Components::DSL

data/lib/rom/constants.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+# Constants and errors common in the whole library
+module ROM
+  include Dry::Core::Constants
+
+  CORE_COMPONENTS = %i[
+    gateways
+    datasets
+    schemas
+    relations
+    views
+    associations
+    mappers
+    commands
+  ].freeze
+
+  AdapterLoadError = Class.new(StandardError)
+
+  # Exception raised when a component is configured with an adapter that's not loaded
+  class AdapterNotPresentError < StandardError
+    # @api private
+    def initialize(adapter, component)
+      super(
+        "Failed to find #{component} class for #{adapter} adapter. " \
+        "Make sure ROM setup was started and the adapter identifier is correct."
+      )
+    end
+  end
+
+  ConfigError = Class.new(StandardError) do
+    attr_reader :name, :component, :owner
+
+    # @api private
+    def initialize(name, component, reason = :inferrence)
+      @name = name
+      @component = component
+      @owner = component.owner
+
+      key = "#{component.type}.#{name}"
+
+      case reason
+      when :inferrence
+        super("Failed to infer +#{key}+ setting for #{component.provider}")
+      else
+        super("#{owner.name} #{key} setting is not valid")
+      end
+    end
+  end
+
+  EnvAlreadyFinalizedError = Class.new(StandardError)
+  GatewayAlreadyDefinedError = Class.new(StandardError)
+  DatasetAlreadyDefinedError = Class.new(StandardError)
+  SchemaAlreadyDefinedError = Class.new(StandardError)
+  RelationAlreadyDefinedError = Class.new(StandardError)
+  AssociationAlreadyDefinedError = Class.new(StandardError)
+  CommandAlreadyDefinedError = Class.new(StandardError)
+  MapperAlreadyDefinedError = Class.new(StandardError)
+  MapperMisconfiguredError = Class.new(StandardError)
+  NoRelationError = Class.new(StandardError)
+  InvalidRelationName = Class.new(StandardError)
+  CommandError = Class.new(StandardError)
+  KeyMissing = Class.new(ROM::CommandError)
+  TupleCountMismatchError = Class.new(CommandError)
+  UnknownPluginError = Class.new(StandardError)
+  UnsupportedRelationError = Class.new(StandardError)
+  MissingAdapterIdentifierError = Class.new(StandardError)
+  AttributeAlreadyDefinedError = Class.new(StandardError)
+
+  # Exception raised when a reserved keyword is used as a relation name
+  class InvalidRelationName < StandardError
+    # @api private
+    def initialize(relation)
+      super("Relation name: #{relation} is a protected word, please use another relation name")
+    end
+  end
+
+  # Exception raised when an element inside a component registry is not found
+  class ElementNotFoundError < KeyError
+    # @api private
+    def initialize(key, registry = nil)
+      msg =
+        if registry
+          "#{key.inspect} doesn't exist in #{registry.type} registry"
+        else
+          "#{key} doesn't exist in the registry"
+        end
+      super(msg)
+    end
+  end
+
+  GatewayMissingError = Class.new(ElementNotFoundError)
+
+  DatasetMissingError = Class.new(ElementNotFoundError)
+
+  SchemaMissingError = Class.new(ElementNotFoundError)
+
+  RelationMissingError = Class.new(ElementNotFoundError)
+
+  MapperMissingError = Class.new(ElementNotFoundError)
+
+  CommandNotFoundError = Class.new(ElementNotFoundError)
+
+  MissingSchemaClassError = Class.new(StandardError) do
+    # @api private
+    def initialize(klass)
+      super("#{klass.inspect} relation is missing schema_class")
+    end
+  end
+
+  MissingSchemaError = Class.new(StandardError) do
+    # @api private
+    def initialize(klass)
+      super("#{klass.inspect} relation is missing schema definition")
+    end
+  end
+
+  MISSING_ELEMENT_ERRORS = {
+    gateways: GatewayMissingError,
+    schemas: SchemaMissingError,
+    datasets: DatasetMissingError,
+    relations: RelationMissingError,
+    associations: RelationMissingError,
+    commands: CommandNotFoundError,
+    mappers: MapperMissingError
+  }.freeze
+
+  DuplicateConfigurationError = Class.new(StandardError)
+  DuplicateContainerError = Class.new(StandardError)
+
+  InvalidOptionValueError = Class.new(StandardError)
+  InvalidOptionKeyError = Class.new(StandardError)
+end