torque-postgresql 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f08898e4218d41dbcc6394500243760cdd29425ad77135a623bea043cfa8d3ae
-  data.tar.gz: 93c5d71e1597364b7e434e6c88faf4cfd64dcbc930756398f7539dc525a21f05
+  metadata.gz: 2ea2d3fe5e64c12ea8cf8b77ee39a08092b23c5f15802442d5bc92464e248111
+  data.tar.gz: 17541c4f9cbd22c940b5082be168c0fd62e9736abe77efc79340c73058342db4
 SHA512:
-  metadata.gz: c7f93afd26ff711ba03f5a5b1381a139690acf8d3a5621ddec1d26a94ae345c2a59e06cdd9805a5101b4d81f51c151ea0fd19bba7a66d080d05387b073cfd55a
-  data.tar.gz: 5db371506b24fe1c5e28aee69054a83724af93642f44cd3646f6aa9ff9bd58b7a2d2632a186762dca570e2adb0ceea1c38cec5d0119b8f0e4e882b4089913895
+  metadata.gz: 39f36019706145c9b6ff5c4e407ee95b7965746d194338a52d1ee3d67876008b62f673996fb41bc0eb257184454ba74cbe3ffc2cb60805bcaf2d366a3a8ad54f
+  data.tar.gz: 8c77b20d700a66a002eecf369d3d7e2f458d88b280e182e93c4e25bcd8ddbe10f03f77d578d50f13a7234683721ed3cc99d49eac9db7f3de1f0ade9c058f5e53

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

@@ -33,9 +33,9 @@ module Torque
         end
 
         # Renames a type.
-        def rename_type(type_name, new_name)
+        def rename_type(type_name, new_name, options = {})
           execute <<-SQL.squish
-            ALTER TYPE #{quote_type_name(type_name)}
+            ALTER TYPE #{quote_type_name(type_name, options[:schema])}
             RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
           SQL
         end
@@ -87,6 +87,18 @@ module Torque
           super table_name, **options, &block
         end
 
+        # Simply add the schema to the table name when changing a table
+        def change_table(table_name, **options)
+          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
+          super table_name, **options
+        end
+
+        # Simply add the schema to the table name when dropping a table
+        def drop_table(table_name, **options)
+          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
+          super table_name, **options
+        end
+
         # Add the schema option when extracting table options
         def table_options(table_name)
           parts = table_name.split('.').reverse
@@ -110,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/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(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
@@ -95,88 +103,29 @@ module Torque
       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 +135,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/table_name.rb

@@ -12,8 +12,8 @@ module Torque
         return @schema if defined?(@schema)
 
         @schema = ([@klass] + @klass.module_parents[0..-2]).find do |klass|
-          next unless klass.respond_to?(:schema)
-          break klass.schema
+          next unless klass.respond_to?(:schema) && !(value = klass.schema).nil?
+          break value
         end
       end
 

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.2.1'
+    VERSION = '3.3.0'
   end
 end

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
@@ -40,6 +40,26 @@ RSpec.describe 'Schema' do
       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
@@ -86,8 +106,11 @@ RSpec.describe 'Schema' do
 
   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
 
@@ -95,7 +118,17 @@ RSpec.describe 'Schema' 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

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 = {
@@ -131,6 +136,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, {})
@@ -139,13 +146,13 @@ RSpec.describe 'TableInheritance' do
 
       it 'respect irregular names' do
         Torque::PostgreSQL.config.irregular_models = {
-          'posts' => 'ActivityPost',
+          '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
@@ -153,7 +160,7 @@ RSpec.describe 'TableInheritance' do
           '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
@@ -176,6 +183,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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
 platform: ruby
 authors:
 - Carlos Silva
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-06 00:00:00.000000000 Z
+date: 2023-11-18 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,7 @@ licenses:
 metadata:
   source_code_uri: https://github.com/crashtech/torque-postgresql
   bug_tracker_uri: https://github.com/crashtech/torque-postgresql/issues
-post_install_message:
+post_install_message: 
 rdoc_options:
 - "--title"
 - Torque PostgreSQL
@@ -310,7 +307,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: