rom 0.9.1 → 1.0.0.beta1

data/lib/rom/commands/class_interface.rb

@@ -0,0 +1,115 @@
+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
+
+      # 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
+
+      # @api private
+      def relation_methods_mod(relation_class)
+        mod = Module.new
+
+        relation_class.view_methods.each do |meth|
+          mod.module_eval <<-RUBY
+          def #{meth}(*args)
+            response = relation.public_send(:#{meth}, *args)
+
+            if response.is_a?(relation.class)
+              new(response)
+            else
+              response
+            end
+          end
+          RUBY
+        end
+
+        mod
+      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
+    end
+  end
+end

data/lib/rom/commands/graph.rb

@@ -8,6 +8,8 @@ module ROM
     #
     # @api private
     class Graph
+      include Dry::Equalizer(:root, :nodes)
+
       extend ClassInterface
 
       include Options
@@ -50,35 +52,27 @@ module ROM
       #
       # @api public
       def call(*args)
-        begin
-          left = root.call(*args)
-
-          right = nodes.map do |node|
-            begin
-              response =
-                if node.lazy?
-                  node.call(args.first, left)
-                else
-                  node.call(left)
-                end
-            rescue => err
-              raise CommandFailure.new(node, err)
-            end
+        left = root.call(*args)
 
-            if node.one? && !node.graph?
-              [response]
+        right = nodes.map { |node|
+          response =
+            if node.lazy?
+              node.call(args.first, left)
             else
-              response
+              node.call(left)
             end
-          end
 
-          if one?
-            [[left], right]
+          if node.one? && !node.graph?
+            [response]
           else
-            [left, right]
+            response
           end
-        rescue => err
-          raise CommandFailure.new(root, err)
+        }
+
+        if one?
+          [[left], right]
+        else
+          [left, right]
         end
       end
 

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

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

@@ -24,7 +24,7 @@ module ROM
 
         # @api private
         def build_command(registry, spec, other, path)
-          name, nodes = other
+          cmd_opts, nodes = other
 
           key, relation =
             if spec.is_a?(Hash)
@@ -33,12 +33,18 @@ module ROM
               [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)
+          command = command.with(input_proc, opts)
 
           if nodes
             if nodes.all? { |node| node.is_a?(Array) }

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

@@ -2,6 +2,8 @@ module ROM
   module Commands
     class Graph
       class InputEvaluator
+        include Dry::Equalizer(:tuple_path, :excluded_keys)
+
         attr_reader :tuple_path
 
         attr_reader :excluded_keys
@@ -35,21 +37,23 @@ module ROM
         def call(*args)
           input, index = args
 
-          begin
-            value =
+          value =
+            begin
               if index
                 tuple_path[0..tuple_path.size-2]
-                  .reduce(input) { |a,e| a.fetch(e) }
+                  .reduce(input) { |a, e| a.fetch(e) }
                   .at(index)[tuple_path.last]
               else
-                tuple_path.reduce(input) { |a,e| a.fetch(e) }
+                tuple_path.reduce(input) { |a, e| a.fetch(e) }
               end
-
-            if excluded_keys
-              value.is_a?(Array) ? value.map(&exclude_proc) : exclude_proc[value]
-            else
-              value
+            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

data/lib/rom/commands/lazy.rb

@@ -7,16 +7,32 @@ module ROM
     #
     # @api private
     class Lazy
+      include Dry::Equalizer(:command, :evaluator)
+
       # @attr_reader [Command] command The wrapped command
       attr_reader :command
 
       # @attr_reader [Proc] evaluator The proc that will evaluate the input
       attr_reader :evaluator
 
+      attr_reader :command_proc
+
       # @api private
-      def initialize(command, evaluator)
+      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
@@ -25,21 +41,7 @@ module ROM
       #
       # @api public
       def call(*args)
-        first = args.first
-        last = args.last
-        size = args.size
-
-        if size > 1 && last.is_a?(Array)
-          last.map.with_index do |item, index|
-            input = evaluator.call(first, index)
-            command.call(input, item)
-          end.reduce(:concat)
-        else
-          input = evaluator.call(first)
-          command.call(input, *args[1..size-1])
-        end
-      rescue => err
-        raise CommandFailure.new(command, err)
+        raise NotImplementedError
       end
 
       # Compose a lazy command with another one
@@ -78,7 +80,7 @@ module ROM
           response = command.public_send(name, *args, &block)
 
           if response.instance_of?(command.class)
-            self.class.new(response, evaluator)
+            self.class.new(response, evaluator, command_proc)
           else
             response
           end
@@ -89,3 +91,7 @@ module ROM
     end
   end
 end
+
+require 'rom/commands/lazy/create'
+require 'rom/commands/lazy/update'
+require 'rom/commands/lazy/delete'