rom-sql 0.9.1 → 1.0.0.beta1

data/lib/rom/plugins/relation/sql/base_view.rb

@@ -1,31 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      module SQL
-        module BaseView
-          # @api private
-          def self.included(klass)
-            super
-            klass.extend(ClassInterface)
-          end
-
-          module ClassInterface
-            def inherited(klass)
-              super
-              klass.view(:base) do
-                header { dataset.columns }
-                relation { select(*attributes(:base)).order(primary_key) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  adapter :sql do
-    register :base_view, ROM::Plugins::Relation::SQL::BaseView, type: :relation
-  end
-end

data/lib/rom/sql/header.rb

@@ -1,61 +0,0 @@
-module ROM
-  module SQL
-    # @private
-    class Header
-      include Dry::Equalizer(:columns, :table)
-
-      SEP_REGEX = /_{2,3}/.freeze
-
-      attr_reader :columns, :table
-
-      def initialize(columns, table)
-        @columns = columns
-        @table = table
-      end
-
-      def to_ary
-        columns
-      end
-      alias_method :to_a, :to_ary
-
-      def to_h
-        columns.each_with_object({}) do |col, h|
-          left, right = col.to_s.split('___')
-          h[left.to_sym] = (right || left).to_sym
-        end
-      end
-
-      def names
-        columns.map { |col| :"#{col.to_s.split(SEP_REGEX).last}" }
-      end
-
-      def exclude(*names)
-        self.class.new(columns.find_all { |col| !names.include?(col) }, table)
-      end
-
-      def project(*names)
-        self.class.new(columns.find_all { |col| names.include?(col) }, table)
-      end
-
-      def qualified
-        self.class.new(columns.map { |col| :"#{table}__#{col}" }, table)
-      end
-
-      def rename(options)
-        self.class.new(columns.map { |col|
-          new_name = options[col]
-
-          if new_name
-            :"#{col}___#{new_name}"
-          else
-            col
-          end
-        }, table)
-      end
-
-      def prefix(col_prefix)
-        rename(Hash[columns.map { |col| [col, :"#{col_prefix}_#{col}"] }])
-      end
-    end
-  end
-end

data/lib/rom/sql/plugin/assoc_macros.rb

@@ -1,133 +0,0 @@
-require 'rom/sql/plugin/assoc_macros/class_interface'
-
-module ROM
-  module SQL
-    module Plugin
-      module AssocMacros
-        # Extends a relation class with assoc-macros and instance-level methods
-        #
-        # @api private
-        def self.included(relation)
-          super
-          relation.extend(ClassInterface)
-        end
-
-        # @api private
-        def model
-          self.class.model
-        end
-
-        # Join configured association.
-        #
-        # Uses INNER JOIN type.
-        #
-        # @example
-        #
-        #   setup.relation(:tasks)
-        #
-        #   setup.relations(:users) do
-        #     one_to_many :tasks, key: :user_id
-        #
-        #     def with_tasks
-        #       association_join(:tasks, select: [:title])
-        #     end
-        #   end
-        #
-        # @api public
-        def association_join(name, options = {})
-          graph_join(name, :inner, options)
-        end
-
-        # Join configured association
-        #
-        # Uses LEFT JOIN type.
-        #
-        # @example
-        #
-        #   setup.relation(:tasks)
-        #
-        #   setup.relations(:users) do
-        #     one_to_many :tasks, key: :user_id
-        #
-        #     def with_tasks
-        #       association_left_join(:tasks, select: [:title])
-        #     end
-        #   end
-        #
-        # @api public
-        def association_left_join(name, options = {})
-          graph_join(name, :left_outer, options)
-        end
-
-        # @api private
-        def graph_join(assoc_name, join_type, options = {})
-          assoc = model.association_reflection(assoc_name)
-
-          if assoc.nil?
-            raise NoAssociationError,
-              "Association #{assoc_name.inspect} has not been " \
-              "defined for relation #{name.relation.inspect}"
-          end
-
-          type = assoc[:type]
-          table_name = assoc[:class].table_name
-
-          graph_rel =
-            if type == :many_to_many
-              select = options[:select] || {}
-              graph_join_many_to_many(table_name, assoc, select)
-            else
-              graph_join_other(table_name, assoc, type, join_type, options)
-            end
-
-          graph_rel = graph_rel.where(assoc[:conditions]) if assoc[:conditions]
-
-          graph_rel
-        end
-
-        # @api private
-        def graph(*args)
-          __new__(dataset.__send__(__method__, *args))
-        end
-
-        private
-
-        def graph_join_many_to_many(name, assoc, select)
-          l_select, r_select =
-            if select.is_a?(Hash)
-              [select[assoc[:join_table]] || [], select[name]]
-            else
-              [[], select]
-            end
-
-          l_graph = graph(
-            assoc[:join_table],
-            { assoc[:left_key] => primary_key },
-            select: l_select, implicit_qualifier: self.name.dataset
-          )
-
-          l_graph.graph(
-            name, { primary_key => assoc[:right_key] }, select: r_select
-          )
-        end
-
-        def graph_join_other(name, assoc, type, join_type, options)
-          key           = assoc[:key]
-          on_conditions = assoc[:on] || {}
-
-          join_keys =
-            if type == :many_to_one
-              { assoc[:class].primary_key => key }
-            else
-              { key => primary_key }
-            end.merge(on_conditions)
-
-          graph(
-            name, join_keys,
-            options.merge(join_type: join_type, implicit_qualifier: self.name.dataset)
-          )
-        end
-      end
-    end
-  end
-end

data/lib/rom/sql/plugin/assoc_macros/class_interface.rb

@@ -1,128 +0,0 @@
-module ROM
-  module SQL
-    module Plugin
-      module AssocMacros
-        # Class DSL for SQL relations
-        #
-        # @api private
-        module ClassInterface
-          # @api private
-          def self.prepare(klass)
-            klass.class_eval do
-              class << self
-                attr_reader :model, :associations
-              end
-            end
-            klass.instance_variable_set('@model', Class.new(Sequel::Model))
-            klass.instance_variable_set('@associations', [])
-          end
-
-          # @api private
-          def self.extended(klass)
-            prepare(klass)
-          end
-
-          # Set up model and association ivars for descendant class
-          #
-          # @api private
-          def inherited(klass)
-            super
-            ClassInterface.prepare(klass)
-          end
-
-          # Set up a one-to-many association
-          #
-          # @example
-          #   class Users < ROM::Relation[:sql]
-          #     one_to_many :tasks, key: :user_id
-          #
-          #     def with_tasks
-          #       association_join(:tasks)
-          #     end
-          #   end
-          #
-          # @param [Symbol] name The name of the association
-          # @param [Hash] options The options hash
-          # @option options [Symbol] :key Name of the key to join on
-          # @option options [Hash] :on Additional conditions for join
-          # @option options [Hash] :conditions Additional conditions for WHERE
-          #
-          # @api public
-          def one_to_many(name, options)
-            associations << [__method__, name, { relation: name }.merge(options)]
-          end
-
-          # Set up a many-to-many association
-          #
-          # @example
-          #   class Tasks < ROM::Relation[:sql]
-          #     many_to_many :tags,
-          #       join_table: :task_tags,
-          #       left_key: :task_id,
-          #       right_key: :tag_id,
-          #
-          #     def with_tags
-          #       association_join(:tags)
-          #     end
-          #   end
-          #
-          # @param [Symbol] name The name of the association
-          # @param [Hash] options The options hash
-          # @option options [Symbol] :join_table Name of the join table
-          # @option options [Hash] :left_key Name of the left join key
-          # @option options [Hash] :right_key Name of the right join key
-          # @option options [Hash] :on Additional conditions for join
-          # @option options [Hash] :conditions Additional conditions for WHERE
-          #
-          # @api public
-          def many_to_many(name, options = {})
-            associations << [__method__, name, { relation: name }.merge(options)]
-          end
-
-          # Set up a many-to-one association
-          #
-          # @example
-          #   class Tasks < ROM::Relation[:sql]
-          #     many_to_one :users, key: :user_id
-          #
-          #     def with_users
-          #       association_join(:users)
-          #     end
-          #   end
-          #
-          # @param [Symbol] name The name of the association
-          # @param [Hash] options The options hash
-          # @option options [Symbol] :join_table Name of the join table
-          # @option options [Hash] :key Name of the join key
-          # @option options [Hash] :on Additional conditions for join
-          # @option options [Hash] :conditions Additional conditions for WHERE
-          #
-          # @api public
-          def many_to_one(name, options = {})
-            associations << [__method__, name, { relation: name }.merge(options)]
-          end
-
-          # Finalize the relation by setting up its associations (if any)
-          #
-          # @api private
-          def finalize(relations, relation)
-            return unless relation.dataset.db.table_exists?(dataset)
-
-            model.set_dataset(relation.dataset)
-            model.dataset.naked!
-
-            associations.each do |*args, assoc_opts|
-              options = Hash[assoc_opts]
-              other = relations[options.delete(:relation) || args[1]].model
-              model.public_send(*args, options.merge(class: other))
-            end
-
-            model.freeze
-
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/read_spec.rb

@@ -1,111 +0,0 @@
-require 'dry-struct'
-
-RSpec.describe 'Reading relations using custom mappers' do
-  include_context 'users and tasks'
-
-  with_adapters do
-    before :each do
-      module Test
-        class Goal < Dry::Struct
-          attribute :id, Types::Strict::Int
-          attribute :title, Types::Strict::String
-        end
-
-        class User < Dry::Struct
-          attribute :id, Types::Strict::Int
-          attribute :name, Types::Strict::String
-          attribute :goals, Types::Strict::Array.member(Goal)
-        end
-
-        class UserGoalCount < Dry::Struct
-          attribute :id, Types::Strict::Int
-          attribute :name, Types::Strict::String
-          attribute :goal_count, Types::Strict::Int
-        end
-      end
-
-      conf.relation(:goals) do
-        use :assoc_macros
-
-        register_as :goals
-        dataset :tasks
-      end
-
-      conf.relation(:users) do
-        use :assoc_macros
-
-        one_to_many :goals, key: :user_id
-
-        def by_name(name)
-          where(name: name)
-        end
-
-        def with_goals
-          association_left_join(:goals, select: [:id, :title])
-        end
-
-        def all
-          select(:id, :name)
-        end
-      end
-
-      conf.relation(:user_goal_counts) do
-        use :assoc_macros
-
-        dataset :users
-        register_as :user_goal_counts
-        one_to_many :goals, key: :user_id
-
-        def all
-          with_goals.select_group(:users__id, :users__name).select_append {
-            count(:tasks).as(:goal_count)
-          }
-        end
-
-        def with_goals
-          association_left_join(:goals, select: [:id, :title])
-        end
-      end
-
-      conf.mappers do
-        define(:users) do
-          model Test::User
-
-          group :goals do
-            model Test::Goal
-
-            attribute :id, from: :tasks_id
-            attribute :title
-          end
-        end
-
-        define(:user_goal_counts) do
-          model Test::UserGoalCount
-        end
-      end
-    end
-
-    it 'loads domain objects' do
-      user = container.relation(:users).as(:users).with_goals.by_name('Jane').to_a.first
-
-      expect(user).to eql(
-        Test::User.new(
-          id: 1, name: 'Jane', goals: [Test::Goal.new(id: 2, title: "Jane's task")]
-        ))
-    end
-
-    # FIXME: on mysql and sqlite
-    if metadata[:postgres]
-      it 'works with grouping and aggregates' do
-        container.relations[:goals].insert(id: 3, user_id: 1, title: 'Get Milk')
-
-        users_with_goal_count = container.relation(:user_goal_counts).as(:user_goal_counts).all
-
-        expect(users_with_goal_count.to_a).to eq([
-          Test::UserGoalCount.new(id: 1, name: "Jane", goal_count: 2),
-          Test::UserGoalCount.new(id: 2, name: "Joe", goal_count: 1)
-        ])
-      end
-    end
-  end
-end