rom 0.7.1 → 0.8.0

data/lib/rom/setup.rb

@@ -1,16 +1,23 @@
 require 'rom/setup/finalize'
+require 'rom/support/deprecations'
 
 module ROM
   # Exposes DSL for defining relations, mappers and commands
   #
   # @api public
   class Setup
-    include Equalizer.new(:repositories, :env)
+    extend Deprecations
+    include Equalizer.new(:gateways, :env)
 
-    # @return [Hash] configured repositories
+    # @return [Hash] configured gateways
     #
     # @api private
-    attr_reader :repositories
+    attr_reader :gateways
+
+    # Deprecated accessor for gateways.
+    #
+    # @see gateways
+    deprecate :repositories, :gateways
 
     # @return [Symbol] default (first) adapter
     #
@@ -38,8 +45,8 @@ module ROM
     attr_reader :env
 
     # @api private
-    def initialize(repositories, default_adapter = nil)
-      @repositories = repositories
+    def initialize(gateways, default_adapter = nil)
+      @gateways = gateways
       @default_adapter = default_adapter
       @relation_classes = []
       @mapper_classes = []
@@ -49,25 +56,25 @@ module ROM
 
     # Finalize the setup
     #
-    # @return [Env] frozen env with access to repositories, relations,
+    # @return [Env] frozen env with access to gateways, relations,
     #                mappers and commands
     #
     # @api public
     def finalize
       raise EnvAlreadyFinalizedError if env
       finalize = Finalize.new(
-        repositories, relation_classes, mapper_classes, command_classes
+        gateways, relation_classes, mapper_classes, command_classes
       )
       @env = finalize.run!
     end
 
-    # Return repository identified by name
+    # Return gateway identified by name
     #
-    # @return [Repository]
+    # @return [Gateway]
     #
     # @api private
     def [](name)
-      repositories.fetch(name)
+      gateways.fetch(name)
     end
 
     # Relation sub-classes are being registered with this method during setup
@@ -95,18 +102,18 @@ module ROM
     #
     # @api private
     def respond_to_missing?(name, _include_context = false)
-      repositories.key?(name)
+      gateways.key?(name)
     end
 
     private
 
-    # Returns repository if method is a name of a registered repository
+    # Returns gateway if method is a name of a registered gateway
     #
-    # @return [Repository]
+    # @return [Gateway]
     #
     # @api private
     def method_missing(name, *)
-      repositories.fetch(name) { super }
+      gateways.fetch(name) { super }
     end
   end
 end

data/lib/rom/setup/finalize.rb

@@ -16,13 +16,13 @@ module ROM
     #
     # @private
     class Finalize
-      attr_reader :repositories, :repo_adapter, :datasets,
+      attr_reader :gateways, :repo_adapter, :datasets,
         :relation_classes, :mapper_classes, :mappers, :command_classes
 
       # @api private
-      def initialize(repositories, relation_classes, mappers, command_classes)
-        @repositories = repositories
-        @repo_adapter_map = ROM.repositories
+      def initialize(gateways, relation_classes, mappers, command_classes)
+        @gateways = gateways
+        @repo_adapter_map = ROM.gateways
         @relation_classes = relation_classes
         @mapper_classes = mappers.select { |mapper| mapper.is_a?(Class) }
         @mappers = (mappers - @mapper_classes).reduce(:merge) || {}
@@ -30,13 +30,13 @@ module ROM
         initialize_datasets
       end
 
-      # Return adapter identifier for a given repository object
+      # Return adapter identifier for a given gateway object
       #
       # @return [Symbol]
       #
       # @api private
-      def adapter_for(repository)
-        @repo_adapter_map.fetch(repositories[repository])
+      def adapter_for(gateway)
+        @repo_adapter_map.fetch(gateways[gateway])
       end
 
       # Run the finalization process
@@ -53,21 +53,21 @@ module ROM
         mappers = load_mappers
         commands = load_commands(relations)
 
-        Env.new(repositories, relations, mappers, commands)
+        Env.new(gateways, relations, mappers, commands)
       end
 
       private
 
-      # Infer all datasets using configured repositories
+      # Infer all datasets using configured gateways
       #
-      # Not all repositories can do that, by default an empty array is returned
+      # Not all gateways can do that, by default an empty array is returned
       #
-      # @return [Hash] repository name => array with datasets map
+      # @return [Hash] gateway name => array with datasets map
       #
       # @api private
       def initialize_datasets
-        @datasets = repositories.each_with_object({}) do |(key, repository), h|
-          h[key] = repository.schema
+        @datasets = gateways.each_with_object({}) do |(key, gateway), h|
+          h[key] = gateway.schema
         end
       end
 
@@ -77,7 +77,7 @@ module ROM
       #
       # @api private
       def load_relations
-        relations = Relation.registry(repositories, relation_classes)
+        relations = Relation.registry(gateways, relation_classes)
         RelationRegistry.new(relations)
       end
 
@@ -106,7 +106,7 @@ module ROM
       #
       # @api private
       def load_commands(relations)
-        registry = Command.registry(relations, repositories, command_classes)
+        registry = Command.registry(relations, gateways, command_classes)
 
         commands = registry.each_with_object({}) do |(name, rel_commands), h|
           h[name] = CommandRegistry.new(rel_commands)
@@ -115,17 +115,17 @@ module ROM
         Registry.new(commands)
       end
 
-      # For every dataset infered from repositories we infer a relation
+      # For every dataset infered from gateways we infer a relation
       #
       # Relations explicitly defined are being skipped
       #
       # @api private
       def infer_schema_relations
-        datasets.each do |repository, schema|
+        datasets.each do |gateway, schema|
           schema.each do |name|
             next if relation_classes.any? { |klass| klass.dataset == name }
-            klass = Relation.build_class(name, adapter: adapter_for(repository))
-            klass.repository(repository)
+            klass = Relation.build_class(name, adapter: adapter_for(gateway))
+            klass.gateway(gateway)
             klass.dataset(name)
           end
         end

data/lib/rom/setup_dsl/relation.rb

@@ -13,7 +13,16 @@ module ROM
       adapter = options.fetch(:adapter)
 
       ClassBuilder.new(name: class_name, parent: self[adapter]).call do |klass|
-        klass.repository(options.fetch(:repository) { :default })
+        klass.gateway(options.fetch(:gateway) {
+          if options.key?(:repository)
+          ROM::Deprecations.announce "The :repository key is", <<-MSG
+            Please use `gateway: :#{options.fetch(:repository)}` instead.
+          MSG
+            options.fetch(:repository)
+          else
+            :default
+          end
+        })
         klass.dataset(name)
       end
     end

data/lib/rom/support/deprecations.rb

@@ -4,15 +4,33 @@ module ROM
     def deprecate(old_name, new_name, msg = nil)
       class_eval do
         define_method(old_name) do |*args, &block|
-          warn <<-MSG.gsub(/^\s+/, '')
-            #{self.class}##{old_name} is deprecated and will be removed in 1.0.0.
+          ROM::Deprecations.announce "#{self.class}##{old_name} is", <<-MSG
             Please use #{self.class}##{new_name} instead.
             #{msg}
-            #{caller.detect { |l| !l.include?('lib/rom')}}
           MSG
           __send__(new_name, *args, &block)
         end
       end
     end
+
+    def deprecate_class_method(old_name, new_name, msg = nil)
+      class_eval do
+        define_singleton_method(old_name) do |*args, &block|
+          ROM::Deprecations.announce"#{self}.#{old_name} is", <<-MSG
+            Please use #{self}.#{new_name} instead.
+            #{msg}
+          MSG
+          __send__(new_name, *args, &block)
+        end
+      end
+    end
+
+    def self.announce(name, msg)
+      warn <<-MSG.gsub(/^\s+/, '')
+        #{name} deprecated and will be removed in 1.0.0.
+        #{msg}
+        #{caller.detect { |l| !l.include?('lib/rom')}}
+      MSG
+    end
   end
 end

data/lib/rom/support/enumerable_dataset.rb

@@ -3,7 +3,7 @@ require 'rom/support/data_proxy'
 module ROM
   # A helper module that adds data-proxy behavior to an enumerable object
   #
-  # This module is intended to be used by repositories
+  # This module is intended to be used by gateways
   #
   # Class that includes this module can define `row_proc` class method which
   # must return a proc-like object which will be used to process each element

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.7.1'.freeze
+  VERSION = '0.8.0'.freeze
 end

data/rom.gemspec

@@ -15,11 +15,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_runtime_dependency 'transproc', '~> 0.2', '>= 0.2.2'
+  gem.add_runtime_dependency 'transproc', '~> 0.2', '>= 0.2.4'
   gem.add_runtime_dependency 'equalizer', '~> 0.0', '>= 0.0.9'
 
   gem.add_development_dependency 'rake', '~> 10.3'
-  gem.add_development_dependency 'rspec-core', '~> 3.2'
-  gem.add_development_dependency 'rspec-mocks', '~> 3.2'
-  gem.add_development_dependency 'rspec-expectations', '~> 3.2'
+  gem.add_development_dependency 'rspec', '~> 3.3'
 end

data/spec/integration/commands/delete_spec.rb

@@ -24,6 +24,8 @@ describe 'Commands / Delete' do
       { name: 'Jane', email: 'jane@doe.org' },
       { name: 'Joe', email: 'joe@doe.org' }
     ])
+
+    expect(rom.relation(:users)).to match_array([])
   end
 
   it 'deletes tuples matching restriction' do
@@ -34,6 +36,10 @@ describe 'Commands / Delete' do
     result = users.try { users.delete.by_name('Joe').call }
 
     expect(result).to match_array([{ name: 'Joe', email: 'joe@doe.org' }])
+
+    expect(rom.relation(:users)).to match_array([
+      { name: 'Jane', email: 'jane@doe.org' },
+    ])
   end
 
   it 'returns untouched relation if there are no tuples to delete' do

data/spec/integration/commands/graph_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe 'Building up a command graph for nested input' do
+  let(:rom) { setup.finalize }
+  let(:setup) { ROM.setup(:memory) }
+
+  before do
+    setup.relation :users
+    setup.relation :tasks
+    setup.relation :books
+    setup.relation :tags
+
+    setup.commands(:users) do
+      define(:create) do
+        input Transproc(:accept_keys, [:name])
+        result :one
+      end
+    end
+
+    setup.commands(:books) do
+      define(:create) do
+        input Transproc(:accept_keys, [:title, :user])
+
+        def execute(tuples, user)
+          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
+        end
+      end
+    end
+
+    setup.commands(:tags) do
+      define(:create) do
+        input Transproc(:accept_keys, [:name, :task])
+
+        def execute(tuples, task)
+          super(tuples.map { |t| t.merge(task: task.fetch(:title)) })
+        end
+      end
+    end
+  end
+
+  it 'creates a command graph for nested input :one result as root' do
+    setup.commands(:tasks) do
+      define(:create) do
+        input Transproc(:accept_keys, [:title, :user])
+        result :one
+
+        def execute(tuple, user)
+          super(tuple.merge(user: user.fetch(:name)))
+        end
+      end
+    end
+
+    input = {
+      user: {
+        name: 'Jane',
+        task: {
+          title: 'Task One',
+          tags: [
+            { name: 'red' }, { name: 'green' }, { name: 'blue' }
+          ]
+        },
+        books: [
+          { title: 'Book One' },
+          { title: 'Book Two' }
+        ]
+      }
+    }
+
+    options = [
+      { user: :users }, [
+        :create, [
+          [{ task: :tasks }, [:create, [:tags, [:create]]]],
+          [:books, [:create]]
+        ]
+      ]
+    ]
+
+    command = rom.command(options)
+
+    command.call(input)
+
+    expect(rom.relation(:users)).to match_array([
+      { name: 'Jane' }
+    ])
+
+    expect(rom.relation(:tasks)).to match_array([
+      { title: 'Task One', user: 'Jane' }
+    ])
+
+    expect(rom.relation(:books)).to match_array([
+      { title: 'Book One', user: 'Jane' },
+      { title: 'Book Two', user: 'Jane' }
+    ])
+
+    expect(rom.relation(:tags)).to match_array([
+      { name: 'red', task: 'Task One' },
+      { name: 'green', task: 'Task One' },
+      { name: 'blue', task: 'Task One' }
+    ])
+  end
+
+  it 'creates a command graph for nested input with :many results as root' do
+    setup.commands(:tasks) do
+      define(:create) do
+        input Transproc(:accept_keys, [:title, :user])
+
+        def execute(tuples, user)
+          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
+        end
+      end
+    end
+
+    input = {
+      user: {
+        name: 'Jane',
+        tasks: [
+          {
+            title: 'Task One',
+            tags: [{ name: 'red' }, { name: 'green' }]
+          },
+          {
+            title: 'Task Two',
+            tags: [{ name: 'blue' }]
+          }
+        ]
+      }
+    }
+
+    options = [
+      { user: :users }, [
+        :create, [
+          [:tasks, [:create, [:tags, [:create]]]],
+        ]
+      ]
+    ]
+
+    command = rom.command(options)
+
+    command.call(input)
+
+    expect(rom.relation(:users)).to match_array([
+      { name: 'Jane' }
+    ])
+
+    expect(rom.relation(:tasks)).to match_array([
+      { title: 'Task One', user: 'Jane' },
+      { title: 'Task Two', user: 'Jane' }
+    ])
+
+    expect(rom.relation(:tags)).to match_array([
+      { name: 'red', task: 'Task One' },
+      { name: 'green', task: 'Task One' },
+      { name: 'blue', task: 'Task Two' }
+    ])
+  end
+
+  it 'works with auto-mapping' do
+    setup.mappers do
+      define(:users) do
+        register_as :entity
+        reject_keys true
+
+        model name: 'Test::User'
+
+        attribute :name
+
+        combine :tasks, on: { name: :user } do
+          model name: 'Test::Task'
+          attribute :title
+
+          combine :tags, on: { title: :task } do
+            model name: 'Test::Tag'
+            attribute :name
+          end
+        end
+      end
+    end
+
+    setup.commands(:tasks) do
+      define(:create) do
+        input Transproc(:accept_keys, [:title, :user])
+
+        def execute(tuples, user)
+          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
+        end
+      end
+    end
+
+    input = {
+      user: {
+        name: 'Jane',
+        tasks: [
+          {
+            title: 'Task One',
+            tags: [{ name: 'red' }, { name: 'green' }]
+          },
+          {
+            title: 'Task Two',
+            tags: [{ name: 'blue' }]
+          }
+        ]
+      }
+    }
+
+    options = [
+      { user: :users }, [
+        :create, [
+          [:tasks, [:create, [:tags, [:create]]]],
+        ]
+      ]
+    ]
+
+    command = rom.command(options).as(:entity)
+
+    result = command.call(input).one
+
+    expect(result).to be_instance_of(Test::User)
+    expect(result.tasks.first).to be_instance_of(Test::Task)
+    expect(result.tasks.first.tags.first).to be_instance_of(Test::Tag)
+  end
+
+  it 'raises a proper error when the input has invalid structure' do
+    input = { user: { name: 'Jane' } }
+
+    options = [
+      { user: :users }, [:create, [{ book: :books }, [:create]]]
+    ]
+
+    command = rom.command(options)
+
+    expect {
+      command.call(input)
+    }.to raise_error(ROM::CommandFailure, /book/)
+  end
+end