rom-repository 0.2.0 → 0.3.0

data/spec/shared/mappers.rb

@@ -0,0 +1,35 @@
+RSpec.shared_context 'mappers' do
+  let(:users) { rom.relation(:users).mappers[:user] }
+  let(:tasks) { rom.relation(:tasks).mappers[:task] }
+  let(:tags) { rom.relation(:tags).mappers[:tag] }
+
+  before do
+    configuration.mappers do
+      define(:users) do
+        model Test::Models::User
+        register_as :user
+
+        attribute :id
+        attribute :name
+      end
+
+      define(:tasks) do
+        model Test::Models::Task
+        register_as :task
+
+        attribute :id
+        attribute :user_id
+        attribute :title
+      end
+
+      define(:tags) do
+        model Test::Models::Tag
+        register_as :tag
+
+        attribute :id
+        attribute :task_id
+        attribute :name
+      end
+    end
+  end
+end

data/spec/shared/models.rb

@@ -0,0 +1,41 @@
+RSpec.shared_context 'models' do
+  let(:user_model) { Test::Models::User }
+  let(:task_model) { Test::Models::Task }
+  let(:tag_model) { Test::Models::Tag }
+
+  before do
+    module Test
+      module Models
+        class User
+          include Dry::Equalizer(:id, :name)
+
+          attr_reader :id, :name
+
+          def initialize(attrs)
+            @id, @name = attrs[:id], attrs[:name]
+          end
+        end
+
+        class Task
+          include Dry::Equalizer(:id, :user_id, :title)
+
+          attr_reader :id, :user_id, :title
+
+          def initialize(attrs)
+            @id, @name, @title = attrs[:id], attrs[:name], attrs[:title]
+          end
+        end
+
+        class Tag
+          include Dry::Equalizer(:id, :task_id, :name)
+
+          attr_reader :id, :task_id, :name
+
+          def initialize(attrs)
+            @id, @task_id, @name = attrs[:id], attrs[:task_id], attrs[:name]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/shared/plugins.rb

@@ -0,0 +1,66 @@
+RSpec.shared_context 'plugins' do
+  before do
+    module Test
+      class WrappingInput
+        def initialize(input)
+          @input = input || Hash
+        end
+      end
+
+      module Timestamps
+        class InputWithTimestamp < WrappingInput
+          def [](value)
+            v = @input[value]
+            now = Time.now
+
+            if v[:created_at]
+              v.merge(updated_at: now)
+            else
+              v.merge(created_at: now, updated_at: now)
+            end
+          end
+        end
+
+        module ClassInterface
+          def build(relation, options = {})
+            super(relation, options.merge(input: InputWithTimestamp.new(input)))
+          end
+        end
+
+        def self.included(klass)
+          super
+
+          klass.extend ClassInterface
+        end
+      end
+
+      module UpcaseName
+        class UpcaseNameInput < WrappingInput
+          def [](value)
+            v = @input[value]
+            v.merge(name: value.fetch(:name).upcase)
+          end
+        end
+
+        module ClassInterface
+          def build(relation, options = {})
+            super(relation, options.merge(input: UpcaseNameInput.new(options.fetch(:input))))
+          end
+        end
+
+        def self.included(klass)
+          super
+
+          klass.extend ClassInterface
+        end
+      end
+    end
+
+    ROM.plugins do
+      adapter :sql do
+        register :timestamps, Test::Timestamps, type: :command
+        register :upcase_name, Test::UpcaseName, type: :command
+      end
+    end
+  end
+end

data/spec/shared/relations.rb

@@ -2,9 +2,31 @@ RSpec.shared_context 'relations' do
   let(:users) { rom.relation(:users) }
   let(:tasks) { rom.relation(:tasks) }
   let(:tags) { rom.relation(:tags) }
+  let(:posts) { rom.relation(:posts) }
+  let(:books) { rom.relation(:books) }
 
   before do
+    configuration.relation(:books) do
+      schema(:books) do
+        attribute :id, ROM::SQL::Types::Serial
+        attribute :title, ROM::SQL::Types::String
+        attribute :created_at, ROM::SQL::Types::Time
+        attribute :updated_at, ROM::SQL::Types::Time
+      end
+    end
+
     configuration.relation(:users) do
+      schema(infer: true) do
+        associations do
+          has_many :posts
+          has_many :labels, through: :posts
+        end
+      end
+
+      def by_name(name)
+        where(name: name)
+      end
+
       def all
         select(:id, :name).order(:name, :id)
       end
@@ -15,6 +37,12 @@ RSpec.shared_context 'relations' do
     end
 
     configuration.relation(:tasks) do
+      schema(infer: true) do
+        associations do
+          belongs_to :user
+        end
+      end
+
       def find(criteria)
         where(criteria)
       end
@@ -25,5 +53,53 @@ RSpec.shared_context 'relations' do
     end
 
     configuration.relation(:tags)
+
+    configuration.relation(:labels) do
+      schema(infer: true) do
+        associations do
+          has_many :posts_labels
+          has_many :posts, through: :posts_labels
+        end
+      end
+    end
+
+    configuration.relation(:posts) do
+      schema(:posts, infer: true) do
+        associations do
+          has_many :labels, through: :posts_labels
+          belongs_to :user, as: :author
+        end
+      end
+    end
+
+    configuration.relation(:posts_labels) do
+      schema(infer: true) do
+        associations do
+          belongs_to :post
+          belongs_to :label
+        end
+      end
+    end
+
+    configuration.relation(:comments) do
+      register_as :comments
+
+      schema(:messages, infer: true) do
+        associations do
+          has_many :reactions, relation: :likes
+          has_many :reactions, relation: :likes, as: :emotions
+        end
+      end
+    end
+
+    configuration.relation(:likes) do
+      register_as :likes
+
+      schema(:reactions, infer: true) do
+        associations do
+          belongs_to :message, relation: :comments
+        end
+      end
+    end
   end
 end

data/spec/shared/repo.rb

@@ -1,9 +1,12 @@
 RSpec.shared_context('repo') do
+  include_context 'models'
+  include_context 'mappers'
+
   let(:repo) { repo_class.new(rom) }
 
   let(:repo_class) do
-    Class.new(ROM::Repository) do
-      relations :users, :tasks, :tags
+    Class.new(ROM::Repository[:users]) do
+      relations :tasks, :tags, :posts, :labels
 
       def find_users(criteria)
         users.find(criteria)
@@ -13,6 +16,26 @@ RSpec.shared_context('repo') do
         users.all
       end
 
+      def all_users_as_users
+        users.as(:user).all
+      end
+
+      def users_with_tasks
+        aggregate(many: { all_tasks: tasks.for_users })
+      end
+
+      def users_with_tasks_and_tags
+        aggregate(many: { all_tasks: tasks_with_tags(tasks.for_users) })
+      end
+
+      def users_with_task
+        aggregate(one: tasks)
+      end
+
+      def users_with_task_by_title(title)
+        aggregate(one: tasks.find(title: title))
+      end
+
       def tasks_for_users(users)
         tasks.for_users(users)
       end
@@ -25,29 +48,27 @@ RSpec.shared_context('repo') do
         tasks.find(id: 2).combine_parents(one: { owner: users })
       end
 
-      def users_with_tasks
-        users.combine_children(many: { all_tasks: tasks.for_users })
-      end
-
-      def users_with_tasks_and_tags
-        users.combine_children(many: { all_tasks: tasks_with_tags(tasks.for_users) })
-      end
-
       def tasks_with_tags(tasks = self.tasks)
         tasks.combine_children(many: tags)
       end
 
-      def users_with_task
-        users.combine_children(one: tasks)
+      def tag_with_wrapped_task
+        tags.wrap_parent(task: tasks)
       end
+    end
+  end
 
-      def users_with_task_by_title(title)
-        users.combine_children(one: tasks.find(title: title))
+  let(:comments_repo) do
+    Class.new(ROM::Repository[:comments]) do
+      relations :likes
+
+      def comments_with_likes
+        aggregate(many: { likes: likes })
       end
 
-      def tag_with_wrapped_task
-        tags.wrap_parent(task: tasks)
+      def comments_with_emotions
+        root.combine(:emotions)
       end
-    end
+    end.new(rom)
   end
 end

data/spec/shared/seeds.rb

@@ -7,5 +7,24 @@ RSpec.shared_context 'seeds' do
     task_id = conn[:tasks].insert user_id: jane_id, title: 'Jane Task'
 
     conn[:tags].insert task_id: task_id, name: 'red'
+
+    jane_post_id = conn[:posts].insert author_id: jane_id, title: 'Hello From Jane', body: 'Jane Post'
+    joe_post_id = conn[:posts].insert author_id: joe_id, title: 'Hello From Joe', body: 'Joe Post'
+
+    red_id = conn[:labels].insert name: 'red'
+    green_id = conn[:labels].insert name: 'green'
+    blue_id = conn[:labels].insert name: 'blue'
+
+    conn[:posts_labels].insert post_id: jane_post_id, label_id: red_id
+    conn[:posts_labels].insert post_id: jane_post_id, label_id: blue_id
+
+    conn[:posts_labels].insert post_id: joe_post_id, label_id: green_id
+
+    conn[:messages].insert author: 'Jane', body: 'Hello folks'
+    conn[:messages].insert author: 'Joe', body: 'Hello Jane'
+
+    conn[:reactions].insert message_id: 1, author: 'Joe'
+    conn[:reactions].insert message_id: 1, author: 'Anonymous'
+    conn[:reactions].insert message_id: 2, author: 'Jane'
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,7 @@
 require "bundler"
 Bundler.setup
 
-if RUBY_ENGINE == "rbx"
+if RUBY_ENGINE == "ruby" && RUBY_VERSION == '2.3.1'
   require "codeclimate-test-reporter"
   CodeClimate::TestReporter.start
 end
@@ -28,6 +28,9 @@ Dir[root.join('shared/*.rb').to_s].each do |f|
   require f
 end
 
+require 'rom/support/deprecations'
+ROM::Deprecations.set_logger!(root.join('../log/deprecations.log'))
+
 # Namespace holding all objects created during specs
 module Test
   def self.remove_constants

data/spec/support/mapper_registry.rb

@@ -1,8 +1,6 @@
 module MapperRegistry
   def mapper_for(relation)
-    ROM::Repository::MapperBuilder.registry.fetch(relation.to_ast.hash) {
-      mapper_builder[relation.to_ast]
-    }
+    mapper_builder[relation.to_ast]
   end
 
   def mapper_builder

data/spec/unit/changeset_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe ROM::Changeset do
+  let(:jane) { { id: 2, name: "Jane" } }
+  let(:relation) { double(ROM::Relation, primary_key: :id) }
+
+  describe '#diff' do
+    it 'returns a hash with changes' do
+      expect(relation).to receive(:fetch).with(2).and_return(jane)
+
+      changeset = ROM::Changeset::Update.new(relation, { name: "Jane Doe" }, primary_key: 2)
+
+      expect(changeset.diff).to eql(name: "Jane Doe")
+    end
+  end
+
+  describe '#diff?' do
+    it 'returns true when data differs from the original tuple' do
+      expect(relation).to receive(:fetch).with(2).and_return(jane)
+
+      changeset = ROM::Changeset::Update.new(relation, { name: "Jane Doe" }, primary_key: 2)
+
+      expect(changeset).to be_diff
+    end
+
+    it 'returns false when data are equal to the original tuple' do
+      expect(relation).to receive(:fetch).with(2).and_return(jane)
+
+      changeset = ROM::Changeset::Update.new(relation, { name: "Jane" }, primary_key: 2)
+
+      expect(changeset).to_not be_diff
+    end
+  end
+
+  describe 'quacks like a hash' do
+    subject(:changeset) { ROM::Changeset::Create.new(relation, data) }
+
+    let(:data) { instance_double(Hash) }
+
+    it 'delegates to its data hash' do
+      expect(data).to receive(:[]).with(:name).and_return('Jane')
+
+      expect(changeset[:name]).to eql('Jane')
+    end
+
+    it 'maintains its own type' do
+      expect(data).to receive(:merge).with(foo: 'bar').and_return(foo: 'bar')
+
+      new_changeset = changeset.merge(foo: 'bar')
+
+      expect(new_changeset).to be_instance_of(ROM::Changeset::Create)
+      expect(new_changeset.options).to eql(changeset.options)
+      expect(new_changeset.to_h).to eql(foo: 'bar')
+    end
+
+    it 'raises NoMethodError when an unknown message was sent' do
+      expect { changeset.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

data/spec/unit/header_builder_spec.rb

@@ -1,18 +1,25 @@
 RSpec.describe 'header builder', '#call' do
   subject(:builder) { ROM::Repository::HeaderBuilder.new }
 
-  let(:user_struct) { builder.struct_builder[:users, [:id, :name]] }
-  let(:task_struct) { builder.struct_builder[:tasks, [:user_id, :title]] }
-  let(:tag_struct) { builder.struct_builder[:tags, [:user_id, :tag]] }
+  let(:user_struct) do
+    builder.struct_builder[:users, [:header, [[:attribute, :id], [:attribute, :name]]]]
+  end
+
+  let(:task_struct) do
+    builder.struct_builder[:tasks, [:header, [[:attribute, :user_id], [:attribute, :title]]]]
+  end
+
+  let(:tag_struct) do
+    builder.struct_builder[:tags, [:header, [[:attribute, :user_id], [:attribute, :tag]]]]
+  end
 
   describe 'with a relation' do
     let(:ast) do
-      [
-        :relation, :users, [
-          :header, [[:attribute, :id], [:attribute, :name]]
-        ],
-        base_name: :users
-      ]
+      [:relation, [
+        :users,
+        { dataset: :users, combine_name: :users },
+        [:header, [[:attribute, :id], [:attribute, :name]]]
+      ]]
     end
 
     it 'produces a valid header' do
@@ -24,32 +31,25 @@ RSpec.describe 'header builder', '#call' do
 
   describe 'with a graph' do
     let(:ast) do
-      [
-        :relation, :users, [
+      [:relation, [
+        :users,
+        { dataset: :users, combine_name: :users },
+        [
           :header, [
             [:attribute, :id],
             [:attribute, :name],
-            [
-              :relation, :tasks, [
-                :header, [
-                  [:attribute, :user_id],
-                  [:attribute, :title]
-                ]
-              ],
-              { base_name: :tasks, keys: { id: :user_id }, combine_type: :many }
-            ],
-            [
-              :relation, :tags, [
-                :header, [
-                  [:attribute, :user_id],
-                  [:attribute, :tag]
-                ]
-              ],
-              { base_name: :tags, keys: { id: :user_id }, combine_type: :many }
-            ]
-          ]
-        ],
-        base_name: :users
+            [:relation, [
+              :tasks,
+              { dataset: :tasks, keys: { id: :user_id }, combine_type: :many, combine_name: :tasks },
+              [:header, [[:attribute, :user_id], [:attribute, :title]]]
+            ]],
+            [:relation, [
+              :tags,
+              { dataset: :tags, keys: { id: :user_id }, combine_type: :many, combine_name: :tags },
+              [:header, [[:attribute, :user_id], [:attribute, :tag]]]
+            ]]
+          ]]
+        ]
       ]
     end
 
@@ -63,9 +63,8 @@ RSpec.describe 'header builder', '#call' do
          header: ROM::Header.coerce([[:user_id], [:tag]], model: tag_struct)]
       ]
 
-      header = ROM::Header.coerce(
-        attributes,
-        model: builder.struct_builder[:users, [:id, :name, :tasks, :tags]]
+      header = ROM::Header.coerce(attributes,
+        model: builder.struct_builder[:users, ast[1][2]]
       )
 
       expect(builder[ast]).to eql(header)