rom 0.4.2 → 0.5.0

data/spec/unit/rom/header_spec.rb

@@ -4,55 +4,99 @@ describe ROM::Header do
   describe '.coerce' do
     subject(:header) { ROM::Header.coerce(input) }
 
-
     context 'with a primitive type' do
-      let(:input) { [[:name, type: String]] }
+      let(:input) { [[:name, type: :string]] }
 
-      let(:expected) { ROM::Header.new(name: ROM::Header::Attribute.coerce(input.first)) }
+      let(:expected) do
+        ROM::Header.new(name: ROM::Header::Attribute.coerce(input.first))
+      end
 
       it 'returns a header with coerced attributes' do
         expect(header).to eql(expected)
 
-        expect(header[:name].type).to be(String)
+        expect(header[:name].type).to be(:string)
       end
     end
 
     context 'with a collection type' do
-      let(:input) { [[:tasks, header: [[:title]], type: Array, model: model]] }
+      let(:input) { [[:tasks, header: [[:title]], type: :array, model: model]] }
       let(:model) { Class.new }
 
-      let(:expected) { ROM::Header.new(tasks: ROM::Header::Attribute.coerce(input.first)) }
+      let(:expected) do
+        ROM::Header.new(tasks: ROM::Header::Attribute.coerce(input.first))
+      end
 
       it 'returns a header with coerced attributes' do
         expect(header).to eql(expected)
 
         tasks = header[:tasks]
 
-        expect(tasks.type).to be(Array)
-        expect(tasks.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]]))
+        expect(tasks.type).to be(:array)
+        expect(tasks.header.model).to be(model)
+        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model))
 
-        expect(input.first[1]).to eql(header: [[:title]], type: Array, model: model)
+        expect(input.first[1])
+          .to eql(header: [[:title]], type: :array, model: model)
       end
     end
 
     context 'with a hash type' do
-      let(:input) { [[:task, header: [[:title]], type: Hash, model: model]] }
+      let(:input) { [[:task, header: [[:title]], type: :hash, model: model]] }
       let(:model) { Class.new }
 
-      let(:expected) { ROM::Header.new(task: ROM::Header::Attribute.coerce(input.first)) }
+      let(:expected) do
+        ROM::Header.new(task: ROM::Header::Attribute.coerce(input.first))
+      end
 
       it 'returns a header with coerced attributes' do
         expect(header).to eql(expected)
 
         tasks = header[:task]
 
-        expect(tasks.type).to be(Hash)
-        expect(tasks.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]]))
+        expect(tasks.type).to be(:hash)
+        expect(tasks.header.model).to be(model)
+        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model))
 
-        expect(input.first[1]).to eql(header: [[:title]], type: Hash, model: model)
+        expect(input.first[1])
+          .to eql(header: [[:title]], type: :hash, model: model)
       end
     end
   end
+
+  describe '#mapping' do
+    it 'return mapping hash for primitive attributes' do
+      header = ROM::Header.coerce([[:title], [:name, from: :user_name]])
+
+      expect(header.mapping).to eql(title: :title, user_name: :name)
+    end
+
+    it 'returns an empty hash when there are no primitive attributes' do
+      header = ROM::Header.coerce([
+        [:city, type: :hash, wrap: true, header: [[:name]]]
+      ])
+
+      expect(header.mapping).to eql({})
+    end
+  end
+
+  describe '#tuple_keys' do
+    it 'return primitive attribute keys' do
+      header = ROM::Header.coerce([[:title], [:name, from: :user_name]])
+      expect(header.tuple_keys).to eql([:title, :user_name])
+    end
+
+    it 'return primitive attribute, wrap and group keys' do
+      header = ROM::Header.coerce([
+        [:title],
+        [:comments, type: :array, header: [[:author], [:text]]],
+        [:location, type: :hash, header: [[:lat], [:lng]]],
+        [:city, type: :hash, wrap: true, header: [[:name, from: :city_name]]],
+        [:tags, type: :array, group: true, header: [[:name, from: :tag_name]]]
+      ])
+
+      expect(header.tuple_keys).to match_array([
+        :title, :comments, :location, :city_name, :tag_name
+      ])
+    end
+  end
 end

data/spec/unit/rom/mapper_builder_spec.rb

@@ -0,0 +1,311 @@
+require 'spec_helper'
+
+describe ROM::MapperBuilder do
+  subject(:builder) { ROM::MapperBuilder.new(:users, relation, options) }
+
+  let(:options) { {} }
+  let(:relation) { double('relation', header: []) }
+  let(:header) { mapper.header }
+  let(:mapper) { builder.call }
+
+  let(:expected_header) { ROM::Header.coerce(attributes) }
+
+  describe '#attribute' do
+    context 'simple attribute' do
+      let(:attributes) { [[:name]] }
+
+      it 'adds an attribute for the header' do
+        builder.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'aliased attribute' do
+      let(:attributes) { [[:name, from: :user_name]] }
+
+      it 'adds an aliased attribute for the header' do
+        builder.attribute :name, from: :user_name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'prefixed attribute' do
+      let(:attributes) { [[:name, from: :user_name]] }
+      let(:options) { { prefix: :user } }
+
+      it 'adds an aliased attribute for the header using configured :prefix' do
+        builder.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'symbolized attribute' do
+      let(:attributes) { [[:name, from: 'name']] }
+      let(:options) { { symbolize_keys: true } }
+
+      it 'adds an attribute with symbolized alias' do
+        builder.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe 'overriding inherited attributes from the relation header' 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])
+
+        builder.attribute :name, type: :string
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when alias matches' do
+      let(:attributes) { [[:name, from: 'name', type: :string]] }
+
+      it 'excludes the inherited attribute' do
+        allow(relation).to receive(:header).and_return(['name'])
+
+        builder.attribute :name, from: 'name', type: :string
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a wrapped attribute matches' do
+      let(:attributes) do
+        [
+          [:city, type: :hash, wrap: true, header: [[:name, from: :city_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        allow(relation).to receive(:header).and_return([:city_name])
+
+        builder.wrap :city do
+          attribute :name, from: :city_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a grouped attribute matches' do
+      let(:attributes) do
+        [
+          [:tags, type: :array, group: true, header: [[:name, from: :tag_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        allow(relation).to receive(:header).and_return([:tag_name])
+
+        builder.group :tags do
+          attribute :name, from: :tag_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a hash attribute matches' do
+      let(:attributes) do
+        [
+          [:city, type: :hash, header: [[:name, from: :city_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        allow(relation).to receive(:header).and_return([:city])
+
+        builder.embedded :city, type: :hash do
+          attribute :name, from: :city_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name of an array attribute matches' do
+      let(:attributes) do
+        [
+          [:tags, type: :array, header: [[:name, from: :tag_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        allow(relation).to receive(:header).and_return([:tags])
+
+        builder.embedded :tags, type: :array do
+          attribute :name, from: :tag_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#exclude' 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'
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe '#embedded' do
+    context 'when :type is set to :hash' do
+      let(:attributes) { [[:city, type: :hash, header: [[:name]]]] }
+
+      it 'adds an embedded hash attribute' do
+        builder.embedded :city, type: :hash do
+          attribute :name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when :type is set to :array' do
+      let(:attributes) { [[:tags, type: :array, header: [[:name]]]] }
+
+      it 'adds an embedded array attribute' do
+        builder.embedded :tags, type: :array do
+          attribute :name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#wrap' 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
+        attribute :name
+      end
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'adds an wrapped hash attribute using a options define attributes' do
+      builder.wrap city: [:name]
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe '#group' 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
+        attribute :name
+      end
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'adds a group attribute using a options define attributes' do
+      builder.group tags: [:name]
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe 'top-level :prefix option' do
+    let(:options) do
+      { prefix: :user }
+    end
+
+    context 'when no attribute overrides top-level setting' do
+      let(:attributes) do
+        [
+          [:name, from: :user_name],
+          [:address, from: :user_address, type: :hash, header: [
+            [:city, from: :user_city]]
+          ],
+          [:contact, type: :hash, wrap: true, header: [
+            [:mobile, from: :user_mobile]]
+          ],
+          [:tasks, type: :array, group: true, header: [
+            [:title, from: :user_title]]
+          ]
+        ]
+      end
+
+      it 'sets aliased attributes using prefix automatically' do
+        builder.attribute :name
+
+        builder.embedded :address, type: :hash do
+          attribute :city
+        end
+
+        builder.wrap :contact do
+          attribute :mobile
+        end
+
+        builder.group :tasks do
+          attribute :title
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when an attribute overrides top-level setting' do
+      let(:attributes) do
+        [
+          [:name, from: :user_name],
+          [:birthday, from: :user_birthday, type: :hash, header: [
+            [:year, from: :bd_year],
+            [:month, from: :bd_month],
+            [:day, from: :bd_day]]
+          ],
+          [:address, from: :user_address, type: :hash, header: [[:city]]],
+          [:contact, type: :hash, wrap: true, header: [
+            [:mobile, from: :contact_mobile]]
+          ],
+          [:tasks, type: :array, group: true, header: [
+            [:title, from: :task_title]]
+          ]
+        ]
+      end
+
+      it 'excludes from aliasing the ones which override it' do
+        builder.attribute :name
+
+        builder.embedded :birthday, type: :hash, prefix: :bd do
+          attribute :year
+          attribute :month
+          attribute :day
+        end
+
+        builder.embedded :address, type: :hash, prefix: false do
+          attribute :city
+        end
+
+        builder.wrap :contact, prefix: :contact do
+          attribute :mobile
+        end
+
+        builder.group :tasks, prefix: :task do
+          attribute :title
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+end

data/spec/unit/rom/mapper_registry_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ROM::MapperRegistry do
+  subject(:registry) { ROM::MapperRegistry.new }
+
+  let(:user_mapper) { double('user_mapper') }
+  let(:index_mapper) { double('index_mapper') }
+
+  before do
+    registry[:users] = user_mapper
+    registry[:index] = index_mapper
+  end
+
+  describe '#by_path' do
+    it 'returns first matching mapper' do
+      mapper = registry.by_path('users')
+
+      expect(mapper).to be(user_mapper)
+
+      mapper = registry.by_path('users.index')
+
+      expect(mapper).to be(index_mapper)
+    end
+  end
+end