pg_versions 2.1 → 3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6eab4d5b85196e9a17fe15efdb09cb6ef83d6821a060c40a5c68e3fae7c9fed
-  data.tar.gz: ff1c5c4157163144f7bb1808115c52e50438d8119415b7ea19df18e82e9d5bcd
+  metadata.gz: c5607f7d063544acad22c803124f555de0e1929d51877a7d116a4564724265fc
+  data.tar.gz: 1b430f7a3e100e1c5e25dd0deff40e52fab5bca8724ef05bcdeabf69ca85cd68
 SHA512:
-  metadata.gz: 12c82c86f3138b9b27eaade5a3eb97779b246de26a680de3e23e6d99daa576cc56a1b04ce2c8b82b81f72f8402a73f5eb2e5e7d4babb57651d458317f40eeea5
-  data.tar.gz: 70c41180db0eff19a524f1b65165800c08a50a22ddf25f07daaacb58a0c0b901e0bbf22b620f61499f52788ec4d9120de373b2cdbb3a1aaae3d02481dc211bd3
+  metadata.gz: 85a44f72043f552245c243305a2373719eb0c439c97b7e89ed3f08fcab4cb5ac59644b880233abda2d2edef6c9981c8c8e225fb7b9114a3e11eb04392ae8b146
+  data.tar.gz: abab7289eafaf1b6886401eca4bc2c65de173804e424c6c527ddbb9ea3dd254dad430f9fff0fd6a008de6e83bd9f17560b7532346401f0f1f92d5eb2331e14b6

data/db/migrate/1_create_pg_versions_table.rb

@@ -1,11 +1,11 @@
 class CreatePgVersionsTable < ActiveRecord::Migration[7.0]
 
         def up
-                PgVersions.create_table
+                PgVersions.create_table(ActiveRecord::Base)
         end
 
         def down
-                PgVersions.drop_table
+                PgVersions.drop_table(ActiveRecord::Base)
         end
 
 end

data/lib/pg_versions/pg_versions.rb

@@ -26,98 +26,140 @@
 
 
 require 'set'
+require 'pg'
 
 #TODO: prepared statements?
+#TODO: use ractor instead of thread for event listening
 
 module PgVersions
 
 
 	class InvalidParameters < StandardError; end
+	class ConnectionClosed < StandardError; end
 
 	def self.timestamp_to_integers(input)
 		"to_char(%s, 'YYYYMMDD')::integer || ',' || to_char(%s, 'HH24MISS')::integer || ',' || to_char(%s, 'US')::integer"%[input, input, input]
 	end
 
 
-	def self.with_connection(pg_connection, reset: false, &block)
-		if pg_connection.kind_of? PG::Connection
+	def self.with_connection(pg_connection_param, reset, &block)
+		if pg_connection_param.kind_of? ::PG::Connection
+			if reset
+				pg_connection_param.sync_reset
+				pg_connection_param.exec("select;")
+			end
+			block.call(pg_connection_param)
+		elsif pg_connection_param.respond_to? :call
+			pg_connection_param.call(reset, &block)
+		elsif pg_connection_param.kind_of?(String) or pg_connection_param.kind_of?(Hash)
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					pg_connection = nil
+					Thread.handle_interrupt(Object => :immediate) {
+						pg_connection = ::PG.connect(pg_connection_param)
+						block.call(pg_connection)
+					}
+				ensure
+					pg_connection&.close
+				end
+			}
+		elsif defined?(ActiveRecord) and pg_connection_param.kind_of?(Class) and pg_connection_param <= ActiveRecord::Base
+			pg_connection = pg_connection_param.connection.raw_connection
 			if reset
 				pg_connection.sync_reset
 				pg_connection.exec("select;")
 			end
 			block.call(pg_connection)
-		elsif pg_connection.respond_to? :call
-			pg_connection.call(reset, &block)
-		elsif pg_connection.nil? and defined? ActiveRecord
-			ActiveRecord::Base.connection_pool.with_connection { |ar_connection|
-				block.call(ar_connection.instance_variable_get(:@connection))
-			}
 		else
-			raise InvalidParameters, "Missing connection. Either pass pg connection object or import ActiveRecord."
+			raise InvalidParameters, "Invalid connection parameter (#{pg_connection_param.inspect}). Either pass PG::Connection object, url string, hash, ActiveRecord::Base class (or subclass) or call one of the ActiveRecord methods that come with PgVersions refinement."
+		end
+	end
+
+
+	refine ActiveRecord::Base.singleton_class do
+		def bump(*channels)
+			PgVersions::bump(self, *channels)
+		end
+
+		def read(*channels)
+			PgVersions::read(self, *channels)
 		end
-	end	
+	end
 
 
-	def self.string_to_version(version_str) 
+	def self.string_to_version(version_str)
 		version_str.split(",").map { |str| Integer(str) }
 	end
 
 
-	def self.create_table(connection=nil)
-		PgVersions.with_connection(connection) { |pg_connection|
+	def self.create_table(connection)
+		PgVersions.with_connection(connection, false) { |pg_connection|
 			open(File.dirname(__FILE__)+"/../../create-table.sql") { |sql_file|
 				pg_connection.exec sql_file.read
 			}
 		}
 	end
 
-	def self.drop_table(connection=nil)
-		PgVersions.with_connection(connection) { |pg_connection|
+
+	def self.drop_table(connection)
+		PgVersions.with_connection(connection, false) { |pg_connection|
 			open(File.dirname(__FILE__)+"/../../drop-table.sql") { |sql_file|
 				pg_connection.exec sql_file.read
 			}
 		}
 	end
-	
+
+
+	def self.bump_sql(*channels)
+		channels = [channels].flatten
+		return ""  if channels.size == 0
+		encoder = PG::TextEncoder::QuotedLiteral.new(elements_type: PG::TextEncoder::String.new)
+		quoted_channels = channels.map.with_index { |channel, i| "(#{i},#{encoder.encode(channel)})" }.join(", ")
+		# table-wide share lock is there to mutually exclude table cleaner
+		# clock_timestamp() - this has to be a timestamp after table lock got acquired
+		"
+			LOCK TABLE pg_versions IN ACCESS SHARE MODE;
+			WITH
+				to_bump(i, channel) AS (VALUES #{quoted_channels})
+				, current_instant(ts) AS (VALUES (clock_timestamp()))
+				, updated AS (
+						INSERT INTO pg_versions(channel, instant, counter)
+						SELECT to_bump.channel, (SELECT ts FROM current_instant), 0 FROM to_bump
+						ON CONFLICT (channel) DO UPDATE SET
+							instant = GREATEST(pg_versions.instant, EXCLUDED.instant),
+							counter = CASE WHEN pg_versions.instant < EXCLUDED.instant THEN 0 ELSE pg_versions.counter + 1 END
+						RETURNING channel, instant, pg_versions.counter
+						)
+			SELECT DISTINCT
+				i
+				, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text AS version
+				, pg_notify(updated.channel::text, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text)::text
+			FROM
+				to_bump
+				JOIN updated ON to_bump.channel = updated.channel;
+		"
+	end
+
+
 	#TODO: ensure this is called only once per transaction, or that all bumps occur in the same order in all transactions, to avoid deadlocks
-	def self.bump(*channels, connection: nil)
-		#TODO: pg_connection.exec returned nil once during testing.
-		PgVersions.with_connection(connection) { |pg_connection|
-			channels = [channels].flatten.sort
-			return {} if channels.size == 0
-			quoted_channels = channels.map.with_index { |channel, i| "(#{i},'#{pg_connection.escape_string(channel)}')" }.join(", ")
-			# table-wide share lock is there to mutually exclude table cleaner
-			# clock_timestamp() - this has to be a timestamp after table lock got acquired
-			pg_connection.exec("
-				LOCK TABLE pg_versions IN ACCESS SHARE MODE;
-				WITH 
-					to_bump(i, channel) AS (VALUES #{quoted_channels})
-					, current_instant(ts) AS (VALUES (clock_timestamp()))
-					, updated AS (
-							INSERT INTO pg_versions(channel, instant, counter)
-							SELECT to_bump.channel, (SELECT ts FROM current_instant), 0 FROM to_bump
-							ON CONFLICT (channel) DO UPDATE SET
-								instant = GREATEST(pg_versions.instant, EXCLUDED.instant),
-								counter = CASE WHEN pg_versions.instant < EXCLUDED.instant THEN 0 ELSE pg_versions.counter + 1 END
-							RETURNING channel, instant, pg_versions.counter
-							)
-				SELECT DISTINCT
-					i
-					, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text AS version
-					, pg_notify(updated.channel::text, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text)::text
-				FROM
-					to_bump
-					JOIN updated ON to_bump.channel = updated.channel;
-			") { |result| 
+	def self.bump(connection, *channels)
+		channels = [channels].flatten.sort.uniq
+		PgVersions.with_connection(connection, false) { |pg_connection|
+			sql = self.bump_sql(*channels)
+			return {} if sql == ""
+			pg_connection.exec(sql) { |result|
 				result.map { |row| [channels[Integer(row["i"])], string_to_version(row["version"])] }.to_h
 			}
 		}
 	end
 
 
-	def self.read(*channels, connection: nil)
-		PgVersions.with_connection(connection) { |pg_connection|
-			channels = [channels].flatten.sort
+	#TODO: bump in the same query instead of calling bump
+	#TODO: do we really need to bump though?
+	#TODO: and then, implement read_sql
+	def self.read(connection, *channels)
+		PgVersions.with_connection(connection, false) { |pg_connection|
+			channels = [channels].flatten.sort.uniq
 			return {} if channels.size == 0
 			versions = {}
 			quoted_channels = channels.map.with_index { |channel, i| "(#{i},'#{pg_connection.escape_string(channel)}')" }.join(", ")
@@ -138,8 +180,7 @@ module PgVersions
 					versions[channels.delete_at(Integer(row["i"]))] = string_to_version(row["version"])
 				}
 			}
-			#TODO: bump in the same query instead of calling bump
-			versions.merge!(self.bump(channels, connection: pg_connection))  if channels.size > 0
+			versions.merge!(self.bump(pg_connection, channels))  if channels.size > 0
 			versions
 		}
 	end
@@ -154,163 +195,279 @@ module PgVersions
 	end
 
 
+	class ConnectionInner
 
-	class ConnectionThread
+		def initialize()
+			@mutex = Mutex.new
+			@command_notify_w = nil
+			@subscriptions = {}
+			@bumps = []
+			@reads = []
+			@closers = []
+			@state = :idle # idle, processing, closing, closed
+		end
 
-		class Closing < StandardError
-			attr_reader :retpipe
-			def initialize(retpipe)
-				@retpipe = retpipe
+
+		def process
+			Thread.handle_interrupt(Object => :never) do
+				command_notify_r = nil
+				@mutex.synchronize {
+					case @state
+					when :idle
+						@state = :processing
+					when :processing
+						raise "Attempt to run processing on a connection that is already being processed"
+					when :closing, :closed
+						return
+					end
+				}
+				begin
+					command_notify_r, @command_notify_w = IO.pipe
+					Thread.handle_interrupt(Object => :immediate) {
+						yield command_notify_r
+					}
+				ensure
+					@mutex.synchronize {
+						command_notify_r&.close
+						@command_notify_w&.close
+						@command_notify_w = nil
+						case @state
+						when :idle, :closed
+							raise "'processor exit in #{@state} state. Please inform the developer of this gem."
+						when :processing
+							@state = :idle
+						when :closing
+							@state = :closed
+							@closers.each { |closer|
+								closer.push true
+							}
+						end
+					}
+				end
 			end
 		end
 
 
-		attr_reader :status
+		def wake_processor
+			@command_notify_w&.write('!')
+			@command_notify_w&.flush
+		end
 
-		def initialize(connection)
-			retry_on_exceptions = [ PG::ConnectionBad, PG::UnableToSend ]
-			retry_on_exceptions << ActiveRecord::ConnectionNotEstablished  if defined? ActiveRecord
 
-			@subscribers = Hash.new { |h,k| h[k] = Set.new }
-			@status = :disconnected
+		def get_channels
+			@mutex.synchronize {
+				return @subscriptions.keys
+			}
+		end
 
-			@thread_requests_mutex = Mutex.new
-			@thread_requests = []
-			thread_requests_notify_r, @thread_requests_notify_w = IO.pipe
 
-			@thread = Thread.new {
-				reset_connection = false
-				retry_delay = 0
-				begin
-					PgVersions.with_connection(connection, reset: reset_connection) do |pg_connection|
-						
-						@status = :connected
-						retry_delay = 0
+		def notify(channel, version)
+			@mutex.synchronize {
+				(@subscriptions[channel] or []).each { |subscriber|
+					subscriber.notify({ channel => version })
+				}
+			}
+		end
 
-						@subscribers.each_key { |channel|
-							listen(pg_connection, channel)
-						}
-						read(pg_connection, @subscribers.keys).each_pair { |channel, version|
-							@subscribers[channel].each { |subscriber|
-								subscriber.notify({ channel => version })
-							}
-						}
 
-						loop {
-							@thread_requests_mutex.synchronize { 
-								@thread_requests.each { |function, retpipe, params|
-									raise Closing, retpipe  if function == :stop
-									retpipe << send(function, pg_connection, *params)
-								}
-								@thread_requests.clear
-							}
+		def taking_bumps
+			@mutex.synchronize {
+				yield @bumps
+				@bumps = []
+			}
+		end
 
-							while notification = pg_connection.notifies
-								channel, payload = notification[:relname], notification[:extra]
-								@subscribers[channel].each { |subscriber|
-									subscriber.notify({ channel => PgVersions.string_to_version(payload) })
-								}
-							end
 
-							#TODO: handle errors
-							reads,_writes,_errors = IO::select([pg_connection.socket_io, thread_requests_notify_r])
-							
-							if reads.include?(pg_connection.socket_io)
-								pg_connection.consume_input
-							end
+		def taking_reads
+			@mutex.synchronize {
+				yield @reads
+				@reads = []
+			}
+		end
 
-							if reads.include?(thread_requests_notify_r)
-								thread_requests_notify_r.read(1)
-							end
-						}
-					rescue Closing => e
-						e.retpipe << true
-					end
-				rescue *retry_on_exceptions => e
-					reset_connection = true
-					@status = :disconnected
-					$stderr.puts "Pg connection failed. Retrying in #{retry_delay/1000.0}s."
-					sleep retry_delay/1000.0
-					retry_delay = { 0=>100, 100=>1000, 1000=>2000, 2000=>2000 }[retry_delay]
-					retry
-				end
-			} 
-			@thread.abort_on_exception = true
+
+		def bump(channels)
+			result = Queue.new
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@bumps << [result, channels]
+			}
+			wake_processor
+			result.pop
 		end
 
-		private def listen(pg_connection, channel)
-			pg_connection.exec("LISTEN #{PG::Connection.quote_ident(channel)}")
+
+		def bump_nonblock(channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@bumps << [nil, channels]
+			}
+			wake_processor
+			nil
 		end
 
-		private def unlisten(pg_connection, channel)
-			pg_connection.exec("UNLISTEN #{PG::Connection.quote_ident(channel)}")
+
+		def read(channels)
+			result = Queue.new
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@reads << [result, channels]
+			}
+			wake_processor
+			result.pop
 		end
 
-		private def subscribe(pg_connection, subscriber, channels)
-			channels.each { |channel|
-				@subscribers[channel] << subscriber
-				listen(pg_connection, channel)  if @subscribers[channel].size == 1
+
+		def subscribe(subscriber, channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				channels.each { |channel|
+					@subscriptions[channel] = []  if @subscriptions[channel].nil?
+					@subscriptions[channel].push(subscriber)
+				}
 			}
-			subscriber.notify(PgVersions.read(channels, connection: pg_connection))
+			subscriber.notify(read(channels))  # this runs wake_processor, so not doing it explicitly
 			true
 		end
-		
-		private def unsubscribe(pg_connection, subscriber, channels)
-			channels.each { |channel|
-				@subscribers[channel].delete(subscriber)
-				if @subscribers[channel].size == 0
-					unlisten(pg_connection, channel)
-					@subscribers.delete(channel)
-				end
+
+
+		def unsubscribe(subscriber, channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				channels.each { |channel|
+					@subscriptions[channel].delete(subscriber)
+					@subscriptions.delete(channel)  if @subscriptions[channel].size == 0
+				}
 			}
+			wake_processor
 			true
 		end
 
-		private def read(pg_connection, channels)
-			PgVersions.read(channels, connection: pg_connection)
-		end
 
-		private def bump(pg_connection, channels)
-			PgVersions.bump(channels, connection: pg_connection)
+		def is_closing
+			@mutex.synchronize {
+				return @state == :closing
+			}
 		end
 
-		def request(function, *params)
-			request_nonblock(function, *params).pop
-		end
 
-		def request_nonblock(function, *params)
-			retpipe = Queue.new
-			@thread_requests_mutex.synchronize {
-				@thread_requests.push [function, retpipe, params]
+		def close
+			result = Queue.new
+			@mutex.synchronize {
+				case @state
+				when :idle
+					@state = :closed
+					return
+				when :processing
+					@state = :closing
+					@closers << result
+					wake_processor
+				when :closing
+					@closers << result
+				when :closed
+					return
+				end
 			}
-			@thread_requests_notify_w.write('!')
-			retpipe
+			result.pop
 		end
-		
+
 	end
 
+
 	class Connection
-		
-		def initialize(connection=nil)
-			@connection_thread = ConnectionThread.new(connection)
+
+		def initialize()
+			@inner = ConnectionInner.new
+		end
+
+
+		def process(connection_param=nil, autoreconnect=true, &block)
+			raise "Both 'connection_param' and a block were given. Don't know which to use."  if !connection_param.nil? and !block.nil?
+			connection_param ||= block
+
+			retry_on_exceptions = [ ::PG::ConnectionBad, ::PG::UnableToSend ]
+			retry_delay = 0
+
+			@inner.process do |notification_r|
+				raise if not notification_r
+				PgVersions.with_connection(connection_param, true) do |pg_connection|
+
+					listening_to_channels = @inner.get_channels
+					listening_to_channels.each { |channel|
+						pg_connection.exec("LISTEN #{::PG::Connection.quote_ident(channel)}")
+					}
+					PgVersions.read(pg_connection, listening_to_channels).each { |channel, version|
+						@inner.notify(channel, version)
+					}
+
+					loop {
+						channels_to_listen_to = @inner.get_channels
+						(listening_to_channels - channels_to_listen_to).each { |removed_channel|
+							pg_connection.exec("UNLISTEN #{::PG::Connection.quote_ident(removed_channel)}")
+						}
+						(channels_to_listen_to - listening_to_channels).each { |added_channel|
+							pg_connection.exec("LISTEN #{::PG::Connection.quote_ident(added_channel)}")
+						}
+						listening_to_channels = channels_to_listen_to
+
+						@inner.taking_bumps { |bumps|
+							channels_to_bump = bumps.map(&:last).flatten.uniq
+							bumped_versions = PgVersions.bump(pg_connection, channels_to_bump)
+							bumps.each { |bumper, channels|
+								bumper.push bumped_versions.slice(*channels)  if not bumper.nil?
+							}
+						}
+
+						@inner.taking_reads { |reads|
+							channels_to_read = reads.map(&:last).uniq
+							read_versions = PgVersions.read(pg_connection, channels_to_read)
+							reads.each { |reader, channels|
+								reader.push read_versions.slice(*channels)
+							}
+						}
+
+						break if @inner.is_closing
+
+						while notification = pg_connection.notifies
+							channel, payload = notification[:relname], notification[:extra]
+							@inner.notify(channel, PgVersions.string_to_version(payload))
+						end
+
+						#TODO: handle errors
+						reads,_writes,_errors = IO::select([pg_connection.socket_io, notification_r])
+						pg_connection.consume_input  if reads.include?(pg_connection.socket_io)
+						notification_r.read(1)  if reads.include?(notification_r)  #TODO: read everything that can be read here
+
+					}
+				end
+			rescue *retry_on_exceptions => error
+				raise  if connection_param.kind_of?(::PG::Connection)  or  !autoreconnect
+				return if @inner.is_closing
+				$stderr.puts "Pg connection failed (retrying in #{retry_delay/1000.0}s):\n\t#{error.message}"
+				sleep retry_delay/1000.0
+				retry_delay = { 0=>100, 100=>1000, 1000=>2000, 2000=>2000 }[retry_delay]
+				retry
+			end
 		end
 
-		def close()
-			@connection_thread.request(:stop)
+
+		def close
+			@inner.close
 		end
 
+
 		def bump(*channels)
-			@connection_thread.request(:bump, channels)
+			@inner.bump(channels)
 		end
 
 
 		def read(*channels)
-			@connection_thread.request(:read, channels)
+			@inner.read(channels)
 		end
 
 
 		def subscribe(*channels, known: {}, batch_delay: 0.01)
-			subscription = Subscription.new(@connection_thread, batch_delay)
+			subscription = Subscription.new(@inner, batch_delay)
 			subscription.subscribe([channels].flatten, known: known)
 			if block_given?
 				Thread.handle_interrupt(Object => :never) {
@@ -328,16 +485,23 @@ module PgVersions
 		end
 
 
+		alias_method :each, def for_each_notification(*channels, known: {}, batch_delay: 0.01, &block)
+			subscribe(*channels, known: known, batch_delay: batch_delay) { |subscription|
+				subscription.for_each_notification(&block)
+			}
+		end
+
+
 		class Subscription
 
-			def initialize(connection_thread, batch_delay)
-				@connection_thread = connection_thread
+			def initialize(inner, batch_delay)
+				@inner = inner
 				@batch_delay = batch_delay
 				@notifications = Queue.new
 				@already_known_versions = Hash.new { |h,k| h[k] = [] }
 				@channels = Hash.new(0)
 			end
-			
+
 
 			def subscribe(channels, known: {})
 				update_already_known_versions(known)
@@ -346,10 +510,10 @@ module PgVersions
 					(@channels[channel] += 1) == 1
 				}
 				if channels.size > 0
-					@connection_thread.request(:subscribe, self, channels)
+					@inner.subscribe(self, channels)
 				end
 			end
-			
+
 
 			def unsubscribe(*channels)
 				channels = [channels].flatten
@@ -359,13 +523,13 @@ module PgVersions
 					@channels.delete(channel)  if @channels[channel] == 0
 					not @channels.has_key?(channel)
 				}
-				@connection_thread.request(:unsubscribe, self, channels)
+				@inner.unsubscribe(self, channels)
 			end
 
 
 			def read(*channels, notify: false)
 				channels = @channels.keys  if channels.size == 0
-				versions = @connection_thread.request(:read, channels)
+				versions = @inner.read(channels)
 				update_already_known_versions(versions)  if not notify
 				versions
 			end
@@ -373,7 +537,7 @@ module PgVersions
 
 			def bump(*channels, notify: false)
 				channels = @channels.keys  if channels.size == 0
-				versions = @connection_thread.request(:bump, channels)
+				versions = @inner.bump(channels)
 				update_already_known_versions(versions)  if not notify
 				versions
 			end
@@ -403,8 +567,7 @@ module PgVersions
 				}
 			end
 
-
-			def each(new_already_known_versions = {}, batch_delay: nil)
+			alias_method :each, def for_each_notification(new_already_known_versions = {}, batch_delay: nil)
 				update_already_known_versions(new_already_known_versions)
 				while notification = wait(batch_delay: batch_delay)
 					yield notification
@@ -419,7 +582,7 @@ module PgVersions
 
 			def drop
 				@notifications << nil
-				@connection_thread.request_nonblock(:unsubscribe, self, @channels.keys)
+				@inner.unsubscribe(self, @channels.keys)  if @channels.keys.size > 0
 				#TODO: what to do if this object gets used after drop?
 			end
 

data/lib/pg_versions/version.rb

@@ -1,3 +1,3 @@
 module PgVersions
-	VERSION = "2.1"
+	VERSION = "3.1"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pg_versions
 version: !ruby/object:Gem::Version
-  version: '2.1'
+  version: '3.1'
 platform: ruby
 authors:
 - yunta
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -85,7 +84,6 @@ homepage: https://gitlab.com/yunta/pg-versions
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Persistent timestamped postgres notification library
 test_files: []