torque-postgresql 3.2.2 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1948838632756aeab31c22f59995a8a41ce1900671e3cc9e1f8d802d898a4fe6
-  data.tar.gz: ca24eb91ead1a52927d1b0069e8408419600ba7884744a31de3909f45b59bb4d
+  metadata.gz: a8dfe147f5a65e1626923bff250d8c057c73e2fc2c2f2ea6812d67537da32e38
+  data.tar.gz: 3205fea618ea9da4d9aeccf3b5d48e3dff72a4a670e181c78c9b9a0b9896cfbf
 SHA512:
-  metadata.gz: 41071ecb22d7730bdb0debe558cf4b14db7ca648637d8f59cc43de31d0ca847b0ce7df2447b2e75be507b7ccd03f668c0dc7fa7232a38217889f5172f923a243
-  data.tar.gz: 74be2a0828976d3f521e3c9ff0c49708cc767dd019c8a22b6e98080bbda036da4297675c8852f124d01de3588f04b390ae7f5138549a3e85a6f6ce0ad1e50ccb
+  metadata.gz: ce88617dcacc292754245e9fff7f7dba62ec672a5b7b4760fff2ff2b28b4b25be7e8413b92bf509f5f9f9c4d0b096559b7ec46de4fdce5294181c363f34367fb
+  data.tar.gz: 6c3e8e96edd6b906bd2f0038869f9f15596fad7f22745c5bd63c08b623a55cf97f6185877206dac54a7e93e81ce5d7644bfeb048e7e2db1780bb7cadc7843159

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -176,11 +176,11 @@ module Torque
         # Build the query for allowed schemas
         def user_defined_schemas_sql
           conditions = []
-          conditions << <<-SQL if schemas_blacklist.any?
-            nspname NOT LIKE ANY (ARRAY['#{schemas_blacklist.join("', '")}'])
+          conditions << <<-SQL.squish if schemas_blacklist.any?
+            nspname NOT LIKE ALL (ARRAY['#{schemas_blacklist.join("', '")}'])
           SQL
 
-          conditions << <<-SQL if schemas_whitelist.any?
+          conditions << <<-SQL.squish if schemas_whitelist.any?
             nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
           SQL
 

data/lib/torque/postgresql/adapter/schema_creation.rb

@@ -16,7 +16,7 @@ module Torque
             statements.concat(o.indexes.map { |c, o| index_in_create(o.name, c, o) })
           end
 
-          if supports_foreign_keys?
+          if @conn.supports_foreign_keys?
             statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -122,6 +122,12 @@ module Torque
           super.sub('SELECT c.relname FROM', "SELECT n.nspname || '.' || c.relname FROM")
         end
 
+        # Add schema and inherits as one of the valid options for table
+        # definition
+        def valid_table_definition_options
+          super + [:schema, :inherits]
+        end
+
         private
 
           # Remove the schema from the sequence name

data/lib/torque/postgresql/associations/preloader/loader_query.rb

@@ -11,20 +11,20 @@ module Torque
 
           def load_records_for_keys(keys, &block)
             condition = query_condition_for(keys)
+            return super if condition.nil?
+
             scope.where(condition).load(&block)
           end
 
           def query_condition_for(keys)
-            if connected_through_array?
-              value = scope.cast_for_condition(foreign_column, keys.to_a)
-              scope.table[association_key_name].overlaps(value)
-            else
-              { association_key_name => keys }
-            end
+            return unless connected_through_array?
+
+            value = scope.cast_for_condition(foreign_column, keys.to_a)
+            scope.table[association_key_name].overlaps(value)
           end
 
           def connected_through_array?
-            foreign_column.array?
+            !association_key_name.is_a?(Array) && foreign_column.array?
           end
         end
 

data/lib/torque/postgresql/config.rb

@@ -4,6 +4,9 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
+    # Stores a version check for compatibility purposes
+    AR710 = (ActiveRecord.gem_version >= Gem::Version.new('7.1.0'))
+
     # Use the same logger as the Active Record one
     def self.logger
       ActiveRecord::Base.logger
@@ -17,8 +20,8 @@ module Torque
       send("#{name}=", klass)
     end
 
-    # Set if any information that requires querying and searching or collectiong
-    # information shuld be eager loaded. This automatically changes when rails
+    # Set if any information that requires querying and searching or collecting
+    # information should be eager loaded. This automatically changes when rails
     # same configuration is set to true
     config.eager_load = false
 

data/lib/torque/postgresql/reflection/association_reflection.rb

@@ -17,7 +17,7 @@ module Torque
         private
 
           # Check if the foreign key should be pluralized
-          def derive_foreign_key
+          def derive_foreign_key(*, **)
             result = super
             result = ActiveSupport::Inflector.pluralize(result) \
               if collection? && connected_through_array?

data/lib/torque/postgresql/schema_cache/bound_schema_reflection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module BoundSchemaReflection
+      def add_model_name(table_name, model)
+        @schema_reflection.add_model_name(@connection, table_name, model)
+      end
+
+      def dependencies(table_name)
+        @schema_reflection.dependencies(@connection, table_name)
+      end
+
+      def associations(table_name)
+        @schema_reflection.associations(@connection, table_name)
+      end
+
+      def lookup_model(table_name, scoped_class = '')
+        @schema_reflection.lookup_model(@connection, table_name, scoped_class)
+      end
+    end
+
+    ActiveRecord::ConnectionAdapters::BoundSchemaReflection.prepend BoundSchemaReflection
+  end
+end

data/lib/torque/postgresql/schema_cache/inheritance.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module SchemaCache
+      module Inheritance
+
+        # Try to find a model based on a given table
+        def lookup_model(table_name, scoped_class = '', source_to_model:)
+          scoped_class = scoped_class.name if scoped_class.is_a?(Class)
+          return source_to_model[table_name] if source_to_model.key?(table_name)
+
+          # Get all the possible scopes
+          scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
+          scopes.unshift('Object::')
+
+          # Check if the table name comes with a schema
+          if table_name.include?('.')
+            schema, table_name = table_name.split('.')
+            scopes.insert(1, schema.camelize) if schema != 'public'
+          end
+
+          # Consider the maximum namespaced possible model name
+          max_name = table_name.tr('_', '/').camelize.split(/(::)/)
+          max_name[-1] = max_name[-1].singularize
+
+          # Test all the possible names against all the possible scopes
+          until scopes.size == 0
+            scope = scopes.join.chomp('::').safe_constantize
+            model = find_model(max_name, table_name, scope) unless scope.nil?
+            return source_to_model[table_name] = model unless model.nil?
+            scopes.pop
+          end
+
+          # If this part is reach, no model name was found
+          raise LookupError.new(<<~MSG.squish)
+            Unable to find a valid model that is associated with the
+            '#{table_name}' table. Please, check if they correctly inherit from
+            ActiveRecord::Base
+          MSG
+        end
+
+        protected
+
+          # Find a model by a given max namespaced class name that matches the
+          # given table name
+          def find_model(max_name, table_name, scope = Object)
+            pieces = max_name.is_a?(::Array) ? max_name : max_name.split(/(::)/)
+            ns_places = (1..(max_name.size - 1)).step(2).to_a
+
+            # Generate all possible combinations
+            conditions = []
+            range = Torque::PostgreSQL.config.inheritance.inverse_lookup \
+              ? 0.upto(ns_places.size) \
+              : ns_places.size.downto(0)
+            range.each do |size|
+              conditions.concat(ns_places.combination(size).to_a)
+            end
+
+            # Now iterate over
+            while (condition = conditions.shift)
+              ns_places.each do |i|
+                pieces[i] = condition.include?(i) ? '::' : ''
+              end
+
+              candidate = pieces.join
+              candidate.prepend("#{scope.name}::") unless scope === Object
+
+              klass = candidate.safe_constantize
+              next if klass.nil?
+
+              # Check if the class match the table name
+              return klass if klass < ::ActiveRecord::Base &&
+                klass.table_name == table_name
+            end
+          end
+
+          # Calculates the inverted dependency (association), where even indirect
+          # inheritance comes up in the list
+          def generate_associations(inheritance_dependencies)
+            return {} if inheritance_dependencies.empty?
+
+            result = Hash.new{ |h, k| h[k] = [] }
+            masters = inheritance_dependencies.values.flatten.uniq
+
+            # Add direct associations
+            masters.map do |master|
+              inheritance_dependencies.each do |(dependent, associations)|
+                result[master] << dependent if associations.include?(master)
+              end
+            end
+
+            # Add indirect associations
+            result.each do |master, children|
+              children.each do |child|
+                children.concat(result[child]).uniq! if result.key?(child)
+              end
+            end
+
+            # Remove the default proc that would create new entries
+            result.default_proc = nil
+            result
+          end
+
+          # Parse the Torque config into the proper hash of irregular models.
+          # This is smart enough to only load necessary models
+          def prepare_irregular_models(data_sources)
+            entries = Torque::PostgreSQL.config.irregular_models
+            entries.slice(*data_sources).each_with_object({}) do |(table, model), hash|
+              hash[table] = model.is_a?(Class) ? model : model.constantize
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/schema_cache/schema_reflection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module SchemaReflection
+      def add_model_name(connection, table_name, model)
+        cache(connection).add_model_name(connection, table_name, model)
+      end
+
+      def dependencies(connection, table_name)
+        cache(connection).dependencies(connection, table_name)
+      end
+
+      def associations(connection, table_name)
+        cache(connection).associations(connection, table_name)
+      end
+
+      def lookup_model(connection, table_name, scoped_class)
+        cache(connection).lookup_model(table_name, scoped_class)
+      end
+    end
+
+    ActiveRecord::ConnectionAdapters::SchemaReflection.prepend SchemaReflection
+  end
+end

data/lib/torque/postgresql/schema_cache.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'torque/postgresql/schema_cache/inheritance'
+
+if Torque::PostgreSQL::AR710
+  require 'torque/postgresql/schema_cache/schema_reflection'
+  require 'torque/postgresql/schema_cache/bound_schema_reflection'
+end
+
 module Torque
   module PostgreSQL
     LookupError = Class.new(ArgumentError)
 
     # :TODO: Create the +add+ to load inheritance info
     module SchemaCache
+      include Torque::PostgreSQL::SchemaCache::Inheritance
 
       def initialize(*) # :nodoc:
         super
@@ -37,7 +45,7 @@ module Torque
         @inheritance_associations = coder['inheritance_associations']
       end
 
-      def add(table_name, *) # :nodoc:
+      def add(connection_or_table_name, table_name = connection_or_table_name, *) # :nodoc:
         super
 
         # Reset inheritance information when a table is added
@@ -64,8 +72,8 @@ module Torque
         ].map(&:size).inject(:+)
       end
 
-      def clear_data_source_cache!(name) # :nodoc:
-        super
+      def clear_data_source_cache!(connection_or_name, name = connection_or_name) # :nodoc:
+        Torque::PostgreSQL::AR710 ? super : super(name)
         @data_sources_model_names.delete name
         @inheritance_dependencies.delete name
         @inheritance_associations.delete name
@@ -89,94 +97,37 @@ module Torque
       end
 
       # A way to manually add models name so it doesn't need the lookup method
-      def add_model_name(table_name, model)
-        return unless data_source_exists?(table_name) && model.is_a?(Class)
-        @data_sources_model_names[table_name] = model
+      def add_model_name(*args)
+        model, *source = args.reverse
+        return unless data_source_exists?(*source.reverse) && model.is_a?(Class)
+
+        @data_sources_model_names[source.first] = model
       end
 
       # Get all the tables that the given one inherits from
-      def dependencies(table_name)
-        reload_inheritance_data!
+      def dependencies(conn, table_name = conn)
+        reload_inheritance_data!(conn == table_name ? connection : conn)
         @inheritance_dependencies[table_name]
       end
 
       # Get the list of all tables that are associated (direct or indirect
       # inheritance) with the provided one
-      def associations(table_name)
-        reload_inheritance_data!
+      def associations(conn, table_name = conn)
+        reload_inheritance_data!(conn == table_name ? connection : conn)
         @inheritance_associations[table_name]
       end
 
-      # Try to find a model based on a given table
-      def lookup_model(table_name, scoped_class = '')
-        scoped_class = scoped_class.name if scoped_class.is_a?(Class)
-        return @data_sources_model_names[table_name] \
-          if @data_sources_model_names.key?(table_name)
-
-        # Get all the possible scopes
-        scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
-        scopes.unshift('Object::')
-
-        # Check if the table name comes with a schema
-        if table_name.include?('.')
-          schema, table_name = table_name.split('.')
-          scopes.insert(1, schema.camelize) if schema != 'public'
-        end
-
-        # Consider the maximum namespaced possible model name
-        max_name = table_name.tr('_', '/').camelize.split(/(::)/)
-        max_name[-1] = max_name[-1].singularize
-
-        # Test all the possible names against all the possible scopes
-        until scopes.size == 0
-          scope = scopes.join.chomp('::').safe_constantize
-          model = find_model(max_name, table_name, scope) unless scope.nil?
-          return @data_sources_model_names[table_name] = model unless model.nil?
-          scopes.pop
-        end
-
-        # If this part is reach, no model name was found
-        raise LookupError.new(<<~MSG.squish)
-          Unable to find a valid model that is associated with the '#{table_name}' table.
-          Please, check if they correctly inherit from ActiveRecord::Base
-        MSG
+      # Override the inheritance implementation to pass over the proper cache of
+      # the existing association between data sources and model names
+      def lookup_model(*args, **xargs)
+        super(*args, **xargs, source_to_model: @data_sources_model_names)
       end
 
       private
 
-        # Find a model by a given max namespaced class name thath matches the
-        # given table name
-        def find_model(max_name, table_name, scope = Object)
-          pieces = max_name.is_a?(::Array) ? max_name : max_name.split(/(::)/)
-          ns_places = (1..(max_name.size - 1)).step(2).to_a
-
-          # Generate all possible combinarions
-          conditions = []
-          range = Torque::PostgreSQL.config.inheritance.inverse_lookup \
-            ? 0.upto(ns_places.size) \
-            : ns_places.size.downto(0)
-          range.each do |size|
-            conditions.concat(ns_places.combination(size).to_a)
-          end
-
-          # Now iterate over
-          while (condition = conditions.shift)
-            ns_places.each{ |i| pieces[i] = condition.include?(i) ? '::' : '' }
-
-            candidate = pieces.join
-            candidate.prepend("#{scope.name}::") unless scope === Object
-
-            klass = candidate.safe_constantize
-            next if klass.nil?
-
-            # Check if the class match the table name
-            return klass if klass < ::ActiveRecord::Base && klass.table_name == table_name
-          end
-        end
-
         # Reload information about tables inheritance and dependencies, uses a
-        # cache to not perform additional checkes
-        def reload_inheritance_data!
+        # cache to not perform additional checks
+        def reload_inheritance_data!(connection)
           return if @inheritance_loaded
           @inheritance_dependencies = connection.inherited_tables
           @inheritance_associations = generate_associations
@@ -186,38 +137,15 @@ module Torque
         # Calculates the inverted dependency (association), where even indirect
         # inheritance comes up in the list
         def generate_associations
-          return {} if @inheritance_dependencies.empty?
-
-          result = Hash.new{ |h, k| h[k] = [] }
-          masters = @inheritance_dependencies.values.flatten.uniq
-
-          # Add direct associations
-          masters.map do |master|
-            @inheritance_dependencies.each do |(dependent, associations)|
-              result[master] << dependent if associations.include?(master)
-            end
-          end
-
-          # Add indirect associations
-          result.each do |master, children|
-            children.each do |child|
-              children.concat(result[child]).uniq! if result.key?(child)
-            end
-          end
-
-          # Remove the default proc that would create new entries
-          result.default_proc = nil
-          result
+          super(@inheritance_dependencies)
         end
 
-        # Use this method to also load any irregular model name. This is smart
-        # enought to only load the sources present on this instance
-        def prepare_data_sources
-          super
-          @data_sources_model_names = Torque::PostgreSQL.config
-            .irregular_models.slice(*@data_sources.keys).map do |table_name, model_name|
-            [table_name, (model_name.is_a?(Class) ? model_name : model_name.constantize)]
-          end.to_h
+        # Use this method to also load any irregular model name
+        def prepare_data_sources(connection = nil)
+          Torque::PostgreSQL::AR710 ? super : super()
+
+          sources = connection.present? ? tables_to_cache(connection) : @data_sources.keys
+          @data_sources_model_names = prepare_irregular_models(sources)
         end
 
     end

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.2.2'
+    VERSION = '3.3.1'
   end
 end

data/spec/tests/has_many_spec.rb

@@ -201,6 +201,47 @@ RSpec.describe 'HasMany' do
       expect(query.to_sql).to match(/INNER JOIN "texts"/)
       expect { query.load }.not_to raise_error
     end
+
+    context 'with query constraint' do
+      let(:activity) { Activity.create! }
+
+      before do
+        skip('Only Rails 7.1 onwards') unless Post.respond_to?(:query_constraints)
+
+        Post.query_constraints :author_id, :id
+        Activity.query_constraints :author_id, :id
+        Activity.has_many :posts
+      end
+
+      after do
+        Post.instance_variable_set(:@has_query_constraints, false)
+        Post.instance_variable_set(:@query_constraints_list, nil)
+        Post.instance_variable_set(:@_query_constraints_list, nil)
+        Activity.instance_variable_set(:@has_query_constraints, false)
+        Activity.instance_variable_set(:@query_constraints_list, nil)
+        Activity.instance_variable_set(:@_query_constraints_list, nil)
+      end
+
+      it 'properly preload records' do
+        FactoryBot.create_list(:post, 5, activity: activity)
+        entries = Activity.all.includes(:posts).load
+
+        expect(entries.size).to be_eql(1)
+        expect(entries.first.posts).to be_loaded
+        expect(entries.first.posts.size).to be_eql(5)
+      end
+
+      it 'properly preload records using preloader' do
+        FactoryBot.create_list(:post, 5, activity: activity)
+        entries = ActiveRecord::Associations::Preloader.new(
+          records: Activity.all,
+          associations: [:posts],
+        ).call.first.records_by_owner
+
+        expect(entries.size).to be_eql(1)
+        expect(entries.values.first.size).to be_eql(5)
+      end
+    end
   end
 
   context 'on array' do

data/spec/tests/schema_spec.rb

@@ -4,8 +4,8 @@ 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)
+    connection.instance_variable_set(:@schemas_blacklist, nil)
+    connection.instance_variable_set(:@schemas_whitelist, nil)
   end
 
   context 'on migration' do

data/spec/tests/table_inheritance_spec.rb

@@ -104,7 +104,12 @@ RSpec.describe 'TableInheritance' do
   end
 
   context 'on schema cache' do
-    subject { ActiveRecord::Base.connection.schema_cache }
+    let(:schema_cache) { ActiveRecord::Base.connection.schema_cache }
+    let(:schema_cache_connection) { schema_cache.instance_variable_get(:@connection) }
+    let(:schema_cache_reflection) { schema_cache.instance_variable_get(:@schema_reflection) }
+    let(:new_schema_cache) { schema_cache_reflection.send(:cache, schema_cache_connection) }
+
+    subject { Torque::PostgreSQL::AR710 ? new_schema_cache : schema_cache }
 
     it 'correctly defines the associations' do
       scenario = {
@@ -120,6 +125,7 @@ RSpec.describe 'TableInheritance' do
       subject.instance_variable_set(:@inheritance_loaded, true)
       subject.instance_variable_set(:@inheritance_dependencies, scenario)
       subject.instance_variable_set(:@inheritance_associations, subject.send(:generate_associations))
+      subject.instance_variable_set(:@data_sources_model_names, {})
       expect(subject.instance_variable_get(:@inheritance_associations)).to eql({
         'A' => %w(B D C N M),
         'B' => %w(C N M),
@@ -131,6 +137,8 @@ RSpec.describe 'TableInheritance' do
     end
 
     context 'on looking up models' do
+      let(:prepare_arguments) { Torque::PostgreSQL::AR710 ? [schema_cache_connection] : nil }
+
       after(:all) do
         schema_cache = ActiveRecord::Base.connection.schema_cache
         schema_cache.instance_variable_set(:@data_sources, {})
@@ -138,26 +146,35 @@ RSpec.describe 'TableInheritance' do
       end
 
       it 'respect irregular names' do
-        Torque::PostgreSQL.config.irregular_models = {
-          'posts' => 'ActivityPost',
-        }
+        allow(Torque::PostgreSQL.config).to receive(:irregular_models).and_return({
+          'public.posts' => 'ActivityPost',
+        })
 
-        subject.send(:prepare_data_sources)
+        subject.send(:prepare_data_sources, *prepare_arguments)
         list = subject.instance_variable_get(:@data_sources_model_names)
-        expect(list).to have_key('posts')
-        expect(list['posts']).to eql(ActivityPost)
+        expect(list).to have_key('public.posts')
+        expect(list['public.posts']).to eql(ActivityPost)
       end
 
       it 'does not load irregular where the data source is not defined' do
-        Torque::PostgreSQL.config.irregular_models = {
+        allow(Torque::PostgreSQL.config).to receive(:irregular_models).and_return({
           'products' => 'Product',
-        }
+        })
 
-        subject.send(:prepare_data_sources)
+        subject.send(:prepare_data_sources, *prepare_arguments)
         list = subject.instance_variable_get(:@data_sources_model_names)
         expect(list).to_not have_key('products')
       end
 
+      it 'works with eager loading' do
+        allow(Torque::PostgreSQL.config).to receive(:eager_load).and_return(true)
+        ActivityPost.reset_table_name
+
+        list = subject.instance_variable_get(:@data_sources_model_names)
+        expect(list).to have_key('activity_posts')
+        expect(list['activity_posts']).to eql(ActivityPost)
+      end
+
       {
         'activities' => 'Activity',
         'activity_posts' => 'ActivityPost',
@@ -176,6 +193,8 @@ RSpec.describe 'TableInheritance' do
     let(:child2) { ActivityBook }
     let(:other) { AuthorJournalist }
 
+    before { ActiveRecord::Base.connection.schema_cache.clear! }
+
     it 'identifies mergeable attributes' do
       result_base = %w(id author_id title active kind created_at updated_at description url file post_id)
       expect(base.inheritance_mergeable_attributes.sort).to eql(result_base.sort)
@@ -228,7 +247,7 @@ RSpec.describe 'TableInheritance' do
       expect(other.table_name).to eql('authors')
     end
 
-    it 'respects the table name prefix and sufix defined on parent module' do
+    it 'respects the table name prefix and suffix defined on parent module' do
       mod = Object.const_set('Private', Module.new)
       mod.define_singleton_method(:table_name_prefix) { 'private.' }
       mod.define_singleton_method(:table_name_suffix) { '_bundle' }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.3.1
 platform: ruby
 authors:
 - Carlos Silva
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-20 00:00:00.000000000 Z
+date: 2024-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -64,20 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.5.3
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.5.3
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -233,6 +227,9 @@ files:
 - lib/torque/postgresql/relation/inheritance.rb
 - lib/torque/postgresql/relation/merger.rb
 - lib/torque/postgresql/schema_cache.rb
+- lib/torque/postgresql/schema_cache/bound_schema_reflection.rb
+- lib/torque/postgresql/schema_cache/inheritance.rb
+- lib/torque/postgresql/schema_cache/schema_reflection.rb
 - lib/torque/postgresql/table_name.rb
 - lib/torque/postgresql/version.rb
 - spec/en.yml
@@ -292,7 +289,8 @@ licenses:
 metadata:
   source_code_uri: https://github.com/crashtech/torque-postgresql
   bug_tracker_uri: https://github.com/crashtech/torque-postgresql/issues
-post_install_message:
+  changelog_uri: https://github.com/crashtech/torque-postgresql/releases
+post_install_message: 
 rdoc_options:
 - "--title"
 - Torque PostgreSQL
@@ -310,7 +308,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubygems_version: 3.2.15
-signing_key:
+signing_key: 
 specification_version: 4
 summary: ActiveRecord extension to access PostgreSQL advanced resources
 test_files: