rom-repository 0.2.0 → 0.3.0

data/spec/unit/relation_proxy_spec.rb

@@ -0,0 +1,170 @@
+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::RelationProxy.new(rom.relation(:users), name: :users)
+  end
+
+  let(:tasks) do
+    ROM::Repository::RelationProxy.new(rom.relation(:tasks), name: :tasks)
+  end
+
+  let(:tags) do
+    ROM::Repository::RelationProxy.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
+    context 'with custom mappers' do
+      before do
+        configuration.mappers do
+          register :users, {
+            name_list: -> users { users.map { |u| u[:name] } },
+            upcase_names: -> names { names.map(&:upcase) },
+            identity: -> users { users }
+          }
+        end
+      end
+
+      it 'sends the relation through custom mappers' do
+        expect(users.map_with(:name_list, :upcase_names).to_a).to match_array(%w(JANE JOE))
+      end
+
+      it 'does not use the default(ROM::Struct) mapper' do
+        expect(users.map_with(:identity).to_a).to match_array(
+          [{ id: 1, name: 'Jane' }, {id: 2, name: 'Joe' }]
+        )
+      end
+    end
+
+    context 'setting custom model type' do
+      let(:user_type) do
+        Class.new(Dry::Types::Struct) do
+          attribute :id, Dry::Types['strict.int']
+          attribute :name, Dry::Types['strict.string']
+        end
+      end
+
+      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,
+          { dataset: :users },
+          [:header, [[:attribute, :id], [:attribute, :name]]]]
+        ]
+      )
+    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,
+          { dataset: :users },
+          [:header, [
+            [:attribute, :id],
+            [:attribute, :name],
+            [:relation, [
+              :tasks,
+              { dataset: :tasks, keys: { id: :user_id }, combine_type: :many, combine_name: :user_tasks },
+              [:header, [[:attribute, :id], [:attribute, :user_id], [:attribute, :title]]]
+            ]]
+          ]
+        ]]]
+      )
+    end
+
+    it 'returns valid ast for a wrapped relation' do
+      relation = tags.wrap_parent(task: tasks)
+
+      expect(relation.to_ast).to eql(
+        [:relation, [
+          :tags,
+          { dataset: :tags },
+          [:header, [
+            [:attribute, :id],
+            [:attribute, :task_id],
+            [:attribute, :name],
+            [:relation, [
+              :tasks,
+              { dataset: :tasks, keys: { id: :task_id }, wrap: true, combine_name: :task },
+              [:header, [ [:attribute, :id], [:attribute, :user_id], [:attribute, :title]]]
+            ]]
+          ]]
+        ]]
+      )
+    end
+  end
+
+  describe '#method_missing' do
+    it 'proxies to the underlying relation' do
+      expect(users.gateway).to be(:default)
+    end
+
+    it 'returns proxy when response was not materialized' do
+      expect(users.by_pk(1)).to be_instance_of(ROM::Repository::RelationProxy)
+    end
+
+    it 'returns curried proxy when response was curried' do
+      expect(users.by_pk).to be_instance_of(ROM::Repository::RelationProxy)
+    end
+
+    it 'raises when method is missing' do
+      expect { users.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

data/spec/unit/sql/relation_spec.rb

@@ -7,8 +7,8 @@ RSpec.describe 'SQL Relation extensions' do
     it 'has valid column names' do
       expect(users.attributes).to eql([:id, :name])
 
-      expect(users.by_id.attributes).to eql([:name])
-      expect(users.by_id(1).attributes).to eql([:name])
+      expect(users.by_pk.attributes).to eql([:name])
+      expect(users.by_pk(1).attributes).to eql([:name])
     end
   end
 
@@ -16,7 +16,7 @@ RSpec.describe 'SQL Relation extensions' do
     context 'using short syntax' do
       before do
         configuration.relation(:users) do
-          view(:by_id, [:name]) do |name|
+          view(:by_pk, [:name]) do |name|
             where(name: name).select(:name)
           end
         end
@@ -28,7 +28,7 @@ RSpec.describe 'SQL Relation extensions' do
     context 'with multi-block syntax' do
       before do
         configuration.relation(:users) do
-          view(:by_id) do
+          view(:by_pk) do
             header [:name]
 
             relation do |name|
@@ -45,7 +45,7 @@ RSpec.describe 'SQL Relation extensions' do
       it 'raises error' do
         expect {
           configuration.relation(:users) do
-            view(:by_id) { |args| }
+            view(:by_pk) { |args| }
           end
         }.to raise_error(ArgumentError)
       end

data/spec/unit/struct_builder_spec.rb

@@ -1,12 +1,12 @@
 RSpec.describe 'struct builder', '#call' do
   subject(:builder) { ROM::Repository::StructBuilder.new }
 
-  let(:input) { [:users, [:id, :name]] }
+  let(:input) { [:users, [:header, [[:attribute, :id], [:attribute, :name]]]] }
 
   before { builder[*input] }
 
   it 'generates a struct for a given relation name and columns' do
-    struct = builder.registry[input.hash]
+    struct = builder.class.cache[input.hash]
 
     user = struct.new(id: 1, name: 'Jane')
 
@@ -17,9 +17,12 @@ RSpec.describe 'struct builder', '#call' do
     expect(user[:name]).to eql('Jane')
 
     expect(Hash[user]).to eql(id: 1, name: 'Jane')
+
+    expect(user.inspect).to eql('#<ROM::Struct[User] id=1 name="Jane">')
+    expect(user.to_s).to match(/\A#<ROM::Struct\[User\]:0x[0-9a-f]+>\z/)
   end
 
-  it 'stores struct in the registry' do
-    expect(builder.registry[input.hash]).to be(builder[*input])
+  it 'stores struct in the cache' do
+    expect(builder.class.cache[input.hash]).to be(builder[*input])
   end
 end

data/spec/unit/struct_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe ROM::Struct do
+  subject(:struct) do
+    Class.new(ROM::Struct) do
+      attr_reader :id, :name
+
+      def initialize(id, name)
+        @id, @name = id, name
+      end
+
+      def id
+        @id.to_i
+      end
+    end.new("1", "Jane")
+  end
+
+  describe '#[]' do
+    it 'reads an attribute value' do
+      expect(struct.id).to be(1)
+      expect(struct.name).to eql("Jane")
+    end
+  end
+end

metadata

@@ -1,107 +1,88 @@
 --- !ruby/object:Gem::Specification
 name: rom-repository
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-06 00:00:00.000000000 Z
+date: 2016-07-27 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: anima
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rom
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rom-support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rom-mapper
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '11.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '11.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
-description: Repository for ROM with auto-mapping and relation extensions
-email: piotr.solnica@gmail.com
+        version: '3.5'
+description: rom-repository adds support for auto-mapping and commands on top of rom-rb
+  relations
+email: piotr.solnica+oss@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -115,32 +96,48 @@ files:
 - README.md
 - Rakefile
 - lib/rom-repository.rb
-- lib/rom/plugins/relation/key_inference.rb
 - lib/rom/repository.rb
+- lib/rom/repository/changeset.rb
+- lib/rom/repository/changeset/create.rb
+- lib/rom/repository/changeset/pipe.rb
+- lib/rom/repository/changeset/update.rb
+- lib/rom/repository/class_interface.rb
+- lib/rom/repository/command_compiler.rb
+- lib/rom/repository/command_proxy.rb
 - lib/rom/repository/header_builder.rb
-- lib/rom/repository/loading_proxy.rb
-- lib/rom/repository/loading_proxy/combine.rb
-- lib/rom/repository/loading_proxy/wrap.rb
 - lib/rom/repository/mapper_builder.rb
+- lib/rom/repository/relation_proxy.rb
+- lib/rom/repository/relation_proxy/wrap.rb
+- lib/rom/repository/root.rb
+- lib/rom/repository/struct_attributes.rb
 - lib/rom/repository/struct_builder.rb
 - lib/rom/repository/version.rb
 - lib/rom/struct.rb
 - log/.gitkeep
 - rom-repository.gemspec
+- spec/integration/changeset_spec.rb
+- spec/integration/command_macros_spec.rb
+- spec/integration/command_spec.rb
 - spec/integration/multi_adapter_spec.rb
 - spec/integration/repository_spec.rb
+- spec/integration/root_repository_spec.rb
 - spec/shared/database.rb
+- spec/shared/mappers.rb
+- spec/shared/models.rb
+- spec/shared/plugins.rb
 - spec/shared/relations.rb
 - spec/shared/repo.rb
 - spec/shared/seeds.rb
 - spec/shared/structs.rb
 - spec/spec_helper.rb
 - spec/support/mapper_registry.rb
+- spec/unit/changeset_spec.rb
 - spec/unit/header_builder_spec.rb
-- spec/unit/loading_proxy_spec.rb
 - spec/unit/plugins/view_spec.rb
+- spec/unit/relation_proxy_spec.rb
 - spec/unit/sql/relation_spec.rb
 - spec/unit/struct_builder_spec.rb
+- spec/unit/struct_spec.rb
 homepage: http://rom-rb.org
 licenses:
 - MIT
@@ -161,8 +158,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Repository for ROM with auto-mapping and relation extensions
+summary: Repository abstraction for rom-rb
 test_files: []

data/lib/rom/plugins/relation/key_inference.rb

@@ -1,31 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      module KeyInference
-        # Infer foreign_key name for this relation
-        #
-        # TODO: this should be configurable and handled by an injected policy
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        def foreign_key
-          :"#{Inflector.singularize(name)}_id"
-        end
-
-        # Return base name which defaults to name attribute
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        def base_name
-          name
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  register :key_inference, ROM::Plugins::Relation::KeyInference, type: :relation
-end

data/lib/rom/repository/loading_proxy/combine.rb

@@ -1,158 +0,0 @@
-module ROM
-  class Repository
-    class LoadingProxy
-      # Provides convenient methods for producing combined relations
-      #
-      # @api public
-      module Combine
-        # Combine with other relations
-        #
-        # @example
-        #   # combining many
-        #   users.combine(many: { tasks: [tasks, id: :task_id] })
-        #   users.combine(many: { tasks: [tasks.for_users, id: :task_id] })
-        #
-        #   # combining one
-        #   users.combine(one: { task: [tasks, id: :task_id] })
-        #
-        # @param [Hash] options
-        #
-        # @return [LoadingProxy]
-        #
-        # @api public
-        def combine(options)
-          combine_opts = options.each_with_object({}) do |(type, relations), result|
-            result[type] = relations.each_with_object({}) do |(name, (other, keys)), h|
-              h[name] = [
-                other.curried? ? other : other.combine_method(relation, keys), keys
-              ]
-            end
-          end
-
-          nodes = combine_opts.flat_map do |type, relations|
-            relations.map { |name, (relation, keys)|
-              relation.combined(name, keys, type)
-            }
-          end
-
-          __new__(relation.combine(*nodes))
-        end
-
-        # Shortcut for combining with parents which infers the join keys
-        #
-        # @example
-        #   tasks.combine_parents(one: users)
-        #
-        # @param [Hash] options
-        #
-        # @return [LoadingProxy]
-        #
-        # @api public
-        def combine_parents(options)
-          combine(options.each_with_object({}) { |(type, parents), h|
-            h[type] =
-              if parents.is_a?(Hash)
-                parents.each_with_object({}) { |(key, parent), r|
-                  r[key] = [parent, combine_keys(parent, :parent)]
-                }
-              else
-                (parents.is_a?(Array) ? parents : [parents])
-                  .each_with_object({}) { |parent, r|
-                  r[parent.combine_tuple_key(type)] = [
-                    parent, combine_keys(parent, :parent)
-                  ]
-                }
-              end
-          })
-        end
-
-        # Shortcut for combining with children which infers the join keys
-        #
-        # @example
-        #   users.combine_parents(many: tasks)
-        #
-        # @param [Hash] options
-        #
-        # @return [LoadingProxy]
-        #
-        # @api public
-        def combine_children(options)
-          combine(options.each_with_object({}) { |(type, children), h|
-            h[type] =
-              if children.is_a?(Hash)
-                children.each_with_object({}) { |(key, child), r|
-                  r[key] = [child, combine_keys(relation, :children)]
-                }
-              else
-                (children.is_a?(Array) ? children : [children])
-                  .each_with_object({}) { |child, r|
-                  r[child.combine_tuple_key(type)] = [
-                    child, combine_keys(relation, :children)
-                  ]
-                }
-              end
-          })
-        end
-
-        # Infer join keys for a given relation and association type
-        #
-        # @param [LoadingProxy] relation
-        # @param [Symbol] type The type can be either :parent or :children
-        #
-        # @return [Hash<Symbol=>Symbol>]
-        #
-        # @api private
-        def combine_keys(relation, type)
-          if type == :parent
-            { relation.foreign_key => relation.primary_key }
-          else
-            { relation.primary_key => relation.foreign_key }
-          end
-        end
-
-        # Infer relation for combine operation
-        #
-        # By default it uses `for_combine` which is implemented as SQL::Relation
-        # extension
-        #
-        # @return [LoadingProxy]
-        #
-        # @api private
-        def combine_method(other, keys)
-          custom_name = :"for_#{other.base_name}"
-
-          if relation.respond_to?(custom_name)
-            __send__(custom_name)
-          else
-            for_combine(keys)
-          end
-        end
-
-        # Infer key under which a combine relation will be loaded
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        def combine_tuple_key(arity)
-          if arity == :one
-            Inflector.singularize(base_name).to_sym
-          else
-            base_name
-          end
-        end
-
-        # Return combine representation of a loading-proxy relation
-        #
-        # This will carry meta info used to produce a correct AST from a relation
-        # so that correct mapper can be generated
-        #
-        # @return [LoadingProxy]
-        #
-        # @api private
-        def combined(name, keys, type)
-          with(name: name, meta: { keys: keys, combine_type: type })
-        end
-      end
-    end
-  end
-end