rom 0.5.0 → 0.6.0.beta1

data/lib/rom/command.rb

@@ -0,0 +1,118 @@
+require 'rom/commands/abstract'
+
+module ROM
+  # Base command class with factory class-level interface and setup-related logic
+  #
+  # @private
+  class Command < Commands::Abstract
+    extend ClassMacros
+
+    include Equalizer.new(:relation, :options)
+
+    defines :relation, :result, :input, :validator, :register_as
+
+    input Hash
+    validator proc {}
+    result :many
+
+    # Registers Create/Update/Delete descendant classes during the setup phase
+    #
+    # @api private
+    def self.inherited(klass)
+      super
+      return if klass.superclass == ROM::Command
+      ROM.register_command(klass)
+    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 self.[](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 self.adapter_namespace(adapter)
+      ROM.adapters.fetch(adapter).const_get(:Commands)
+    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 self.build(relation, options = {})
+      new(relation, self.options.merge(options))
+    end
+
+    # Build command registry hash for provided relations
+    #
+    # @param [RelationRegistry] relations registry
+    # @param [Hash] repositories
+    # @param [Array] descendants a list of command subclasses
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def self.registry(relations, repositories, descendants)
+      descendants.each_with_object({}) do |klass, h|
+        rel_name = klass.relation
+
+        next unless rel_name
+
+        relation = relations[rel_name]
+        name = klass.register_as || klass.default_name
+
+        repository = repositories[relation.class.repository]
+        repository.extend_command_class(klass, relation.dataset)
+
+        (h[rel_name] ||= {})[name] = klass.build(relation)
+      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 self.default_name
+      Inflector.underscore(Inflector.demodulize(name)).to_sym
+    end
+
+    # Return default options based on class macros
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def self.options
+      { input: input, validator: validator, result: result }
+    end
+  end
+end

data/lib/rom/command_registry.rb

@@ -3,34 +3,14 @@ require 'rom/commands/result'
 module ROM
   # Command registry exposes "try" interface for executing commands
   #
-  # @public
+  # @api public
   class CommandRegistry < Registry
-    class Evaluator
-      include Concord.new(:registry)
-
-      private
-
-      # Call a command when method is matching command name
-      #
-      # TODO: this will be replaced by explicit definition of methods for all
-      #       registered commands
-      #
-      # @api public
-      def method_missing(name, *args, &block)
-        command = registry[name]
-
-        super unless command
-
-        if args.size > 1
-          command.new(*args, &block)
-        else
-          command.call(*args, &block)
-        end
-      end
-    end
+    include Commands
 
     # Try to execute a command in a block
     #
+    # @yield [command] Passes command to the block
+    #
     # @example
     #
     #   rom.command(:users).try { create(name: 'Jane') }
@@ -40,10 +20,16 @@ module ROM
     # @return [Commands::Result]
     #
     # @api public
-    def try(&f)
-      Commands::Result::Success.new(Evaluator.new(self).instance_exec(&f))
+    def try(&block)
+      response = block.call
+
+      if response.is_a?(Command) || response.is_a?(Composite)
+        try { response.call }
+      else
+        Result::Success.new(response)
+      end
     rescue CommandError => e
-      Commands::Result::Failure.new(e)
+      Result::Failure.new(e)
     end
   end
 end

data/lib/rom/commands.rb

@@ -1,62 +1,4 @@
-module ROM
-  module Commands
-    class AbstractCommand
-      VALID_RESULTS = [:one, :many].freeze
-
-      attr_reader :relation, :options, :result
-
-      # @api private
-      def initialize(relation, options)
-        @relation = relation
-        @options = options
-
-        @result = options[:result] || :many
-
-        unless VALID_RESULTS.include?(result)
-          raise InvalidOptionError.new(:result, VALID_RESULTS)
-        end
-      end
-
-      # Call the command and return one or many tuples
-      #
-      # @api public
-      def call(*args)
-        tuples = execute(*args)
-
-        if result == :one
-          tuples.first
-        else
-          tuples
-        end
-      end
-
-      # Target relation on which the command will operate
-      #
-      # By default this is set to the relation that's passed to the constructor.
-      # Specialized commands like Delete may set the target to a different
-      # relation.
-      #
-      # @return [Relation]
-      #
-      # @api public
-      def target
-        relation
-      end
-
-      # Assert that tuple count in the target relation corresponds to :result
-      # setting
-      #
-      # @raises TupleCountMismatchError
-      #
-      # @api private
-      def assert_tuple_count
-        if result == :one && target.size > 1
-          raise TupleCountMismatchError, "#{inspect} expects one tuple"
-        end
-      end
-    end
-  end
-end
+require 'rom/support/options'
 
 require 'rom/commands/create'
 require 'rom/commands/update'

data/lib/rom/commands/abstract.rb

@@ -0,0 +1,147 @@
+require 'rom/commands/composite'
+
+module ROM
+  module Commands
+    # Abstract command class
+    #
+    # Provides a constructor accepting relation with options and basic behavior
+    # for calling, currying and composing commands.
+    #
+    # Typically command subclasses should inherit from specialized
+    # Create/Update/Delete, not this one.
+    #
+    # @abstract
+    #
+    # @private
+    class Abstract
+      include Options
+
+      option :type, allow: [:create, :update, :delete]
+      option :result, reader: true, allow: [:one, :many]
+      option :target
+      option :validator, reader: true
+      option :input, reader: true
+      option :curry_args, type: Array, reader: true, default: []
+
+      attr_reader :relation
+
+      # @api private
+      def initialize(relation, options = {})
+        @relation = relation
+        super
+      end
+
+      # Execute the command
+      #
+      # @abstract
+      #
+      # @return [Array] an array with inserted tuples
+      #
+      # @api private
+      def execute(*)
+        raise(
+          NotImplementedError,
+          "#{self.class}##{__method__} must be implemented"
+        )
+      end
+
+      # Call the command and return one or many tuples
+      #
+      # @api public
+      def call(*args)
+        tuples = execute(*(args + curry_args))
+
+        if result == :one
+          tuples.first
+        else
+          tuples
+        end
+      end
+
+      # Curry this command with provided args
+      #
+      # Curried command can be called without args
+      #
+      # @return [Command]
+      #
+      # @api public
+      def curry(*args)
+        self.class.new(relation, options.merge(curry_args: args))
+      end
+      alias_method :with, :curry
+
+      # Compose a command with another one
+      #
+      # The other one will be called with the result from the first one
+      #
+      # @example
+      #
+      #   command = users.create.curry(name: 'Jane')
+      #   command >>= tasks.create.curry(title: 'Task One')
+      #
+      #   command.call # creates user, passes it to tasks and creates task
+      #
+      # @return [Composite]
+      #
+      # @api public
+      def >>(other)
+        Composite.new(self, other)
+      end
+
+      # Return new update command with new relation
+      #
+      # @api private
+      def new(*args, &block)
+        self.class.build(relation.public_send(*args, &block), options)
+      end
+
+      # Target relation on which the command will operate
+      #
+      # By default this is set to the relation that's passed to the constructor.
+      # Specialized commands like Delete may set the target to a different
+      # relation.
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def target
+        relation
+      end
+
+      # Assert that tuple count in the target relation corresponds to :result
+      # setting
+      #
+      # @raise TupleCountMismatchError
+      #
+      # @api private
+      def assert_tuple_count
+        if result == :one && tuple_count > 1
+          raise TupleCountMismatchError, "#{inspect} expects one tuple"
+        end
+      end
+
+      # Return number of tuples in the target relation
+      #
+      # This should be overridden by repositories when `#count` is not available
+      # in the relation objects
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      def tuple_count
+        target.count
+      end
+
+      private
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if relation.respond_to?(name)
+          new(name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/composite.rb

@@ -0,0 +1,47 @@
+module ROM
+  module Commands
+    # Composite command that consists of left and right commands
+    #
+    # @api public
+    class Composite
+      include Equalizer.new(:left, :right)
+
+      # @return [Proc,Command] left command
+      #
+      # @api private
+      attr_reader :left
+
+      # @return [Proc,Command] right command
+      #
+      # @api private
+      attr_reader :right
+
+      # @api private
+      def initialize(left, right)
+        @left, @right = left, right
+      end
+
+      # Calls the composite command
+      #
+      # Right command is called with a result from the left one
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(*args)
+        right.call(left.call(*args))
+      end
+
+      # Compose another composite command from self and other
+      #
+      # @param [Proc, Command] other command
+      #
+      # @return [Composite]
+      #
+      # @api public
+      def >>(other)
+        self.class.new(self, other)
+      end
+    end
+  end
+end

data/lib/rom/commands/create.rb

@@ -1,4 +1,4 @@
-require 'rom/commands/with_options'
+require 'rom/command'
 
 module ROM
   module Commands
@@ -7,22 +7,7 @@ module ROM
     # This command inserts a new tuple into a relation
     #
     # @abstract
-    class Create < AbstractCommand
-      include WithOptions
-
-      # Execute the command
-      #
-      # @abstract
-      #
-      # @return [Array] an array with inserted tuples
-      #
-      # @api private
-      def execute(_tuple)
-        raise(
-          NotImplementedError,
-          "#{self.class}##{__method__} must be implemented"
-        )
-      end
+    class Create < Command
     end
   end
 end