rom 3.3.3 → 4.0.0.beta1

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.curry(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,95 +0,0 @@
-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.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'

data/lib/rom/commands/result.rb

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

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

@@ -1,3 +0,0 @@
-require 'rom/commands/create'
-require 'rom/commands/update'
-require 'rom/commands/delete'

data/lib/rom/configuration.rb

@@ -1,90 +0,0 @@
-require 'forwardable'
-
-require 'rom/environment'
-require 'rom/setup'
-require 'rom/configuration_dsl'
-
-module ROM
-  class Configuration
-    extend Forwardable
-    include ROM::ConfigurationDSL
-
-    NoDefaultAdapterError = Class.new(StandardError)
-
-    attr_reader :environment, :setup
-
-    def_delegators :@setup, :register_relation, :register_command, :register_mapper, :register_plugin,
-                            :relation_classes, :command_classes, :mapper_classes,
-                            :auto_registration
-
-    def_delegators :@environment, :gateways, :gateways_map, :configure, :config
-
-    # @api public
-    def initialize(*args, &block)
-      @environment = Environment.new(*args)
-      @setup = Setup.new
-
-      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.has_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 default_adapter
-      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
-    end
-  end
-end

data/lib/rom/configuration_dsl/command.rb

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

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