rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/compat/components.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "rom/components/core"
+require "rom/components/dataset"
+require "rom/components/relation"
+require "rom/components/command"
+
+module ROM
+  class Components::Core
+    # @api private
+    def trigger(event, payload)
+      registry.trigger("configuration.#{event}", payload)
+    end
+
+    # @api private
+    def notifications
+      registry.notifications
+    end
+  end
+
+  class Components::Dataset < Components::Core
+    mod = Module.new do
+      # @api private
+      def evaluate_block(ds, block)
+        if block.parameters.flatten.include?(:schema)
+          super
+        else
+          ds.instance_exec(relation_constant, &block)
+        end
+      end
+
+      def relation_constant
+        registry.components.get(:relations, id: relation_id).constant
+      end
+    end
+
+    prepend(mod)
+  end
+
+  class Components::Relation < Components::Core
+    mod = Module.new do
+      def build
+        schema = local_components.get(:schemas, id: id)&.build
+
+        if schema
+          trigger(
+            "relations.schema.set",
+            schema: schema,
+            adapter: adapter,
+            gateway: config[:gateway],
+            relation: constant,
+            registry: registry
+          )
+        end
+
+        trigger("relations.class.ready", relation: constant, adapter: adapter)
+
+        components.update(local_components)
+
+        relation = super
+
+        trigger("relations.object.registered", registry: registry, relation: relation)
+
+        relation
+      end
+    end
+
+    prepend(mod)
+  end
+
+  class Components::Command < Components::Core
+    mod = Module.new do
+      def build
+        relation = registry.relations[config.relation]
+
+        trigger(
+          "commands.class.before_build",
+          command: constant,
+          gateway: registry.gateways[relation.gateway],
+          dataset: relation.dataset,
+          relation: relation,
+          adapter: adapter
+        )
+
+        super
+      end
+    end
+
+    prepend(mod)
+  end
+end

data/lib/rom/compat/global.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rom/container"
+require "rom/global"
+
+module ROM
+  # @api private
+  # @deprecated
+  alias_method :plugin_registry, :plugins
+
+  # @api public
+  module Global
+    # @api public
+    # @deprecated
+    alias_method :container, :setup
+  end
+end

data/lib/rom/compat/mapper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rom/mapper"
+
+module ROM
+  class Mapper
+    class << self
+      prepend SettingProxy
+
+      def setting_mapping
+        @setting_mapper ||= ROM::Transformer.setting_mapping.merge(
+          inherit_header: [],
+          reject_keys: [],
+          symbolize_keys: [],
+          copy_keys: [],
+          prefix: [],
+          prefix_separator: []
+        ).freeze
+      end
+    end
+  end
+end

data/lib/rom/compat/registries.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rom/registries/root"
+
+module ROM
+  # @api public
+  class Registries::Root
+    option :notifications, optional: true
+
+    # @api private
+    # @api deprecated
+    def trigger(event, payload)
+      notifications&.trigger(event, payload)
+    end
+
+    # @api public
+    # @deprecated
+    def map_with(*ids)
+      with(opts: {map_with: ids})
+    end
+
+    undef :build
+    # @api private
+    def build(key, &block)
+      item = components.(key, &block)
+
+      if commands? && (mappers = opts[:map_with])
+        item >> mappers.map { |mapper| item.relation.mappers[mapper] }.reduce(:>>)
+      else
+        item
+      end
+    end
+
+    private
+
+    # @api private
+    def respond_to_missing?(name, *)
+      super || key?(name)
+    end
+
+    # @api public
+    # @deprecated
+    def method_missing(name, *args, &block)
+      fetch(name) { super }
+    end
+  end
+end

data/lib/rom/compat/relation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rom/relation"
+require_relative "schema/dsl"
+
+module ROM
+  class Relation
+    class << self
+      prepend SettingProxy
+
+      def setting_mapping
+        @setting_mapping ||= {
+          auto_map: [],
+          auto_struct: [],
+          struct_namespace: [],
+          wrap_class: [],
+          adapter: [:component, :adapter],
+          gateway: [:component, :gateway],
+          schema_class: [:schema, :constant],
+          schema_dsl: [:schema, :dsl_class],
+          schema_attr_class: [:schema, :attr_class],
+          schema_inferrer: [:schema, :inferrer]
+        }.freeze
+      end
+    end
+
+    extend Notifications::Listener
+
+    # This is used by the deprecated command => relation view delegation syntax
+    # @api private
+    def self.view_methods
+      ancestor_methods = ancestors.reject { |klass| klass == self }
+        .map(&:instance_methods).flatten(1)
+
+      instance_methods - ancestor_methods + auto_curried_methods.to_a
+    end
+
+    config.schema.dsl_class = ROM::Schema::DSL
+  end
+end

data/lib/rom/compat/schema/dsl.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "rom/support/inflector"
+
+require "rom/initializer"
+require "rom/types"
+require "rom/attribute"
+require "rom/schema/associations_dsl"
+
+module ROM
+  class Schema
+    # Schema DSL exposed as `schema { .. }` in relation classes
+    #
+    # @see Components::DSL::Schema
+    #
+    # @deprecated
+    #
+    # @api public
+    class DSL
+      extend Initializer
+
+      # @!attribute [r] relation
+      #   @return [Relation::Name] The name of the schema's relation
+      option :relation
+
+      # @!attribute [r] adapter
+      #   @return [Symbol] The adapter identifier used in gateways
+      option :adapter
+
+      # @!attribute [r] inflector
+      #   @return [Dry::Inflector] String inflector
+      #   @api private
+      option :inflector, default: -> { Inflector }
+
+      # @!attribute [r] schema_class
+      #   @return [Class] Schema class that should be instantiated
+      option :constant, default: -> { Schema }
+      alias_method :schema_class, :constant
+
+      # @!attribute [r] attr_class
+      #   @return [Class] Attribute class that should be used
+      option :attr_class, default: -> { Attribute }
+
+      # @!attribute [r] attributes
+      #   @return [Hash<Symbol, Hash>] A hash with attribute names as
+      #   keys and attribute representations as values.
+      #
+      #   @see [Schema.build_attribute_info]
+      option :attributes, default: -> { EMPTY_HASH.dup }
+
+      # @!attribute [r] definition
+      #   @return [Class] An optional block that will be evaluated as part of this DSL
+      option :definition, type: Types.Instance(Proc), default: -> { proc {} }
+
+      # @!attribute [r] plugins
+      #   @return [Array<Plugin>]
+      option :plugins, default: -> { EMPTY_ARRAY }
+
+      # @api private
+      def self.new(**options, &block)
+        if block
+          super(definition: block, **options)
+        else
+          super
+        end
+      end
+
+      # Defines a relation attribute with its type and options.
+      #
+      # When only options are given, type is left as nil. It makes
+      # sense when it is used alongside a schema inferrer, which will
+      # populate the type.
+      #
+      # @see Relation.schema
+      #
+      # @api public
+      def attribute(name, type_or_options, options = EMPTY_HASH)
+        if attributes.include?(name)
+          raise(
+            ::ROM::AttributeAlreadyDefinedError,
+            "Attribute #{name.inspect} already defined"
+          )
+        end
+
+        build_attribute_info(name, type_or_options, options).tap do |attr_info|
+          attributes[name] = attr_info
+        end
+      end
+
+      # Specify which key(s) should be the primary key
+      #
+      # @api public
+      def primary_key(*names)
+        names.each do |name|
+          attributes[name][:type] = attributes[name][:type].meta(primary_key: true)
+        end
+        self
+      end
+
+      # Define associations for a relation
+      #
+      # @example
+      #   class Users < ROM::Relation[:sql]
+      #     schema(infer: true) do
+      #       associations do
+      #         has_many :tasks
+      #         has_many :posts
+      #         has_many :posts, as: :priority_posts, view: :prioritized
+      #         belongs_to :account
+      #       end
+      #     end
+      #   end
+      #
+      #   class Posts < ROM::Relation[:sql]
+      #     schema(infer: true) do
+      #       associations do
+      #         belongs_to :users, as: :author
+      #       end
+      #     end
+      #
+      #     view(:prioritized) do
+      #       where { priority <= 3 }
+      #     end
+      #   end
+      #
+      # @return [AssociationDSL]
+      #
+      # @api public
+      def associations(&block)
+        if block
+          __assoc_dsl__.instance_eval(&block)
+        else
+          __assoc_dsl__.registry.values
+        end
+      end
+
+      # @api private
+      def __assoc_dsl__
+        @__assoc_dsl__ ||= AssociationsDSL.new(relation, inflector)
+      end
+
+      # Enable a plugin in the schema DSL
+      #
+      # @param [Symbol] name Plugin name
+      # @param [Hash] options Plugin options
+      #
+      # @api public
+      def use(name, **options)
+        plugin = ::ROM.plugins[:schema].fetch(name, adapter).configure do |config|
+          config.update(options)
+        end
+        plugins << plugin.enable(self)
+        self
+      end
+
+      # @api public
+      def plugin(name, **options)
+        plugin = plugins.detect { |pl| pl.name == name }
+        plugin.config.update(options) unless options.empty?
+        plugin
+      end
+
+      # @api private
+      def call
+        schema_class.define(relation, **config)
+      end
+
+      # @api private
+      def config
+        @config ||=
+          begin
+            # Enable available plugin's
+            plugins.each do |plugin|
+              next unless plugin.type == :schema
+              plugin.enable(self) unless plugin.enabled?
+            end
+
+            # Apply custom definition block if it exists
+            instance_eval(&definition) if definition
+
+            # Apply plugin defaults
+            plugins.each do |plugin|
+              next unless plugin.type == :schema
+              plugin.__send__(:apply_to, self)
+            end
+
+            attributes.freeze
+            associations.freeze
+
+            opts.freeze
+          end
+      end
+
+      # @api public
+      def inspect
+        %(<##{self.class} relation=#{relation} attributes=#{attributes} plugins=#{plugins}>)
+      end
+
+      private
+
+      # Return schema opts
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def opts
+        {attributes: attributes.values,
+         associations: associations,
+         attr_class: attr_class,
+         plugins: plugins}
+      end
+
+      # Builds a representation of the information needed to create an
+      # attribute. It returns a hash with `:type` and `:options` keys.
+      #
+      # @return [Hash]
+      #
+      # @see [Schema.build_attribute_info]
+      #
+      # @api private
+      def build_attribute_info(name, type_or_options, options = EMPTY_HASH)
+        type, options = if type_or_options.is_a?(::Hash)
+                          [nil, type_or_options]
+                        else
+                          [build_type(type_or_options, options), options]
+                        end
+        Schema.build_attribute_info(
+          type, **options, name: name
+        )
+      end
+
+      # Builds a type instance from base type and meta options
+      #
+      # @return [Dry::Types::Type] Type instance
+      #
+      # @api private
+      def build_type(type, options = EMPTY_HASH)
+        meta = Attribute::META_OPTIONS
+          .map { |opt| [opt, options[opt]] if options.key?(opt) }
+          .compact
+          .to_h
+
+        base =
+          if options[:read]
+            type.meta(source: relation, read: options[:read])
+          elsif type.optional? && type.meta[:read]
+            type.meta(source: relation, read: type.meta[:read].optional)
+          else
+            type.meta(source: relation)
+          end
+
+        if meta.empty?
+          base
+        else
+          base.meta(meta)
+        end
+      end
+    end
+  end
+end

data/lib/rom/compat/setting_proxy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/core/class_attributes"
+
+module ROM
+  module SettingProxy
+    extend Dry::Core::ClassAttributes
+
+    private
+
+    # @api private
+    def respond_to_missing?(name, include_all = false)
+      super || setting_mapping.key?(name)
+    end
+
+    # Delegate to config when accessing deprecated class attributes
+    #
+    # @api private
+    def method_missing(name, *args, &block)
+      return super unless setting_mapping.key?(name)
+
+      mapping = setting_mapping[name]
+      ns, key = mapping
+
+      if args.empty?
+        if mapping.empty?
+          config[name]
+        else
+          config[ns][Array(key).first]
+        end
+      else
+        value = args.first
+
+        if mapping.empty?
+          config[name] = value
+        else
+          Array(key).each { |k| config[ns][k] = value }
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/rom/compat/setup.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "rom/setup"
+require "rom/support/notifications"
+
+module ROM
+  # @api public
+  class Setup
+    extend Notifications
+
+    register_event("configuration.relations.class.ready")
+    register_event("configuration.relations.object.registered")
+    register_event("configuration.relations.registry.created")
+    register_event("configuration.relations.schema.allocated")
+    register_event("configuration.relations.schema.set")
+    register_event("configuration.relations.dataset.allocated")
+    register_event("configuration.commands.class.before_build")
+
+    mod = Module.new do
+      # @api public
+      def finalize
+        super { attach_listeners }
+      end
+
+      # @api private
+      def registry_options
+        super.merge(notifications: notifications)
+      end
+    end
+
+    prepend(mod)
+
+    # @api public
+    # @deprecated
+    def notifications
+      @notifications ||= Notifications.event_bus(:configuration)
+    end
+
+    # @api private
+    def attach_listeners
+      # Anything can attach globally to certain events, including plugins, so here
+      # we're making sure that only plugins that are enabled in this configuration
+      # will be triggered
+      global_listeners = Notifications.listeners.to_a
+        .reject { |(src, *)| plugin_registry.map(&:mod).include?(src) }.to_h
+
+      plugin_listeners = Notifications.listeners.to_a
+        .select { |(src, *)| plugins.map(&:mod).include?(src) }.to_h
+
+      listeners.update(global_listeners).update(plugin_listeners)
+    end
+
+    # @api private
+    def listeners
+      notifications.listeners
+    end
+
+    # @api public
+    # @deprecated
+    def inflector=(inflector)
+      config.inflector = inflector
+    end
+
+    # Enable auto-registration for a given configuration object
+    #
+    # @param [String, Pathname] directory The root path to components
+    # @param [Hash] options
+    # @option options [Boolean, String] :namespace Toggle root namespace
+    #                                              or provide a custom namespace name
+    #
+    # @return [Setup]
+    #
+    # @deprecated
+    #
+    # @see Configuration#auto_register
+    #
+    # @api public
+    def auto_registration(directory, **options)
+      auto_registration = AutoRegistration.new(directory, inflector: inflector, **options)
+      auto_registration.relations.each { |r| register_relation(r) }
+      auto_registration.commands.each { |r| register_command(r) }
+      auto_registration.mappers.each { |r| register_mapper(r) }
+      self
+    end
+
+    # @api private
+    # @deprecated
+    def relation_classes(gateway = nil)
+      if gateway
+        gid = gateway.is_a?(Symbol) ? gateway : gateway.config.id
+        components.relations.select { |r| r.config[:gateway] == gid }
+      else
+        components.relations
+      end.map(&:constant)
+    end
+
+    # @api public
+    # @deprecated
+    def command_classes
+      components.commands.map(&:constant)
+    end
+
+    # @api public
+    # @deprecated
+    def mapper_classes
+      components.mappers.map(&:constant)
+    end
+
+    # @api public
+    # @deprecated
+    def [](key)
+      gateways.fetch(key)
+    end
+
+    # @api public
+    # @deprecated
+    def gateways
+      @gateways ||=
+        begin
+          register_gateways
+          registry.gateways.map { |gateway| [gateway.config.id, gateway] }.to_h
+        end
+    end
+    alias_method :environment, :gateways
+
+    # @api private
+    # @deprecated
+    def gateways_map
+      @gateways_map ||= gateways.map(&:reverse).to_h
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_all = false)
+      gateways.key?(name) || super
+    end
+
+    private
+
+    # Returns gateway if method is a name of a registered gateway
+    #
+    # @return [Gateway]
+    #
+    # @api public
+    # @deprecated
+    def method_missing(name, *)
+      gateways[name] || super
+    end
+  end
+
+  Configuration = Setup
+end