rom-repository 0.2.0 → 0.3.0

data/lib/rom/repository/loading_proxy.rb

@@ -1,182 +0,0 @@
-require 'rom/support/options'
-require 'rom/relation/materializable'
-
-require 'rom/repository/loading_proxy/combine'
-require 'rom/repository/loading_proxy/wrap'
-
-module ROM
-  class Repository
-    # LoadingProxy decorates a relation and automatically generate mappers that
-    # will map raw tuples into structs
-    #
-    # @api public
-    class LoadingProxy
-      include Options
-      include Relation::Materializable
-
-      include LoadingProxy::Combine
-      include LoadingProxy::Wrap
-
-      option :name, reader: true, type: Symbol
-      option :mapper_builder, reader: true, default: proc { MapperBuilder.new }
-      option :meta, reader: true, type: Hash, default: EMPTY_HASH
-
-      # @attr_reader [ROM::Relation::Lazy] relation Decorated relation
-      attr_reader :relation
-
-      # @api private
-      def initialize(relation, options = {})
-        super
-        @relation = relation
-      end
-
-      # Materialize wrapped relation and send it through a mapper
-      #
-      # For performance reasons a combined relation will skip mapping since
-      # we only care about extracting key values for combining
-      #
-      # @api public
-      def call(*args)
-        ((combine? || composite?) ? relation : (relation >> mapper)).call(*args)
-      end
-
-      # Map this relation with other mappers too
-      #
-      # @api public
-      def map_with(*names)
-        if names.size == 1 && names[0].is_a?(Class)
-          with(meta: meta.merge(model: names[0]))
-        else
-          mappers = [mapper]+names.map { |name| relation.mappers[name] }
-          mappers.reduce(self) { |a, e| a >> e }
-        end
-      end
-      alias_method :as, :map_with
-
-      # Return AST for this relation
-      #
-      # @return [Array]
-      #
-      # @api private
-      def to_ast
-        attr_ast = attributes.map { |name| [:attribute, name] }
-
-        node_ast = nodes.map(&:to_ast)
-        wrap_ast = wraps.map(&:to_ast)
-
-        wrap_attrs = wraps.flat_map { |wrap|
-          wrap.attributes.map { |c| [:attribute, :"#{wrap.base_name}_#{c}"] }
-        }
-
-        meta = options[:meta].merge(base_name: relation.base_name)
-        meta.delete(:wraps)
-
-        [:relation, name, [:header, (attr_ast - wrap_attrs) + node_ast + wrap_ast], meta]
-      end
-
-      # Infer a mapper for the relation
-      #
-      # @return [ROM::Mapper]
-      #
-      # @api private
-      def mapper
-        mapper_builder[to_ast]
-      end
-
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        relation.respond_to?(name) || super
-      end
-
-      # Return new instance with new options
-      #
-      # @return [LoadingProxy]
-      #
-      # @api private
-      def with(new_options)
-        __new__(relation, new_options)
-      end
-
-      # Return if this relation is combined
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def combine?
-        meta[:combine_type]
-      end
-
-      # Return if this relation is a composite
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def composite?
-        relation.is_a?(Relation::Composite)
-      end
-
-      # Return meta info for this relation
-      #
-      # @return [Hash]
-      #
-      # @api private
-      def meta
-        options[:meta]
-      end
-
-      # Return all nodes that this relation combines
-      #
-      # @return [Array<LoadingProxy>]
-      #
-      # @api private
-      def nodes
-        relation.respond_to?(:nodes) ? relation.nodes : []
-      end
-
-      private
-
-      # Return a new instance with another relation and options
-      #
-      # @return [LoadingProxy]
-      #
-      # @api private
-      def __new__(relation, new_options = {})
-        self.class.new(relation, options.merge(new_options))
-      end
-
-      # Return all nodes that this relation wraps
-      #
-      # @return [Array<LoadingProxy>]
-      #
-      # @api private
-      def wraps
-        meta.fetch(:wraps, [])
-      end
-
-      # Forward to relation and wrap it with proxy if response was a relation too
-      #
-      # TODO: this will be simplified once ROM::Relation has lazy-features built-in
-      #       and ROM::Lazy is gone
-      #
-      # @api private
-      def method_missing(meth, *args, &block)
-        if relation.respond_to?(meth)
-          result = relation.__send__(meth, *args, &block)
-
-          if result.kind_of?(Relation::Materializable) && !result.is_a?(Relation::Loaded)
-            __new__(result)
-          else
-            result
-          end
-        else
-          super
-        end
-      end
-
-      # @api private
-      def respond_to_missing?(meth, _include_private = false)
-        relation.respond_to?(meth) || super
-      end
-    end
-  end
-end

data/spec/unit/loading_proxy_spec.rb

@@ -1,147 +0,0 @@
-RSpec.describe 'loading proxy' do
-  include_context 'database'
-  include_context 'relations'
-  include_context 'repo'
-  include_context 'structs'
-  include_context 'seeds'
-
-  let(:users) do
-    ROM::Repository::LoadingProxy.new(rom.relation(:users), name: :users)
-  end
-
-  let(:tasks) do
-    ROM::Repository::LoadingProxy.new(rom.relation(:tasks), name: :tasks)
-  end
-
-  let(:tags) do
-    ROM::Repository::LoadingProxy.new(rom.relation(:tags), name: :tags)
-  end
-
-  describe '#each' do
-    it 'yields loaded structs' do
-      result = []
-
-      users.each { |user| result << user }
-
-      expect(result).to eql([jane, joe])
-    end
-
-    it 'returns an enumerator when block is not given' do
-      expect(users.each.to_a).to eql([jane, joe])
-    end
-  end
-
-  describe '#map_with/#as' do
-    before do
-      configuration.mappers do
-        register :users, name_list: -> users { users.map(&:name) }
-      end
-    end
-
-    it 'sends the relation through multiple mappers' do
-      expect(users.map_with(:name_list).to_a).to eql(%w(Jane Joe))
-    end
-
-    context 'setting custom model type' do
-      let(:user_type) { Class.new { include Anima.new(:id, :name) } }
-      let(:custom_users) { users.as(user_type) }
-
-      it 'instantiates custom model' do
-        expect(custom_users.where(name: 'Jane').one).to be_instance_of(user_type)
-      end
-    end
-  end
-
-  describe 'retrieving a single struct' do
-    describe '#first' do
-      it 'returns exactly one struct' do
-        expect(users.first).to eql(jane)
-      end
-    end
-
-    describe '#one' do
-      it 'returns exactly one struct' do
-        expect(users.find(id: 1).one).to eql(jane)
-
-        expect(users.find(id: 3).one).to be(nil)
-
-        expect { users.find(id: [1,2]).one }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-
-    describe '#one!' do
-      it 'returns exactly one struct' do
-        expect(users.find(id: 1).one!).to eql(jane)
-
-        expect { users.find(id: [1, 2]).one! }.to raise_error(ROM::TupleCountMismatchError)
-        expect { users.find(id: [3]).one! }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns valid ast for a single relation' do
-      expect(users.to_ast).to eql(
-        [
-          :relation, :users, [
-            :header, [[:attribute, :id], [:attribute, :name]]
-          ],
-          base_name: :users
-        ]
-      )
-    end
-
-    it 'returns valid ast for a combined relation' do
-      relation = users.combine(many: { user_tasks: [tasks, id: :user_id] })
-
-      expect(relation.to_ast).to eql(
-        [
-          :relation, :users, [
-            :header, [
-              [:attribute, :id],
-              [:attribute, :name],
-              [
-                :relation, :user_tasks, [
-                  :header, [
-                    [:attribute, :id],
-                    [:attribute, :user_id],
-                    [:attribute, :title]
-                  ]
-                ],
-                { base_name: :tasks, keys: { id: :user_id }, combine_type: :many }
-              ]
-            ]
-          ],
-          base_name: :users
-        ]
-      )
-    end
-
-    it 'returns valid ast for a wrapped relation' do
-      relation = tags.wrap_parent(task: tasks)
-
-      expect(relation.to_ast).to eql(
-        [
-          :relation, :tags, [
-            :header, [
-              [:attribute, :id],
-              [:attribute, :task_id],
-              [:attribute, :name],
-              [
-                :relation, :task, [
-                  :header, [
-                    [:attribute, :id],
-                    [:attribute, :user_id],
-                    [:attribute, :title]
-                  ]
-                ],
-                { base_name: :tasks, keys: { id: :task_id }, wrap: true }
-              ]
-            ]
-          ],
-          base_name: :tags
-        ]
-      )
-    end
-  end
-end