rom 0.4.2 → 0.5.0

data/lib/rom/transformer.rb

@@ -1,77 +0,0 @@
-module ROM
-
-  class Transformer
-    attr_reader :operations
-
-    class Operation
-      attr_reader :attribute, :key, :names
-
-      def initialize(attribute)
-        @attribute = attribute
-        @key = attribute.key
-        @names = attribute.header.map(&:key)
-      end
-    end
-
-    class Wrap < Operation
-      def call(tuples)
-        keys = nil
-
-        tuples.map { |tuple|
-          keys ||= tuple.keys - names
-
-          root = Hash[keys.zip(tuple.values_at(*keys))]
-          child = Hash[names.zip(tuple.values_at(*names))]
-
-          root.merge(key => child)
-        }
-      end
-    end
-
-    class Group < Operation
-      def call(tuples)
-        keys = nil
-
-        tuples.
-          group_by { |tuple|
-            keys ||= tuple.keys - names
-            Hash[keys.zip(tuple.values_at(*keys))]
-          }.map { |root, children|
-            root.merge(
-             key => children.map { |child| Hash[names.zip(child.values_at(*names))] }
-            )
-          }
-      end
-    end
-
-    def self.build(header)
-      operations = header.map do |attribute|
-        type = attribute.type
-
-        if type == Hash
-          Wrap.new(attribute)
-        elsif type == Array
-          Group.new(attribute)
-        end
-      end.compact
-
-      sorted_ops =
-        operations.select { |op| Group === op } +
-        operations.select { |op| Wrap === op }
-
-      new(sorted_ops.flatten)
-    end
-
-    def initialize(operations)
-      @operations = operations
-    end
-
-    def call(input)
-      output = input
-      operations.each { |op| output = op.call(output) }
-      output
-    end
-
-  end
-
-end

data/spec/integration/ra/group_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe 'Group operation' do
-  include_context 'users and tasks'
-
-  specify 'defining a grouped relation' do
-    setup.relation(:users) do
-      include ROM::RA
-
-      def with_tasks
-        group(join(tasks), tasks: [:title, :priority])
-      end
-
-      def by_name(name)
-        restrict(name: name)
-      end
-
-    end
-
-    users = rom.relations.users
-
-    expect(users.with_tasks.to_a).to eql(
-      [
-        {
-          name: "Joe", email: "joe@doe.org", tasks: [
-            { title: "be nice", priority: 1 },
-            { title: "sleep well", priority: 2 }
-          ]
-        },
-        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
-      ]
-    )
-
-    expect(users.with_tasks.by_name("Jane").to_a).to eql(
-      [
-        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
-      ]
-    )
-
-    expect(users.by_name("Jane").with_tasks.to_a).to eql(
-      [
-        { name: "Jane", email: "jane@doe.org", tasks: [{ title: "be cool", priority: 2 }] }
-      ]
-    )
-  end
-end

data/spec/integration/ra/join_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe 'Join operation' do
-  include_context 'users and tasks'
-
-  specify 'defining a joined one-to-many relation' do
-    setup.relation(:users) do
-      include ROM::RA
-
-      def with_tasks
-        join(tasks)
-      end
-    end
-
-    setup.relation(:tasks)
-
-    users = rom.relations.users
-
-    expect(users.with_tasks.to_a).to eql(
-      [
-        { name: 'Joe', email: 'joe@doe.org', title: 'be nice', priority: 1 },
-        { name: 'Joe', email: 'joe@doe.org', title: 'sleep well', priority: 2 },
-        { name: 'Jane', email: 'jane@doe.org', title: 'be cool', priority: 2 }
-      ]
-    )
-  end
-
-  specify 'defining a joined many-to-one relation' do
-    setup.relation(:users)
-
-    setup.relation(:tasks) do
-      include ROM::RA
-
-      def with_user
-        join(users)
-      end
-    end
-
-    tasks = rom.relations.tasks
-
-    expect(tasks.with_user.to_a).to eql(
-      [
-        { title: 'be nice', priority: 1, name: 'Joe', email: 'joe@doe.org' },
-        { title: 'sleep well', priority: 2, name: 'Joe', email: 'joe@doe.org' },
-        { title: 'be cool', priority: 2, name: 'Jane', email: 'jane@doe.org' }
-      ]
-    )
-  end
-
-end

data/spec/integration/ra/wrap_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe 'Wrap operation' do
-  include_context 'users and tasks'
-
-  specify 'defining a wrapped relation' do
-    setup.relation(:users) do
-      include ROM::RA
-
-      def with_task
-        wrap(join(tasks), task: [:title, :priority])
-      end
-    end
-
-    users = rom.relations.users
-
-    expect(users.with_task.to_a).to eql(
-      [
-        {
-          name: "Joe",
-          email: "joe@doe.org",
-          task: { title: "be nice", priority: 1 }
-        },
-        {
-          name: "Joe",
-          email: "joe@doe.org",
-          task: { title: "sleep well", priority: 2 }
-        },
-        {
-          name: "Jane",
-          email: "jane@doe.org",
-          task: { title: "be cool", priority: 2 }
-        }
-      ]
-    )
-  end
-end

data/spec/unit/rom/ra/operation/group_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe 'Group operation' do
-  subject(:group) { relation.group(options) }
-
-  let(:relation) do
-    ROM::Relation.new(dataset, header).extend(ROM::RA)
-  end
-
-  let(:header) do
-    [:name, :email, :street, :zipcode, :city]
-  end
-
-  let(:options) do
-    { addresses: [:street, :zipcode, :city] }
-  end
-
-  context 'when group values are present' do
-    let(:dataset) do
-      [{ name: 'Jane',
-       email: 'jane@doe.org',
-       street: 'Street 1',
-       zipcode: '1234',
-       city: 'Cracow' }]
-    end
-
-    it 'groups given attributes under specified key' do
-      expect(group.to_a).to eql(
-        [{ name: 'Jane',
-           email: 'jane@doe.org',
-           addresses: [{ street: 'Street 1', zipcode: '1234', city: 'Cracow' }] }]
-      )
-    end
-
-    it 'exposes the header' do
-      expect(group.header).to eql([:name, :email, :addresses])
-    end
-  end
-
-  context 'when group values are not present' do
-    let(:dataset) do
-      [{ name: 'Jane',
-       email: 'jane@doe.org',
-       street: nil,
-       zipcode: nil,
-       city: nil }]
-    end
-
-    it 'sets empty array for grouped attributes' do
-      expect(group.to_a).to eql(
-        [{ name: 'Jane', email: 'jane@doe.org', addresses: [] }]
-      )
-    end
-  end
-end

data/spec/unit/rom/ra/operation/wrap_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe 'Wrap operation' do
-  subject(:wrap) { relation.wrap(address: [:street, :zipcode, :city]) }
-
-  let(:relation) do
-    ROM::Relation.new([{ name: 'Jane',
-       email: 'jane@doe.org',
-       street: 'Street 1',
-       zipcode: '1234',
-       city: 'Cracow' }], header).extend(ROM::RA)
-  end
-
-  let(:header) do
-    [:name, :email, :street, :zipcode, :city]
-  end
-
-  it 'wraps given attributes under specified key' do
-    expect(wrap.to_a).to eql(
-      [{ name: 'Jane',
-         email: 'jane@doe.org',
-         address: { street: 'Street 1', zipcode: '1234', city: 'Cracow' } }]
-    )
-  end
-
-  it 'exposes the header' do
-    expect(wrap.header).to eql([:name, :email, :address])
-  end
-end

data/spec/unit/rom/transformer_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Transformer do
-  subject(:transformer) { ROM::Transformer.build(header) }
-
-  let(:header) do
-    ROM::Header.coerce([
-      [:name],
-      [:address, type: Hash, header: [[:street], [:zipcode]]],
-      [:tasks, type: Array, header: [[:title], [:priority]]]
-    ])
-  end
-
-  let(:relation) do
-    [{ name: 'Jane',
-       street: 'Street 1',
-       zipcode: '123',
-       title: 'Sing a song',
-       priority: 'high' },
-     { name: 'Jane',
-       street: 'Street 1',
-       zipcode: '123',
-       title: 'Relax',
-       priority: 'very-high' }]
-  end
-
-  it 'transforms a tuple' do
-    expect(transformer.call(relation)).to eql([
-      name: 'Jane',
-      address: { street: 'Street 1', zipcode: '123' },
-      tasks: [
-        { title: 'Sing a song', priority: 'high' },
-        { title: 'Relax', priority: 'very-high' }
-      ]
-    ])
-  end
-
-  it 'skip transforming if tuple is empty' do
-    expect(transformer.call([])).to eql([])
-  end
-end