rom 0.3.1 → 0.4.0

data/lib/rom/adapter/memory/storage.rb

@@ -0,0 +1,25 @@
+module ROM
+  class Adapter
+    class Memory < Adapter
+
+      class Storage
+        attr_reader :data
+
+        def initialize(*)
+          super
+          @data = {}
+        end
+
+        def [](name)
+          data[name] ||= Dataset.new([])
+        end
+
+        def key?(name)
+          data.key?(name)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/boot.rb

@@ -1,6 +1,7 @@
 require 'rom/boot/dsl'
 require 'rom/relation_builder'
 require 'rom/reader_builder'
+require 'rom/command_registry'
 
 module ROM
 
@@ -18,6 +19,7 @@ module ROM
       @schema = {}
       @relations = {}
       @mappers = []
+      @commands = {}
       @adapter_relation_map = {}
       @env = nil
     end
@@ -77,6 +79,10 @@ module ROM
       self
     end
 
+    def commands(name, &block)
+      @commands.update(name => DSL.new(self).commands(&block))
+    end
+
     # Finalize the setup
     #
     # @return [Env] frozen env with access to repositories, schema, relations and mappers
@@ -88,8 +94,9 @@ module ROM
       schema = load_schema
       relations = load_relations(schema)
       readers = load_readers(relations)
+      commands = load_commands(relations)
 
-      @env = Env.new(repositories, schema, relations, readers)
+      @env = Env.new(repositories, schema, relations, readers, commands)
     end
 
     # @api private
@@ -162,6 +169,26 @@ module ROM
       ReaderRegistry.new(readers)
     end
 
+    def load_commands(relations)
+      return Registry.new unless relations.elements.any?
+
+      commands = @commands.each_with_object({}) do |(name, definitions), h|
+        adapter = adapter_relation_map[name]
+
+        rel_commands = {}
+
+        definitions.each do |command_name, definition|
+          rel_commands[command_name] = adapter.command(
+            command_name, relations[name], definition
+          )
+        end
+
+        h[name] = CommandRegistry.new(rel_commands)
+      end
+
+      Registry.new(commands)
+    end
+
   end
 
 end

data/lib/rom/boot/command_dsl.rb

@@ -0,0 +1,48 @@
+require 'rom/mapper_builder'
+
+module ROM
+
+  class CommandDSL
+    attr_reader :commands
+
+    class CommandDefinition
+      attr_reader :options
+
+      def initialize(options, &block)
+        @options = options
+        instance_exec(&block) if block
+      end
+
+      def to_h
+        options
+      end
+
+      def type
+        options[:type]
+      end
+
+      def method_missing(name, *args, &block)
+        if args.size == 1
+          options[name] = args.first
+        else
+          super
+        end
+      end
+    end
+
+    def initialize
+      @commands = {}
+    end
+
+    def call
+      commands
+    end
+
+    def define(name, options = {}, &block)
+      commands[name] = CommandDefinition.new(options, &block)
+      self
+    end
+
+  end
+
+end

data/lib/rom/boot/dsl.rb

@@ -1,5 +1,6 @@
 require 'rom/boot/schema_dsl'
 require 'rom/boot/mapper_dsl'
+require 'rom/boot/command_dsl'
 
 module ROM
   class Boot
@@ -24,6 +25,12 @@ module ROM
         dsl.call
       end
 
+      def commands(&block)
+        dsl = CommandDSL.new
+        dsl.instance_exec(&block)
+        dsl.call
+      end
+
     end
 
   end

data/lib/rom/command_registry.rb

@@ -0,0 +1,68 @@
+module ROM
+
+  class Result
+    attr_reader :value, :error
+
+    def to_ary
+      raise NotImplementedError
+    end
+    alias_method :to_a, :to_ary
+
+    class Success < Result
+      def initialize(value)
+        @value = value
+      end
+
+      def >(f)
+        f.call(value)
+      end
+
+      def to_ary
+        value
+      end
+      alias_method :to_a, :to_ary
+    end
+
+    class Failure < Result
+      def initialize(error)
+        @error = error
+      end
+
+      def >(f)
+        self
+      end
+
+      def to_ary
+        error
+      end
+    end
+  end
+
+  class CommandRegistry < Registry
+
+    class Evaluator
+      include Concord.new(:registry)
+
+      private
+
+      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
+
+    def try(&f)
+      Result::Success.new(Evaluator.new(self).instance_exec(&f))
+    rescue CommandError => e
+      Result::Failure.new(e)
+    end
+  end
+
+end

data/lib/rom/commands.rb

@@ -0,0 +1,64 @@
+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
+
+        if !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/commands/create'
+require 'rom/commands/update'
+require 'rom/commands/delete'

data/lib/rom/commands/create.rb

@@ -0,0 +1,28 @@
+require 'rom/commands/with_options'
+
+module ROM
+  module Commands
+
+    # Create command
+    #
+    # 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
+
+    end
+
+  end
+end

data/lib/rom/commands/delete.rb

@@ -0,0 +1,44 @@
+module ROM
+  module Commands
+
+    # Delete command
+    #
+    # This command removes tuples from its target relation
+    #
+    # @abstract
+    class Delete < AbstractCommand
+      attr_reader :target
+
+      def initialize(relation, options)
+        super
+        @target = options[:target] || relation
+      end
+
+      # @see AbstractCommand#call
+      def call(*args)
+        assert_tuple_count
+        super
+      end
+
+      # Execute the command
+      #
+      # @abstract
+      #
+      # @return [Array] an array with removed tuples
+      #
+      # @api private
+      def execute
+        raise NotImplementedError, "#{self.class}##{__method__} must be implemented"
+      end
+
+      # Return new delete command with new target
+      #
+      # @api private
+      def new(*args, &block)
+        self.class.new(relation, options.merge(target: relation.public_send(*args, &block)))
+      end
+
+    end
+
+  end
+end

data/lib/rom/commands/update.rb

@@ -0,0 +1,42 @@
+require 'rom/commands/with_options'
+
+module ROM
+  module Commands
+
+    # Update command
+    #
+    # This command updates all tuples in its relation with new attributes
+    #
+    # @abstract
+    class Update < AbstractCommand
+      include WithOptions
+
+      alias_method :set, :call
+
+      # @see AbstractCommand#call
+      def call(*args)
+        assert_tuple_count
+        super
+      end
+
+      # Execute the update command
+      #
+      # @return [Array] an array with updated tuples
+      #
+      # @abstract
+      #
+      # @api private
+      def execute(params)
+        raise NotImplementedError, "#{self.class}##{__method__} must be implemented"
+      end
+
+      # Return new update command with new relation
+      #
+      # @api private
+      def new(*args, &block)
+        self.class.new(relation.public_send(*args, &block), options)
+      end
+    end
+
+  end
+end

data/lib/rom/commands/with_options.rb

@@ -0,0 +1,21 @@
+module ROM
+  module Commands
+
+    # Common behavior for Create and Update commands
+    #
+    # TODO: find a better name for this module
+    module WithOptions
+      attr_reader :validator, :input
+
+      # @api private
+      def initialize(relation, options)
+        super
+
+        @validator = options[:validator] || Proc.new {}
+        @input = options[:input] || Hash
+      end
+
+    end
+
+  end
+end

data/lib/rom/env.rb

@@ -5,16 +5,17 @@ module ROM
   # @api public
   class Env
     include Adamantium::Flat
-    include Equalizer.new(:repositories, :schema, :relations, :mappers)
+    include Equalizer.new(:repositories, :schema, :relations, :mappers, :commands)
 
-    attr_reader :repositories, :schema, :relations, :mappers
+    attr_reader :repositories, :schema, :relations, :mappers, :commands
 
     # @api private
-    def initialize(repositories, schema, relations, mappers)
+    def initialize(repositories, schema, relations, mappers, commands)
       @repositories = repositories
       @schema = schema
       @relations = relations
       @mappers = mappers
+      @commands = commands
     end
 
     # Returns a reader with access to defined mappers
@@ -28,6 +29,17 @@ module ROM
       mappers[name]
     end
 
+    # Returns commands registry for the given relation
+    #
+    # @example
+    #
+    #   rom.command(:users).create
+    #
+    # @api public
+    def command(name)
+      commands[name]
+    end
+
     # @api private
     def [](name)
       repositories.fetch(name)
@@ -35,14 +47,18 @@ module ROM
 
     # @api private
     def respond_to_missing?(name, include_private = false)
-      repositories.key?(name)
+      repositories.key?(name) || super
     end
 
     private
 
     # @api private
-    def method_missing(name, *args)
-      repositories.fetch(name)
+    def method_missing(name, *args, &block)
+      if repositories.key?(name)
+        repositories[name]
+      else
+        super
+      end
     end
   end