rom 0.5.0 → 0.6.0.beta1

data/spec/unit/rom/commands_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe 'Commands' do
+  include_context 'users and tasks'
+
+  let(:users) { rom.relations.users }
+
+  before do
+    setup.relation(:users) do
+      def by_id(id)
+        restrict(id: id)
+      end
+    end
+  end
+
+  describe '.build_class' do
+    it 'creates a command class constant' do
+      klass = ROM::Command.build_class(:create, :users, adapter: :memory) do
+        def super?
+          true
+        end
+      end
+
+      expect(klass.name).to eql('ROM::Memory::Commands::Create[Users]')
+      expect(klass.register_as).to eql(:create)
+
+      command = klass.build(rom.relations.users)
+
+      expect(command).to be_a(ROM::Memory::Commands::Create)
+      expect(command).to be_super
+    end
+  end
+
+  describe '.build' do
+    it 'returns create command when type is set to :create' do
+      klass = Class.new(ROM::Commands::Create[:memory]) do
+        relation :users
+      end
+
+      command = klass.build(users)
+
+      expect(command).to be_kind_of(ROM::Memory::Commands::Create)
+    end
+
+    it 'returns update command when type is set to :update' do
+      klass = Class.new(ROM::Commands::Update[:memory]) do
+        relation :users
+      end
+
+      command = klass.build(users)
+
+      expect(command).to be_kind_of(ROM::Memory::Commands::Update)
+    end
+
+    it 'returns delete command when type is set to :delete' do
+      klass = Class.new(ROM::Commands::Delete[:memory]) do
+        relation :users
+      end
+
+      command = klass.build(users)
+
+      expect(command).to be_kind_of(ROM::Memory::Commands::Delete)
+    end
+
+    describe 'extending command with a db-specific behavior' do
+      before do
+        setup.repositories[:default].instance_exec do
+          def extend_command_class(klass, _)
+            klass.class_eval do
+              def super_command?
+                true
+              end
+            end
+            klass
+          end
+        end
+      end
+
+      it 'applies to defined classes' do
+        klass = Class.new(ROM::Commands::Create[:memory]) { relation :users }
+        command = klass.build(users)
+        expect(command).to be_super_command
+      end
+
+      it 'applies to generated classes' do
+        klass = ROM::Command.build_class(:create, :users, adapter: :memory)
+        command = klass.build(users)
+        expect(command).to be_super_command
+      end
+    end
+  end
+
+  describe '.registry' do
+    it 'builds a hash with commands grouped by relations' do
+      commands = {}
+
+      [:Create, :Update, :Delete].each do |command_type|
+        klass = Class.new(ROM::Commands.const_get(command_type)) do
+          relation :users
+        end
+        klass.class_eval "def self.name; 'Test::#{command_type}'; end"
+        commands[command_type] = klass
+      end
+
+      registry = ROM::Command.registry(
+        rom.relations, setup.repositories, commands.values
+      )
+
+      expect(registry).to eql(
+        users: {
+          create: commands[:Create].build(users),
+          update: commands[:Update].build(users),
+          delete: commands[:Delete].build(users)
+        }
+      )
+    end
+  end
+
+  describe '#>>' do
+    let(:users) { double('users') }
+    let(:tasks) { double('tasks') }
+    let(:logs) { [] }
+
+    it 'composes two commands' do
+      user_input = { name: 'Jane' }
+      user_tuple = { user_id: 1, name: 'Jane' }
+
+      task_input = { title: 'Task One' }
+      task_tuple = { user_id: 1, title: 'Task One' }
+
+      create_user = Class.new(ROM::Commands::Create) {
+        def execute(user_input)
+          relation.insert(user_input)
+        end
+      }.build(users)
+
+      create_task = Class.new(ROM::Commands::Create) {
+        def execute(user_tuple, task_input)
+          relation.insert(task_input.merge(user_id: user_tuple[:user_id]))
+        end
+      }.build(tasks)
+
+      create_log = Class.new(ROM::Commands::Create) {
+        result :one
+
+        def execute(task_tuple)
+          relation << task_tuple
+        end
+      }.build(logs)
+
+      command = create_user.curry(user_input)
+      command >>= create_task.curry(task_input)
+      command >>= create_log
+
+      expect(users).to receive(:insert).with(user_input).and_return(user_tuple)
+      expect(tasks).to receive(:insert).with(task_tuple).and_return(task_tuple)
+
+      result = command.call
+
+      expect(result).to eql(task_tuple)
+      expect(logs).to include(task_tuple)
+    end
+  end
+
+  describe 'access to exposed relations' do
+    it 'exposes relation' do
+      command = ROM::Commands::Update[:memory].build(users)
+
+      users.insert(id: 1, name: 'Jane')
+
+      expect(command.by_id(1).relation).to eql(users.by_id(1))
+    end
+  end
+end

data/spec/unit/rom/env_spec.rb

@@ -3,17 +3,50 @@ require 'spec_helper'
 describe ROM::Env do
   include_context 'users and tasks'
 
-  before { setup.relation(:users) }
+  before do
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name).project(:name)
+      end
+    end
 
-  it 'exposes repositories on method-missing' do
-    expect(rom.memory).to be(rom.repositories[:memory])
+    setup.relation(:tasks)
+
+    setup.mappers do
+      define(:users) do
+        attribute :name
+        attribute :email
+      end
+
+      define(:name_list, parent: :users) do
+        attribute :name
+        exclude :email
+      end
+    end
   end
 
-  it 'responds to methods corresponding to repository names' do
-    expect(rom).to respond_to(:memory)
+  describe '#relation' do
+    it 'yields selected relation to the block and returns a loaded relation' do
+      result = rom.relation(:users) { |r| r.by_name('Jane') }.as(:name_list)
+
+      expect(result.call).to match_array([{ name: 'Jane' }])
+    end
+
+    it 'returns lazy-mapped relation' do
+      by_name = rom.relation(:users).as(:name_list).by_name
+
+      expect(by_name['Jane']).to match_array([{ name: 'Jane' }])
+    end
+
+    it 'returns lazy relation without mappers when mappers are not defined' do
+      expect(rom.relation(:tasks)).to be_instance_of(ROM::Relation::Lazy)
+      expect(rom.relation(:tasks).relation).to be(rom.relations.tasks)
+    end
   end
 
-  it 'raises exception when unknown repository is referenced' do
-    expect { rom.not_here }.to raise_error(NoMethodError)
+  describe '#mappers' do
+    it 'returns mappers for all relations' do
+      expect(rom.mappers.users).to eql(rom.readers.users.mappers)
+    end
   end
 end

data/spec/unit/rom/global_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ROM do
+  describe '.setup' do
+    it 'allows passing in repository instances' do
+      klass = Class.new(ROM::Repository)
+      repo = klass.new
+
+      setup = ROM.setup(test: repo)
+
+      expect(setup.repositories[:test]).to be(repo)
+    end
+  end
+end

data/spec/unit/rom/{mapper_builder_spec.rb → mapper/dsl_spec.rb}

@@ -1,12 +1,16 @@
 require 'spec_helper'
 
-describe ROM::MapperBuilder do
-  subject(:builder) { ROM::MapperBuilder.new(:users, relation, options) }
+describe ROM::Mapper do
+  subject(:mapper) do
+    klass = Class.new(parent)
+    options.each { |k, v| klass.send(k, v) }
+    klass
+  end
+
+  let(:parent) { Class.new(ROM::Mapper) }
 
   let(:options) { {} }
-  let(:relation) { double('relation', header: []) }
   let(:header) { mapper.header }
-  let(:mapper) { builder.call }
 
   let(:expected_header) { ROM::Header.coerce(attributes) }
 
@@ -15,7 +19,7 @@ describe ROM::MapperBuilder do
       let(:attributes) { [[:name]] }
 
       it 'adds an attribute for the header' do
-        builder.attribute :name
+        mapper.attribute :name
 
         expect(header).to eql(expected_header)
       end
@@ -25,7 +29,7 @@ describe ROM::MapperBuilder do
       let(:attributes) { [[:name, from: :user_name]] }
 
       it 'adds an aliased attribute for the header' do
-        builder.attribute :name, from: :user_name
+        mapper.attribute :name, from: :user_name
 
         expect(header).to eql(expected_header)
       end
@@ -36,7 +40,18 @@ describe ROM::MapperBuilder do
       let(:options) { { prefix: :user } }
 
       it 'adds an aliased attribute for the header using configured :prefix' do
-        builder.attribute :name
+        mapper.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'prefixed attribute using custom separator' do
+      let(:attributes) { [[:name, from: :'u.name']] }
+      let(:options) { { prefix: :u, prefix_separator: '.' } }
+
+      it 'adds an aliased attribute for the header using configured :prefix' do
+        mapper.attribute :name
 
         expect(header).to eql(expected_header)
       end
@@ -47,21 +62,21 @@ describe ROM::MapperBuilder do
       let(:options) { { symbolize_keys: true } }
 
       it 'adds an attribute with symbolized alias' do
-        builder.attribute :name
+        mapper.attribute :name
 
         expect(header).to eql(expected_header)
       end
     end
   end
 
-  describe 'overriding inherited attributes from the relation header' do
+  describe 'overriding inherited attributes' do
     context 'when name matches' do
       let(:attributes) { [[:name, type: :string]] }
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return([:name])
+        parent.attribute :name
 
-        builder.attribute :name, type: :string
+        mapper.attribute :name, type: :string
 
         expect(header).to eql(expected_header)
       end
@@ -71,9 +86,9 @@ describe ROM::MapperBuilder do
       let(:attributes) { [[:name, from: 'name', type: :string]] }
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return(['name'])
+        parent.attribute 'name'
 
-        builder.attribute :name, from: 'name', type: :string
+        mapper.attribute :name, from: 'name', type: :string
 
         expect(header).to eql(expected_header)
       end
@@ -87,9 +102,9 @@ describe ROM::MapperBuilder do
       end
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return([:city_name])
+        parent.attribute :city_name
 
-        builder.wrap :city do
+        mapper.wrap :city do
           attribute :name, from: :city_name
         end
 
@@ -105,9 +120,9 @@ describe ROM::MapperBuilder do
       end
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return([:tag_name])
+        parent.attribute :tag_name
 
-        builder.group :tags do
+        mapper.group :tags do
           attribute :name, from: :tag_name
         end
 
@@ -123,9 +138,9 @@ describe ROM::MapperBuilder do
       end
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return([:city])
+        parent.attribute :city
 
-        builder.embedded :city, type: :hash do
+        mapper.embedded :city, type: :hash do
           attribute :name, from: :city_name
         end
 
@@ -141,9 +156,9 @@ describe ROM::MapperBuilder do
       end
 
       it 'excludes the inherited attribute' do
-        allow(relation).to receive(:header).and_return([:tags])
+        parent.attribute :tags
 
-        builder.embedded :tags, type: :array do
+        mapper.embedded :tags, type: :array do
           attribute :name, from: :tag_name
         end
 
@@ -156,8 +171,7 @@ describe ROM::MapperBuilder do
     let(:attributes) { [[:name, from: 'name']] }
 
     it 'removes an attribute from the inherited header' do
-      allow(relation).to receive(:header).and_return(['name'])
-      builder.attribute :name, from: 'name'
+      mapper.attribute :name, from: 'name'
       expect(header).to eql(expected_header)
     end
   end
@@ -167,7 +181,7 @@ describe ROM::MapperBuilder do
       let(:attributes) { [[:city, type: :hash, header: [[:name]]]] }
 
       it 'adds an embedded hash attribute' do
-        builder.embedded :city, type: :hash do
+        mapper.embedded :city, type: :hash do
           attribute :name
         end
 
@@ -179,7 +193,7 @@ describe ROM::MapperBuilder do
       let(:attributes) { [[:tags, type: :array, header: [[:name]]]] }
 
       it 'adds an embedded array attribute' do
-        builder.embedded :tags, type: :array do
+        mapper.embedded :tags, type: :array do
           attribute :name
         end
 
@@ -192,7 +206,7 @@ describe ROM::MapperBuilder do
     let(:attributes) { [[:city, type: :hash,  wrap: true, header: [[:name]]]] }
 
     it 'adds an wrapped hash attribute using a block to define attributes' do
-      builder.wrap :city do
+      mapper.wrap :city do
         attribute :name
       end
 
@@ -200,7 +214,7 @@ describe ROM::MapperBuilder do
     end
 
     it 'adds an wrapped hash attribute using a options define attributes' do
-      builder.wrap city: [:name]
+      mapper.wrap city: [:name]
 
       expect(header).to eql(expected_header)
     end
@@ -210,7 +224,7 @@ describe ROM::MapperBuilder do
     let(:attributes) { [[:tags, type: :array, group: true, header: [[:name]]]] }
 
     it 'adds a group attribute using a block to define attributes' do
-      builder.group :tags do
+      mapper.group :tags do
         attribute :name
       end
 
@@ -218,7 +232,7 @@ describe ROM::MapperBuilder do
     end
 
     it 'adds a group attribute using a options define attributes' do
-      builder.group tags: [:name]
+      mapper.group tags: [:name]
 
       expect(header).to eql(expected_header)
     end
@@ -246,17 +260,17 @@ describe ROM::MapperBuilder do
       end
 
       it 'sets aliased attributes using prefix automatically' do
-        builder.attribute :name
+        mapper.attribute :name
 
-        builder.embedded :address, type: :hash do
+        mapper.embedded :address, type: :hash do
           attribute :city
         end
 
-        builder.wrap :contact do
+        mapper.wrap :contact do
           attribute :mobile
         end
 
-        builder.group :tasks do
+        mapper.group :tasks do
           attribute :title
         end
 
@@ -284,23 +298,23 @@ describe ROM::MapperBuilder do
       end
 
       it 'excludes from aliasing the ones which override it' do
-        builder.attribute :name
+        mapper.attribute :name
 
-        builder.embedded :birthday, type: :hash, prefix: :bd do
+        mapper.embedded :birthday, type: :hash, prefix: :bd do
           attribute :year
           attribute :month
           attribute :day
         end
 
-        builder.embedded :address, type: :hash, prefix: false do
+        mapper.embedded :address, type: :hash, prefix: false do
           attribute :city
         end
 
-        builder.wrap :contact, prefix: :contact do
+        mapper.wrap :contact, prefix: :contact do
           attribute :mobile
         end
 
-        builder.group :tasks, prefix: :task do
+        mapper.group :tasks, prefix: :task do
           attribute :title
         end