backports 3.19.0 → 3.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7545e11eda01d2ea412b51973b69d70ede1544ad14d11511085f80d51f1e9924
-  data.tar.gz: 9cfd27da7f62e6606b73afa3770e25eb7fd90d254eb95c242fe375e38a10f078
+  metadata.gz: b3d95602bc2a5f1d8835d424036e6d51671baa7c8d46f4482c61b6519044d493
+  data.tar.gz: '059fa80520c54c368ad38f6477bbb2b9debe734970b0e007ba04be2b37c0138f'
 SHA512:
-  metadata.gz: 64f2afe9cf49d42da0122399c765cf8e9eda203145957fa3a296f169ac36c1f471cd08d3384d397b987c9cf368947e4f5db6fe0ba460d0fbad014ff0a40e35e8
-  data.tar.gz: 0d52dd7e5b79dd2dd225ddff67a34bdd329141e4c0ce924369271ce9e4fde48e2462452940e18110d64b6d9c10f3fd8c4cd5d57a8944317a8124c0b37f22887a
+  metadata.gz: 0b4031dc752ebb19df160368c272e37b0bf9a939288ccccc9d5043567efed030d157d2da1668ec0787216ab05f730b3ff8d7c23b78a5e2400719cd5183232a69
+  data.tar.gz: c92bbe1f69c27f5ed6e18162e8fe96665a9828480bd2c10a13750f1b8190db53a0ef25b2009f2414cb3d193e22c0810b12a259ef84d079bac6f53dde9aafcd96

data/CHANGELOG.md

@@ -8,7 +8,13 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 Note: [Next major version (X-mas 2021?)](https://github.com/marcandre/backports/issues/139) may drop support for Ruby < 2.2, please comment.
 
-## [3.19.0](https://github.com/marcandre/backports/compare/v3.19.0...v3.18.2) - 2020-12-28
+## [3.20.0](https://github.com/marcandre/backports/compare/v3.19.0...v3.20.0) - 2020-12-30
+
+### Added
+
+Ractor backport (all methods)
+
+## [3.19.0](https://github.com/marcandre/backports/compare/v3.18.2...v3.19.0) - 2020-12-28
 
 ### Added
 
@@ -35,7 +41,7 @@ Note: [Next major version (X-mas 2021?)](https://github.com/marcandre/backports/
 
 Require per ruby version now properly requiring 2.3.0 backports for `String` [#152]
 
-## [3.18.1](https://github.com/marcandre/backports/compare/v3.18.1...v3.18.2) - 2020-66-22
+## [3.18.1](https://github.com/marcandre/backports/compare/v3.18.1...v3.18.2) - 2020-06-22
 
 ### Fixed
 

data/Gemfile

@@ -11,6 +11,6 @@ end
 
 if RUBY_VERSION >= '2.4.0'
   group :development do
-    gem 'rubocop', '~> 1.1.0'
+    gem 'rubocop', '~> 1.6.0'
   end
 end

data/README.md

@@ -1,6 +1,7 @@
 # Backports Library [<img src="https://travis-ci.org/marcandre/backports.svg?branch=master">](https://travis-ci.org/marcandre/backports) [<img src="https://badge.fury.io/rb/backports.svg" alt="Gem Version" />](http://badge.fury.io/rb/backports) [![Tidelift](https://tidelift.com/badges/package/rubygems/backports)](https://tidelift.com/subscription/pkg/rubygems-backports?utm_source=rubygems-backports&utm_medium=referral&utm_campaign=readme)
 
-Yearning to use some of the new cool features in Ruby 2.7 while using 2.3.x?
+Yearning to use write a gem using some new cool features in Ruby 3.0 while
+still supporting Ruby 2.5.x?
 Have some legacy code in Ruby 1.8 but can't live without `flat_map`?
 
 This gem is for you!
@@ -16,13 +17,13 @@ for Ruby < 2.2.
 
 ### Explicitly (recommended)
 
-For example, if you want to use transform_values and transform_keys, even in
+For example, if you want to use `transform_values` and `transform_keys`, even in
 Ruby implementations that don't include it:
 
     require 'backports/2.4.0/hash/transform_values'
     require 'backports/2.5.0/hash/transform_keys'
 
-This will enable Hash#transform_values and Hash#transform_keys, using the
+This will enable `Hash#transform_values` and `Hash#transform_keys`, using the
 native versions if available or otherwise provide a pure Ruby version.
 
 ### By Module
@@ -32,19 +33,17 @@ Class:
 
     require 'backports/2.3.0/hash'
 
-This will make sure that Hash responds to dig, fetch_values, <, <=, >, >= and
-to_proc
+This will make sure that Hash responds to `dig`, `fetch_values`, `to_proc` and comparisons.
 
 ### Up to a specific Ruby version (for quick coding)
 
 You can load all backports up to a specific version.
-For example, to bring any
-version of Ruby mostly up to Ruby 2.7.0's standards:
+For example, to bring any version of Ruby mostly up to Ruby 3.0.0's standards:
 
-    require 'backports/2.7.0'
+    require 'backports/3.0.0'
 
 This will bring in all the features of 1.8.7 and many features of Ruby 1.9.x
-all the way up to Ruby 2.7.0 (for all versions of Ruby)!
+all the way up to Ruby 3.0.0 (for all versions of Ruby)!
 
 You may `require 'backports/latest'` as a
 shortcut to the latest Ruby version supported.
@@ -118,6 +117,12 @@ itself, JRuby and Rubinius.
   - `except`
   - `transform_keys`, `transform_keys!` (with hash argument)
 
+#### Ractor
+  - All methods, with the caveats:
+    - uses Ruby's `Thread` internally
+    - will not raise some errors when `Ractor` would (in particular `Ractor::IsolationError`)
+    - supported in Ruby 2.0+ only
+
 #### Symbol
   - `name`
 

data/lib/backports/3.0.0/ractor.rb

@@ -0,0 +1,5 @@
+if RUBY_VERSION < '2'
+  warn 'Ractor not backported to Ruby 1.x'
+else
+  require_relative '../ractor/ractor' unless defined?(Ractor.current)
+end

data/lib/backports/ractor/cloner.rb

@@ -0,0 +1,91 @@
+require_relative '../2.4.0/hash/transform_values'
+require_relative '../2.5.0/hash/transform_keys'
+
+class Ractor
+  module Cloner
+    extend self
+
+    def deep_clone(obj)
+      return obj if Ractor.ractor_shareable_self?(obj, false) { false }
+
+      @processed = {}.compare_by_identity
+      @changed = nil
+      result = process(obj) do |r|
+        copy_contents(r)
+      end
+      return result if result
+
+      Ractor.ractor_mark_set_shareable(@processed)
+      obj
+    end
+
+    # Yields a deep copy.
+    # If no deep copy is needed, `obj` is returned and
+    # nothing is yielded
+    private def clone_deeper(obj)
+      return obj if Ractor.ractor_shareable_self?(obj, false) { false }
+
+      result = process(obj) do |r|
+        copy_contents(r)
+      end
+      return obj unless result
+
+      yield result if block_given?
+      result
+    end
+
+    # Yields if `obj` is a new structure
+    # Returns the deep copy, or `false` if no deep copy is needed
+    private def process(obj)
+      @processed.fetch(obj) do
+        # For recursive structures, assume that we'll need a duplicate.
+        # If that's not the case, we will have duplicated the whole structure
+        # for nothing...
+        @processed[obj] = result = obj.dup
+        changed = track_change { yield result }
+        return false if obj.frozen? && !changed
+
+        @changed = true
+        result.freeze if obj.frozen?
+
+        result
+      end
+    end
+
+    # returns if the block called `deep clone` and that the deep copy was needed
+    private def track_change
+      prev = @changed
+      @changed = false
+      yield
+      @changed
+    ensure
+      @changed = prev
+    end
+
+    # modifies in place `obj` by calling `deep clone` on its contents
+    private def copy_contents(obj)
+      case obj
+      when ::Hash
+        if obj.default
+          clone_deeper(obj.default) do |copy|
+            obj.default = copy
+          end
+        end
+        obj.transform_keys! { |key| clone_deeper(key) }
+        obj.transform_values! { |value| clone_deeper(value) }
+      when ::Array
+        obj.map! { |item| clone_deeper(item) }
+      when ::Struct
+        obj.each_pair do |key, item|
+          clone_deeper(item) { |copy| obj[key] = copy }
+        end
+      end
+      obj.instance_variables.each do |var|
+        clone_deeper(obj.instance_variable_get(var)) do |copy|
+          obj.instance_variable_set(var, copy)
+        end
+      end
+    end
+  end
+  private_constant :Cloner
+end

data/lib/backports/ractor/errors.rb

@@ -0,0 +1,16 @@
+class Ractor
+  class ClosedError < ::StopIteration
+  end
+
+  class Error < ::StandardError
+  end
+
+  class RemoteError < Error
+    attr_reader :ractor
+
+    def initialize(message = nil)
+      @ractor = Ractor.current
+      super
+    end
+  end
+end

data/lib/backports/ractor/queues.rb

@@ -0,0 +1,62 @@
+require_relative '../tools/filtered_queue'
+
+class Ractor
+  # Standard ::Queue but raises if popping and closed
+  class BaseQueue < ::Backports::FilteredQueue
+    ClosedQueueError = ::Ractor::ClosedError
+
+    # yields message (if any)
+    def pop_non_blocking
+      yield pop(timeout: 0)
+    rescue TimeoutError
+      nil
+    end
+  end
+
+  class IncomingQueue < BaseQueue
+    TYPE = :incoming
+
+    protected def reenter
+      raise ::Ractor::Error, 'Can not reenter'
+    end
+  end
+
+  # * Wraps exception
+  # * Add `ack: ` to push (blocking)
+  class OutgoingQueue < BaseQueue
+    TYPE = :outgoing
+
+    WrappedException = ::Struct.new(:exception, :ractor)
+
+    def initialize
+      @ack_queue = ::Queue.new
+      super
+    end
+
+    def pop(timeout: nil, ack: true)
+      r = super(timeout: timeout)
+      @ack_queue << :done if ack
+      raise r.exception if WrappedException === r
+
+      r
+    end
+
+    def close(how = :hard)
+      super()
+      return if how == :soft
+
+      clear
+      @ack_queue.close
+    end
+
+    def push(obj, ack:)
+      super(obj)
+      if ack
+        r = @ack_queue.pop # block until popped
+        raise ClosedError, "The #{self.class::TYPE}-port is already closed" unless r == :done
+      end
+      self
+    end
+  end
+  private_constant :BaseQueue, :OutgoingQueue, :IncomingQueue
+end

data/lib/backports/ractor/ractor.rb

@@ -0,0 +1,238 @@
+# Ruby 2.0+ backport of `Ractor` class
+# Extra private methods and instance variables all start with `ractor_`
+class Ractor
+  require_relative '../tools/arguments'
+
+  require_relative 'cloner'
+  require_relative 'errors'
+  require_relative 'queues'
+  require_relative 'sharing'
+
+  # Implementation notes
+  #
+  # Uses one `Thread` for each `Ractor`, as well as queues for communication
+  #
+  # The incoming queue is strict: contrary to standard queue, you can't pop from an empty closed queue.
+  # Since standard queues return `nil` is those conditions, we wrap/unwrap `nil` values and consider
+  # all `nil` values to be results of closed queues. `ClosedQueueError` are re-raised as `Ractor::ClosedError`
+  #
+  # The outgoing queue is strict and blocking. Same wrapping / raising as incoming,
+  # with an extra queue to acknowledge when a value has been read (or if the port is closed while waiting).
+  #
+  # The last result is a bit tricky as it needs to be pushed on the outgoing queue but can not be blocking.
+  # For this, we "soft close" the outgoing port.
+
+  def initialize(*args, &block)
+    @ractor_incoming_queue = IncomingQueue.new
+    @ractor_outgoing_queue = OutgoingQueue.new
+    raise ArgumentError, 'must be called with a block' unless block
+
+    kw = args.last
+    if kw.is_a?(Hash) && kw.size == 1 && kw.key?(:name)
+      args.pop
+      name = kw[:name]
+    end
+    @ractor_name = name && Backports.coerce_to_str(name)
+
+    if Ractor.main == nil # then initializing main Ractor
+      @ractor_thread = ::Thread.current
+      @ractor_origin = nil
+      @ractor_thread.thread_variable_set(:ractor, self)
+    else
+      @ractor_origin = caller(1, 1).first.split(':in `').first
+
+      args.map! { |a| Ractor.ractor_isolate(a, false) }
+      ractor_thread_start(args, block)
+    end
+  end
+
+  private def ractor_thread_start(args, block)
+    Thread.new do
+      @ractor_thread = Thread.current
+      @ractor_thread_group = ThreadGroup.new.add(@ractor_thread)
+      ::Thread.current.thread_variable_set(:ractor, self)
+      result = nil
+      begin
+        result = instance_exec(*args, &block)
+      rescue ::Exception => err # rubocop:disable Lint/RescueException
+        begin
+          raise RemoteError, "thrown by remote Ractor: #{err.message}"
+        rescue RemoteError => e # Hack to create exception with `cause`
+          result = OutgoingQueue::WrappedException.new(e)
+        end
+      ensure
+        ractor_thread_terminate(result)
+      end
+    end
+  end
+
+  private def ractor_thread_terminate(result)
+    begin
+      ractor_outgoing_queue.push(result, ack: false) unless ractor_outgoing_queue.closed?
+    rescue ClosedQueueError
+      return # ignore
+    end
+    ractor_incoming_queue.close
+    ractor_outgoing_queue.close(:soft)
+  ensure
+    # TODO: synchronize?
+    @ractor_thread_group.list.each do |thread|
+      thread.kill unless thread == Thread.current
+    end
+  end
+
+  def send(obj, move: false)
+    ractor_incoming_queue << Ractor.ractor_isolate(obj, move)
+    self
+  rescue ::ClosedQueueError
+    raise ClosedError, 'The incoming-port is already closed'
+  end
+  alias_method :<<, :send
+
+  def take
+    ractor_outgoing_queue.pop(ack: true)
+  end
+
+  def name
+    @ractor_name
+  end
+
+  RACTOR_STATE = {
+    'sleep' => 'blocking',
+    'run' => 'running',
+    'aborting' => 'aborting',
+    false => 'terminated',
+    nil => 'terminated',
+  }.freeze
+  private_constant :RACTOR_STATE
+
+  def inspect
+    state = RACTOR_STATE[@ractor_thread ? @ractor_thread.status : 'run']
+    info = [
+      'Ractor:#1',
+      name,
+      @ractor_origin,
+      state
+    ].compact.join(' ')
+
+    "#<#{info}>"
+  end
+
+  def close_incoming
+    r = ractor_incoming_queue.closed?
+    ractor_incoming_queue.close
+    r
+  end
+
+  def close_outgoing
+    r = ractor_outgoing_queue.closed?
+    ractor_outgoing_queue.close
+    r
+  end
+
+  private def receive
+    ractor_incoming_queue.pop
+  end
+
+  private def receive_if(&block)
+    raise ArgumentError, 'no block given' unless block
+    ractor_incoming_queue.pop(&block)
+  end
+
+  class << self
+    def yield(value, move: false)
+      value = ractor_isolate(value, move)
+      current.ractor_outgoing_queue.push(value, ack: true)
+    rescue ClosedQueueError
+      raise ClosedError, 'The outgoing-port is already closed'
+    end
+
+    def receive
+      current.__send__(:receive)
+    end
+    alias_method :recv, :receive
+
+    def receive_if(&block)
+      current.__send__(:receive_if, &block)
+    end
+
+    def select(*ractors, yield_value: not_given = true, move: false)
+      cur = Ractor.current
+      queues = ractors.map do |r|
+        r == cur ? r.ractor_incoming_queue : r.ractor_outgoing_queue
+      end
+      if !not_given
+        out = current.ractor_outgoing_queue
+        yield_value = ractor_isolate(yield_value, move)
+      elsif ractors.empty?
+        raise ArgumentError, 'specify at least one ractor or `yield_value`'
+      end
+
+      while true # rubocop:disable Style/InfiniteLoop
+                  # Don't `loop`, in case of `ClosedError` (not that there should be any)
+        queues.each_with_index do |q, i|
+          q.pop_non_blocking do |val|
+            r = ractors[i]
+            return [r == cur ? :receive : r, val]
+          end
+        end
+
+        if out && out.num_waiting > 0
+          # Not quite atomic...
+          out.push(yield_value, ack: true)
+          return [:yield, nil]
+        end
+
+        sleep(0.001)
+      end
+    end
+
+    def make_shareable(obj)
+      return obj if ractor_check_shareability?(obj, true)
+
+      raise Ractor::Error, '#freeze does not freeze object correctly'
+    end
+
+    def shareable?(obj)
+      ractor_check_shareability?(obj, false)
+    end
+
+    def current
+      Thread.current.thread_variable_get(:ractor)
+    end
+
+    def count
+      ObjectSpace.each_object(Ractor).count(&:ractor_live?)
+    end
+
+    # @api private
+    def ractor_reset
+      ObjectSpace.each_object(Ractor).each do |r|
+        next if r == Ractor.current
+        next unless (th = r.ractor_thread)
+
+        th.kill
+        th.join
+      end
+      Ractor.current.ractor_incoming_queue.clear
+    end
+
+    attr_reader :main
+
+    private def ractor_init
+      @ractor_shareable = ::ObjectSpace::WeakMap.new
+      @main = Ractor.new { nil }
+    end
+  end
+
+  # @api private
+  def ractor_live?
+    !defined?(@ractor_thread) || # May happen if `count` is called from another thread before `initialize` has completed
+      @ractor_thread.status
+  end
+
+  # @api private
+  attr_reader :ractor_outgoing_queue, :ractor_incoming_queue, :ractor_thread
+
+  ractor_init
+end

data/lib/backports/ractor/sharing.rb

@@ -0,0 +1,93 @@
+class Ractor
+  class << self
+    # @api private
+    def ractor_isolate(val, move = false)
+      return val if move
+
+      Cloner.deep_clone(val)
+    end
+
+    private def ractor_check_shareability?(obj, freeze_all)
+      ractor_shareable_self?(obj, freeze_all) do
+        visited = {}
+
+        return false unless ractor_shareable_parts?(obj, freeze_all, visited)
+
+        ractor_mark_set_shareable(visited)
+
+        true
+      end
+    end
+
+    # yield if shareability can't be determined without looking at its parts
+    def ractor_shareable_self?(obj, freeze_all)
+      return true if @ractor_shareable.key?(obj)
+      return true if ractor_shareable_by_nature?(obj, freeze_all)
+      if obj.frozen? || (freeze_all && obj.freeze)
+        yield
+      else
+        false
+      end
+    end
+
+    private def ractor_shareable_parts?(obj, freeze_all, visited)
+      return true if visited.key?(obj)
+      visited[obj] = true
+
+      ractor_traverse(obj) do |part|
+        return false unless ractor_shareable_self?(part, freeze_all) do
+          ractor_shareable_parts?(part, freeze_all, visited)
+        end
+      end
+
+      true
+    end
+
+    def ractor_mark_set_shareable(visited)
+      visited.each do |key|
+        @ractor_shareable[key] = Ractor
+      end
+    end
+
+    private def ractor_traverse(obj, &block)
+      case obj
+      when ::Hash
+        Hash obj.default
+        yield obj.default_proc
+        obj.each do |key, value|
+          yield key
+          yield value
+        end
+      when ::Range
+        yield obj.begin
+        yield obj.end
+      when ::Array, ::Struct
+        obj.each(&block)
+      when ::Complex
+        yield obj.real
+        yield obj.imaginary
+      when ::Rational
+        yield obj.numerator
+        yield obj.denominator
+      end
+      obj.instance_variables.each do |var|
+        yield obj.instance_variable_get(var)
+      end
+    end
+
+    private def ractor_shareable_by_nature?(obj, freeze_all)
+      case obj
+      when ::Module, ::Ractor
+        true
+      when ::Regexp, ::Range, ::Numeric
+        !freeze_all # Assume that these are literals that would have been frozen in 3.0
+                    # unless we're making them shareable, in which case we might as well
+                    # freeze them for real.
+      when ::Symbol, false, true, nil # Were only frozen in Ruby 2.3+
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/backports/tools/filtered_queue.rb

@@ -0,0 +1,202 @@
+module Backports
+  class FilteredQueue
+    require 'backports/2.3.0/queue/close'
+    CONSUME_ON_ESCAPE = true
+
+    class ClosedQueueError < ::ClosedQueueError
+    end
+    class TimeoutError < ::ThreadError
+    end
+
+    class Message
+      # Not using Struct as we want comparision by identity
+      attr_reader :value
+      attr_accessor :reserved
+
+      def initialize(value)
+        @value = value
+        @reserved = false
+      end
+    end
+    private_constant :Message
+
+    # Like ::Queue, but with
+    # - filtering
+    # - timeout
+    # - raises on closed queues
+
+    attr_reader :num_waiting
+
+    # Timeout processing based on https://spin.atomicobject.com/2017/06/28/queue-pop-with-timeout-fixed/
+    def initialize
+      @mutex = ::Mutex.new
+      @queue = []
+      @closed = false
+      @received = ::ConditionVariable.new
+      @num_waiting = 0
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+        @received.broadcast
+      end
+      self
+    end
+
+    def closed?
+      @closed
+    end
+
+    def <<(x)
+      @mutex.synchronize do
+        ensure_open
+        @queue << Message.new(x)
+        @received.signal
+      end
+      self
+    end
+    alias_method :push, :<<
+
+    def clear
+      @mutex.synchronize do
+        @queue.clear
+      end
+      self
+    end
+
+    def pop(timeout: nil, &block)
+      msg = nil
+      exclude = [] if block # exclusion list of messages rejected by this call
+      timeout_time = timeout + Time.now.to_f if timeout
+      while true do
+        @mutex.synchronize do
+          reenter if reentrant?
+          msg = acquire!(timeout_time, exclude)
+          return consume!(msg).value unless block
+        end
+        return msg.value if filter?(msg, &block)
+      end
+    end
+
+    def empty?
+      avail = @mutex.synchronize do
+        available!
+      end
+
+      !avail
+    end
+
+    protected def timeout_value
+      raise self.class::TimeoutError, "timeout elapsed"
+    end
+
+    protected def closed_queue_value
+      ensure_open
+    end
+
+    # @return if outer message should be consumed or not
+    protected def reenter
+      true
+    end
+
+    ### private section
+    #
+    # bang methods require synchronization
+
+    # @returns:
+    # * true if message consumed (block result truthy or due to reentrant call)
+    # * false if rejected
+    private def filter?(msg)
+      consume = self.class::CONSUME_ON_ESCAPE
+      begin
+        reentered = consume_on_reentry(msg) do
+          consume = !!(yield msg.value)
+        end
+        reentered ? reenter : consume
+      ensure
+        commit(msg, consume) unless reentered
+      end
+    end
+
+    # @returns msg
+    private def consume!(msg)
+      @queue.delete(msg)
+    end
+
+    private def reject!(msg)
+      msg.reserved = false
+      @received.broadcast
+    end
+
+    private def commit(msg, consume)
+      @mutex.synchronize do
+        if consume
+          consume!(msg)
+        else
+          reject!(msg)
+        end
+      end
+    end
+
+    private def consume_on_reentry(msg)
+      q_map = current_filtered_queues
+      if (outer_msg = q_map[self])
+        commit(outer_msg, reenter)
+      end
+      q_map[self] = msg
+      begin
+        yield
+      ensure
+        reentered = !q_map.delete(self)
+      end
+      reentered
+    end
+
+    private def reentrant?
+      !!current_filtered_queues[self]
+    end
+
+    # @returns Hash { FilteredQueue => Message }
+    private def current_filtered_queues
+      t = Thread.current
+      t.thread_variable_get(:backports_currently_filtered_queues) or
+        t.thread_variable_set(:backports_currently_filtered_queues, {}.compare_by_identity)
+    end
+
+    # private methods assume @mutex synchonized
+    # adds to exclude list
+    private def acquire!(timeout_time, exclude = nil)
+      while true do
+        if (msg = available!(exclude))
+          msg.reserved = true
+          exclude << msg if exclude
+          return msg
+        end
+        return closed_queue_value if @closed
+        # wait for element or timeout
+        if timeout_time
+          remaining_time = timeout_time - ::Time.now.to_f
+          return timeout_value if remaining_time <= 0
+        end
+        begin
+          @num_waiting += 1
+          @received.wait(@mutex, remaining_time)
+        ensure
+          @num_waiting -= 1
+        end
+      end
+    end
+
+    private def available!(exclude = nil)
+      @queue.find do |msg|
+        next if exclude && exclude.include?(msg)
+        !msg.reserved
+      end
+    end
+
+    private def ensure_open
+      raise self.class::ClosedQueueError, 'queue closed' if @closed
+    end
+  end
+end

data/lib/backports/version.rb

@@ -1,3 +1,3 @@
 module Backports
-  VERSION = "3.19.0" unless Backports.constants.include? :VERSION # the guard is against a redefinition warning that happens on Travis
+  VERSION = "3.20.0" unless Backports.constants.include? :VERSION # the guard is against a redefinition warning that happens on Travis
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backports
 version: !ruby/object:Gem::Version
-  version: 3.19.0
+  version: 3.20.0
 platform: ruby
 authors:
 - Marc-André Lafortune
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies: []
 description: Essential backports that enable many of the nice features of Ruby for
   earlier versions.
@@ -538,6 +538,7 @@ files:
 - lib/backports/3.0.0/hash.rb
 - lib/backports/3.0.0/hash/except.rb
 - lib/backports/3.0.0/hash/transform_keys.rb
+- lib/backports/3.0.0/ractor.rb
 - lib/backports/3.0.0/symbol.rb
 - lib/backports/3.0.0/symbol/name.rb
 - lib/backports/3.0.rb
@@ -548,6 +549,11 @@ files:
 - lib/backports/force/string_length.rb
 - lib/backports/force/string_size.rb
 - lib/backports/latest.rb
+- lib/backports/ractor/cloner.rb
+- lib/backports/ractor/errors.rb
+- lib/backports/ractor/queues.rb
+- lib/backports/ractor/ractor.rb
+- lib/backports/ractor/sharing.rb
 - lib/backports/rails.rb
 - lib/backports/rails/array.rb
 - lib/backports/rails/enumerable.rb
@@ -566,6 +572,7 @@ files:
 - lib/backports/tools/arguments.rb
 - lib/backports/tools/deprecation.rb
 - lib/backports/tools/extreme_object.rb
+- lib/backports/tools/filtered_queue.rb
 - lib/backports/tools/float_integer_conversion.rb
 - lib/backports/tools/io.rb
 - lib/backports/tools/make_block_optional.rb