rom 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cedd21af22c9eed4d993f2550a24089b9f8cacb
-  data.tar.gz: 5275819a3330d267f7ffd5dc8d9cc8a8ea186a9b
+  metadata.gz: 85a6e3c77b6e9a8d724fdd73056c4bdde3730beb
+  data.tar.gz: 6f964fb1181920ab5222f66d3482cf9ebcddf810
 SHA512:
-  metadata.gz: c4d159975a7a1a8ed67c08f7f085e9f8fa57c1ac40c36ed71d20b6111d326b3ac8d18fe46d94f9e436e13fc73f099320c0eab1e50fb717c2c246459575261496
-  data.tar.gz: a77514fb8bbafeeaef756c069e182b77d147999aca85000bc7089ff4a9d557cd3a003704b1766645fefe0d80c49c41456f19a38eaebed6697b5f8c96da0b1632
+  metadata.gz: 31e1ff16669d9481ba1d516f27d9016054ef35c1ac2daa3dad5de8792ef9bd30813b7de01f48132726574f52edb7a1b2a374245602932683b02a473e1c577e93
+  data.tar.gz: 62698c8268af71829168e3c8b27edac7553cc7e03b7c6362b485585e9404e10bd9bb1438f68cf3be9f8122c7d8670ac280e4867345f9f5a1d8aa6759e5e2d265

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## v0.4.2 2014-12-19
+
+### Added
+
+* Mappers support tuple transformation using wrap and group operations (solnic)
+* PORO model builder supports namespaced constants via `name: 'MyApp:Entities::User` (solnic)
+
+### Changed
+
+* `ROM::RA` interface is no longer mixed into relations by default (solnic)
+* ~2.5 x speed up in aggregate mapping (solnic)
+* PORO model builder only defines attribute readers now (no writers!) (solnic)
+* Registry objects in Env will now raise `KeyError` when unknown name is referenced (solnic)
+
+[Compare v0.4.1...v0.4.2](https://github.com/rom-rb/rom/compare/v0.4.1...v0.4.2)
+
 ## v0.4.1 2014-12-15
 
 ### Added
@@ -5,6 +21,7 @@
 * Adapter can now implement `Adapter#dataset(name, header)` to return a dataset (solnic)
 * For multi-step setup the DSL is available in `ROM` too (solnic)
 * Global environment can be stored via `ROM.finalize` and accessible via `ROM.env` (solnic)
+* Mapper won't infer attributes from the header if `:inherit_header` option is set to false (solnic)
 
 ### Changed
 

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 group :console do
   gem 'pry'
-  gem 'pg'
+  gem 'pg', platforms: [:mri]
 end
 
 group :test do
@@ -31,6 +31,6 @@ group :sql do
 end
 
 group :benchmarks do
-  gem 'activerecord'
+  gem 'activerecord', '4.2.0.rc3'
   gem 'benchmark-ips'
 end

data/lib/rom.rb

@@ -7,6 +7,7 @@ require 'rom/support/registry'
 
 require 'rom/header'
 require 'rom/relation'
+require 'rom/transformer'
 require 'rom/mapper'
 require 'rom/reader'
 
@@ -16,6 +17,8 @@ require 'rom/adapter'
 require 'rom/repository'
 require 'rom/env'
 
+require 'rom/ra'
+
 require 'rom/boot'
 
 module ROM

data/lib/rom/boot/base_relation_dsl.rb

@@ -8,6 +8,7 @@ module ROM
         @env = env
         @name = name
         @header = []
+        @repository = nil
       end
 
       def repository(name = nil)

data/lib/rom/header.rb

@@ -24,7 +24,7 @@ module ROM
         end
 
         def mapping
-          [name, header.mapping]
+          header.mapping
         end
 
         def embedded?
@@ -107,7 +107,7 @@ module ROM
     end
 
     def mapping
-      Hash[map(&:mapping)]
+      Hash[select { |a| !a.embedded? }.map(&:mapping)]
     end
 
     def values

data/lib/rom/mapper.rb

@@ -2,7 +2,7 @@ module ROM
 
   # @api private
   class Mapper
-    attr_reader :header, :model, :loader
+    attr_reader :header, :model, :loader, :transformer
 
     class Basic < Mapper
       attr_reader :mapping
@@ -12,21 +12,36 @@ module ROM
         @mapping = header.mapping
       end
 
-      def load(tuple, mapping = self.mapping)
-        loader[Hash[call(tuple, mapping)]]
+      def load(tuple)
+        super(Hash[call(tuple)])
       end
 
-      def call(tuple, mapping = self.mapping)
-        tuple.map { |key, value| [mapping[key], value] }
+      def call(tuple)
+        tuple.map { |key, value| [header.mapping[key], value] }
       end
     end
 
     class Recursive < Basic
-      def call(tuple, mapping = self.mapping)
+      attr_reader :transformer
+
+      def initialize(*args)
+        super
+        @transformer = Transformer.build(header)
+      end
+
+      def process(relation)
+        transformer.call(relation.to_a).each { |tuple| yield(load(tuple)) }
+      end
+
+      def call(tuple, header = self.header)
+        mapping = header.mapping
+
         tuple.map do |key, value|
           case value
-          when Hash  then [key, Hash[call(value, mapping[key])]]
-          when Array then [key, value.map { |v| Hash[call(v, mapping[key])] }]
+          when Hash
+            [key, loader[Hash[call(value, header[key])], header[key].model]]
+          when Array
+            [key, value.map { |v| loader[Hash[call(v, header[key])], header[key].model] }]
           else
             [mapping[key], value]
           end
@@ -44,12 +59,7 @@ module ROM
           self
         end
 
-      loader =
-        if model
-          -> tuple { model.new(tuple) }
-        else
-          -> tuple { tuple }
-        end
+      loader = Proc.new { |tuple, m| m ? m.new(tuple) : tuple }
 
       klass.new(header, model, loader)
     end
@@ -60,8 +70,12 @@ module ROM
       @loader = loader
     end
 
+    def process(relation)
+      relation.each { |tuple| yield(load(tuple)) }
+    end
+
     def load(tuple)
-      loader[tuple]
+      loader[tuple, model]
     end
 
   end

data/lib/rom/mapper_builder.rb

@@ -6,7 +6,7 @@ module ROM
   class MapperBuilder
 
     class AttributeDSL
-      attr_reader :attributes
+      attr_reader :attributes, :model_class, :model_builder
 
       def initialize
         @attributes = []
@@ -16,6 +16,20 @@ module ROM
         Header.coerce(attributes)
       end
 
+      def model(options = nil)
+        if options.is_a?(Class)
+          @model_class = options
+        elsif options
+          @model_builder = ModelBuilder[options.fetch(:type) { :poro }].new(options)
+        end
+
+        if options
+          self
+        else
+          model_class || (model_builder && model_builder.call(header))
+        end
+      end
+
       def attribute(name, options = {})
         attributes << [name, options]
       end
@@ -78,7 +92,7 @@ module ROM
       if block
         dsl = AttributeDSL.new
         dsl.instance_exec(&block)
-        attributes << [options, header: dsl.header, type: type]
+        attributes << [options, header: dsl.header, type: type, model: dsl.model]
       else
         options.each do |name, header|
           attributes << [name, header: header.zip, type: type]

data/lib/rom/model_builder.rb

@@ -2,7 +2,7 @@ module ROM
 
   # @api private
   class ModelBuilder
-    attr_reader :options, :const_name, :klass
+    attr_reader :options, :const_name, :namespace, :klass
 
     def self.[](type)
       case type
@@ -16,18 +16,31 @@ module ROM
       new(*args).call
     end
 
-    def initialize(options)
+    def initialize(options = {})
       @options = options
-      @const_name = options[:name]
+
+      if options[:name]
+        split = options[:name].split('::')
+
+        @const_name = split.last
+
+        @namespace =
+          if split.size > 1
+            Inflecto.constantize((split-[const_name]).join('::'))
+          else
+            Object
+          end
+      end
     end
 
     def define_const
-      Object.const_set(const_name, klass)
+      namespace.const_set(const_name, klass)
     end
 
     def call(header)
       define_class(header)
       define_const if const_name
+      @klass
     end
 
     class PORO < ModelBuilder
@@ -37,15 +50,12 @@ module ROM
 
         attributes = header.keys
 
-        @klass.send(:attr_accessor, *attributes)
-
-        ivar_list = attributes.map { |name| "@#{name}" }.join(", ")
-        sym_list = attributes.map { |name| ":#{name}" }.join(", ")
+        @klass.send(:attr_reader, *attributes)
 
         @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def initialize(params)
-        #{ivar_list} = params.values_at(#{sym_list})
-            end
+          def initialize(params)
+            #{attributes.map { |name| "@#{name} = params[:#{name}]" }.join("\n")}
+          end
         RUBY
 
         self

data/lib/rom/ra.rb

@@ -9,186 +9,162 @@ module ROM
   # @api private
   module RA
 
-    # Exposes in-memory relational operations
+    # Join two relations in-memory using natural-join
     #
-    # See examples for join, group and wrap operations
+    # @example
+    #
+    #   require 'rom'
+    #   require 'rom/adapter/memory'
+    #
+    #   setup = ROM.setup(memory: 'memory://localhost')
+    #
+    #   setup.schema do
+    #     base_relation(:users) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :name
+    #     end
+    #
+    #     base_relation(:tasks) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :title
+    #     end
+    #   end
+    #
+    #   setup.relation(:tasks)
+    #
+    #   setup.relation(:users) do
+    #     def with_tasks
+    #       in_memory { join(tasks) }
+    #     end
+    #   end
+    #
+    #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+    #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
+    #
+    #   rom.relations.users.with_tasks.to_a
+    #   => [{:user_id=>1, :name=>"Piotr", :title=>"Relax"}]
     #
     # @api public
-    def in_memory(&block)
-      DSL.new(self).instance_exec(&block)
+    def join(*args)
+      left, right = args.size > 1 ? args : [self, args.first]
+      Operation::Join.new(left, right)
     end
 
-    class DSL
-      include Concord.new(:relation)
-
-      # Join two relations in-memory using natural-join
-      #
-      # @example
-      #
-      #   require 'rom'
-      #   require 'rom/adapter/memory'
-      #
-      #   setup = ROM.setup(memory: 'memory://localhost')
-      #
-      #   setup.schema do
-      #     base_relation(:users) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :name
-      #     end
-      #
-      #     base_relation(:tasks) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :title
-      #     end
-      #   end
-      #
-      #   setup.relation(:tasks)
-      #
-      #   setup.relation(:users) do
-      #     def with_tasks
-      #       in_memory { join(tasks) }
-      #     end
-      #   end
-      #
-      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
-      #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
-      #
-      #   rom.relations.users.with_tasks.to_a
-      #   => [{:user_id=>1, :name=>"Piotr", :title=>"Relax"}]
-      #
-      # @api public
-      def join(*args)
-        left, right = args.size > 1 ? args : [relation, args.first]
-        Operation::Join.new(left, right)
-      end
-
-      # Groups two relations in-memory using group operation
-      #
-      # @example
-      #
-      #   require 'rom'
-      #   require 'rom/adapter/memory'
-      #
-      #   setup = ROM.setup(memory: 'memory://localhost')
-      #
-      #   setup.schema do
-      #     base_relation(:users) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :name
-      #     end
-      #
-      #     base_relation(:tasks) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :title
-      #     end
-      #   end
-      #
-      #   setup.relation(:tasks)
-      #
-      #   setup.relation(:users) do
-      #     def with_tasks
-      #       in_memory { group(join(tasks), tasks: [:title]) }
-      #     end
-      #   end
-      #
-      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
-      #   rom.relations.tasks.insert user_id: 1, title: 'Work'
-      #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
-      #
-      #   rom.relations.users.with_tasks.to_a
-      #   => [{:user_id=>1, :name=>"Piotr", tasks: [{:title=>"Relax"}, {:title=>"Work"}]}]
-      #
-      # @api public
-      def group(*args)
-        with_options(*args) { |relation, options|
-          Operation::Group.new(relation, options)
-        }
-      end
-
-      # Embed one relation in another in-memory using wrap operation
-      #
-      # @example
-      #
-      #   require 'rom'
-      #   require 'rom/adapter/memory'
-      #
-      #   setup = ROM.setup(memory: 'memory://localhost')
-      #
-      #   setup.schema do
-      #     base_relation(:users) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :name
-      #     end
-      #
-      #     base_relation(:addresses) do
-      #       repository :memory
-      #
-      #       attribute :user_id
-      #       attribute :street
-      #       attribute :zipcode
-      #       attribute :city
-      #     end
-      #   end
-      #
-      #   setup.relation(:addresses)
-      #
-      #   setup.relation(:users) do
-      #     def with_address
-      #       in_memory { wrap(join(addresses), address: [:street, :zipcode, :city]) }
-      #     end
-      #   end
-      #
-      #   rom = setup.finalize
-      #
-      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
-      #   rom.relations.addresses.insert user_id: 1, street: 'Street 1', zipcode: '123', city: 'Kraków'
-      #
-      #   rom.relations.users.with_address.to_a
-      #   => [{:user_id=>1, :name=>"Piotr", :address=>{:street=>"Street 1", :zipcode=>"123", :city=>"Kraków"}}]
-      #
-      # @api public
-      def wrap(*args)
-        with_options(*args) { |relation, options|
-          Operation::Wrap.new(relation, options)
-        }
-      end
-
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        relation.respond_to?(name) || super
-      end
-
-      private
+    # Groups two relations in-memory using group operation
+    #
+    # @example
+    #
+    #   require 'rom'
+    #   require 'rom/adapter/memory'
+    #
+    #   setup = ROM.setup(memory: 'memory://localhost')
+    #
+    #   setup.schema do
+    #     base_relation(:users) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :name
+    #     end
+    #
+    #     base_relation(:tasks) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :title
+    #     end
+    #   end
+    #
+    #   setup.relation(:tasks)
+    #
+    #   setup.relation(:users) do
+    #     def with_tasks
+    #       in_memory { group(join(tasks), tasks: [:title]) }
+    #     end
+    #   end
+    #
+    #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+    #   rom.relations.tasks.insert user_id: 1, title: 'Work'
+    #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
+    #
+    #   rom.relations.users.with_tasks.to_a
+    #   => [{:user_id=>1, :name=>"Piotr", tasks: [{:title=>"Relax"}, {:title=>"Work"}]}]
+    #
+    # @api public
+    def group(*args)
+      ra_with_options(*args) { |relation, options|
+        Operation::Group.new(relation, options)
+      }
+    end
 
-      # @api private
-      def with_options(*args)
-        relation =
-          if args.size > 1
-            args.first
-          else
-            self.relation
-          end
+    # Embed one relation in another in-memory using wrap operation
+    #
+    # @example
+    #
+    #   require 'rom'
+    #   require 'rom/adapter/memory'
+    #
+    #   setup = ROM.setup(memory: 'memory://localhost')
+    #
+    #   setup.schema do
+    #     base_relation(:users) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :name
+    #     end
+    #
+    #     base_relation(:addresses) do
+    #       repository :memory
+    #
+    #       attribute :user_id
+    #       attribute :street
+    #       attribute :zipcode
+    #       attribute :city
+    #     end
+    #   end
+    #
+    #   setup.relation(:addresses)
+    #
+    #   setup.relation(:users) do
+    #     def with_address
+    #       in_memory { wrap(join(addresses), address: [:street, :zipcode, :city]) }
+    #     end
+    #   end
+    #
+    #   rom = setup.finalize
+    #
+    #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+    #   rom.relations.addresses.insert user_id: 1, street: 'Street 1', zipcode: '123', city: 'Kraków'
+    #
+    #   rom.relations.users.with_address.to_a
+    #   => [{:user_id=>1, :name=>"Piotr", :address=>{:street=>"Street 1", :zipcode=>"123", :city=>"Kraków"}}]
+    #
+    # @api public
+    def wrap(*args)
+      ra_with_options(*args) { |relation, options|
+        Operation::Wrap.new(relation, options)
+      }
+    end
 
-        options = args.last
+    private
 
-        yield(relation, options)
-      end
+    # @api private
+    def ra_with_options(*args)
+      relation =
+        if args.size > 1
+          args.first
+        else
+          self
+        end
 
-      # @api private
-      def method_missing(name, *args, &block)
-        relation.public_send(name, *args, &block)
-      end
+      options = args.last
 
+      yield(relation, options)
     end
 
   end

data/lib/rom/ra/operation/group.rb

@@ -20,9 +20,7 @@ module ROM
         def each(&block)
           return to_enum unless block
 
-          tuples = relation.to_a
-
-          result = tuples.each_with_object({}) do |tuple, grouped|
+          result = relation.each_with_object({}) do |tuple, grouped|
             left = tuple.reject { |k,_| attribute_names.include?(k) }
             right = tuple.reject { |k,_| !attribute_names.include?(k) }
 

data/lib/rom/reader.rb

@@ -36,7 +36,7 @@ module ROM
     #
     # @api public
     def each
-      relation.each { |tuple| yield(mapper.load(tuple)) }
+      mapper.process(relation) { |tuple| yield(tuple) }
     end
 
     # @api private

data/lib/rom/relation.rb

@@ -1,5 +1,3 @@
-require 'rom/ra'
-
 module ROM
 
   # Base relation class
@@ -22,7 +20,6 @@ module ROM
   class Relation
     include Charlatan.new(:dataset)
     include Equalizer.new(:header, :dataset)
-    include RA
 
     # @api private
     attr_reader :header

data/lib/rom/support/registry.rb

@@ -17,7 +17,7 @@ module ROM
     end
 
     def [](name)
-      elements[name]
+      elements.fetch(name)
     end
 
     def respond_to_missing?(name, include_private = false)
@@ -27,7 +27,11 @@ module ROM
     private
 
     def method_missing(name, *args)
-      self[name]
+      if elements.key?(name)
+        self[name]
+      else
+        super
+      end
     end
 
   end

data/lib/rom/transformer.rb

@@ -0,0 +1,77 @@
+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/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.4.1'.freeze
+  VERSION = '0.4.2'.freeze
 end

data/spec/integration/mappers/definition_dsl_spec.rb

@@ -99,7 +99,6 @@ describe 'Mapper definition DSL' do
     it 'builds a new model' do
       expect(mapper.model).to be(UserWithoutName)
     end
-
   end
 
   describe 'grouped relation mapper' do
@@ -107,8 +106,10 @@ describe 'Mapper definition DSL' do
       setup.relation(:tasks)
 
       setup.relation(:users) do
+        include ROM::RA
+
         def with_tasks
-          in_memory { group(join(tasks), tasks: [:title, :priority]) }
+          join(tasks)
         end
       end
 
@@ -179,13 +180,48 @@ describe 'Mapper definition DSL' do
       )
     end
 
+    it 'allows defining grouped attributes mapped to a model via block' do
+      setup.mappers do
+        define(:with_tasks, parent: :users) do
+          model name: 'UserWithTasks'
+
+          attribute :name
+          attribute :email
+
+          group :tasks do
+            model name: 'Task'
+
+            attribute :title
+            attribute :priority
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
+      Task.send(:include, Equalizer.new(:title, :priority))
+
+      jane = rom.read(:users).with_tasks.to_a.last
+
+      expect(jane).to eql(
+        UserWithTasks.new(
+          name: 'Jane',
+          email: 'jane@doe.org',
+          tasks: [Task.new(title: 'be cool', priority: 2)]
+        )
+      )
+    end
+
   end
 
   describe 'wrapped relation mapper' do
     before do
       setup.relation(:tasks) do
+        include ROM::RA
+
         def with_user
-          in_memory { wrap(join(users), user: [:email]) }
+          join(users)
         end
       end
 
@@ -257,6 +293,37 @@ describe 'Mapper definition DSL' do
       )
     end
 
+    it 'allows defining wrapped attributes mapped to a model' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          model name: 'TaskWithUser'
+
+          attribute :title
+          attribute :priority
+
+          wrap :user do
+            model name: 'User'
+            attribute :email
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUser.send(:include, Equalizer.new(:title, :priority, :user))
+      User.send(:include, Equalizer.new(:email))
+
+      jane = rom.read(:tasks).with_user.to_a.last
+
+      expect(jane).to eql(
+        TaskWithUser.new(
+          title: 'be cool',
+          priority: 2,
+          user: User.new(email: 'jane@doe.org')
+        )
+      )
+    end
+
   end
 
 end

data/spec/integration/mappers/renaming_attributes_spec.rb

@@ -23,16 +23,14 @@ describe 'Mappers / Renaming attributes' do
     setup.relation(:addresses)
 
     setup.relation(:users) do
+      include ROM::RA
+
       def with_address
-        in_memory {
-          wrap(join(users, addresses), address: [:address_id, :address_street])
-        }
+        join(addresses)
       end
 
       def with_addresses
-        in_memory {
-          group(join(users, addresses), addresses: [:address_id, :address_street])
-        }
+        join(addresses)
       end
     end
   end

data/spec/integration/ra/group_spec.rb

@@ -5,11 +5,10 @@ describe 'Group operation' do
 
   specify 'defining a grouped relation' do
     setup.relation(:users) do
+      include ROM::RA
 
       def with_tasks
-        in_memory {
-          group(join(tasks), tasks: [:title, :priority])
-        }
+        group(join(tasks), tasks: [:title, :priority])
       end
 
       def by_name(name)

data/spec/integration/ra/join_spec.rb

@@ -5,8 +5,10 @@ describe 'Join operation' do
 
   specify 'defining a joined one-to-many relation' do
     setup.relation(:users) do
+      include ROM::RA
+
       def with_tasks
-        in_memory { join(tasks) }
+        join(tasks)
       end
     end
 
@@ -27,8 +29,10 @@ describe 'Join operation' do
     setup.relation(:users)
 
     setup.relation(:tasks) do
+      include ROM::RA
+
       def with_user
-        in_memory { join(users) }
+        join(users)
       end
     end
 

data/spec/integration/ra/wrap_spec.rb

@@ -5,8 +5,10 @@ describe 'Wrap operation' do
 
   specify 'defining a wrapped relation' do
     setup.relation(:users) do
+      include ROM::RA
+
       def with_task
-        in_memory { wrap(join(tasks), task: [:title, :priority]) }
+        wrap(join(tasks), task: [:title, :priority])
       end
     end
 

data/spec/integration/relations/reading_spec.rb

@@ -32,8 +32,10 @@ describe 'Reading relations' do
 
   it 'maps grouped relations' do
     setup.relation(:users) do
+      include ROM::RA
+
       def with_tasks
-        in_memory { group(join(tasks), tasks: [:title, :priority]) }
+        join(tasks)
       end
 
       def sorted
@@ -78,8 +80,10 @@ describe 'Reading relations' do
 
   it 'maps wrapped relations' do
     setup.relation(:users) do
+      include ROM::RA
+
       def with_task
-        in_memory { wrap(join(tasks), task: [:title, :priority]) }
+        join(tasks)
       end
 
       def sorted

data/spec/integration/relations/registry_dsl_spec.rb

@@ -15,8 +15,10 @@ describe 'Relation registration DSL' do
     end
 
     setup.relation(:users) do
+      include ROM::RA
+
       def with_tasks
-        in_memory { join(tasks) }
+        join(tasks)
       end
     end
 

data/spec/integration/schema_spec.rb

@@ -27,7 +27,7 @@ describe 'Defining schema' do
 
   describe '.schema' do
     it 'returns an empty schema if it was not defined' do
-      expect(schema.users).to be_nil
+      expect { schema.users }.to raise_error(NoMethodError)
     end
 
     context 'with an adapter that supports header injection' do

data/spec/unit/rom/model_builder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ROM::ModelBuilder do
+  describe '#call' do
+    it 'builds a class with a constructor accepting attributes' do
+      builder = ROM::ModelBuilder::PORO.new
+
+      klass = builder.call(name: :user_name)
+
+      object = klass.new(name: 'Jane')
+
+      expect(object.name).to eql('Jane')
+
+      expect { object.name = 'Jane' }.to raise_error(NoMethodError)
+
+      klass = builder.call(name: :user_name, email: :user_email)
+
+      object = klass.new(name: 'Jane', email: 'jane@doe.org')
+
+      expect(object.name).to eql('Jane')
+      expect(object.email).to eql('jane@doe.org')
+    end
+
+    it 'defines a constant for the model when :name option is present' do
+      builder = ROM::ModelBuilder::PORO.new(name: 'User')
+
+      builder.call(name: :user_name, email: :user_email)
+
+      expect(Object.const_defined?(:User)).to be(true)
+    end
+
+    it 'defines a constant within a namespace for the model when :name option is present' do
+      module MyApp; module Entities; end; end
+
+      builder = ROM::ModelBuilder::PORO.new(name: 'MyApp::Entities::User')
+
+      builder.call(name: :user_name, email: :user_email)
+
+      expect(MyApp::Entities.const_defined?(:User)).to be(true)
+      expect(Object.const_defined?(:User)).to be(false)
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe 'Group operation' do
-  subject(:group) { opts = options; relation.in_memory { group(opts) } }
+  subject(:group) { relation.group(options) }
 
   let(:relation) do
-    ROM::Relation.new(dataset, header)
+    ROM::Relation.new(dataset, header).extend(ROM::RA)
   end
 
   let(:header) do

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe 'Wrap operation' do
-  subject(:wrap) { relation.in_memory { wrap(address: [:street, :zipcode, :city]) } }
+  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)
+       city: 'Cracow' }], header).extend(ROM::RA)
   end
 
   let(:header) do

data/spec/unit/rom/transformer_spec.rb

@@ -0,0 +1,41 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rom
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Piotr Solnica
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-15 00:00:00.000000000 Z
+date: 2014-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -198,6 +198,7 @@ files:
 - lib/rom/relation_builder.rb
 - lib/rom/repository.rb
 - lib/rom/support/registry.rb
+- lib/rom/transformer.rb
 - lib/rom/version.rb
 - rom.gemspec
 - spec/integration/adapters/extending_relations_spec.rb
@@ -224,10 +225,12 @@ files:
 - spec/unit/rom/env_spec.rb
 - spec/unit/rom/header_spec.rb
 - spec/unit/rom/mapper_spec.rb
+- spec/unit/rom/model_builder_spec.rb
 - spec/unit/rom/ra/operation/group_spec.rb
 - spec/unit/rom/ra/operation/wrap_spec.rb
 - spec/unit/rom/relation_spec.rb
 - spec/unit/rom/repository_spec.rb
+- spec/unit/rom/transformer_spec.rb
 homepage: http://rom-rb.org
 licenses:
 - MIT