rom-core 4.0.0.beta1

data/lib/rom/commands/composite.rb

@@ -0,0 +1,53 @@
+require 'rom/pipeline'
+
+module ROM
+  module Commands
+    # Composite command that consists of left and right commands
+    #
+    # @api public
+    class Composite < Pipeline::Composite
+      # Calls the composite command
+      #
+      # Right command is called with a result from the left one
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(*args)
+        response = left.call(*args)
+
+        if response.nil? || (many? && response.size == 0)
+          return one? ? nil : EMPTY_ARRAY
+        end
+
+        if one? && !graph?
+          if right.is_a?(Command) || right.is_a?(Commands::Composite)
+            right.call([response].first)
+          else
+            right.call([response]).first
+          end
+        elsif one? && graph?
+          right.call(response).first
+        else
+          right.call(response)
+        end
+      end
+      alias_method :[], :call
+
+      # @api private
+      def graph?
+        left.is_a?(Graph)
+      end
+
+      # @api private
+      def result
+        left.result
+      end
+
+      # @api private
+      def decorate?(response)
+        super || response.is_a?(Graph)
+      end
+    end
+  end
+end

data/lib/rom/commands/create.rb

@@ -0,0 +1,13 @@
+require 'rom/command'
+
+module ROM
+  module Commands
+    # Create command
+    #
+    # This command inserts a new tuple into a relation
+    #
+    # @abstract
+    class Create < Command
+    end
+  end
+end

data/lib/rom/commands/delete.rb

@@ -0,0 +1,14 @@
+require 'rom/command'
+
+module ROM
+  module Commands
+    # Delete command
+    #
+    # This command removes tuples from its target relation
+    #
+    # @abstract
+    class Delete < Command
+      restrictable true
+    end
+  end
+end

data/lib/rom/commands/graph.rb

@@ -0,0 +1,88 @@
+require 'rom/initializer'
+require 'rom/pipeline'
+require 'rom/commands/graph/class_interface'
+
+module ROM
+  module Commands
+    # Command graph
+    #
+    # @api private
+    class Graph
+      extend Initializer
+      include Dry::Equalizer(:root, :nodes)
+
+      extend ClassInterface
+
+      include Pipeline
+      include Pipeline::Proxy
+
+      # @attr_reader [Command] root The root command
+      param :root
+
+      # @attr_reader [Array<Command>] nodes The child commands
+      param :nodes
+
+      alias_method :left, :root
+      alias_method :right, :nodes
+
+      # @attr_reader [Symbol] root's relation name
+      option :name, default: -> { root.name }
+
+      option :mappers, default: -> { MapperRegistry.new }
+
+      # Calls root and all nodes with the result from root
+      #
+      # Graph results are mappable through `combine` operation in mapper DSL
+      #
+      # @example
+      #   create_user = rom.commands[:users].create
+      #   create_task = rom.commands[:tasks].create
+      #
+      #   command = create_user
+      #     .with(name: 'Jane')
+      #     .combine(create_task.with(title: 'Task'))
+      #
+      #   command.call
+      #
+      # @return [Array] nested array with command results
+      #
+      # @api public
+      def call(*args)
+        left = root.call(*args)
+
+        right = nodes.map { |node|
+          response =
+            if node.lazy?
+              node.call(args.first, left)
+            else
+              node.call(left)
+            end
+
+          if node.one? && !node.graph?
+            [response]
+          else
+            response
+          end
+        }
+
+        if one?
+          [[left], right]
+        else
+          [left, right]
+        end
+      end
+
+      # @api private
+      def graph?
+        true
+      end
+
+      private
+
+      # @api public
+      def composite_class
+        Command::Composite
+      end
+    end
+  end
+end

data/lib/rom/commands/graph/class_interface.rb

@@ -0,0 +1,62 @@
+require 'rom/commands/graph/input_evaluator'
+
+module ROM
+  module Commands
+    class Graph
+      # Class methods for command Graph
+      #
+      # @api private
+      module ClassInterface
+        # Build a command graph recursively
+        #
+        # This is used by `Container#command` when array with options is passed in
+        #
+        # @param [Registry] registry The command registry from container
+        # @param [Array] options The options array
+        # @param [Array] path The path for input evaluator proc
+        #
+        # @return [Graph]
+        #
+        # @api private
+        def build(registry, options, path = EMPTY_ARRAY)
+          options.reduce { |spec, other| build_command(registry, spec, other, path) }
+        end
+
+        # @api private
+        def build_command(registry, spec, other, path)
+          cmd_opts, nodes = other
+
+          key, relation =
+            if spec.is_a?(Hash)
+              spec.to_a.first
+            else
+              [spec, spec]
+            end
+
+          name, opts =
+            if cmd_opts.is_a?(Hash)
+              cmd_opts.to_a.first
+            else
+              [cmd_opts]
+            end
+
+          command = registry[relation][name]
+          tuple_path = Array[*path] << key
+          input_proc = InputEvaluator.build(tuple_path, nodes)
+
+          command = command.with(input_proc, opts)
+
+          if nodes
+            if nodes.all? { |node| node.is_a?(Array) }
+              command.combine(*nodes.map { |node| build(registry, node, tuple_path) })
+            else
+              command.combine(build(registry, nodes, tuple_path))
+            end
+          else
+            command
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/graph/input_evaluator.rb

@@ -0,0 +1,62 @@
+module ROM
+  module Commands
+    class Graph
+      class InputEvaluator
+        include Dry::Equalizer(:tuple_path, :excluded_keys)
+
+        attr_reader :tuple_path
+
+        attr_reader :excluded_keys
+
+        attr_reader :exclude_proc
+
+        def self.build(tuple_path, nodes)
+          new(tuple_path, extract_excluded_keys(nodes))
+        end
+
+        def self.extract_excluded_keys(nodes)
+          return unless nodes
+
+          nodes
+            .map { |item| item.is_a?(Array) && item.size > 1 ? item.first : item }
+            .compact
+            .map { |item| item.is_a?(Hash) ? item.keys.first : item }
+            .reject { |item| item.is_a?(Array) }
+        end
+
+        def self.exclude_proc(excluded_keys)
+          -> input { input.reject { |k, _| excluded_keys.include?(k) } }
+        end
+
+        def initialize(tuple_path, excluded_keys)
+          @tuple_path = tuple_path
+          @excluded_keys = excluded_keys
+          @exclude_proc = self.class.exclude_proc(excluded_keys)
+        end
+
+        def call(*args)
+          input, index = args
+
+          value =
+            begin
+              if index
+                tuple_path[0..tuple_path.size-2]
+                  .reduce(input) { |a, e| a.fetch(e) }
+                  .at(index)[tuple_path.last]
+              else
+                tuple_path.reduce(input) { |a, e| a.fetch(e) }
+              end
+            rescue KeyError => e
+              raise KeyMissing, e.message
+            end
+
+          if excluded_keys
+            value.is_a?(Array) ? value.map(&exclude_proc) : exclude_proc[value]
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/lazy.rb

@@ -0,0 +1,99 @@
+require 'rom/commands/composite'
+require 'rom/commands/graph'
+
+module ROM
+  module Commands
+    # Lazy command wraps another command and evaluates its input when called
+    #
+    # @api private
+    class Lazy
+      include Dry::Equalizer(:command, :evaluator)
+
+      # @attr_reader [Command] command The wrapped command
+      attr_reader :command
+
+      alias_method :unwrap, :command
+
+      # @attr_reader [Proc] evaluator The proc that will evaluate the input
+      attr_reader :evaluator
+
+      attr_reader :command_proc
+
+      # @api private
+      def self.[](command)
+        case command
+        when Commands::Create then Lazy::Create
+        when Commands::Update then Lazy::Update
+        when Commands::Delete then Lazy::Delete
+        else
+          self
+        end
+      end
+
+      # @api private
+      def initialize(command, evaluator, command_proc = nil)
+        @command = command
+        @evaluator = evaluator
+        @command_proc = command_proc || proc { |*| command }
+      end
+
+      # Evaluate command's input using the input proc and pass to command
+      #
+      # @return [Array,Hash]
+      #
+      # @api public
+      def call(*args)
+        raise NotImplementedError
+      end
+
+      # Compose a lazy command with another one
+      #
+      # @see Commands::Abstract#>>
+      #
+      # @return [Composite]
+      #
+      # @api public
+      def >>(other)
+        Composite.new(self, other)
+      end
+
+      # @see Abstract#combine
+      #
+      # @api public
+      def combine(*others)
+        Graph.new(self, others)
+      end
+
+      # @api private
+      def lazy?
+        true
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        super || command.respond_to?(name)
+      end
+
+      private
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if command.respond_to?(name)
+          response = command.public_send(name, *args, &block)
+
+          if response.instance_of?(command.class)
+            self.class.new(response, evaluator, command_proc)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+require 'rom/commands/lazy/create'
+require 'rom/commands/lazy/update'
+require 'rom/commands/lazy/delete'

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

@@ -0,0 +1,23 @@
+module ROM
+  module Commands
+    class Lazy
+      class Create < 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)
+              command_proc[command, parent, children].call(children, parent)
+            end.reduce(:concat)
+          else
+            input = evaluator.call(first)
+            command.call(input, *args[1..size-1])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module ROM
+  module Commands
+    class Lazy
+      class Delete < Lazy
+        def call(*args)
+          first = args.first
+          last = args.last
+          size = args.size
+
+          if size > 1 && last.is_a?(Array)
+            raise NotImplementedError
+          else
+            input = evaluator.call(first)
+
+            if input.is_a?(Array)
+              input.map do |item|
+                command_proc[command, *(size > 1 ? [last, item] : [input])].call
+              end
+            else
+              command_proc[command, input].call
+            end
+          end
+        end
+      end
+    end
+  end
+end