torque-postgresql 2.4.2 → 3.0.0

data/spec/tests/belongs_to_many_spec.rb

@@ -344,7 +344,8 @@ RSpec.describe 'BelongsToMany' do
       subject.tags.concat(records)
 
       entries = Video.all
-      ActiveRecord::Associations::Preloader.new.preload(entries, :tags, Tag.all)
+      arguments = { records: entries, associations: :tags, available_records: Tag.all.to_a }
+      ActiveRecord::Associations::Preloader.new(**arguments).call
       entries = entries.load
 
       expect(entries.size).to be_eql(1)
@@ -392,53 +393,4 @@ RSpec.describe 'BelongsToMany' do
       end
     end
   end
-
-  context 'using uuid' do
-    let(:connection) { ActiveRecord::Base.connection }
-    let(:game) { Class.new(ActiveRecord::Base) }
-    let(:player) { Class.new(ActiveRecord::Base) }
-    let(:other) { player.create }
-
-    # TODO: Set as a shred example
-    before do
-      connection.create_table(:players, id: :uuid) { |t| t.string :name }
-      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
-
-      options = { anonymous_class: player, foreign_key: :player_ids }
-      options[:inverse_of] = false if Torque::PostgreSQL::AR610
-
-      game.table_name = 'games'
-      player.table_name = 'players'
-      game.belongs_to_many :players, **options
-    end
-
-    subject { game.create }
-
-    it 'loads associated records' do
-      subject.update(player_ids: [other.id])
-      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
-        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
-      SQL
-
-      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
-      expect(subject.players.to_a).to be_eql([other])
-    end
-
-    it 'can preload records' do
-      records = 5.times.map { player.create }
-      subject.players.concat(records)
-
-      entries = game.all.includes(:players).load
-
-      expect(entries.size).to be_eql(1)
-      expect(entries.first.players).to be_loaded
-      expect(entries.first.players.size).to be_eql(5)
-    end
-
-    it 'can joins records' do
-      query = game.all.joins(:players)
-      expect(query.to_sql).to match(/INNER JOIN "players"/)
-      expect { query.load }.not_to raise_error
-    end
-  end
 end

data/spec/tests/enum_set_spec.rb

@@ -31,7 +31,8 @@ RSpec.describe 'Enum' do
     it 'can be defined as an array' do
       subject.enum(:content_status, array: true, enum_type: :content_status)
       expect(subject['content_status'].name).to be_eql('content_status')
-      expect(subject['content_status'].type).to be_eql(:content_status)
+      expect(subject['content_status'].type).to be_eql(:enum)
+      expect(subject['content_status'].options[:enum_type]).to be_eql(:content_status)
 
       array = subject['content_status'].respond_to?(:options) \
         ? subject['content_status'].options[:array] \
@@ -42,19 +43,18 @@ RSpec.describe 'Enum' do
   end
 
   context 'on schema' do
-    let(:dump_result) do
-      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
-      dump_result.string
-    end
-
     it 'can be used on tables' do
-      checker = /t\.enum +"conflicts", +array: true, +enum_type: :conflicts/
-      expect(dump_result).to match checker
+      dump_io = StringIO.new
+      checker = /t\.enum +"conflicts", +array: true, +enum_type: "conflicts"/
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+      expect(dump_io.string).to match checker
     end
 
     xit 'can have a default value as an array of symbols' do
-      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +enum_type: :types/
-      expect(dump_result).to match checker
+      dump_io = StringIO.new
+      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +enum_type: "types"/
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+      expect(dump_io.string).to match checker
     end
   end
 

data/spec/tests/enum_spec.rb

@@ -26,12 +26,6 @@ RSpec.describe 'Enum' do
   end
 
   context 'on migration' do
-    it 'can be created' do
-      connection.create_enum(:status, %i(foo bar))
-      expect(connection.type_exists?(:status)).to be_truthy
-      expect(connection.enum_values(:status)).to be_eql(['foo', 'bar'])
-    end
-
     it 'can be deleted' do
       connection.create_enum(:status, %i(foo bar))
       expect(connection.type_exists?(:status)).to be_truthy
@@ -46,16 +40,6 @@ RSpec.describe 'Enum' do
       expect(connection.type_exists?(:status)).to be_truthy
     end
 
-    it 'can have prefix' do
-      connection.create_enum(:status, %i(foo bar), prefix: true)
-      expect(connection.enum_values(:status)).to be_eql(['status_foo', 'status_bar'])
-    end
-
-    it 'can have suffix' do
-      connection.create_enum(:status, %i(foo bar), suffix: 'tst')
-      expect(connection.enum_values(:status)).to be_eql(['foo_tst', 'bar_tst'])
-    end
-
     it 'inserts values at the end' do
       connection.create_enum(:status, %i(foo bar))
       connection.add_enum_values(:status, %i(baz qux))
@@ -85,80 +69,6 @@ RSpec.describe 'Enum' do
     end
   end
 
-  context 'on table definition' do
-    subject { table_definition.new(connection, 'articles') }
-
-    it 'has the enum method' do
-      expect(subject).to respond_to(:enum)
-    end
-
-    it 'can be used in a single form' do
-      subject.enum('content_status')
-      expect(subject['content_status'].name).to be_eql('content_status')
-      expect(subject['content_status'].type).to be_eql(:content_status)
-    end
-
-    it 'can be used in a multiple form' do
-      subject.enum('foo', 'bar', 'baz', enum_type: :content_status)
-      expect(subject['foo'].type).to be_eql(:content_status)
-      expect(subject['bar'].type).to be_eql(:content_status)
-      expect(subject['baz'].type).to be_eql(:content_status)
-    end
-
-    it 'can have custom type' do
-      subject.enum('foo', enum_type: :content_status)
-      expect(subject['foo'].name).to be_eql('foo')
-      expect(subject['foo'].type).to be_eql(:content_status)
-    end
-
-    it 'can use the deprecated subtype option' do
-      subject.enum('foo', subtype: :content_status)
-      expect(subject['foo'].name).to be_eql('foo')
-      expect(subject['foo'].type).to be_eql(:content_status)
-    end
-
-    it 'raises StatementInvalid when type isn\'t defined' do
-      subject.enum('foo')
-      creation = connection.send(:schema_creation).accept subject
-      expect{ connection.execute creation }.to raise_error(ActiveRecord::StatementInvalid)
-    end
-  end
-
-  context 'on schema' do
-    it 'dumps when has it' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /create_enum \"content_status\", \[/
-    end
-
-    it 'sorts the enum entries to better consistency' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      items = dump_io.string.scan(/create_enum "(\w+)"/).flatten
-      expect(items).to be_eql(items.sort)
-    end
-
-    it 'do not dump when has none' do
-      connection.drop_type(:content_status, force: :cascade)
-
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).not_to match /create_enum \"content_status\", \[/
-    end
-
-    it 'can be used on tables too' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"status", +enum_type: :content_status/
-    end
-
-    it 'can have a default value as symbol' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"role", +default: :visitor, +enum_type: :roles/
-    end
-  end
-
   context 'on value' do
     subject { Enum::ContentStatus }
     let(:values) { %w(created draft published archived) }

data/spec/tests/has_many_spec.rb

@@ -411,50 +411,4 @@ RSpec.describe 'HasMany' do
       expect { query.load }.not_to raise_error
     end
   end
-
-  context 'using uuid' do
-    let(:connection) { ActiveRecord::Base.connection }
-    let(:game) { Class.new(ActiveRecord::Base) }
-    let(:player) { Class.new(ActiveRecord::Base) }
-
-    # TODO: Set as a shred example
-    before do
-      connection.create_table(:players, id: :uuid) { |t| t.string :name }
-      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
-
-      options = { anonymous_class: game, foreign_key: :player_ids }
-      options[:inverse_of] = false if Torque::PostgreSQL::AR610
-
-      game.table_name = 'games'
-      player.table_name = 'players'
-      player.has_many :games, array: true, **options
-    end
-
-    subject { player.create }
-
-    it 'loads associated records' do
-      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
-        SELECT "games"\\.\\* FROM "games"
-        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
-      SQL
-
-      expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
-      expect(subject.games.to_a).to be_eql([])
-    end
-
-    it 'can preload records' do
-      5.times { game.create(player_ids: [subject.id]) }
-      entries = player.all.includes(:games).load
-
-      expect(entries.size).to be_eql(1)
-      expect(entries.first.games).to be_loaded
-      expect(entries.first.games.size).to be_eql(5)
-    end
-
-    it 'can joins records' do
-      query = player.all.joins(:games)
-      expect(query.to_sql).to match(/INNER JOIN "games"/)
-      expect { query.load }.not_to raise_error
-    end
-  end
 end

data/spec/tests/table_inheritance_spec.rb

@@ -73,33 +73,37 @@ RSpec.describe 'TableInheritance' do
   end
 
   context 'on schema' do
-    let(:dump_result) do
-      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
-      dump_result.string
-    end
-
     it 'dumps single inheritance with body' do
+      dump_io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+
       parts = '"activity_books"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: "activities"'
-      expect(dump_result).to match(/create_table #{parts} do /)
+      parts << ', inherits: :activities'
+      expect(dump_io.string).to match(/create_table #{parts} do /)
     end
 
     it 'dumps single inheritance without body' do
+      dump_io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+
       parts = '"activity_post_samples"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: "activity_posts"'
-      expect(dump_result).to match(/create_table #{parts}(?! do \|t\|)/)
+      parts << ', inherits: :activity_posts'
+      expect(dump_io.string).to match(/create_table #{parts}(?! do \|t\|)/)
     end
 
     it 'dumps multiple inheritance' do
+      dump_io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+
       parts = '"activity_posts"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: (\["images", "activities"\]|\["activities", "images"\])'
-      expect(dump_result).to match(/create_table #{parts}/)
+      parts << ', inherits: (\[:images, :activities\]|\[:activities, :images\])'
+      expect(dump_io.string).to match(/create_table #{parts}/)
     end
   end
 

metadata

@@ -1,23 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Carlos Silva
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-20 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '7.0'
   type: :runtime
@@ -25,9 +22,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
@@ -161,7 +155,7 @@ dependencies:
 description: Add support to complex resources of PostgreSQL, like data types, array
   associations, and auxiliary statements (CTE)
 email:
-- me@carlosfsilva.com
+- carlinhus.fsilva@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -195,14 +189,15 @@ files:
 - lib/torque/postgresql/arel/select_manager.rb
 - lib/torque/postgresql/arel/visitors.rb
 - lib/torque/postgresql/associations.rb
-- lib/torque/postgresql/associations/association.rb
 - lib/torque/postgresql/associations/association_scope.rb
 - lib/torque/postgresql/associations/belongs_to_many_association.rb
 - lib/torque/postgresql/associations/builder.rb
 - lib/torque/postgresql/associations/builder/belongs_to_many.rb
 - lib/torque/postgresql/associations/builder/has_many.rb
+- lib/torque/postgresql/associations/foreign_association.rb
 - lib/torque/postgresql/associations/preloader.rb
 - lib/torque/postgresql/associations/preloader/association.rb
+- lib/torque/postgresql/associations/preloader/loader_query.rb
 - lib/torque/postgresql/attributes.rb
 - lib/torque/postgresql/attributes/builder.rb
 - lib/torque/postgresql/attributes/builder/enum.rb
@@ -213,7 +208,6 @@ files:
 - lib/torque/postgresql/attributes/period.rb
 - lib/torque/postgresql/autosave_association.rb
 - lib/torque/postgresql/auxiliary_statement.rb
-- lib/torque/postgresql/auxiliary_statement/recursive.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
 - lib/torque/postgresql/collector.rb
@@ -238,9 +232,7 @@ files:
 - lib/torque/postgresql/relation/inheritance.rb
 - lib/torque/postgresql/relation/merger.rb
 - lib/torque/postgresql/schema_cache.rb
-- lib/torque/postgresql/table_name.rb
 - lib/torque/postgresql/version.rb
-- lib/torque/range.rb
 - spec/en.yml
 - spec/factories/authors.rb
 - spec/factories/comments.rb
@@ -258,12 +250,10 @@ files:
 - spec/models/activity_post/sample.rb
 - spec/models/author.rb
 - spec/models/author_journalist.rb
-- spec/models/category.rb
 - spec/models/comment.rb
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
-- spec/models/internal/user.rb
 - spec/models/item.rb
 - spec/models/post.rb
 - spec/models/question.rb
@@ -289,27 +279,21 @@ files:
 - spec/tests/lazy_spec.rb
 - spec/tests/period_spec.rb
 - spec/tests/quoting_spec.rb
-- spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
-- spec/tests/schema_spec.rb
 - spec/tests/table_inheritance_spec.rb
 homepage: https://github.com/crashtech/torque-postgresql
 licenses:
 - MIT
-metadata:
-  source_code_uri: https://github.com/crashtech/torque-postgresql
-  bug_tracker_uri: https://github.com/crashtech/torque-postgresql/issues
+metadata: {}
 post_install_message:
-rdoc_options:
-- "--title"
-- Torque PostgreSQL
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -338,12 +322,10 @@ test_files:
 - spec/models/activity_post.rb
 - spec/models/author.rb
 - spec/models/author_journalist.rb
-- spec/models/category.rb
 - spec/models/comment.rb
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
-- spec/models/internal/user.rb
 - spec/models/item.rb
 - spec/models/post.rb
 - spec/models/question.rb
@@ -369,7 +351,5 @@ test_files:
 - spec/tests/lazy_spec.rb
 - spec/tests/period_spec.rb
 - spec/tests/quoting_spec.rb
-- spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
-- spec/tests/schema_spec.rb
 - spec/tests/table_inheritance_spec.rb

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