rom-core 4.0.0.beta1

data/lib/rom/commands/lazy/update.rb

@@ -0,0 +1,34 @@
+module ROM
+  module Commands
+    class Lazy
+      class Update < Lazy
+        def call(*args)
+          first = args.first
+          last = args.last
+          size = args.size
+
+          if size > 1 && last.is_a?(Array)
+            last.map.with_index do |parent, index|
+              children = evaluator.call(first, index)
+
+              children.map do |child|
+                command_proc[command, parent, child].call(child, parent)
+              end
+            end.reduce(:concat)
+          else
+            input = evaluator.call(first)
+
+            if input.is_a?(Array)
+              input.map.with_index do |item, index|
+                command_proc[command, last, item].call(item,  *args[1..size-1])
+              end
+            else
+              command_proc[command, *(size > 1 ? [last, input] : [input])]
+                .call(input, *args[1..size-1])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/result.rb

@@ -0,0 +1,96 @@
+module ROM
+  module Commands
+    # Abstract result class for success and error results
+    #
+    # @api public
+    class Result
+      # Return command execution result
+      #
+      # @api public
+      attr_reader :value
+
+      # Return potential command execution result error
+      #
+      # @api public
+      attr_reader :error
+
+      # Coerce result to an array
+      #
+      # @abstract
+      #
+      # @api public
+      def to_ary
+        raise NotImplementedError
+      end
+      alias_method :to_a, :to_ary
+
+      # Return true if command successful
+      #
+      # @api public
+      def success?
+        is_a?(Success)
+      end
+
+      # Return true if command failed
+      #
+      # @api public
+      def failure?
+        is_a?(Failure)
+      end
+
+      # Success result has a value and no error
+      #
+      # @api public
+      class Success < Result
+        # @api private
+        def initialize(value)
+          @value = value.is_a?(self.class) ? value.value : value
+        end
+
+        # Call next command on continuation
+        #
+        # @api public
+        def >(other)
+          other.call(value)
+        end
+
+        # Return the value
+        #
+        # @return [Array]
+        #
+        # @api public
+        def to_ary
+          value.to_ary
+        end
+      end
+
+      # Failure result has an error and no value
+      #
+      # @api public
+      class Failure < Result
+        # @api private
+        def initialize(error)
+          @error = error
+        end
+
+        # Do not call next command on continuation
+        #
+        # @return [self]
+        #
+        # @api public
+        def >(_other)
+          self
+        end
+
+        # Return the error
+        #
+        # @return [Array<CommandError>]
+        #
+        # @api public
+        def to_ary
+          error
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/update.rb

@@ -0,0 +1,14 @@
+require 'rom/command'
+
+module ROM
+  module Commands
+    # Update command
+    #
+    # This command updates all tuples in its relation with new attributes
+    #
+    # @abstract
+    class Update < Command
+      restrictable true
+    end
+  end
+end

data/lib/rom/configuration.rb

@@ -0,0 +1,114 @@
+require 'forwardable'
+
+require 'rom/environment'
+require 'rom/setup'
+require 'rom/configuration_dsl'
+require 'rom/support/notifications'
+
+module ROM
+  class Configuration
+    extend Forwardable
+    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')
+
+    include ROM::ConfigurationDSL
+
+    NoDefaultAdapterError = Class.new(StandardError)
+
+    attr_reader :environment, :setup, :notifications
+
+    def_delegators :@setup, :register_relation, :register_command, :register_mapper, :register_plugin,
+                            :command_classes, :mapper_classes,
+                            :auto_registration
+
+    def_delegators :@environment, :gateways, :gateways_map, :configure, :config
+
+    # @api public
+    def initialize(*args, &block)
+      @environment = Environment.new(*args)
+      @notifications = Notifications.event_bus(:configuration)
+      @setup = Setup.new(notifications)
+
+      use :mappers # enable mappers by default
+
+      block.call(self) unless block.nil?
+    end
+
+    # Apply a plugin to the configuration
+    #
+    # @param [Mixed] The plugin identifier, usually a Symbol
+    # @param [Hash] Plugin options
+    #
+    # @api public
+    def use(plugin, options = {})
+      if plugin.is_a?(Array)
+        plugin.each { |p| use(p) }
+      elsif plugin.is_a?(Hash)
+        plugin.to_a.each { |p| use(*p) }
+      else
+        ROM.plugin_registry.configuration.fetch(plugin).apply_to(self, options)
+      end
+
+      self
+    end
+
+    # Return gateway identified by name
+    #
+    # @return [Gateway]
+    #
+    # @api private
+    def [](name)
+      gateways.fetch(name)
+    end
+
+    # Returns gateway if method is a name of a registered gateway
+    #
+    # @return [Gateway]
+    #
+    # @api private
+    def method_missing(name, *)
+      gateways.fetch(name) { super }
+    end
+
+    # Hook for respond_to? used internally
+    #
+    # @api private
+    def respond_to?(name, include_all = false)
+      gateways.key?(name) || super
+    end
+
+    # @api private
+    def default_gateway
+      @default_gateway ||= gateways[:default]
+    end
+
+    # @api private
+    def adapter_for_gateway(gateway)
+      ROM.adapters.select do |key, value|
+        value.const_defined?(:Gateway) && gateway.kind_of?(value.const_get(:Gateway))
+      end.keys.first
+    end
+
+    # @api private
+    def relation_classes(gateway = nil)
+      if gateway
+        gw_name = gateway.is_a?(Symbol) ? gateway : gateways_map[gateway]
+        setup.relation_classes.select { |rel| rel.gateway == gw_name }
+      else
+        setup.relation_classes
+      end
+    end
+
+    # @api private
+    def default_adapter
+      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
+    end
+  end
+end

data/lib/rom/configuration_dsl.rb

@@ -0,0 +1,87 @@
+require 'rom/configuration_dsl/relation'
+require 'rom/configuration_dsl/command_dsl'
+
+module ROM
+  # This extends Configuration class with the DSL methods
+  #
+  # @api public
+  module ConfigurationDSL
+    # Relation definition DSL
+    #
+    # @example
+    #
+    #   setup.relation(:users) do
+    #     def names
+    #       project(:name)
+    #     end
+    #   end
+    #
+    # @api public
+    def relation(name, options = EMPTY_HASH, &block)
+      klass_opts = { adapter: default_adapter }.merge(options)
+      klass = Relation.build_class(name, klass_opts)
+      klass.schema_opts(dataset: name, relation: name)
+      klass.class_eval(&block) if block
+      register_relation(klass)
+      klass
+    end
+
+    # Command definition DSL
+    #
+    # @example
+    #
+    #   setup.commands(:users) do
+    #     define(:create) do
+    #       input NewUserParams
+    #       result :one
+    #     end
+    #
+    #     define(:update) do
+    #       input UserParams
+    #       result :many
+    #     end
+    #
+    #     define(:delete) do
+    #       result :many
+    #     end
+    #   end
+    #
+    # @api public
+    def commands(name, &block)
+      register_command(*CommandDSL.new(name, default_adapter, &block).command_classes)
+    end
+
+    # Configures a plugin for a specific adapter to be enabled for all relations
+    #
+    # @example
+    #   config = ROM::Configuration.new(:sql, 'sqlite::memory')
+    #
+    #   config.plugin(:sql, relations: :instrumentation) do |p|
+    #     p.notifications = MyNotificationsBackend
+    #   end
+    #
+    #   config.plugin(:sql, relations: :pagination)
+    #
+    # @param [Symbol] adapter The adapter identifier
+    # @param [Hash<Symbol=>Symbol>] spec Component identifier => plugin identifier
+    #
+    # @return [Plugin]
+    #
+    # @api public
+    def plugin(adapter, spec, &block)
+      type, name = spec.flatten(1)
+      plugin = plugin_registry.send(type).adapter(adapter).fetch(name) { plugin_registry.send(type).fetch(name) }
+
+      if block
+        register_plugin(plugin.configure(&block))
+      else
+        register_plugin(plugin)
+      end
+    end
+
+    # @api private
+    def plugin_registry
+      ROM.plugin_registry
+    end
+  end
+end

data/lib/rom/configuration_dsl/command.rb

@@ -0,0 +1,41 @@
+require 'dry/core/inflector'
+require 'dry/core/class_builder'
+
+module ROM
+  module ConfigurationDSL
+    # Setup DSL-specific command extensions
+    #
+    # @private
+    class Command
+      # Generate a command subclass
+      #
+      # This is used by Setup#commands DSL and its `define` block
+      #
+      # @api private
+      def self.build_class(name, relation, options = EMPTY_HASH, &block)
+        type = options.fetch(:type) { name }
+        command_type = Dry::Core::Inflector.classify(type)
+        adapter = options.fetch(:adapter)
+        parent = ROM::Command.adapter_namespace(adapter).const_get(command_type)
+        class_name = generate_class_name(adapter, command_type, relation)
+
+        Dry::Core::ClassBuilder.new(name: class_name, parent: parent).call do |klass|
+          klass.register_as(name)
+          klass.relation(relation)
+          klass.class_eval(&block) if block
+        end
+      end
+
+      # Create a command subclass name based on adapter, type and relation
+      #
+      # @api private
+      def self.generate_class_name(adapter, command_type, relation)
+        pieces = ['ROM']
+        pieces << Dry::Core::Inflector.classify(adapter)
+        pieces << 'Commands'
+        pieces << "#{command_type}[#{Dry::Core::Inflector.classify(relation)}s]"
+        pieces.join('::')
+      end
+    end
+  end
+end

data/lib/rom/configuration_dsl/command_dsl.rb

@@ -0,0 +1,35 @@
+require 'rom/configuration_dsl/command'
+
+module ROM
+  module ConfigurationDSL
+    # Command `define` DSL used by Setup#commands
+    #
+    # @private
+    class CommandDSL
+      attr_reader :relation, :adapter, :command_classes
+
+      # @api private
+      def initialize(relation, adapter = nil, &block)
+        @relation = relation
+        @adapter = adapter
+        @command_classes = []
+        instance_exec(&block)
+      end
+
+      # 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(name, options = EMPTY_HASH, &block)
+        @command_classes << Command.build_class(
+          name, relation, { adapter: adapter }.merge(options), &block
+        )
+      end
+    end
+  end
+end

data/lib/rom/configuration_dsl/relation.rb

@@ -0,0 +1,26 @@
+require 'dry/core/class_builder'
+require 'dry/core/inflector'
+
+module ROM
+  module ConfigurationDSL
+    # Setup DSL-specific relation extensions
+    #
+    # @private
+    class Relation
+      # Generate a relation subclass
+      #
+      # This is used by Setup#relation DSL
+      #
+      # @api private
+      def self.build_class(name, options = EMPTY_HASH)
+        class_name = "ROM::Relation[#{Dry::Core::Inflector.camelize(name)}]"
+        adapter = options.fetch(:adapter)
+
+        Dry::Core::ClassBuilder.new(name: class_name, parent: ROM::Relation[adapter]).call do |klass|
+          klass.gateway(options.fetch(:gateway, :default))
+          klass.schema(name) { }
+        end
+      end
+    end
+  end
+end