rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/registries/root.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "dry/core/memoizable"
+
+require_relative "../core"
+require_relative "../constants"
+require_relative "../initializer"
+require_relative "../inferrer"
+require_relative "container"
+
+module ROM
+  module Registries
+    class Root
+      extend Initializer
+
+      include Dry::Core::Memoizable
+      include Dry::Effects::Handler.Reader(:registry)
+      include Enumerable
+
+      option :config, default: -> { ROM.config }
+
+      option :components, default: -> { Components::Registry.new(provider: Setup.new) }
+
+      option :container, default: -> { Container.new }
+
+      option :inferrer, default: -> { Inferrer.new }
+
+      option :loader, optional: true
+
+      option :type, optional: true
+
+      option :path, default: -> { EMPTY_ARRAY }
+
+      option :root, default: -> { self }
+
+      option :opts, default: -> { EMPTY_HASH }
+
+      CORE_COMPONENTS.each do |type|
+        require_relative type.to_s
+
+        define_method(type) do |**options|
+          registry = scoped(__method__, type: __method__, **options)
+
+          klass =
+            case type
+            when :relations then Relations
+            when :commands then Commands
+            when :mappers then Mappers
+            when :datasets then Datasets
+            when :schemas then Schemas
+            when :views then Views
+            when :associations then Associations
+            end
+
+          klass ? klass.new(**registry.options) : registry
+        end
+
+        define_method(:"#{type}?") do
+          self.type == type
+        end
+      end
+
+      # @api public
+      def fetch(key, &block)
+        case key
+        when Symbol
+          fetch("#{namespace}.#{key}", &block)
+        when String
+          return container[key] if container.key?(key)
+
+          loader&.auto_load_component_file(type, key)
+
+          with_registry(root) { build(key, &block) }.tap { |item|
+            container.register(key, item)
+          }
+        when Array
+          with_registry(self) { inferrer.call(key, type, **opts) }
+        else
+          if key.respond_to?(:to_sym)
+            fetch(key.to_sym, &block)
+          else
+            element_not_found(key)
+          end
+        end
+      rescue KeyError
+        element_not_found(key)
+      end
+      alias_method :[], :fetch
+
+      # @api public
+      def infer(id, **options)
+        fetch(id) do
+          inferred_config = config[handler.key].inherit(**config.component, **options)
+          define_component(id: id, **inferred_config).build
+        end
+      end
+
+      # @api private
+      def provider
+        components.provider
+      end
+
+      # @api private
+      def provider_type
+        config.component.type
+      end
+
+      # @api private
+      def handler
+        components.handlers[type]
+      end
+
+      # @api private
+      def build(key, &block)
+        components.(key, &block)
+      end
+
+      # @api private
+      memoize def namespace
+        path.join(".")
+      end
+
+      # @api private
+      memoize def compiler
+        inferrer.compiler(type, **opts)
+      end
+
+      # @api private
+      memoize def relation_ids
+        components.relations.map(&:id)
+      end
+
+      # @api private
+      def scoped(*scope, **options)
+        with(path: path + scope, **options)
+      end
+
+      # @api private
+      def each
+        keys.each { |key| yield(fetch(key)) }
+      end
+
+      # @api private
+      def plugins
+        config.component.plugins
+      end
+
+      # @api private
+      def keys
+        all = (components.keys + container.keys).uniq
+        return all if path.empty?
+
+        all.select { |key| key.start_with?(namespace) }
+      end
+
+      # @api private
+      def ids
+        components[type].map(&:id)
+      end
+
+      # @api private
+      def key?(key)
+        keys.include?("#{namespace}.#{key}")
+      end
+
+      # @api public
+      def empty?
+        keys.empty?
+      end
+
+      # @api private
+      def inspect
+        %(#<#{self.class} adapters=#{components.gateways.map(&:adapter)} keys=#{keys}>)
+      end
+
+      # Disconnect all gateways
+      #
+      # @example
+      #   rom = ROM.setup(:sql, 'sqlite://my_db.sqlite')
+      #   rom.relations[:users].insert(name: "Jane")
+      #   rom.disconnect
+      #
+      # @return [Hash<Symbol=>Gateway>] a hash with disconnected gateways
+      #
+      # @api public
+      def disconnect
+        container.keys.grep(/gateways/).each { |key| self[key].disconnect }
+      end
+
+      private
+
+      # @api private
+      def define_component(**options)
+        provider.public_send(handler.key, **options)
+      end
+
+      # @api private
+      def element_not_found(key)
+        raise MISSING_ELEMENT_ERRORS.fetch(type), key
+      end
+    end
+  end
+end

data/lib/rom/registries/schemas.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "nestable"
+
+module ROM
+  module Registries
+    # @api public
+    class Schemas < Root
+      prepend Nestable
+
+      # Resolve relation's canonical schema
+      #
+      # @param provider [#config]
+      # @return [Schema]
+      #
+      # @api public
+      def canonical(provider)
+        schema = scoped(provider.config.component.id).fetch(provider.config.component.dataset) {
+          fetch(provider.config.component.id)
+        }
+
+        if schema.is_a?(self.class)
+          unscoped.fetch(provider.config.component.id)
+        else
+          schema
+        end
+      end
+
+      # @api private
+      def unscoped
+        root.schemas
+      end
+
+      # @api private
+      def define_component(**options)
+        return super unless provider_type == :relation
+
+        comp = components.get(:schemas, relation: config.component.id, abstract: false)
+
+        comp || super(**options, relation_id: config.component.id)
+      end
+    end
+  end
+end

data/lib/rom/registries/views.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "nestable"
+
+module ROM
+  module Registries
+    class Views < Root
+      prepend Nestable
+    end
+  end
+end

data/lib/rom/relation/class_interface.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "dry/effects"
+
+require "rom/support/inflector"
+
+require "rom/constants"
+require "rom/relation/name"
+require "rom/schema"
+
+module ROM
+  class Relation
+    # Global class-level API for relation classes
+    #
+    # @api public
+    module ClassInterface
+      extend Notifications::Listener
+
+      # Return adapter-specific relation subclass
+      #
+      # @example
+      #   ROM::Relation[:memory]
+      #   # => ROM::Memory::Relation
+      #
+      # @return [Class]
+      #
+      # @api public
+      def [](adapter)
+        ROM.adapters.fetch(adapter).const_get(:Relation)
+      rescue KeyError
+        raise AdapterNotPresentError.new(adapter, :relation)
+      end
+
+      # Dynamically define a method that will forward to the dataset and wrap
+      # response in the relation itself
+      #
+      # @example
+      #   class SomeAdapterRelation < ROM::Relation
+      #     forward :super_query
+      #   end
+      #
+      # @api public
+      def forward(*methods)
+        methods.each do |method|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args, &block)
+              new(dataset.__send__(:#{method}, *args, &block))
+            end
+          RUBY
+        end
+      end
+
+      # @api private
+      def curried
+        Curried
+      end
+    end
+  end
+end

data/lib/rom/relation/combined.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "rom/relation/graph"
+require "rom/relation/commands"
+
+module ROM
+  class Relation
+    # Represents a relation graphs which combines root relation
+    # with other relation nodes
+    #
+    # @api public
+    class Combined < Graph
+      include Commands
+
+      # Create a new relation combined with others
+      #
+      # @param [Relation] relation
+      # @param [Array<Relation>] nodes
+      #
+      # @return [Combined]
+      #
+      # @api public
+      def self.new(relation, nodes)
+        struct_ns = relation.options[:struct_namespace]
+        new_nodes = nodes.uniq(&:name).map { |node| node.struct_namespace(struct_ns) }
+
+        root =
+          if relation.is_a?(self)
+            new_nodes.concat(relation.nodes)
+            relation.root
+          else
+            relation
+          end
+
+        super(root, new_nodes)
+      end
+
+      # Combine this graph with more nodes
+      #
+      # @param [Array<Relation>] others A list of relations
+      #
+      # @return [Graph]
+      #
+      # @api public
+      def combine_with(*others)
+        self.class.new(root, nodes + others)
+      end
+
+      # Combine with other relations
+      #
+      # @see Relation#combine
+      #
+      # @return [Combined]
+      #
+      # @api public
+      def combine(*args)
+        self.class.new(root, nodes + root.combine(*args).nodes)
+      end
+
+      # Materialize combined relation
+      #
+      # @return [Loaded]
+      #
+      # @api public
+      def call(*args)
+        left = root.with(auto_map: false, auto_struct: false).call(*args)
+
+        right =
+          if left.empty?
+            nodes.map { |node| Loaded.new(node, EMPTY_ARRAY) }
+          else
+            nodes.map { |node| node.call(left) }
+          end
+
+        if auto_map?
+          Loaded.new(self, mapper.([left, right]))
+        else
+          Loaded.new(self, [left, right])
+        end
+      end
+
+      # Return a new combined relation with adjusted node returned from a block
+      #
+      # @example with a node identifier
+      #   combine(:tasks).node(:tasks) { |tasks| tasks.prioritized }
+      #
+      # @example with a nested path
+      #   combine(tasks: :tags).node(tasks: :tags) { |tags| tags.where(name: 'red') }
+      #
+      # @param [Symbol] name The node relation name
+      #
+      # @yieldparam [Relation] relation The relation node
+      # @yieldreturn [Relation] The new relation node
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def node(name, &block)
+        if name.is_a?(Symbol) && !nodes.map { |n| n.name.key }.include?(name)
+          raise ArgumentError, "#{name.inspect} is not a valid aggregate node name"
+        end
+
+        new_nodes = nodes.map { |node|
+          case name
+          when Symbol
+            name == node.name.key ? yield(node) : node
+          when Hash
+            other, *rest = name.flatten(1)
+            if other == node.name.key
+              nodes.detect { |n| n.name.key == other }.node(*rest, &block)
+            else
+              node
+            end
+          else
+            node
+          end
+        }
+
+        with_nodes(new_nodes)
+      end
+
+      # Return a `:create` command that can insert data from a nested hash.
+      #
+      # This is limited to `:create` commands only, because automatic restriction
+      # for `:update` commands would be quite complex. It's possible that in the
+      # future support for `:update` commands will be added though.
+      #
+      # Another limitation is that it can only work when you're composing
+      # parent and its child(ren), which follows canonical hierarchy from your
+      # database, so that parents are created first, then their PKs are set
+      # as FKs in child tuples. It should be possible to make it work with
+      # both directions (parent => child or child => parent), and it would
+      # require converting input tuples based on how they depend on each other,
+      # which we could do in the future.
+      #
+      # Expanding functionality of this method is planned for rom 5.0.
+      #
+      # @see Relation#command
+      #
+      # @raise NotImplementedError when type is not `:create`
+      #
+      # @api public
+      def command(type, *args)
+        if type == :create
+          super
+        else
+          raise NotImplementedError,
+                "#{self.class}#command doesn't work with #{type.inspect} command type yet"
+        end
+      end
+
+      private
+
+      # @api private
+      def decorate?(other)
+        super || other.is_a?(self.class) || other.is_a?(Wrap)
+      end
+    end
+  end
+end

data/lib/rom/relation/commands.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ROM
+  class Relation
+    # Extensions for relation classes which provide access to commands
+    #
+    # @api public
+    module Commands
+      # Return a command for the relation
+      #
+      # This method can either return an existing custom command identified
+      # by `type` param, or generate a command dynamically based on relation
+      # AST.
+      #
+      # @example build a simple :create command
+      #   users.command(:create)
+      #
+      # @example build a command which returns multiple results
+      #   users.command(:create, result: many)
+      #
+      # @example build a command which uses a specific plugin
+      #   users.command(:create, use: :timestamps)
+      #
+      # @example build a command which sends results through a custom mapper
+      #   users.command(:create, mapper: :my_mapper_identifier)
+      #
+      # @example return an existing custom command
+      #   users.command(:my_custom_command_identifier)
+      #
+      # @param type [Symbol] The command type (:create, :update or :delete)
+      # @param opts [Hash] Additional options
+      # @option opts [Symbol] :mapper (nil) An optional mapper applied to the command result
+      # @option opts [Array<Symbol>] :use ([]) A list of command plugins
+      # @option opts [Symbol] :result (:one) Set how many results the command should return.
+      #                                       Can be `:one` or `:many`
+      #
+      # @return [ROM::Command]
+      #
+      # @api public
+      def command(type, mapper: nil, use: EMPTY_ARRAY, plugins_options: EMPTY_HASH, **opts)
+        base_command =
+          if commands.key?(type)
+            commands[type]
+          else
+            commands[[type, adapter, to_ast, use, plugins_options, opts]]
+          end
+
+        command =
+          if mapper
+            base_command >> mappers[mapper]
+          elsif auto_map?
+            base_command >> self.mapper
+          else
+            base_command
+          end
+
+        if command.restrictible?
+          command.new(self)
+        else
+          command
+        end
+      end
+    end
+  end
+end

data/lib/rom/relation/composite.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rom/relation/loaded"
+require "rom/relation/materializable"
+require "rom/pipeline"
+
+module ROM
+  class Relation
+    # Left-to-right relation composition used for data-pipelining
+    #
+    # @api public
+    class Composite < Pipeline::Composite
+      include Materializable
+
+      # Call the pipeline by passing results from left to right
+      #
+      # Optional args are passed to the left object
+      #
+      # @return [Loaded]
+      #
+      # @api public
+      def call(*args)
+        relation = left.call(*args)
+        response = right.call(relation)
+
+        if response.is_a?(Loaded)
+          response
+        else
+          relation.new(response)
+        end
+      end
+      alias_method :[], :call
+
+      # @see Relation#map_to
+      #
+      # @api public
+      def map_to(klass)
+        self >> left.map_to(klass).mapper
+      end
+
+      private
+
+      # @api private
+      #
+      # @see Pipeline::Proxy#decorate?
+      #
+      # @api private
+      def decorate?(response)
+        super || response.is_a?(Graph)
+      end
+    end
+  end
+end