torque-postgresql 2.4.4 → 3.0.0

data/lib/torque/postgresql/auxiliary_statement/recursive.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module Torque
-  module PostgreSQL
-    class AuxiliaryStatement
-      class Recursive < AuxiliaryStatement
-        # Setup any additional option in the recursive mode
-        def initialize(*, **options)
-          super
-
-          @connect = options[:connect]&.to_a&.first
-          @union_all = options[:union_all]
-          @sub_query = options[:sub_query]
-
-          if options.key?(:with_depth)
-            @depth = options[:with_depth].values_at(:name, :start, :as)
-            @depth[0] ||= 'depth'
-          end
-
-          if options.key?(:with_path)
-            @path = options[:with_path].values_at(:name, :source, :as)
-            @path[0] ||= 'path'
-          end
-        end
-
-        private
-
-          # Build the string or arel query
-          def build_query(base)
-            # Expose columns and get the list of the ones for select
-            columns = expose_columns(base, @query.try(:arel_table))
-            sub_columns = columns.dup
-            type = @union_all.present? ? 'all' : ''
-
-            # Build any extra columns that are dynamic and from the recursion
-            extra_columns(base, columns, sub_columns)
-
-            # Prepare the query depending on its type
-            if @query.is_a?(String) && @sub_query.is_a?(String)
-              args = @args.each_with_object({}) { |h, (k, v)| h[k] = base.connection.quote(v) }
-              ::Arel.sql("(#{@query} UNION #{type.upcase} #{@sub_query})" % args)
-            elsif relation_query?(@query)
-              @query = @query.where(@where) if @where.present?
-              @bound_attributes.concat(@query.send(:bound_attributes))
-
-              if relation_query?(@sub_query)
-                @bound_attributes.concat(@sub_query.send(:bound_attributes))
-
-                sub_query = @sub_query.select(*sub_columns).arel
-                sub_query.from([@sub_query.arel_table, table])
-              else
-                sub_query = ::Arel.sql(@sub_query)
-              end
-
-              @query.select(*columns).arel.union(type, sub_query)
-            else
-              raise ArgumentError, <<-MSG.squish
-                Only String and ActiveRecord::Base objects are accepted as query and sub query
-                objects, #{@query.class.name} given for #{self.class.name}.
-              MSG
-            end
-          end
-
-          # Setup the statement using the class configuration
-          def prepare(base, settings)
-            super
-
-            prepare_sub_query(base, settings)
-          end
-
-          # Make sure that both parts of the union are ready
-          def prepare_sub_query(base, settings)
-            @union_all = settings.union_all if @union_all.nil?
-            @sub_query ||= settings.sub_query
-            @depth ||= settings.depth
-            @path ||= settings.path
-
-            # Collect the connection
-            @connect ||= settings.connect || begin
-              key = base.primary_key
-              [key.to_sym, :"parent_#{key}"] unless key.nil?
-            end
-
-            raise ArgumentError, <<-MSG.squish if @sub_query.nil? && @query.is_a?(String)
-              Unable to generate sub query from a string query. Please provide a `sub_query`
-              property on the "#{table_name}" settings.
-            MSG
-
-            if @sub_query.nil?
-              raise ArgumentError, <<-MSG.squish if @connect.blank?
-                Unable to generate sub query without setting up a proper way to connect it
-                with the main query. Please provide a `connect` property on the "#{table_name}"
-                settings.
-              MSG
-
-              left, right = @connect.map(&:to_s)
-              condition = @query.arel_table[right].eq(table[left])
-
-              if @query.where_values_hash.key?(right)
-                @sub_query = @query.unscope(where: right.to_sym).where(condition)
-              else
-                @sub_query = @query.where(condition)
-                @query = @query.where(right => nil)
-              end
-            elsif @sub_query.respond_to?(:call)
-              # Call a proc to get the real sub query
-              call_args = @sub_query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
-              @sub_query = @sub_query.call(*call_args)
-            end
-          end
-
-          # Add depth and path if they were defined in settings
-          def extra_columns(base, columns, sub_columns)
-            return if @query.is_a?(String) || @sub_query.is_a?(String)
-
-            # Add the connect attribute to the query
-            if defined?(@connect)
-              columns.unshift(@query.arel_table[@connect[0]])
-              sub_columns.unshift(@sub_query.arel_table[@connect[0]])
-            end
-
-            # Build a column to represent the depth of the recursion
-            if @depth.present?
-              name, start, as = @depth
-              col = table[name]
-              base.select_extra_values += [col.as(as)] unless as.nil?
-
-              columns << ::Arel.sql(start.to_s).as(name)
-              sub_columns << (col + ::Arel.sql('1')).as(name)
-            end
-
-            # Build a column to represent the path of the record access
-            if @path.present?
-              name, source, as = @path
-              source = @query.arel_table[source || @connect[0]]
-
-              col = table[name]
-              base.select_extra_values += [col.as(as)] unless as.nil?
-              parts = [col, source.cast(:varchar)]
-
-              columns << ::Arel.array([source]).cast(:varchar, true).as(name)
-              sub_columns << ::Arel::Nodes::NamedFunction.new('array_append', parts).as(name)
-            end
-          end
-
-      end
-    end
-  end
-end

data/lib/torque/postgresql/table_name.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Torque
-  module PostgreSQL
-    class TableName < Delegator
-      def initialize(klass, table_name)
-        @klass = klass
-        @table_name = table_name
-      end
-
-      def schema
-        return @schema if defined?(@schema)
-
-        @schema = ([@klass] + @klass.module_parents[0..-2]).find do |klass|
-          next unless klass.respond_to?(:schema) && !(value = klass.schema).nil?
-          break value
-        end
-      end
-
-      def to_s
-        schema.nil? ? @table_name : "#{schema}.#{@table_name}"
-      end
-
-      alias __getobj__ to_s
-
-      def ==(other)
-        other.to_s =~ /("?#{schema | search_path_schemes.join('|')}"?\.)?"?#{@table_name}"?/
-      end
-
-      def __setobj__(value)
-        @table_name = value
-      end
-
-      private
-
-        def search_path_schemes
-          klass.connection.schemas_search_path_sanitized
-        end
-    end
-  end
-end

data/lib/torque/range.rb

@@ -1,22 +0,0 @@
-module Torque
-  module Range
-    def intersection(other)
-      ActiveSupport::Deprecation.warn('Range extensions will be removed in future versions')
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-
-      new_min = self.cover?(other.min) ? other.min : other.cover?(min) ? min : nil
-      new_max = self.cover?(other.max) ? other.max : other.cover?(max) ? max : nil
-
-      new_min && new_max ? new_min..new_max : nil
-    end
-    alias_method :&, :intersection
-
-    def union(other)
-      ActiveSupport::Deprecation.warn('Range extensions will be removed in future versions')
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-
-      ([min, other.min].min)..([max, other.max].max)
-    end
-    alias_method :|, :union
-  end
-end

data/spec/models/category.rb

@@ -1,2 +0,0 @@
-class Category < ActiveRecord::Base
-end

data/spec/models/internal/user.rb

@@ -1,5 +0,0 @@
-module Internal
-  class User < ActiveRecord::Base
-    self.schema = 'internal'
-  end
-end

data/spec/tests/range_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.xdescribe 'Range' do
-  let(:sample) { (5..15) }
-
-  it 'has intersection' do
-    expect { sample.intersection(10) }.to raise_error(ArgumentError, /Range/)
-
-    result = sample & (10..15)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(10)
-    expect(result.max).to be_eql(15)
-
-    result = sample & (15..20)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(15)
-    expect(result.max).to be_eql(15)
-
-    result = sample & (0..10)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(5)
-    expect(result.max).to be_eql(10)
-
-    result = sample & (-10..0)
-    expect(result).to be_nil
-  end
-
-  it 'has union' do
-    expect { sample.union(10) }.to raise_error(ArgumentError, /Range/)
-
-    result = sample | (0..10)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(0)
-    expect(result.max).to be_eql(15)
-  end
-end

data/spec/tests/schema_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Schema' do
-  let(:connection) { ActiveRecord::Base.connection }
-
-  before do
-    connection.instance_variable_set(:@schmeas_blacklist, nil)
-    connection.instance_variable_set(:@schmeas_whitelist, nil)
-  end
-
-  context 'on migration' do
-    it 'can check for existance' do
-      expect(connection.schema_exists?(:information_schema)).to be_falsey
-      expect(connection.schema_exists?(:information_schema, filtered: false)).to be_truthy
-    end
-
-    it 'can be created' do
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
-      connection.create_schema(:legacy)
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
-    end
-
-    it 'can be deleted' do
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
-
-      connection.create_schema(:legacy)
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
-
-      connection.drop_schema(:legacy)
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
-    end
-
-    it 'works with whitelist' do
-      expect(connection.schema_exists?(:legacy)).to be_falsey
-      connection.create_schema(:legacy)
-
-      expect(connection.schema_exists?(:legacy)).to be_falsey
-      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
-
-      connection.schemas_whitelist.push('legacy')
-      expect(connection.schema_exists?(:legacy)).to be_truthy
-    end
-
-    context 'reverting' do
-      let(:migration) { ActiveRecord::Migration::Current.new('Testing') }
-
-      before { connection.create_schema(:legacy) }
-
-      it 'reverts the creation of a schema' do
-        expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
-        migration.revert { migration.connection.create_schema(:legacy) }
-        expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
-      end
-
-      it 'reverts the creation of a table' do
-        connection.create_table(:users, schema: :legacy) { |t| t.string(:name) }
-
-        expect(connection.table_exists?('legacy.users')).to be_truthy
-        migration.revert { migration.connection.create_table(:users, schema: :legacy) }
-        expect(connection.table_exists?('legacy.users')).to be_falsey
-      end
-    end
-  end
-
-  context 'on schema' do
-    let(:dump_result) do
-      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
-      dump_result.string
-    end
-
-    it 'does not add when there is no extra schemas' do
-      connection.drop_schema(:internal, force: :cascade)
-      expect(dump_result).not_to match /Custom schemas defined in this database/
-    end
-
-    it 'does not include tables from blacklisted schemas' do
-      connection.schemas_blacklist.push('internal')
-      expect(dump_result).not_to match /create_table \"users\",.*schema: +"internal"/
-    end
-
-    context 'with internal schema whitelisted' do
-      before { connection.schemas_whitelist.push('internal') }
-
-      it 'dumps the schemas' do
-        expect(dump_result).to match /create_schema \"internal\"/
-      end
-
-      it 'shows the internal users table in the connection tables list' do
-        expect(connection.tables).to include('internal.users')
-      end
-
-      it 'dumps tables on whitelisted schemas' do
-        expect(dump_result).to match /create_table \"users\",.*schema: +"internal"/
-      end
-    end
-
-    it 'does not affect serial ids' do
-      connection.create_table(:primary_keys, id: :serial) do |t|
-        t.string :title
-      end
-
-      parts = '"primary_keys", id: :serial, force: :cascade'
-      expect(dump_result).to match(/create_table #{parts} do /)
-    end
-  end
-
-  context 'on relation' do
-    let(:model) { Internal::User }
-    let(:table_name) { Torque::PostgreSQL::TableName.new(model, 'users') }
-
-    it 'adds the schema to the query' do
-      model.reset_table_name
-      expect(table_name.to_s).to eq('internal.users')
-      expect(model.all.to_sql).to match(/FROM "internal"."users"/)
-    end
-
-    it 'can load the schema from the module' do
-      allow(Internal).to receive(:schema).and_return('internal')
-      allow(model).to receive(:schema).and_return(nil)
-
-      model.reset_table_name
-      expect(table_name.to_s).to eq('internal.users')
-      expect(model.all.to_sql).to match(/FROM "internal"."users"/)
-    end
-
-    it 'does not change anything if the model has not configured a schema' do
-      allow(model).to receive(:schema).and_return(nil)
-
-      model.reset_table_name
-      expect(table_name.to_s).to eq('users')
-      expect(model.all.to_sql).to match(/FROM "users"/)
-    end
-  end
-end