rom 0.6.0.beta3 → 0.6.0.rc1

data/spec/unit/rom/setup_spec.rb

@@ -101,8 +101,8 @@ describe ROM::Setup do
         expect(env.relations).to eql(ROM::RelationRegistry.new)
       end
 
-      it 'builds empty readers' do
-        expect(env.readers).to eql(ROM::ReaderRegistry.new)
+      it 'builds empty mappers' do
+        expect(env.mappers).to eql(ROM::Registry.new)
       end
 
       it 'builds empty commands' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom
 version: !ruby/object:Gem::Version
-  version: 0.6.0.beta3
+  version: 0.6.0.rc1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: transproc
@@ -17,6 +17,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: equalizer
   requirement: !ruby/object:Gem::Requirement
@@ -152,8 +158,8 @@ files:
 - lib/rom/model_builder.rb
 - lib/rom/processor.rb
 - lib/rom/processor/transproc.rb
-- lib/rom/reader.rb
 - lib/rom/relation.rb
+- lib/rom/relation/class_interface.rb
 - lib/rom/relation/composite.rb
 - lib/rom/relation/curried.rb
 - lib/rom/relation/lazy.rb
@@ -220,7 +226,6 @@ files:
 - spec/unit/rom/memory/storage_spec.rb
 - spec/unit/rom/model_builder_spec.rb
 - spec/unit/rom/processor/transproc_spec.rb
-- spec/unit/rom/reader_spec.rb
 - spec/unit/rom/registry_spec.rb
 - spec/unit/rom/relation/composite_spec.rb
 - spec/unit/rom/relation/lazy_spec.rb

data/lib/rom/reader.rb

@@ -1,174 +0,0 @@
-module ROM
-  # Exposes mapped tuples via enumerable interface
-  #
-  # See example for each method
-  #
-  # @api public
-  class Reader
-    include Enumerable
-    include Equalizer.new(:path, :relation, :mapper)
-
-    # Map relation to an array using a mapper
-    #
-    # @return [Array]
-    #
-    # @api public
-    alias_method :to_ary, :to_a
-
-    # @return [String] access path used to read a relation
-    #
-    # @api private
-    attr_reader :path
-
-    # @return [Relation] relation used by the reader
-    #
-    # @api private
-    attr_reader :relation
-
-    # @return [MapperRegistry] registry of mappers used by the reader
-    #
-    # @api private
-    attr_reader :mappers
-
-    # @return [Mapper] mapper to read the relation
-    #
-    # @api private
-    attr_reader :mapper
-
-    # Builds a reader instance for the provided relation
-    #
-    # @param [Symbol] name of the root relation
-    # @param [Relation] relation that the reader will use
-    # @param [MapperRegistry] mappers registry of mappers
-    # @param [Array<Symbol>] method_names a list of method names exposed by the relation
-    #
-    # @return [Reader]
-    #
-    # @api private
-    def self.build(name, relation, mappers, method_names = [])
-      klass = build_class(relation, method_names)
-      klass.new(name, relation, mappers)
-    end
-
-    # Build a reader subclass for the relation
-    #
-    # This method defines public methods on the class narrowing down data access
-    # only to the methods exposed by a given relation
-    #
-    # @param [Relation] relation that the reader will use
-    # @param [Array<Symbol>] method_names a list of method names exposed by the relation
-    #
-    # @return [Class]
-    #
-    # @api private
-    def self.build_class(relation, method_names)
-      klass_name = "#{Reader.name}[#{Inflector.camelize(relation.name)}]"
-
-      ClassBuilder.new(name: klass_name, parent: Reader).call do |klass|
-        method_names.each do |method_name|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(*args, &block)
-              new_relation = relation.send(#{method_name.inspect}, *args, &block)
-              self.class.new(
-                new_path(#{method_name.to_s.inspect}), new_relation, mappers
-              )
-            end
-          RUBY
-        end
-      end
-    end
-
-    # @api private
-    def initialize(path, relation, mappers, mapper = nil)
-      @path = path.to_s
-      @relation = relation
-      @mappers = mappers
-      @mapper = mapper || mappers.by_path(@path)
-    end
-
-    # @api private
-    def header
-      mapper.header
-    end
-
-    # Yields tuples mapped to objects
-    #
-    # @example
-    #
-    #   # accessing root relation
-    #   rom.read(:users).each { |user| # ... }
-    #
-    #   # accessing virtual relations
-    #   rom.read(:users).adults.recent.active.each { |user| # ... }
-    #
-    # @api public
-    def each
-      mapper.call(relation).each { |tuple| yield(tuple) }
-    end
-
-    # Returns a single tuple from the relation if there is one.
-    #
-    # @raise [ROM::TupleCountMismatchError] if the relation contains more than
-    #   one tuple
-    #
-    # @api public
-    def one
-      if relation.count > 1
-        raise(
-          TupleCountMismatchError,
-          'The relation consists of more than one tuple'
-        )
-      else
-        mapper.call(relation).first
-      end
-    end
-
-    # Like [one], but additionally raises an error if the relation is empty.
-    #
-    # @raise [ROM::TupleCountMismatchError] if the relation does not contain
-    #   exactly one tuple
-    #
-    # @api public
-    def one!
-      one || raise(
-        TupleCountMismatchError,
-        'The relation does not contain any tuples'
-      )
-    end
-
-    # Map tuples using a specific mapper if name is provided
-    #
-    # Defaults to Enumerable#map behavior
-    #
-    # @example
-    #
-    #   rom.read(:users).map(:my_mapper_name)
-    #   rom.read(:users).map { |user| ... }
-    #
-    # @return [Array,Reader]
-    #
-    # @api public
-    def map(*args)
-      if args.any?
-        mappers[args[0]].call(relation)
-      else
-        super
-      end
-    end
-
-    private
-
-    # @api private
-    def method_missing(name, *)
-      raise(
-        NoRelationError,
-        "undefined relation #{name.inspect} within #{path.inspect}"
-      )
-    end
-
-    # @api private
-    def new_path(name)
-      path.dup << ".#{name}"
-    end
-  end
-end

data/spec/unit/rom/reader_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Reader do
-  subject(:reader) { ROM::Reader.new(name, relation, mappers) }
-
-  let(:name) { :users }
-  let(:relation) { [jane, joe] }
-  let(:jane) { { name: 'Jane' } }
-  let(:joe) { { name: 'Joe' } }
-  let(:mappers) { ROM::MapperRegistry.new(users: mapper) }
-  let(:mapper) { double('mapper', header: []) }
-
-  describe '.build' do
-    subject(:reader) do
-      ROM::Reader.build(name, relation, mappers, [:all])
-    end
-
-    before do
-      relation.instance_exec do
-        def name
-          'users'
-        end
-
-        def all(*_args)
-          find_all
-        end
-      end
-    end
-
-    it 'sets reader class name' do
-      expect(reader.class.name).to eql("ROM::Reader[Users]")
-    end
-
-    it 'defines methods from relation' do
-      block = proc {}
-
-      user_id = 1
-
-      expect(relation).to receive(:all)
-        .with(user_id, &block)
-        .and_return([joe])
-
-      expect(mapper).to receive(:call)
-        .with([joe])
-        .and_return([joe])
-
-      result = reader.all(user_id, &block)
-
-      expect(result.path).to eql('users.all')
-      expect(result.to_a).to eql([joe])
-    end
-
-    it 'raises error when relation does not respond to the method' do
-      expect { reader.not_here }
-        .to raise_error(ROM::NoRelationError, /not_here/)
-    end
-
-    it 'raises error when relation does not respond to the method with args' do
-      expect { reader.find_by_id(1) }
-        .to raise_error(ROM::NoRelationError, /find_by_id/)
-    end
-  end
-
-  describe '#initialize' do
-    it 'raises error when mapper cannot be found' do
-      expect { ROM::Reader.new(:not_here, relation, mappers) }
-        .to raise_error(ROM::MapperMissingError, /not_here/)
-    end
-  end
-
-  describe '#each' do
-    it 'yields mapped tuples from relations' do
-      expect(mapper).to receive(:call)
-        .with(relation)
-        .and_return(relation)
-
-      result = []
-      reader.each { |user| result << user }
-      expect(result).to eql([jane, joe])
-    end
-  end
-
-  shared_examples_for 'one and one!' do |method|
-    context 'with a single tuple' do
-      let(:relation) { [jane] }
-
-      it 'returns a single tuple' do
-        expect(mapper).to receive(:call)
-          .with(relation)
-          .and_return(relation)
-
-        expect(reader.public_send(method)).to eql(jane)
-      end
-    end
-
-    context 'with more than one tuple' do
-      it 'raises an error' do
-        expect { reader.public_send(method) }
-          .to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-  end
-
-  describe '#one' do
-    it_should_behave_like 'one and one!', :one
-
-    context 'without any tuple' do
-      let(:relation) { [] }
-
-      it 'returns nil' do
-        expect(mapper).to receive(:call)
-          .with(relation)
-          .and_return(relation)
-
-        expect(reader.one).to be_nil
-      end
-    end
-  end
-
-  describe '#one!' do
-    it_should_behave_like 'one and one!', :one!
-
-    context 'without any tuple' do
-      let(:relation) { [] }
-
-      it 'raises an error' do
-        expect(mapper).to receive(:call)
-          .with(relation)
-          .and_return(relation)
-
-        expect { reader.one! }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-  end
-
-  describe '#to_ary' do
-    it 'casts relation to an array with loaded objects' do
-      expect(mapper).to receive(:call)
-        .with(relation)
-        .and_return(relation)
-
-      result = reader.to_ary
-      expect(result).to eql(relation)
-    end
-  end
-end