rom 0.9.0.beta1 → 0.9.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae4a8d67f3c8c7869c5eafa16d721cc6c4ba90eb
-  data.tar.gz: d2c9c1cdcde7ade22ad695dea60bea91a05bea42
+  metadata.gz: 68b700901edb358688ae8f41a8f474cab6dc1254
+  data.tar.gz: 97d2569ad4ad0b653e725b0598fe6edb0d6d70b8
 SHA512:
-  metadata.gz: d8c3ba712a476f5f326863890e3e4abc42154601501595fb44e321854610ee4fed2d047b6d4c15b56be746c322d641f48f72f1ade653fc96ae547e6370218bef
-  data.tar.gz: 728ea3d960c3f18e0e314706dd90e6f35e32aa5014755a0875ba0a1613caa29358cad2af2fe7bc2c2b55f7d7fdccc780b60d9be89b297da7a3550440dc9784b0
+  metadata.gz: 5627b18505dd2e30d7eca6b6514b84f6f81573cd99a44eb7fb67b15966e37fccc007df8b3d3016b8a65a4363321d10e056e5e93c255c0ef13704693592345c5c
+  data.tar.gz: 46dd954fd398b22e3a5a5af01215ff9f52ab51ee9b750de68d7a5c9510a4275f29fb9e04914d03cb52e026653cf3c0754fa88aad10fb4feebd8ae28d138ea122

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## v0.9.0 to-be-released
 
+### Added
+
+* Configuration API for gateways supporting following options:
+  - `infer_relations` either `true` or `false` - if disabled schema inference
+    won't be used to automatically set up relations for you
+  - `inferrable_relations` a list of allowed relations that should be inferred
+  - `not_inferrable_relations` a list of relations that should not be inferred
+
+### Changed
+
+* Global setup with auto-registration ported to the `:auto_registration` environment plugin (AMHOL)
+* Multi-environment setup possible now via `ROM::Environment` object (AMHOL)
+* All relations are now lazy with auto-currying enabled (solnic)
+* Low-level query DSL provided by adapters is now public but using it directly in
+  application layer is discouraged (solnic)
+* `ROM::Mapper` component extracted into standalone `rom-mapper` gem (solnic)
+* Support libraries extracted to `rom-support` gem (solnic)
+
+## Fixed
+
+* `register_as` is now properly inferred for relations and their descendants (solnic)
+* Adapter-specific interface is properly included in relation descendants (solnic)
+* Combined commands (aka command graph) properly rejects keys from nested input
+  prior sending the input to individual commands (solnic)
+
 [Compare v0.8.1...HEAD](https://github.com/rom-rb/rom/compare/v0.8.1...HEAD)
 
 ## v0.8.1 2015-07-12

data/Gemfile

@@ -40,7 +40,7 @@ group :tools do
   gem 'guard-rspec'
   gem 'guard-rubocop'
 
-  gem 'byebug'
+  gem 'byebug', platform: :mri
 
   platform :mri do
     gem 'mutant', '>= 0.8.0', github: 'mbj/mutant', branch: 'master'

data/lib/rom/commands/abstract.rb

@@ -77,7 +77,7 @@ module ROM
       #
       # @api public
       def curry(*args)
-        if curry_args.empty? && args.first.is_a?(Proc)
+        if curry_args.empty? && args.first.is_a?(Graph::InputEvaluator)
           Lazy.new(self, args.first)
         else
           self.class.build(relation, options.merge(curry_args: args))

data/lib/rom/commands/graph.rb

@@ -63,8 +63,6 @@ module ROM
                 end
             rescue => err
               raise CommandFailure.new(node, err)
-            rescue CommandFailure => err
-              raise err
             end
 
             if node.one? && !node.graph?
@@ -81,8 +79,6 @@ module ROM
           end
         rescue => err
           raise CommandFailure.new(root, err)
-        rescue CommandFailure => err
-          raise err
         end
       end
 

data/lib/rom/commands/graph/class_interface.rb

@@ -1,3 +1,5 @@
+require 'rom/commands/graph/input_evaluator'
+
 module ROM
   module Commands
     class Graph
@@ -31,25 +33,10 @@ module ROM
               [spec, spec]
             end
 
-          command = registry[relation][name]
 
+          command = registry[relation][name]
           tuple_path = Array[*path] << key
-
-          input_proc = -> *args do
-            input, index = args
-
-            begin
-              if index
-                tuple_path[0..tuple_path.size-2]
-                  .reduce(input) { |a,e| a.fetch(e) }
-                  .at(index)[tuple_path.last]
-              else
-                tuple_path.reduce(input) { |a,e| a.fetch(e) }
-              end
-            rescue KeyError => err
-              raise CommandFailure.new(command, err)
-            end
-          end
+          input_proc = InputEvaluator.build(tuple_path, nodes)
 
           command = command.with(input_proc)
 

data/lib/rom/commands/graph/input_evaluator.rb

@@ -0,0 +1,58 @@
+module ROM
+  module Commands
+    class Graph
+      class InputEvaluator
+        attr_reader :tuple_path
+
+        attr_reader :excluded_keys
+
+        attr_reader :exclude_proc
+
+        def self.build(tuple_path, nodes)
+          new(tuple_path, extract_excluded_keys(nodes))
+        end
+
+        def self.extract_excluded_keys(nodes)
+          return unless nodes
+
+          nodes
+            .map { |item| item.is_a?(Array) && item.size > 1 ? item.first : item }
+            .compact
+            .map { |item| item.is_a?(Hash) ? item.keys.first : item }
+            .reject { |item| item.is_a?(Array) }
+        end
+
+        def self.exclude_proc(excluded_keys)
+          -> input { input.reject { |k, _| excluded_keys.include?(k) } }
+        end
+
+        def initialize(tuple_path, excluded_keys)
+          @tuple_path = tuple_path
+          @excluded_keys = excluded_keys
+          @exclude_proc = self.class.exclude_proc(excluded_keys)
+        end
+
+        def call(*args)
+          input, index = args
+
+          begin
+            value =
+              if index
+                tuple_path[0..tuple_path.size-2]
+                  .reduce(input) { |a,e| a.fetch(e) }
+                  .at(index)[tuple_path.last]
+              else
+                tuple_path.reduce(input) { |a,e| a.fetch(e) }
+              end
+
+            if excluded_keys
+              value.is_a?(Array) ? value.map(&exclude_proc) : exclude_proc[value]
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/lazy.rb

@@ -31,11 +31,15 @@ module ROM
 
         if size > 1 && last.is_a?(Array)
           last.map.with_index do |item, index|
-            command.call(evaluator[first, index], item)
+            input = evaluator.call(first, index)
+            command.call(input, item)
           end.reduce(:concat)
         else
-          command.call(evaluator[first], *args[1..size-1])
+          input = evaluator.call(first)
+          command.call(input, *args[1..size-1])
         end
+      rescue => err
+        raise CommandFailure.new(command, err)
       end
 
       # Compose a lazy command with another one

data/lib/rom/environment.rb

@@ -113,6 +113,11 @@ module ROM
       config = setup_config(*args)
       @boot = Setup.new(setup_gateways(config), adapters.keys.first)
 
+      config.each do |name, config_args|
+        options = config_args.is_a?(Array) && config_args.last
+        load_config(@boot.config.gateways[name], options) if options.is_a?(Hash)
+      end
+
       if block
         @boot.instance_exec(&block)
         @boot.finalize
@@ -172,7 +177,7 @@ module ROM
       boot.mappers(*args, &block)
     end
 
-    # Finalize the setup and store default global container under 
+    # Finalize the setup and store default global container under
     # ROM::Environmrnt#container
     #
     # @example
@@ -213,6 +218,15 @@ module ROM
       boot.register_command(klass) if boot
     end
 
+    # Return gateway config that was used to setup this environment's container
+    #
+    # @return [Configurable::Config]
+    #
+    # @api public
+    def config
+      boot.config
+    end
+
     private
 
     # Helper method to handle single- or multi-repo setup options
@@ -228,11 +242,23 @@ module ROM
     def setup_gateways(config)
       config.each_with_object({}) do |(name, spec), hash|
         identifier, *args = Array(spec)
+
         gateway = Gateway.setup(identifier, *(args.flatten))
         hash[name] = gateway
 
         gateways[gateway] = identifier unless identifier.is_a?(Gateway)
       end
     end
+
+    # @api private
+    def load_config(config, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          load_config(config[key], value)
+        else
+          config.send("#{key}=", value)
+        end
+      end
+    end
   end
 end

data/lib/rom/gateway.rb

@@ -50,7 +50,13 @@ module ROM
           See https://github.com/rom-rb/rom/blob/master/CHANGELOG.md
         STRING
       when Symbol
-        class_from_symbol(gateway_or_scheme).new(*args)
+        klass = class_from_symbol(gateway_or_scheme)
+
+        if klass.instance_method(:initialize).arity == 0
+          klass.new
+        else
+          klass.new(*args)
+        end
       else
         if args.empty?
           gateway_or_scheme

data/lib/rom/relation/class_interface.rb

@@ -19,7 +19,9 @@ module ROM
         klass.extend Deprecations
         klass.defines :adapter
 
-        return if klass.superclass == ROM::Relation
+        # Extend with functionality required by adapters *only* if this is a direct
+        # descendant of an adapter-specific relation subclass
+        return unless respond_to?(:adapter) && klass.superclass == ROM::Relation[adapter]
 
         klass.class_eval do
           use :registry_reader
@@ -31,7 +33,7 @@ module ROM
 
           gateway :default
 
-          dataset(default_name)
+          dataset default_name
 
           # Relation's dataset name
           #
@@ -44,19 +46,26 @@ module ROM
 
           # Set or get name under which a relation will be registered
           #
-          # This defaults to `dataset` name
+          # This defaults to `dataset` or `default_name` for descendant relations
           #
           # @return [Symbol]
           #
           # @api public
           def self.register_as(value = Undefined)
             if value == Undefined
-              super() || dataset
+              super_val = super()
+
+              if superclass == ROM::Relation[adapter]
+                super_val || dataset
+              else
+                super_val == dataset ? default_name : super_val
+              end
             else
               super
             end
           end
 
+          # @api public
           def self.exposed_relations(*args)
             Deprecations.announce("#{self}.exposed_relations", 'this method has no effect anymore')
             Set.new

data/lib/rom/setup.rb

@@ -1,3 +1,5 @@
+require 'rom/support/configurable'
+
 require 'rom/setup/finalize'
 require 'rom/support/deprecations'
 
@@ -6,6 +8,8 @@ module ROM
   #
   # @api public
   class Setup
+    include Configurable
+
     extend Deprecations
     include Equalizer.new(:gateways, :container)
 
@@ -57,15 +61,24 @@ module ROM
 
     # Finalize the setup
     #
-    # @return [Container] frozen container with access to gateways, 
+    # @return [Container] frozen container with access to gateways,
     #                relations, mappers and commands
     #
     # @api public
     def finalize
       raise EnvAlreadyFinalizedError if container
+
+      # initialize default configs for all gateways
+      gateways.each_key do |key|
+        gateway_config = config.gateways[key]
+
+        gateway_config.infer_relations = true unless gateway_config.key?(:infer_relations)
+      end
+
       finalize = Finalize.new(
-        gateways, relation_classes, mapper_classes, command_classes
+        gateways, relation_classes, mapper_classes, command_classes, config.freeze
       )
+
       @container = finalize.run!
     end
 

data/lib/rom/setup/finalize.rb

@@ -17,16 +17,17 @@ module ROM
     # @private
     class Finalize
       attr_reader :gateways, :repo_adapter, :datasets,
-        :relation_classes, :mapper_classes, :mappers, :command_classes
+        :relation_classes, :mapper_classes, :mappers, :command_classes, :config
 
       # @api private
-      def initialize(gateways, relation_classes, mappers, command_classes)
+      def initialize(gateways, relation_classes, mappers, command_classes, config)
         @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) || {}
         @command_classes = command_classes
+        @config = config
         initialize_datasets
       end
 
@@ -47,7 +48,7 @@ module ROM
       #
       # @api private
       def run!
-        infer_schema_relations
+        infer_relations_relations
 
         relations = load_relations
         mappers = load_mappers
@@ -67,7 +68,7 @@ module ROM
       # @api private
       def initialize_datasets
         @datasets = gateways.each_with_object({}) do |(key, gateway), h|
-          h[key] = gateway.schema
+          h[key] = gateway.schema if config.gateways[key][:infer_relations]
         end
       end
 
@@ -120,16 +121,35 @@ module ROM
       # Relations explicitly defined are being skipped
       #
       # @api private
-      def infer_schema_relations
+      def infer_relations_relations
         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(gateway))
-            klass.gateway(gateway)
-            klass.dataset(name)
+            if infer_relation?(gateway, name)
+              klass = Relation.build_class(name, adapter: adapter_for(gateway))
+              klass.gateway(gateway)
+              klass.dataset(name)
+            else
+              next
+            end
           end
         end
       end
+
+      def infer_relation?(gateway, name)
+        inferrable_relations(gateway).include?(name) && relation_classes.none? { |klass|
+          klass.dataset == name
+        }
+      end
+
+      def inferrable_relations(gateway)
+        gateway_config = config.gateways[gateway]
+        schema = gateways[gateway].schema
+
+        allowed = gateway_config[:inferrable_relations] || schema
+        skipped = gateway_config[:not_inferrable_relations] || []
+
+        schema & allowed - skipped
+      end
     end
   end
 end

data/lib/rom/support/configurable.rb

@@ -0,0 +1,66 @@
+module ROM
+  # @api private
+  module Configurable
+    class Config
+      WRITER_REGEXP = /=$/.freeze
+
+      attr_reader :settings
+
+      # @api private
+      def initialize
+        @settings = {}
+      end
+
+      # @api public
+      def [](name)
+        public_send(name)
+      end
+
+      # @api private
+      def key?(name)
+        settings.key?(name)
+      end
+
+      # @api private
+      def freeze
+        settings.each_value { |value| value.freeze }
+        super
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        true
+      end
+
+      private
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        return settings.fetch(meth, nil) if frozen?
+
+        name = meth.to_s
+        key = name.gsub(WRITER_REGEXP, '').to_sym
+
+        if writer?(name)
+          settings[key] = args.first
+        else
+          settings.fetch(key) { settings[key] = self.class.new }
+        end
+      end
+
+      # @api private
+      def writer?(name)
+        ! WRITER_REGEXP.match(name).nil?
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    # @api public
+    def configure
+      yield(config)
+    end
+  end
+end

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.9.0.beta1'.freeze
+  VERSION = '0.9.0.rc1'.freeze
 end

data/spec/integration/commands/graph_spec.rb

@@ -12,15 +12,12 @@ describe 'Building up a command graph for nested input' do
 
     setup.commands(:users) do
       define(:create) do
-        input T(:accept_keys, [:name])
         result :one
       end
     end
 
     setup.commands(:books) do
       define(:create) do
-        input T(:accept_keys, [:title, :user])
-
         def execute(tuples, user)
           super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
         end
@@ -29,8 +26,6 @@ describe 'Building up a command graph for nested input' do
 
     setup.commands(:tags) do
       define(:create) do
-        input T(:accept_keys, [:name, :task])
-
         def execute(tuples, task)
           super(tuples.map { |t| t.merge(task: task.fetch(:title)) })
         end
@@ -41,7 +36,6 @@ describe 'Building up a command graph for nested input' do
   it 'creates a command graph for nested input :one result as root' do
     setup.commands(:tasks) do
       define(:create) do
-        input T(:accept_keys, [:title, :user])
         result :one
 
         def execute(tuple, user)
@@ -102,8 +96,6 @@ describe 'Building up a command graph for nested input' do
   it 'creates a command graph for nested input with :many results as root' do
     setup.commands(:tasks) do
       define(:create) do
-        input T(:accept_keys, [:title, :user])
-
         def execute(tuples, user)
           super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
         end
@@ -178,8 +170,6 @@ describe 'Building up a command graph for nested input' do
 
     setup.commands(:tasks) do
       define(:create) do
-        input T(:accept_keys, [:title, :user])
-
         def execute(tuples, user)
           super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
         end

data/spec/integration/relations/inheritance_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe 'Inheritance relation hierarchy' do
+  before do
+    ROM.setup(:memory)
+
+    module Test
+      class Users < ROM::Relation[:memory]
+        dataset :users
+
+        def by_email(email)
+          restrict(email: email)
+        end
+      end
+
+      class OtherUsers < Users
+        register_as :other_users
+      end
+    end
+
+    ROM.finalize
+  end
+
+  it 'registers parent and descendant relations' do
+    rom = ROM.env
+
+    users = rom.relations.users
+    other_users = rom.relations.other_users
+
+    expect(users).to be_instance_of(Test::Users)
+    expect(other_users).to be_instance_of(Test::OtherUsers)
+
+    jane = { name: 'Jane', email: 'jane@doe.org' }
+
+    other_users.insert(jane)
+
+    expect(other_users.by_email('jane@doe.org').one).to eql(jane)
+  end
+end

data/spec/unit/rom/relation_spec.rb

@@ -29,9 +29,51 @@ describe ROM::Relation do
     end
   end
 
-  describe '#name' do
-    before { ROM.setup(:memory) }
+  describe ".register_as" do
+    it "defaults to dataset with a generated class" do
+      rel = Class.new(ROM::Relation[:memory]) { dataset :users }
+      expect(rel.register_as).to eq(:users)
+      rel.register_as(:guests)
+      expect(rel.register_as).to eq(:guests)
+    end
+
+    it "defaults to dataset with a defined class that has dataset inferred" do
+      class Test::Users < ROM::Relation[:memory]; end
+      expect(Test::Users.register_as).to eq(:test_users)
+    end
+
+    it "defaults to dataset with a defined class that has dataset set manually" do
+      class Test::Users < ROM::Relation[:memory]
+        dataset :guests
+      end
+      expect(Test::Users.register_as).to eq(:guests)
+    end
+
+    it "defaults to :name for descendant classes" do
+      class Test::SuperUsers < ROM::Relation[:memory]
+        dataset :users
+      end
+
+      class Test::DescendantUsers < Test::SuperUsers;end
+
+      expect(Test::DescendantUsers.register_as).to eq(:test_descendant_users)
+    end
+
+    it "sets custom value for super and descendant classes" do
+      class Test::SuperUsers < ROM::Relation[:memory]
+        register_as :users
+      end
+
+      class Test::DescendantUsers < Test::SuperUsers
+        register_as :descendant_users
+      end
+
+      expect(Test::SuperUsers.register_as).to eq(:users)
+      expect(Test::DescendantUsers.register_as).to eq(:descendant_users)
+    end
+  end
 
+  describe '#name' do
     context 'missing dataset' do
       context 'with Relation inside module' do
         before do
@@ -58,6 +100,19 @@ describe ROM::Relation do
           expect(relation.name).to eq(:test_super_relation)
         end
       end
+
+      context 'with a descendant relation' do
+        before do
+          class Test::SuperRelation < ROM::Relation[:memory]; end
+          class Test::DescendantRelation < Test::SuperRelation; end
+        end
+
+        it 'inherits :name from the super relation' do
+          relation = Test::DescendantRelation.new([])
+
+          expect(relation.name).to eql(:test_super_relation)
+        end
+      end
     end
 
     context 'manualy set dataset' do
@@ -93,29 +148,6 @@ describe ROM::Relation do
     end
   end
 
-  describe ".register_as" do
-    before { ROM.setup(:memory) }
-
-    it "defaults to dataset with a generated class" do
-      rel = Class.new(ROM::Relation[:memory]) { dataset :users }
-      expect(rel.register_as).to eq(:users)
-      rel.register_as(:guests)
-      expect(rel.register_as).to eq(:guests)
-    end
-
-    it "defaults to dataset with a defined class that has dataset inferred" do
-      class Test::Users < ROM::Relation[:memory]; end
-      expect(Test::Users.register_as).to eq(:test_users)
-    end
-
-    it "defaults to dataset with a defined class that has dataset set manually" do
-      class Test::Users < ROM::Relation[:memory]
-        dataset :guests
-      end
-      expect(Test::Users.register_as).to eq(:guests)
-    end
-  end
-
   describe "#to_a" do
     it "materializes relation to an array" do
       expect(relation.to_a).to eql([jane, joe])

data/spec/unit/rom/setup_spec.rb

@@ -1,6 +1,46 @@
 require 'spec_helper'
 
 describe ROM::Setup do
+  it 'is configurable' do
+    setup = ROM::Setup.new({})
+
+    setup.configure do |config|
+      config.sql.infer_relations = false
+    end
+
+    expect(setup.config.sql.infer_relations).to be(false)
+    expect(setup.config[:sql][:infer_relations]).to be(false)
+
+    expect(setup.config).to respond_to(:sql)
+    expect(setup.config).to respond_to(:other=)
+
+    setup.config.freeze
+
+    expect(setup.config.other).to be(nil)
+    expect(setup.config.key?(:other)).to be(false)
+    expect(setup.config.key?(:sql)).to be(true)
+  end
+
+  it 'is configurable via settings hash' do
+    setup = ROM.setup(:memory, 'something', infer_schema: false)
+
+    setup.finalize
+
+    expect(setup.config.gateways.default.infer_schema).to be(false)
+
+    setup = ROM.setup(:memory, infer_schema: false)
+
+    setup.finalize
+
+    expect(setup.config.gateways.default.infer_schema).to be(false)
+
+    setup = ROM.setup(default: [:memory, infer_schema: false])
+
+    setup.finalize
+
+    expect(setup.config.gateways.default.infer_schema).to be(false)
+  end
+
   describe '#finalize' do
     context 'with gateway that supports schema inferring' do
       it 'builds relation from inferred schema' do
@@ -33,6 +73,62 @@ describe ROM::Setup do
         expect(rom.relations.test_users).to be_instance_of(Test::Users)
       end
 
+      it 'skips inferring when it is turned off for the adapter' do
+        setup = ROM.setup(:memory)
+
+        setup.configure { |config| config.gateways.default.infer_relations = false }
+
+        repo = setup.default
+
+        expect(repo).not_to receive(:schema)
+
+        setup.finalize
+      end
+
+      it 'infers configured relations' do
+        setup = ROM.setup(:memory)
+
+        setup.configure do |config|
+          config.gateways.default.inferrable_relations = [:test_tasks]
+        end
+
+        repo = setup.default
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
+
+        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
+        expect(repo).to_not receive(:dataset).with(:test_users)
+
+        rom = setup.finalize
+
+        expect(rom.relations.elements.key?(:test_users)).to be(false)
+        expect(rom.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
+        expect(rom.relations[:test_tasks].dataset).to be(dataset)
+      end
+
+      it 'skip inferring blacklisted relations' do
+        setup = ROM.setup(:memory)
+
+        setup.configure do |config|
+          config.gateways.default.not_inferrable_relations = [:test_users]
+        end
+
+        repo = setup.default
+        dataset = double('dataset')
+
+        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
+
+        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
+        expect(repo).to_not receive(:dataset).with(:test_users)
+
+        rom = setup.finalize
+
+        expect(rom.relations.elements.key?(:test_users)).to be(false)
+        expect(rom.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
+        expect(rom.relations[:test_tasks].dataset).to be(dataset)
+      end
+
       it 'can register multiple relations with same dataset' do
         setup = ROM.setup(:memory)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom
 version: !ruby/object:Gem::Version
-  version: 0.9.0.beta1
+  version: 0.9.0.rc1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-10 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: transproc
@@ -147,6 +147,7 @@ files:
 - lib/rom/commands/delete.rb
 - lib/rom/commands/graph.rb
 - lib/rom/commands/graph/class_interface.rb
+- lib/rom/commands/graph/input_evaluator.rb
 - lib/rom/commands/lazy.rb
 - lib/rom/commands/result.rb
 - lib/rom/commands/update.rb
@@ -192,6 +193,7 @@ files:
 - lib/rom/setup_dsl/mapper_dsl.rb
 - lib/rom/setup_dsl/relation.rb
 - lib/rom/setup_dsl/setup.rb
+- lib/rom/support/configurable.rb
 - lib/rom/version.rb
 - rakelib/benchmark.rake
 - rakelib/mutant.rake
@@ -223,6 +225,7 @@ files:
 - spec/integration/mappers/unwrap_spec.rb
 - spec/integration/mappers/wrap_spec.rb
 - spec/integration/multi_repo_spec.rb
+- spec/integration/relations/inheritance_spec.rb
 - spec/integration/relations/reading_spec.rb
 - spec/integration/relations/registry_dsl_spec.rb
 - spec/integration/repositories/extending_relations_spec.rb