rom 2.0.2 → 5.2.5

data/lib/rom/commands/class_interface.rb

@@ -1,148 +0,0 @@
-require 'rom/support/class_builder'
-
-module ROM
-  # Base command class with factory class-level interface and setup-related logic
-  #
-  # @private
-  class Command
-    module ClassInterface
-      # Return adapter specific sub-class based on the adapter identifier
-      #
-      # This is a syntax sugar to make things consistent
-      #
-      # @example
-      #   ROM::Commands::Create[:memory]
-      #   # => ROM::Memory::Commands::Create
-      #
-      # @param [Symbol] adapter identifier
-      #
-      # @return [Class]
-      #
-      # @api public
-      def [](adapter)
-        adapter_namespace(adapter).const_get(Inflector.demodulize(name))
-      end
-
-      # Return namespaces that contains command subclasses of a specific adapter
-      #
-      # @param [Symbol] adapter identifier
-      #
-      # @return [Module]
-      #
-      # @api private
-      def adapter_namespace(adapter)
-        ROM.adapters.fetch(adapter).const_get(:Commands)
-      rescue KeyError
-        raise AdapterNotPresentError.new(adapter, :relation)
-      end
-
-      # Build a command class for a specific relation with options
-      #
-      # @example
-      #   class CreateUser < ROM::Commands::Create[:memory]
-      #   end
-      #
-      #   command = CreateUser.build(rom.relations[:users])
-      #
-      # @param [Relation] relation
-      # @param [Hash] options
-      #
-      # @return [Command]
-      #
-      # @api public
-      def build(relation, options = EMPTY_HASH)
-        new(relation, self.options.merge(options))
-      end
-
-      # Create a command class with a specific type
-      #
-      # @param [Symbol] command name
-      # @param [Class] parent class
-      #
-      # @yield [Class] create class
-      #
-      # @return [Class, Object] return result of the block if it was provided
-      #
-      # @api public
-      def create_class(name, type, &block)
-        klass = ClassBuilder
-          .new(name: "#{Inflector.classify(type)}[:#{name}]", parent: type)
-          .call
-
-        if block
-          yield(klass)
-        else
-          klass
-        end
-      end
-
-      # Use a configured plugin in this relation
-      #
-      # @example
-      #   class CreateUser < ROM::Commands::Create[:memory]
-      #     use :pagintion
-      #
-      #     per_page 30
-      #   end
-      #
-      # @param [Symbol] plugin
-      # @param [Hash] options
-      # @option options [Symbol] :adapter (:default) first adapter to check for plugin
-      #
-      # @api public
-      def use(plugin, _options = EMPTY_HASH)
-        ROM.plugin_registry.commands.fetch(plugin, adapter).apply_to(self)
-      end
-
-      # Extend a command class with relation view methods
-      #
-      # @param [Relation]
-      #
-      # @return [Class]
-      #
-      # @api public
-      def extend_for_relation(relation)
-        include(relation_methods_mod(relation.class))
-      end
-
-      # Return default name of the command class based on its name
-      #
-      # During setup phase this is used by defalut as `register_as` option
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def default_name
-        Inflector.underscore(Inflector.demodulize(name)).to_sym
-      end
-
-      # Return default options based on class macros
-      #
-      # @return [Hash]
-      #
-      # @api private
-      def options
-        { input: input, validator: validator, result: result }
-      end
-
-      # @api private
-      def relation_methods_mod(relation_class)
-        Module.new do
-          relation_class.view_methods.each do |meth|
-            module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{meth}(*args)
-                response = relation.public_send(:#{meth}, *args)
-
-                if response.is_a?(relation.class)
-                  new(response)
-                else
-                  response
-                end
-              end
-            RUBY
-          end
-        end
-      end
-    end
-  end
-end

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