rom-repository 1.4.0 → 2.0.0.beta1

data/spec/shared/repo.rb

@@ -1,86 +0,0 @@
-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[:users]) do
-      relations :tasks, :tags, :posts, :labels, :posts_labels, :books, :authors
-
-      def find_users(criteria)
-        users.find(criteria)
-      end
-
-      def all_users
-        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 users_with_posts_and_their_labels
-        users.combine(posts: [:labels])
-      end
-
-      def posts_with_labels
-        posts.combine_children(many: labels)
-      end
-
-      def label_with_posts
-        labels.combine_children(one: posts)
-      end
-
-      def tasks_for_users(users)
-        tasks.for_users(users)
-      end
-
-      def task_with_user
-        tasks.find(tasks[:id].qualified => 2).wrap_parent(user: users)
-      end
-
-      def task_with_owner
-        tasks.find(id: 2).combine_parents(one: { owner: users })
-      end
-
-      def tasks_with_tags(tasks = self.tasks)
-        tasks.combine_children(many: tags)
-      end
-
-      def tag_with_wrapped_task
-        tags.wrap_parent(task: tasks)
-      end
-    end
-  end
-
-  let(:comments_repo) do
-    Class.new(ROM::Repository[:comments]) do
-      relations :likes
-
-      def comments_with_likes
-        aggregate(many: { likes: likes })
-      end
-
-      def comments_with_emotions
-        root.combine(:emotions)
-      end
-    end.new(rom)
-  end
-end

data/spec/shared/seeds.rb

@@ -1,30 +0,0 @@
-RSpec.shared_context 'seeds' do
-  before do
-    jane_id = conn[:users].insert name: 'Jane'
-    joe_id = conn[:users].insert name: 'Joe'
-
-    conn[:tasks].insert user_id: joe_id, title: 'Joe Task'
-    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/shared/structs.rb

@@ -1,140 +0,0 @@
-RSpec.shared_context 'structs' do
-  let(:user_struct) do
-    repo.users.mapper.model
-  end
-
-  let(:task_struct) do
-    repo.tasks.mapper.model
-  end
-
-  let(:tag_struct) do
-    repo.tags.mapper.model
-  end
-
-  let(:post_struct) do
-    repo.posts.mapper.model
-  end
-
-  let(:label_struct) do
-    repo.labels.mapper.model
-  end
-
-  let(:post_with_labels_struct) do
-    mapper_for(repo.posts_with_labels).model
-  end
-
-  let(:label_with_posts_struct) do
-    mapper_for(repo.label_with_posts).model
-  end
-
-  let(:tag_with_task_struct) do
-    mapper_for(repo.tag_with_wrapped_task).model
-  end
-
-  let(:user_with_tasks_struct) do
-    mapper_for(repo.users_with_tasks).model
-  end
-
-  let(:user_with_task_struct) do
-    mapper_for(repo.users_with_task).model
-  end
-
-  let(:user_with_posts_struct) do
-    mapper_for(repo.users_with_posts_and_their_labels).model
-  end
-
-  let(:task_with_tags_struct) do
-    mapper_for(repo.tasks_with_tags).model
-  end
-
-  let(:task_with_user_struct) do
-    mapper_for(repo.task_with_user).model
-  end
-
-  let(:task_with_owner_struct) do
-    mapper_for(repo.task_with_owner).model
-  end
-
-  let(:jane) do
-    user_struct.new(id: 1, name: 'Jane')
-  end
-
-  let(:jane_with_tasks) do
-    user_with_tasks_struct.new(id: 1, name: 'Jane', all_tasks: [jane_task])
-  end
-
-  let(:jane_with_task) do
-    user_with_task_struct.new(id: 1, name: 'Jane', task: jane_task)
-  end
-
-  let(:jane_without_task) do
-    user_with_task_struct.new(id: 1, name: 'Jane', task: nil)
-  end
-
-  let(:jane_task) do
-    task_struct.new(id: 2, user_id: 1, title: 'Jane Task')
-  end
-
-  let(:task_with_user) do
-    task_with_user_struct.new(id: 2, user_id: 1, title: 'Jane Task', user: jane)
-  end
-
-  let(:task_with_owner) do
-    task_with_owner_struct.new(id: 2, user_id: 1, title: 'Jane Task', owner: jane)
-  end
-
-  let(:tag) do
-    tag_struct.new(id: 1, task_id: 2, name: 'red')
-  end
-
-  let(:task) do
-    task_struct.new(id: 2, user_id: 1, title: 'Jane Task')
-  end
-
-  let(:tag_with_task) do
-    tag_with_task_struct.new(id: 1, task_id: 2, name: 'red', task: task)
-  end
-
-  let(:task_with_tag) do
-    task_with_tags_struct.new(id: 2, user_id: 1, title: 'Jane Task', tags: [tag])
-  end
-
-  let(:user_with_task_and_tags) do
-    user_with_tasks_struct.new(id: 1, name: 'Jane', all_tasks: [task_with_tag])
-  end
-
-  let(:joe) do
-    user_struct.new(id: 2, name: 'Joe')
-  end
-
-  let(:joe_with_tasks) do
-    user_with_tasks_struct.new(id: 2, name: 'Joe', all_tasks: [joe_task])
-  end
-
-  let(:joe_with_task) do
-    user_with_task_struct.new(id: 2, name: 'Joe', task: joe_task)
-  end
-
-  let(:joe_task) do
-    task_struct.new(id: 1, user_id: 2, title: 'Joe Task')
-  end
-
-  let(:jane_with_posts) do
-    user_with_posts_struct.new(id: 1, name: 'Jane', posts: [post_with_label])
-  end
-
-  let(:label_red) do
-    label_with_posts_struct.new(id: 1, name: 'red', post: 1)
-  end
-
-  let(:label_blue) do
-    label_with_posts_struct.new(id: 3, name: 'blue', post: 1)
-  end
-
-  let(:post_with_label) do
-    post_with_labels_struct.new(id: 2, title: 'Hello From Jane',
-                                body: 'Jane Post',
-                                author_id: 1,
-                                labels: [label_red, label_blue])
-  end
-end

data/spec/spec_helper.rb

@@ -1,83 +0,0 @@
-# this is needed for guard to work, not sure why :(
-require "bundler"
-Bundler.setup
-
-if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
-  require 'yaml'
-  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
-  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
-
-  if RUBY_VERSION == latest_mri
-    require 'simplecov'
-    SimpleCov.start do
-      add_filter '/spec/'
-    end
-  end
-end
-
-require 'rom-sql'
-require 'rom-repository'
-
-begin
-  require 'byebug'
-rescue LoadError
-end
-
-root = Pathname(__FILE__).dirname
-LOGGER = Logger.new(File.open('./log/test.log', 'a'))
-
-require 'dry/core/deprecations'
-Dry::Core::Deprecations.set_logger!(root.join('../log/deprecations.log'))
-
-# Make inference errors quiet
-class ROM::SQL::Schema::Inferrer
-  def self.on_error(*args)
-    # shush
-  end
-end
-
-# Namespace holding all objects created during specs
-module Test
-  def self.remove_constants
-    constants.each(&method(:remove_const))
-  end
-end
-
-warning_api_available = RUBY_VERSION >= '2.4.0'
-
-module SileneceWarnings
-  def warn(str)
-    if str['/sequel/'] || str['/rspec-core']
-      nil
-    else
-      super
-    end
-  end
-end
-
-DB_URI = if defined? JRUBY_VERSION
-           'jdbc:postgresql://localhost/rom_repository'
-         else
-           'postgres://localhost/rom_repository'
-         end
-
-Warning.extend(SileneceWarnings) if warning_api_available
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.warnings = warning_api_available
-
-  config.after do
-    Test.remove_constants
-  end
-
-  Dir[root.join('support/*.rb').to_s].each do |f|
-    require f
-  end
-
-  Dir[root.join('shared/*.rb').to_s].each do |f|
-    require f
-  end
-
-  config.include(MapperRegistry)
-end

data/spec/support/mapper_registry.rb

@@ -1,9 +0,0 @@
-module MapperRegistry
-  def mapper_for(relation)
-    mapper_builder[relation.to_ast]
-  end
-
-  def mapper_builder
-    @mapper_builder ||= ROM::Repository::MapperBuilder.new
-  end
-end

data/spec/support/mutant.rb

@@ -1,10 +0,0 @@
-module Mutant
-  class Selector
-    # Expression based test selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end # Expression
-  end # Selector
-end # Mutant

data/spec/unit/changeset/associate_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Changeset, '#associate' do
-  include_context 'database setup'
-
-  before do
-    [:todos, :projects, :people].each { |table| conn.drop_table?(table) }
-
-    conn.create_table :people do
-      primary_key :id
-      column :name, String
-    end
-
-    conn.create_table :projects do
-      primary_key :id
-      column :name, String
-    end
-
-    conn.create_table :todos do
-      primary_key :id
-      foreign_key :user_id, :people, null: false, on_delete: :cascade
-      foreign_key :project_id, :projects, null: true, on_delete: :cascade
-      column :title, String
-    end
-
-    configuration.relation(:people) do
-      schema(infer: true) do
-        associations do
-          has_many :todos
-        end
-      end
-    end
-
-    configuration.relation(:projects) do
-      schema(infer: true) do
-        associations do
-          has_many :todos
-        end
-      end
-    end
-
-    configuration.relation(:todos) do
-      schema(infer: true) do
-        associations do
-          belongs_to :people, as: :user
-          belongs_to :projects, as: :project
-        end
-      end
-    end
-  end
-
-  let(:user_repo) do
-    Class.new(ROM::Repository[:people]) { commands :create }.new(rom)
-  end
-
-  let(:project_repo) do
-    Class.new(ROM::Repository[:projects]) { commands :create }.new(rom)
-  end
-
-  let(:task_repo) do
-    Class.new(ROM::Repository[:todos]) { commands :create }.new(rom)
-  end
-
-  context 'with Create' do
-    let(:jane) do
-      user_repo.create(name: 'Jane')
-    end
-
-    let(:project) do
-      project_repo.create(name: 'rom-rb')
-    end
-
-    it 'associates child with parent' do
-      changeset = task_repo.changeset(title: 'Test 1').associate(jane, :user)
-
-      expect(changeset.commit).to include(user_id: jane.id, title: 'Test 1')
-    end
-
-    it 'associates child with multiple parents' do
-      changeset = task_repo.changeset(title: 'Test 1').
-                    associate(jane, :user).
-                    associate(project)
-
-      expect(changeset.commit).
-        to include(user_id: jane.id, project_id: project.id, title: 'Test 1')
-    end
-
-    it 'raises when assoc name cannot be inferred' do
-      other = Class.new do
-        def self.schema
-          []
-        end
-      end.new
-
-      expect { task_repo.changeset(title: 'Test 1').associate(other) }.
-        to raise_error(ArgumentError, /can't infer association name for/)
-    end
-  end
-
-  context 'with Update' do
-    let!(:john) do
-      user_repo.create(name: 'John')
-    end
-
-    let!(:jane) do
-      user_repo.create(name: 'Jane')
-    end
-
-    let!(:task) do
-      task_repo.create(title: 'Test 1', user_id: john.id)
-    end
-
-    it 'associates child with parent' do
-      changeset = task_repo.changeset(task.id, title: 'Test 2')
-
-      expect(changeset.associate(jane, :user).commit).
-        to include(user_id: jane.id, title: 'Test 2')
-    end
-  end
-end