rom 2.0.2 → 4.2.1

data/lib/rom/commands/composite.rb

@@ -1,54 +0,0 @@
-require 'rom/pipeline'
-require 'rom/support/constants'
-
-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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/builder.rb

@@ -1,176 +0,0 @@
-module ROM
-  module Commands
-    class Graph
-      # Command graph builder DSL
-      #
-      # @api public
-      class Builder
-        # @api private
-        UnspecifiedRelationError = Class.new(StandardError)
-        DoubleRestrictionError = Class.new(StandardError)
-
-        # @api private
-        class Node
-          # @api private
-          Restriction = Struct.new(:relation, :proc)
-
-          # @api private
-          Command = Struct.new(:name, :relation, :key, :proc)
-
-          # @api private
-          def initialize
-            @nodes = []
-          end
-
-          # @api public
-          def to_ast
-            []
-          end
-
-          # Any missing method called on this is treated as a ROM command
-          #
-          # @api private
-          def method_missing(*args, &block)
-            command(*args, &block)
-          end
-
-          # @api public
-          def command(name, relation = nil, key = nil, proc = nil, &block)
-            if relation.is_a?(Hash)
-              key, relation = relation.to_a.first
-            end
-
-            raise UnspecifiedRelationError if relation.nil?
-
-            if relation.is_a?(RestrictionNode)
-              RestrictionNode.new(relation.restriction).command(name, from: key, &block)
-            else
-              key ||= relation
-
-              command = Command.new(name, relation, key, proc)
-              node = CommandNode.new(command)
-              block.call(node) if block
-              node
-            end
-          end
-
-          # @api public
-          def restrict(name, &block)
-            RestrictionNode.new(Restriction.new(name, block), self)
-          end
-        end
-
-        # @api private
-        class CommandNode < Node
-          # @api private
-          def initialize(command = nil)
-            @command = command
-            @nodes = []
-          end
-
-          # Tiny bit of synctactic sugar
-          #
-          # @api public
-          def each(&block)
-            block.call(self)
-          end
-
-          # Return command ast from this union node
-          #
-          # @return [Array]
-          #
-          # @api private
-          def to_ast
-            if @command.proc
-              command = [@command.name => @command.proc]
-            else
-              command = [@command.name]
-            end
-
-            key_relation_map = { @command.key => @command.relation }
-
-            command << @nodes.map(&:to_ast) unless @nodes.empty?
-
-            [key_relation_map, command]
-          end
-
-          # @api public
-          def command(*args, &block)
-            node = super
-            @nodes << node
-            node
-          end
-        end
-
-        # @api private
-        class RestrictionNode < Node
-          attr_reader :restriction
-
-          def initialize(restriction, parent_node = nil)
-            super()
-            @restriction = restriction
-            @parent_node = parent_node
-          end
-
-          # @api public
-          def command(name, options = {}, &block)
-            relation = @restriction.relation
-            key = options[:from] || relation
-            proc = @restriction.proc
-
-            if @parent_node
-              @parent_node.command(name, relation, key, proc, &block)
-            else
-              super(name, relation, key, proc, &block)
-            end
-          end
-
-          # @api private
-          def restrict(*args, &block)
-            raise DoubleRestrictionError
-          end
-        end
-
-        # @api private
-        class RootNode < Node
-          def to_ast
-            if @nodes.size > 0
-              @nodes.first.to_ast
-            else
-              []
-            end
-          end
-
-          def command(*args, &block)
-            node = super
-            @nodes << node
-            node
-          end
-        end
-
-        # @api private
-        class BuilderNode < RootNode
-          def initialize(container)
-            super()
-            @container = container
-          end
-
-          def command(*args, &block)
-            super
-            @container.command(to_ast)
-          end
-        end
-
-        # @api public
-        def initialize(container)
-          @container = container
-        end
-
-        # @api private
-        def method_missing(*args, &block)
-          BuilderNode.new(@container).send(*args, &block)
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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/graph.rb

@@ -1,103 +0,0 @@
-require 'rom/pipeline'
-require 'rom/support/options'
-require 'rom/commands/graph/class_interface'
-
-module ROM
-  module Commands
-    # Command graph
-    #
-    # @api private
-    class Graph
-      include Dry::Equalizer(:root, :nodes)
-
-      extend ClassInterface
-
-      include Options
-      include Pipeline
-      include Pipeline::Proxy
-
-      # @attr_reader [Command] root The root command
-      attr_reader :root
-
-      # @attr_reader [Array<Command>] nodes The child commands
-      attr_reader :nodes
-
-      # @attr_reader [Symbol] root's relation name
-      attr_reader :name
-
-      alias_method :left, :root
-      alias_method :right, :nodes
-
-      option :mappers, reader: true, default: proc { MapperRegistry.new }
-
-      # @api private
-      def initialize(root, nodes, options = EMPTY_HASH)
-        super
-        @root = root
-        @nodes = nodes
-        @name = root.name
-      end
-
-      # Calls root and all nodes with the result from root
-      #
-      # Graph results are mappable through `combine` operation in mapper DSL
-      #
-      # @example
-      #   create_user = rom.command(:users).create
-      #   create_task = rom.command(: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
-
-      # Return a new graph with updated options
-      #
-      # @api private
-      def with(new_options)
-        self.class.new(root, nodes, options.merge(new_options))
-      end
-
-      # @api private
-      def graph?
-        true
-      end
-
-      private
-
-      # @api public
-      def composite_class
-        Command::Composite
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

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

@@ -1,34 +0,0 @@
-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/lazy.rb

@@ -1,99 +0,0 @@
-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'