rom 5.4.2 → 6.0.0.alpha1

data/lib/rom/compat/transformer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rom/transformer"
+
+module ROM
+  Transformer.class_eval do
+    class << self
+      prepend SettingProxy
+
+      # Configure relation for the transformer
+      #
+      # @example with a custom name
+      #   class UsersMapper < ROM::Transformer
+      #     relation :users, as: :json_serializer
+      #
+      #     map do
+      #       rename_keys user_id: :id
+      #       deep_stringify_keys
+      #     end
+      #   end
+      #
+      #   users.map_with(:json_serializer)
+      #
+      # @param name [Symbol]
+      # @param options [Hash]
+      # @option options :as [Symbol] Mapper identifier
+      #
+      # @deprecated
+      #
+      # @api public
+      def relation(name = Undefined, as: name)
+        if name == Undefined
+          config.component.relation
+        else
+          config.component.relation = name
+          config.component.namespace = name
+          config.component.id = as
+        end
+      end
+
+      def setting_mapping
+        @setting_mapping ||= {
+          register_as: [:component, :id],
+          relation: [:component, [:id, :relation, :namespace]]
+        }.freeze
+      end
+    end
+  end
+end

data/lib/rom/compat.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# This file loads a bunch of patches that maintain compatibility with rom 5.x.
+# It is not loaded by default in 6.0. During 6.x release series, these patches
+# will be gradually deprecated and eventually removed in rom 7.0.
+
+require "rom/core"
+
+# old api patches
+require_relative "compat/global"
+require_relative "compat/auto_registration"
+require_relative "compat/setting_proxy"
+require_relative "compat/setup"
+require_relative "compat/relation"
+require_relative "compat/command"
+require_relative "compat/transformer"
+require_relative "compat/mapper"
+
+# new api patches
+require_relative "compat/components/dsl/schema"
+require_relative "compat/components"
+require_relative "compat/registries"

data/lib/rom/components/association.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Association < Core
+      # @!attribute [r] definition
+      #   @return [Association::Definition]
+      option :definition
+
+      # @api public
+      def build
+        association_class.new(definition, registry.relations)
+      end
+
+      private
+
+      # @api private
+      def association_class
+        ROM.adapters[config.adapter].const_get(:Associations).const_get(definition.type)
+      end
+    end
+  end
+end

data/lib/rom/components/command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Command < Core
+      # @!attribute [r] constant
+      #   @return [Class] Component's target class
+      option :constant, type: Types.Interface(:new)
+
+      # @api public
+      def build
+        gateway.command(constant, relation: registry.relations[config.relation])
+      end
+
+      # @api private
+      def adapter
+        config.adapter
+      end
+    end
+  end
+end

data/lib/rom/components/core.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "dry/effects"
+require "dry/core/class_attributes"
+require "dry/core/memoizable"
+
+require "rom/constants"
+require "rom/initializer"
+require "rom/types"
+
+module ROM
+  module Components
+    # Abstract component class
+    #
+    # @api public
+    class Core
+      include Dry::Effects.Reader(:registry)
+
+      extend Initializer
+      extend Dry::Core::ClassAttributes
+
+      include Dry::Core::Memoizable
+
+      defines :type
+
+      # @api private
+      def self.inherited(klass)
+        super
+        klass.type(Inflector.component_id(klass).to_sym)
+      end
+
+      # @!attribute [r] provider
+      #   @return [Object] Component's provider
+      option :provider
+
+      # @!attribute [r] config
+      #   @return [Object] Component's config
+      option :config, type: Types.Instance(Dry::Configurable::Config)
+
+      # @!attribute [r] gateway
+      #   @return [Proc] Optional component evaluation block
+      option :block, type: Types.Interface(:to_proc), optional: true
+
+      # @api public
+      def type
+        self.class.type
+      end
+
+      # @api public
+      def abstract
+        config.abstract
+      end
+      alias_method :abstract?, :abstract
+
+      # Default container key
+      #
+      # @return [String]
+      #
+      # @api public
+      memoize def key
+        "#{namespace}.#{id}"
+      end
+
+      # @api public
+      def id
+        config.id
+      end
+
+      # @api public
+      def namespace
+        config.namespace
+      end
+
+      # This method is meant to return a run-time component instance
+      #
+      # @api public
+      def build(**)
+        raise NotImplementedError
+      end
+
+      # @api public
+      def inflector
+        config.inflector
+      end
+
+      # @api private
+      def components
+        provider.components
+      end
+
+      # @api private
+      def local_components
+        EMPTY_ARRAY
+      end
+
+      # @api private
+      def apply_plugins
+        already_applied = plugins.reject(&:applied?).map do |plugin|
+          plugin.enable(constant) unless plugin.enabled?
+          plugin.apply unless plugin.applied?
+          plugin.name
+        end
+
+        apply_external_plugins(gateway_plugins, already_applied) if gateway?
+        apply_external_plugins(provider_plugins, already_applied)
+      end
+
+      # @api private
+      def apply_external_plugins(plugins, already_applied)
+        plugins
+          .reject { |plugin| already_applied.include?(plugin.name) }
+          .each { |external_plugin|
+            config.plugins << external_plugin.configure.enable(constant).apply
+          }
+      end
+
+      # @api private
+      def plugins
+        config.plugins.select { |plugin| plugin.type == type }
+      end
+
+      # @api private
+      def gateway_plugins
+        gateway.config.plugins.select { |plugin| plugin.type == type }
+      end
+
+      # @api private
+      def provider_plugins
+        provider.config.component.plugins.select { |plugin| plugin.type == type }
+      end
+
+      # @api public
+      def plugin_options
+        plugins.map(&:plugin_options).reduce(:merge) || EMPTY_HASH
+      end
+
+      # @api public
+      def gateway?
+        registry.gateways.key?(config[:gateway])
+      end
+
+      # @api public
+      def gateway
+        registry.gateways[config[:gateway]]
+      end
+    end
+  end
+end

data/lib/rom/components/dataset.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Dataset < Core
+      # @api public
+      def build
+        if gateway?
+          blocks.reduce(gateway.dataset(id)) { |ds, blk| evaluate_block(ds, blk) }
+        elsif block
+          schema ? block.(schema) : block.()
+        else
+          EMPTY_ARRAY
+        end
+      end
+
+      # @api private
+      def blocks
+        [*dataset_components.map(&:block), block].compact
+      end
+
+      # @api private
+      def evaluate_block(ds, block)
+        ds.instance_exec(schema, &block)
+      end
+
+      # @api adapter
+      def adapter
+        config.adapter
+      end
+
+      # @api adapter
+      def relation_id
+        config.relation_id
+      end
+
+      private
+
+      # @api private
+      memoize def schema
+        if id == relation_id
+          registry.schemas[id] if registry.schemas.key?(id)
+        elsif relation_id
+          registry.fetch("schemas.#{relation_id}.#{id}") {
+            registry.fetch("schemas.#{relation_id}")
+          }
+        elsif registry.schemas.key?(id)
+          registry.schemas[id]
+        end
+      end
+      # @api private
+      memoize def dataset_components
+        provider.components.datasets(abstract: true, adapter: adapter)
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/association.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rom/schema/associations_dsl"
+require "rom/relation/name"
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # Setup DSL-specific relation extensions
+      #
+      # @private
+      class Association < Core
+        key :associations
+
+        # @api private
+        def call
+          configure
+
+          backend.instance_eval(&block)
+
+          backend.call.each do |definition|
+            components.add(key, definition: definition, config: config.join(definition, :right))
+          end
+        end
+
+        # @api private
+        def backend
+          @backend ||= ROM::Schema::AssociationsDSL.new(source, inflector)
+        end
+
+        # @api private
+        def source
+          if provider.config.component.key?(:id)
+            # TODO: decouple associations DSL from Relation::Name
+            ROM::Relation::Name[
+              provider.config.component.id, provider.config.component.dataset
+            ]
+          else
+            config.source
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # Command `define` DSL used by Setup#commands
+      #
+      # @private
+      class Command < Core
+        key :commands
+
+        nested(true)
+
+        # Define a command class
+        #
+        # @param [Symbol] name of the command
+        # @param [Hash] options
+        # @option options [Symbol] :type The type of the command
+        #
+        # @return [Class] generated class
+        #
+        # @api public
+        def define(id, type: id, **options, &block)
+          command_type = inflector.classify(type)
+          parent = adapter_namespace.const_get(command_type)
+
+          constant = build_class(name: class_name(command_type), parent: parent) do |dsl|
+            config.update(options)
+
+            config.component.update(dsl.config)
+            config.component.update(id: id, adapter: dsl.adapter)
+
+            class_exec(&block) if block
+          end
+
+          call(constant: constant, config: constant.config.component)
+        end
+
+        # @api private
+        def class_name(command_type)
+          class_name_inferrer[
+            config[:relation],
+            type: :command,
+            inflector: inflector,
+            adapter: adapter,
+            command_type: command_type,
+            class_namespace: provider.config.class_namespace
+          ]
+        end
+
+        # @api private
+        def adapter_namespace
+          ROM::Command.adapter_namespace(adapter)
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/core.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "dry/core/memoizable"
+require "dry/core/class_builder"
+
+require "rom/plugins/class_methods"
+require "rom/constants"
+require "rom/initializer"
+
+module ROM
+  module Components
+    module DSL
+      # @private
+      class Core
+        extend Initializer
+        extend Dry::Core::ClassAttributes
+        include Plugins::ClassMethods
+
+        defines(:key, :type, :nested)
+
+        include Dry::Core::Memoizable
+
+        nested false
+
+        # @api private
+        option :provider
+
+        # @api private
+        option :config, optional: true, default: -> { EMPTY_HASH }
+
+        # @api private
+        option :block, optional: true
+
+        # @api private
+        def self.inherited(klass)
+          super
+          klass.type(Inflector.component_id(klass).to_sym)
+        end
+
+        # @api private
+        def build_class(name: class_name, parent: class_parent, &block)
+          Dry::Core::ClassBuilder.new(name: name, parent: parent).call do |klass|
+            klass.config.component.update(config)
+            klass.class_exec(self, &block) if block
+          end
+        end
+
+        # @api private
+        def key
+          self.class.key
+        end
+
+        # @api private
+        def type
+          self.class.type
+        end
+
+        # @api private
+        def call(**options)
+          components.add(key, config: configure, block: block, **options)
+        end
+
+        # @api private
+        def configure
+          config.freeze
+        end
+
+        # @api private
+        def plugin(name, **options)
+          plugin = enabled_plugins[name]
+          plugin.config.update(options) unless options.empty?
+          plugin
+        end
+
+        # @api private
+        def enabled_plugins
+          config.plugins
+            .select { |plugin| plugin.type == type }
+            .to_h { |plugin| [plugin.name, plugin] }
+        end
+
+        # @api private
+        def enable_plugins
+          config.plugins.map! do |plugin|
+            if plugin.is_a?(Symbol)
+              plugins[plugin].configure.enable(self)
+            elsif plugin.type == type
+              plugin.configure.enable(respond_to?(:constant) ? constant : self)
+            else
+              plugin
+            end
+          end
+        end
+
+        private
+
+        # @api private
+        def components
+          provider.components
+        end
+
+        # @api private
+        def inflector
+          provider.config.component.inflector
+        end
+
+        # @api private
+        def class_name_inferrer
+          provider.config.class_name_inferrer
+        end
+
+        # @api private
+        memoize def adapter
+          config.adapter || gateway_adapter
+        end
+
+        # @api private
+        def gateway_adapter
+          if provider.config.key?(:gateways)
+            provider.config.gateways[config.gateway]&.fetch(:adapter)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/dataset.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # @private
+      class Dataset < Core
+        key :datasets
+
+        def configure
+          if relation?
+            config.join!({namespace: relation_id}, :right) if config.id != relation_id
+
+            config.relation_id = relation_id
+          end
+          super
+        end
+
+        private
+
+        def relation_id
+          provider.config.component.id
+        end
+
+        def relation?
+          provider.config.component.type == :relation
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/gateway.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # @private
+      class Gateway < Core
+        key :gateways
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/mapper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "dry/core/class_builder"
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # Mapper definition DSL used by Setup DSL
+      #
+      # @private
+      class Mapper < Core
+        key(:mappers)
+
+        nested(true)
+
+        # Define a mapper class
+        #
+        # @param [Symbol] id Mapper identifier
+        # @param [Hash] options
+        #
+        # @return [Class]
+        #
+        # @api public
+        def define(id, parent: id, **options, &block)
+          class_opts = {name: class_name(id), parent: class_parent(parent)}
+
+          constant = build_class(**class_opts) do |dsl|
+            config.update(options)
+
+            config.component.update(id: id, relation: parent)
+            config.component.join!({namespace: parent}, :right) if dsl.config.namespace != parent
+
+            class_eval(&block) if block
+          end
+
+          call(constant: constant, config: constant.config.component)
+        end
+
+        # @api private
+        def class_parent(parent)
+          components.get(:mappers, relation: parent)&.constant || ROM::Mapper
+        end
+
+        # @api private
+        def class_name(id)
+          "ROM::Mapper[#{id}]"
+        end
+
+        # Register any object as a mapper for a given relation
+        #
+        # @param [Symbol] relation The relation registry id
+        # @param [Hash<Symbol, Object>] mappers A hash with mapper objects
+        #
+        # @return [Array<Components::Mapper>]
+        #
+        # @api public
+        def register(namespace, mappers)
+          mappers.map do |id, mapper|
+            call(
+              object: mapper,
+              config: config.join({id: id, relation: namespace, namespace: namespace}, :right)
+            )
+          end
+        end
+      end
+    end
+  end
+end