rom 3.3.3 → 4.0.0.beta1

data/lib/rom/command_registry.rb

@@ -1,148 +0,0 @@
-require 'dry/core/deprecations'
-
-require 'rom/types'
-require 'rom/commands/result'
-
-module ROM
-  # Specialized registry class for commands
-  #
-  # @api public
-  class CommandRegistry
-    extend Initializer
-    extend Dry::Core::Deprecations[:rom]
-
-    include Commands
-
-    CommandNotFoundError = Class.new(KeyError)
-    RegistryType = Types.Definition(Registry) | Types.Constructor(Registry) { |r| Registry.new(r, self.class.name) }
-
-    # Name of the relation from which commands are under
-    #
-    # @return [String]
-    #
-    # @api private
-    param :relation_name
-
-    # Internal command registry
-    #
-    # @return [Registry]
-    #
-    # @api private
-    param :registry, type: RegistryType
-
-    option :mappers, optional: true
-    option :mapper, optional: true
-
-    # Try to execute a command in a block
-    #
-    # @yield [command] Passes command to the block
-    #
-    # @example
-    #
-    #   rom.command(:users).try { create(name: 'Jane') }
-    #   rom.command(:users).try { update(:by_id, 1).call(name: 'Jane Doe') }
-    #   rom.command(:users).try { delete(:by_id, 1) }
-    #
-    # @return [Commands::Result]
-    #
-    # @api public
-    def try(&block)
-      self.class.warn "CommandRegistry#try will be removed in rom 4.0"
-
-      response = block.call
-
-      if response.is_a?(Command) || response.is_a?(Composite)
-        try { response.call }
-      else
-        Result::Success.new(response)
-      end
-    rescue CommandError => e
-      Result::Failure.new(e)
-    end
-
-    # Return a command from the registry
-    #
-    # If mapper is set command will be turned into a composite command with
-    # auto-mapping
-    #
-    # @example
-    #   create_user = rom.command(:users)[:create]
-    #   create_user[name: 'Jane']
-    #
-    #   # with mapping, assuming :entity mapper is registered for :users relation
-    #   create_user = rom.command(:users).as(:entity)[:create]
-    #   create_user[name: 'Jane'] # => result is send through :entity mapper
-    #
-    # @param [Symbol] name The name of a registered command
-    #
-    # @return [Command,Command::Composite]
-    #
-    # @api public
-    def [](name)
-      command = fetch_command(name)
-      mapper = options[:mapper]
-
-      if mapper
-        command.curry >> mapper
-      else
-        command
-      end
-    end
-
-    # Specify a mapper that should be used for commands from this registry
-    #
-    # @example
-    #   entity_commands = rom.command(:users).as(:entity)
-    #
-    #
-    # @param [Symbol] mapper_name The name of a registered mapper
-    #
-    # @return [CommandRegistry]
-    #
-    # @api public
-    def as(mapper_name)
-      with(mapper: mappers[mapper_name])
-    end
-
-    # Return new instance of this registry with updated options
-    #
-    # @return [CommandRegistry]
-    #
-    # @api private
-    def with(new_options)
-      self.class.new(relation_name, registry, options.merge(new_options))
-    end
-
-    private
-
-    # Fetch a command from the registry and raise a specialized error
-    # in case the command is not found
-    #
-    # @api private
-    def fetch_command(name)
-      registry.fetch(name) do
-        raise CommandNotFoundError.new(
-          "There is no :#{name} command for :#{relation_name} relation"
-        )
-      end
-    end
-
-    # Allow checking if a certain command is available using dot-notation
-    #
-    # @api private
-    def respond_to_missing?(name, include_private = false)
-      registry.key?(name) || super
-    end
-
-    # Allow retrieving commands using dot-notation
-    #
-    # @api private
-    def method_missing(name, *)
-      if registry.key?(name)
-        self[name]
-      else
-        super
-      end
-    end
-  end
-end

data/lib/rom/commands/class_interface.rb

@@ -1,270 +0,0 @@
-require 'dry/core/class_builder'
-require 'dry/core/inflector'
-
-module ROM
-  # Base command class with factory class-level interface and setup-related logic
-  #
-  # @private
-  class Command
-    module ClassInterface
-      # This hook sets up default class state
-      #
-      # @api private
-      def inherited(klass)
-        super
-        klass.instance_variable_set(:'@before', before.dup)
-        klass.instance_variable_set(:'@after', after.dup)
-      end
-
-      # Sets up the base class
-      #
-      # @api private
-      def self.extended(klass)
-        super
-        klass.set_hooks(:before, [])
-        klass.set_hooks(:after, [])
-      end
-
-      # 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(Dry::Core::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 = Dry::Core::ClassBuilder
-          .new(name: "#{Dry::Core::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
-
-      # Set before-execute hooks
-      #
-      # @overload before(hook)
-      #   Set an before hook as a method name
-      #
-      #   @example
-      #     class CreateUser < ROM::Commands::Create[:sql]
-      #       relation :users
-      #       register_as :create
-      #
-      #       before :my_hook
-      #
-      #       def my_hook(tuple, *)
-      #         puts "hook called#
-      #       end
-      #     end
-      #
-      # @overload before(hook_opts)
-      #   Set an before hook as a method name with arguments
-      #
-      #   @example
-      #     class CreateUser < ROM::Commands::Create[:sql]
-      #       relation :users
-      #       register_as :create
-      #
-      #       before my_hook: { arg1: 1, arg1: 2 }
-      #
-      #       def my_hook(tuple, arg1:, arg2:)
-      #         puts "hook called with args: #{arg1} and #{arg2}"
-      #       end
-      #     end
-      #
-      #   @param [Hash<Symbol=>Hash>] hook Options with method name and pre-set args
-      #
-      # @return [Array<Hash, Symbol>] A list of all configured before hooks
-      #
-      # @api public
-      def before(*hooks)
-        if hooks.size > 0
-          set_hooks(:before, hooks)
-        else
-          @before
-        end
-      end
-
-      # Set after-execute hooks
-      #
-      # @overload after(hook)
-      #   Set an after hook as a method name
-      #
-      #   @example
-      #     class CreateUser < ROM::Commands::Create[:sql]
-      #       relation :users
-      #       register_as :create
-      #
-      #       after :my_hook
-      #
-      #       def my_hook(tuple, *)
-      #         puts "hook called#
-      #       end
-      #     end
-      #
-      # @overload after(hook_opts)
-      #   Set an after hook as a method name with arguments
-      #
-      #   @example
-      #     class CreateUser < ROM::Commands::Create[:sql]
-      #       relation :users
-      #       register_as :create
-      #
-      #       after my_hook: { arg1: 1, arg1: 2 }
-      #
-      #       def my_hook(tuple, arg1:, arg2:)
-      #         puts "hook called with args: #{arg1} and #{arg2}"
-      #       end
-      #     end
-      #
-      #   @param [Hash<Symbol=>Hash>] hook Options with method name and pre-set args
-      #
-      # @return [Array<Hash, Symbol>] A list of all configured after hooks
-      #
-      # @api public
-      def after(*hooks)
-        if hooks.size > 0
-          set_hooks(:after, hooks)
-        else
-          @after
-        end
-      end
-
-      # Set new or more hooks
-      #
-      # @api private
-      def set_hooks(type, hooks)
-        ivar = :"@#{type}"
-
-        if instance_variable_defined?(ivar)
-          instance_variable_get(ivar).concat(hooks)
-        else
-          instance_variable_set(ivar, hooks)
-        end
-      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
-        Dry::Core::Inflector.underscore(Dry::Core::Inflector.demodulize(name)).to_sym
-      end
-
-      # Return default options based on class macros
-      #
-      # @return [Hash]
-      #
-      # @api private
-      def options
-        { input: input, result: result, before: before, after: after }
-      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,53 +0,0 @@
-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

@@ -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