rom-sql 1.3.5 → 2.0.0.beta1

data/lib/rom/sql/association/one_to_many.rb

@@ -1,60 +0,0 @@
-module ROM
-  module SQL
-    class Association
-      class OneToMany < Association
-        result :many
-
-        # @api public
-        def call(relations, right = relations[target.relation])
-          schema = right.schema.qualified
-
-          relation = right.inner_join(source_table, join_keys(relations))
-
-          if view
-            apply_view(schema, relation)
-          else
-            schema.(relation)
-          end
-        end
-
-        # @api public
-        def combine_keys(relations)
-          Hash[*with_keys(relations)]
-        end
-
-        # @api public
-        def join_keys(relations)
-          with_keys(relations) { |source_key, target_key|
-            { qualify(source_alias, source_key) => qualify(target, target_key) }
-          }
-        end
-
-        # @api private
-        def associate(relations, child, parent)
-          pk, fk = join_key_map(relations)
-          child.merge(fk => parent.fetch(pk))
-        end
-
-        protected
-
-        # @api private
-        def source_table
-          self_ref? ? Sequel.as(source.dataset, source_alias) : source
-        end
-
-        # @api private
-        def source_alias
-          self_ref? ? :"#{source.dataset.to_s[0]}_0" : source
-        end
-
-        # @api private
-        def with_keys(relations, &block)
-          source_key = relations[source.relation].primary_key
-          target_key = foreign_key || relations[target.relation].foreign_key(source.relation)
-          return [source_key, target_key] unless block
-          yield(source_key, target_key)
-        end
-      end
-    end
-  end
-end

data/lib/rom/sql/extensions/mysql/inferrer.rb

@@ -1,10 +0,0 @@
-require 'rom/sql/schema/inferrer'
-
-module ROM
-  module SQL
-    class Schema
-      class MysqlInferrer < Inferrer[:mysql]
-      end
-    end
-  end
-end

data/lib/rom/sql/qualified_attribute.rb

@@ -1,53 +0,0 @@
-require 'dry/core/cache'
-
-module ROM
-  module SQL
-    # Used as a pair table name + field name.
-    # Similar to Sequel::SQL::QualifiedIdentifier but we don't want
-    # Sequel types to leak into ROM
-    #
-    # @api private
-    class QualifiedAttribute
-      include Dry::Equalizer(:dataset, :attribute)
-
-      extend Dry::Core::Cache
-
-      # Dataset (table) name
-      #
-      # @api private
-      attr_reader :dataset
-
-      # Attribute (field, column) name
-      #
-      # @api private
-      attr_reader :attribute
-
-      # @api private
-      def self.[](*args)
-        fetch_or_store(args) { new(*args) }
-      end
-
-      # @api private
-      def initialize(dataset, attribute)
-        @dataset = dataset
-        @attribute = attribute
-      end
-
-      # Used by Sequel for building SQL statements
-      #
-      # @api private
-      def sql_literal_append(ds, sql)
-        ds.qualified_identifier_sql_append(sql, dataset, attribute)
-      end
-
-      # Convinient interface for attribute names
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def to_sym
-        attribute
-      end
-    end
-  end
-end

data/lib/rom/sql/schema/dsl.rb

@@ -1,75 +0,0 @@
-require 'rom/sql/attribute'
-require 'rom/sql/schema/inferrer'
-require 'rom/sql/schema/associations_dsl'
-
-module ROM
-  module SQL
-    class Schema < ROM::Schema
-      # Extended schema DSL
-      #
-      # @api private
-      class DSL < ROM::Schema::DSL
-        attr_reader :associations_dsl
-
-        # Define associations for a relation
-        #
-        # @example
-        #   class Users < ROM::Relation[:sql]
-        #     schema(infer: true) do
-        #       associations do
-        #         has_many :tasks
-        #         has_many :posts
-        #         has_many :posts, as: :priority_posts, view: :prioritized
-        #         belongs_to :account
-        #       end
-        #     end
-        #   end
-        #
-        #   class Posts < ROM::Relation[:sql]
-        #     schema(infer: true) do
-        #       associations do
-        #         belongs_to :users, as: :author
-        #       end
-        #     end
-        #
-        #     view(:prioritized) do
-        #       where { priority <= 3 }
-        #     end
-        #   end
-        #
-        # @return [AssociationDSL]
-        #
-        # @api public
-        def associations(&block)
-          @associations_dsl = AssociationsDSL.new(relation, &block)
-        end
-
-        # Return a schema
-        #
-        # @api private
-        def call
-          SQL::Schema.define(
-            relation, opts.merge(attributes: attributes.values, attr_class: SQL::Attribute)
-          )
-        end
-
-        private
-
-        # Return schema opts
-        #
-        # @return [Hash]
-        #
-        # @api private
-        def opts
-          opts = { inferrer: inferrer }
-
-          if associations_dsl
-            { **opts, associations: associations_dsl.call }
-          else
-            opts
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/association/many_to_many_spec.rb

@@ -1,89 +0,0 @@
-RSpec.describe ROM::SQL::Association::ManyToMany, helpers: true do
-  subject(:assoc) do
-    ROM::SQL::Association::ManyToMany.new(source, target, options)
-  end
-
-  let(:options) { { through: :tasks_tags } }
-
-  let(:tags) { double(:tags, primary_key: :id) }
-  let(:tasks) { double(:tasks, primary_key: :id) }
-  let(:tasks_tags) { double(:tasks, primary_key: [:task_id, :tag_id]) }
-
-  let(:source) { :tasks }
-  let(:target) { :tags }
-
-  let(:relations) do
-    { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
-  end
-
-  shared_examples_for 'many-to-many association' do
-    describe '#combine_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
-
-        expect(assoc.combine_keys(relations)).to eql(id: :tag_id)
-      end
-    end
-  end
-
-  describe '#result' do
-    it 'is :many' do
-      expect(assoc.result).to be(:many)
-    end
-  end
-
-  describe '#associate' do
-    let(:join_assoc) { double(:join_assoc) }
-
-    let(:source) { :tags }
-    let(:target) { :tasks }
-
-    it 'returns a list of join keys for given child tuples' do
-      expect(tasks_tags).to receive(:associations).and_return(assoc.target => join_assoc)
-      expect(join_assoc).to receive(:join_key_map).with(relations).and_return([:task_id, :id])
-      expect(tasks_tags).to receive(:foreign_key).with(:tags).and_return(:tag_id)
-
-      task_tuple = { id: 3 }
-      tag_tuples = [{ id: 1 }, { id: 2 }]
-
-      expect(assoc.associate(relations, tag_tuples, task_tuple)).to eql([
-        { tag_id: 1, task_id: 3 }, { tag_id: 2, task_id: 3 }
-      ])
-    end
-  end
-
-  context 'with default names' do
-    it_behaves_like 'many-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
-        )
-      end
-    end
-  end
-
-  context 'with custom relation names' do
-    let(:source) { assoc_name(:tasks, :user_tasks) }
-    let(:target) { assoc_name(:tags, :user_tags) }
-
-    let(:relations) do
-      { tasks: tasks, tags: tags, tasks_tags: tasks_tags }
-    end
-
-    it_behaves_like 'many-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks_tags).to receive(:foreign_key).with(:tasks).and_return(:tag_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:user_tasks, :id) => qualified_attribute(:tasks_tags, :tag_id)
-        )
-      end
-    end
-  end
-end

data/spec/unit/association/many_to_one_spec.rb

@@ -1,81 +0,0 @@
-RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
-  subject(:assoc) do
-    ROM::SQL::Association::ManyToOne.new(source, target, options)
-  end
-
-  let(:options) { {} }
-
-  let(:users) { double(:users, primary_key: :id) }
-  let(:tasks) { double(:tasks) }
-
-  let(:source) { :tasks }
-  let(:target) { :users }
-
-  let(:relations) do
-    { users: users, tasks: tasks }
-  end
-
-  describe '#result' do
-    it 'is :one' do
-      expect(assoc.result).to be(:one)
-    end
-  end
-
-  describe '#associate' do
-    it 'returns child tuple with FK set' do
-      expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-      task_tuple = { title: 'Task' }
-      user_tuple = { id: 3 }
-
-      expect(assoc.associate(relations, task_tuple, user_tuple)).to eql(
-        user_id: 3, title: 'Task'
-      )
-    end
-  end
-
-  shared_examples_for 'many-to-many association' do
-    describe '#combine_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.combine_keys(relations)).to eql(user_id: :id)
-      end
-    end
-  end
-
-  context 'with default names' do
-    it_behaves_like 'many-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:tasks, :user_id) => qualified_attribute(:users, :id)
-        )
-      end
-    end
-  end
-
-  context 'with custom relation names' do
-    let(:source) { assoc_name(:tasks, :user_tasks) }
-    let(:target) { assoc_name(:users, :people) }
-
-    let(:relations) do
-      { users: users, tasks: tasks }
-    end
-
-    it_behaves_like 'many-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:user_tasks, :user_id) => qualified_attribute(:people, :id)
-        )
-      end
-    end
-  end
-end

data/spec/unit/association/name_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe ROM::SQL::Association::Name do
-  describe '.[]' do
-    it 'returns a name object from a relation name' do
-      rel_name = ROM::Relation::Name[:users]
-      assoc_name = ROM::SQL::Association::Name[rel_name]
-
-      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :users))
-    end
-
-    it 'returns a name object from a relation and a dataset symbols' do
-      rel_name = ROM::Relation::Name[:users, :people]
-      assoc_name = ROM::SQL::Association::Name[:users, :people]
-
-      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :people))
-    end
-
-    it 'returns a name object from a relation and a dataset symbols and an alias' do
-      rel_name = ROM::Relation::Name[:users, :people]
-      assoc_name = ROM::SQL::Association::Name[:users, :people, :author]
-
-      expect(assoc_name).to eql(ROM::SQL::Association::Name.new(rel_name, :author))
-    end
-
-    it 'caches names' do
-      name = ROM::SQL::Association::Name[:users]
-
-      expect(name).to be(ROM::SQL::Association::Name[:users])
-
-      name = ROM::SQL::Association::Name[:users, :people]
-
-      expect(name).to be(ROM::SQL::Association::Name[:users, :people])
-
-      name = ROM::SQL::Association::Name[:users, :people, :author]
-
-      expect(name).to be(ROM::SQL::Association::Name[:users, :people, :author])
-    end
-  end
-
-  describe '#aliased?' do
-    it 'returns true if a name has an alias' do
-      expect(ROM::SQL::Association::Name[:users, :people, :author]).to be_aliased
-    end
-
-    it 'returns false if a name has no alias' do
-      expect(ROM::SQL::Association::Name[:users, :people]).to_not be_aliased
-    end
-  end
-
-  describe '#inspect' do
-    it 'includes info about the relation name' do
-      expect(ROM::SQL::Association::Name[:users].inspect).to eql(
-        "ROM::SQL::Association::Name(users)"
-      )
-    end
-
-    it 'includes info about the relation name and its dataset' do
-      expect(ROM::SQL::Association::Name[:users, :people].inspect).to eql(
-        "ROM::SQL::Association::Name(users on people)"
-      )
-    end
-
-    it 'includes info about the relation name, its dataset and alias' do
-      expect(ROM::SQL::Association::Name[:users, :people, :author].inspect).to eql(
-        "ROM::SQL::Association::Name(users on people as author)"
-      )
-    end
-  end
-end

data/spec/unit/association/one_to_many_spec.rb

@@ -1,82 +0,0 @@
-RSpec.describe ROM::SQL::Association::OneToMany, helpers: true do
-  subject(:assoc) do
-    ROM::SQL::Association::OneToMany.new(source, target, options)
-  end
-
-  let(:options) { {} }
-
-  let(:users) { double(:users, primary_key: :id) }
-  let(:tasks) { double(:tasks) }
-
-  describe '#associate' do
-    let(:source) { :users }
-    let(:target) { :tasks }
-
-    let(:relations) do
-      { users: users, tasks: tasks }
-    end
-
-    it 'returns child tuple with FK set' do
-      expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-      task_tuple = { title: 'Task' }
-      user_tuple = { id: 3 }
-
-      expect(assoc.associate(relations, task_tuple, user_tuple)).to eql(
-        user_id: 3, title: 'Task'
-      )
-    end
-  end
-
-  shared_examples_for 'one-to-many association' do
-    describe '#combine_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.combine_keys(relations)).to eql(id: :user_id)
-      end
-    end
-  end
-
-  context 'with default names' do
-    let(:source) { :users }
-    let(:target) { :tasks }
-
-    let(:relations) do
-      { users: users, tasks: tasks }
-    end
-
-    it_behaves_like 'one-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:users, :id) => qualified_attribute(:tasks, :user_id)
-        )
-      end
-    end
-  end
-
-  context 'with custom relation names' do
-    let(:source) { assoc_name(:users, :people) }
-    let(:target) { assoc_name(:tasks, :user_tasks) }
-
-    let(:relations) do
-      { users: users, tasks: tasks }
-    end
-
-    it_behaves_like 'one-to-many association'
-
-    describe '#join_keys' do
-      it 'returns a hash with combine keys' do
-        expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
-
-        expect(assoc.join_keys(relations)).to eql(
-          qualified_attribute(:people, :id) => qualified_attribute(:user_tasks, :user_id)
-        )
-      end
-    end
-  end
-end