backports 3.20.1 → 3.20.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa5429b607594bcd855bad1a66bbfdc01e3facb1f76be0c338fd549b502ec1c4
-  data.tar.gz: e7e08e840cc7559df5708a0bfa5d1499a3e809fb9bf79b260e4c98e7ca634c60
+  metadata.gz: 4e5c6feae3c15c70a78dda33abcb10c737393eb6898d1756c8f3da4e5f604b25
+  data.tar.gz: 3339a5a0ae48803b9853627c096790f555a3a8f852af7b66c4331f683fcaac55
 SHA512:
-  metadata.gz: 5e59f88a7ef8c1487cc1c1fb04d28a96d44b26d8cc5379a6ea9f18edfca62d97fe0b84c27a03c600a6137febf9096917f0ec1d7a52574fc536f7c345b2e256af
-  data.tar.gz: 9e732e7626034ae45dd1daf0cd54f20319854f27f041c5624e8c96d287a66ffeee780e8d0c142472e8b88cba597b65ee300b161b811acade9aaa697ff3352ff7
+  metadata.gz: d843af1e7bd02fe062f600df7b130c37b2ce41bf178831049bbcd57fadbb9cac1c73d9bf4feebca71dcb39998492442083822d60c1691e1e67f195e21005ea97
+  data.tar.gz: f37e52397480aeb259cf469093980cdef01500e845b94fbe90d67864f37323d2dcdbd59fa308ada90cc7c1820a02b20c07c4a647e986840f0c9222c1b4313a35

data/Gemfile

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

data/README.md

@@ -1,6 +1,6 @@
 # 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 write a gem using some new cool features in Ruby 3.0 while
+Yearning to 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`?
 
@@ -135,7 +135,7 @@ itself, JRuby and Rubinius.
   - `clamp` (with range)
 
 #### Complex
-  - +<=>+
+  - `<=>`
 
 #### Enumerable
   - `filter_map`
@@ -167,10 +167,10 @@ itself, JRuby and Rubinius.
   - `then`
 
 #### Method
-  - +<<+, +>>+
+  - `<<`, `>>`
 
 #### Proc
-  - +<<+, +>>+
+  - `<<`, `>>`
 
 #### Range
   - `cover?` (with `Range` argument)

data/lib/backports/2.5.0/integer/sqrt.rb

@@ -9,7 +9,7 @@ class Integer
     bits_shift = n.bit_length / 2 + 1
     bitn_mask = root = 1 << bits_shift
     loop do
-      root ^= bitn_mask if (root * root) > n # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      root ^= bitn_mask if (root * root) > n
       bitn_mask >>= 1
       return root if bitn_mask == 0
       root |= bitn_mask

data/lib/backports/3.0.0/ractor.rb

@@ -1,5 +1,19 @@
 if RUBY_VERSION < '2'
   warn 'Ractor not backported to Ruby 1.x'
+elsif defined?(Ractor.current)
+  # all good
 else
-  require_relative '../ractor/ractor' unless defined?(Ractor.current)
+  # Cloner:
+  require_relative '../2.4.0/hash/transform_values'
+  require_relative '../2.5.0/hash/transform_keys'
+  # Queues & FilteredQueue
+  require_relative '../2.3.0/queue/close'
+
+  class Ractor
+  end
+
+  module Backports
+    Ractor = ::Ractor
+  end
+  require_relative '../ractor/ractor'
 end

data/lib/backports/ractor/cloner.rb

@@ -1,91 +1,94 @@
-require_relative '../2.4.0/hash/transform_values'
-require_relative '../2.5.0/hash/transform_keys'
+# shareable_constant_value: literal
 
-class Ractor
-  module Cloner
-    extend self
+using ::RubyNext if defined?(::RubyNext)
 
-    def deep_clone(obj)
-      return obj if Ractor.ractor_shareable_self?(obj, false) { false }
+module Backports
+  class Ractor
+    module Cloner
+      extend self
 
-      @processed = {}.compare_by_identity
-      @changed = nil
-      result = process(obj) do |r|
-        copy_contents(r)
+      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
-      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 }
 
-    # 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
 
-      result = process(obj) do |r|
-        copy_contents(r)
+        yield result if block_given?
+        result
       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
+      # 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?
+          @changed = true
+          result.freeze if obj.frozen?
 
-        result
+          result
+        end
       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
+      # 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
+      # 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.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)
+        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
-  private_constant :Cloner
 end

data/lib/backports/ractor/errors.rb

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

data/lib/backports/{tools → ractor}/filtered_queue.rb

@@ -1,10 +1,18 @@
+# shareable_constant_value: literal
+
 module Backports
+  # Like ::Queue, but with
+  # - filtering
+  # - timeout
+  # - raises on closed queues
+  #
+  # Independent from other Ractor related backports.
   class FilteredQueue
-    require 'backports/2.3.0/queue/close'
     CONSUME_ON_ESCAPE = true
 
     class ClosedQueueError < ::ClosedQueueError
     end
+
     class TimeoutError < ::ThreadError
     end
 
@@ -20,11 +28,6 @@ module Backports
     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/
@@ -69,7 +72,7 @@ module Backports
       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
+      while true do # rubocop:disable Style/InfiniteLoop, Style/WhileUntilDo
         @mutex.synchronize do
           reenter if reentrant?
           msg = acquire!(timeout_time, exclude)
@@ -167,7 +170,7 @@ module Backports
     # private methods assume @mutex synchonized
     # adds to exclude list
     private def acquire!(timeout_time, exclude = nil)
-      while true do
+      while true do # rubocop:disable Style/InfiniteLoop, Style/WhileUntilDo
         if (msg = available!(exclude))
           msg.reserved = true
           exclude << msg if exclude

data/lib/backports/ractor/queues.rb

@@ -1,62 +1,66 @@
-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
+# shareable_constant_value: literal
+
+require_relative 'filtered_queue'
+
+module Backports
+  class Ractor
+    # Standard ::Queue but raises if popping and closed
+    class BaseQueue < FilteredQueue
+      ClosedQueueError = Ractor::ClosedError
+
+      # yields message (if any)
+      def pop_non_blocking
+        yield pop(timeout: 0)
+      rescue TimeoutError
+        nil
+      end
     end
-  end
 
-  class IncomingQueue < BaseQueue
-    TYPE = :incoming
+    class IncomingQueue < BaseQueue
+      TYPE = :incoming
 
-    protected def reenter
-      raise ::Ractor::Error, 'Can not reenter'
+      protected def reenter
+        raise Ractor::Error, 'Can not reenter'
+      end
     end
-  end
 
-  # * Wraps exception
-  # * Add `ack: ` to push (blocking)
-  class OutgoingQueue < BaseQueue
-    TYPE = :outgoing
+    # * Wraps exception
+    # * Add `ack: ` to push (blocking)
+    class OutgoingQueue < BaseQueue
+      TYPE = :outgoing
 
-    WrappedException = ::Struct.new(:exception, :ractor)
+      WrappedException = ::Struct.new(:exception, :ractor)
 
-    def initialize
-      @ack_queue = ::Queue.new
-      super
-    end
+      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
+      def pop(timeout: nil, ack: true)
+        r = super(timeout: timeout)
+        @ack_queue << :done if ack
+        raise r.exception if WrappedException === r
 
-      r
-    end
+        r
+      end
 
-    def close(how = :hard)
-      super()
-      return if how == :soft
+      def close(how = :hard)
+        super()
+        return if how == :soft
 
-      clear
-      @ack_queue.close
-    end
+        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
+      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
-      self
     end
+    private_constant :BaseQueue, :OutgoingQueue, :IncomingQueue
   end
-  private_constant :BaseQueue, :OutgoingQueue, :IncomingQueue
 end

data/lib/backports/ractor/ractor.rb

@@ -1,261 +1,272 @@
+# shareable_constant_value: literal
+
 # 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'
-
-  RactorThreadGroups = ::ObjectSpace::WeakMap.new # ThreadGroup => Ractor
-  private_constant :RactorThreadGroups
-  # 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(:backports_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)
+module Backports
+  class Ractor
+    require_relative '../tools/arguments'
+
+    require_relative 'cloner'
+    require_relative 'errors'
+    require_relative 'queues'
+    require_relative 'sharing'
+
+    RactorThreadGroups = ::ObjectSpace::WeakMap.new # ThreadGroup => Ractor
+    private_constant :RactorThreadGroups
+    # 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)
+
+      @id = Ractor.ractor_next_id
+      if Ractor.main == nil # then initializing main Ractor
+        @ractor_thread = ::Thread.current
+        @ractor_origin = nil
+        @ractor_thread.thread_variable_set(:backports_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
-  end
 
-  private def ractor_thread_start(args, block)
-    ::Thread.new do
-      @ractor_thread = Thread.current
-      @ractor_thread_group = ThreadGroup.new
-      RactorThreadGroups[@ractor_thread_group] = self
-      @ractor_thread_group.add(@ractor_thread)
-      ::Thread.current.thread_variable_set(:backports_ractor, self)
-      result = nil
-      begin
-        result = instance_exec(*args, &block)
-      rescue ::Exception => err # rubocop:disable Lint/RescueException
+    private def ractor_thread_start(args, block)
+      ::Thread.new do
+        @ractor_thread = ::Thread.current
+        @ractor_thread_group = ::ThreadGroup.new
+        RactorThreadGroups[@ractor_thread_group] = self
+        @ractor_thread_group.add(@ractor_thread)
+        ::Thread.current.thread_variable_set(:backports_ractor, self)
+        result = nil
         begin
-          raise RemoteError, "thrown by remote Ractor: #{err.message}"
-        rescue RemoteError => e # Hack to create exception with `cause`
-          result = OutgoingQueue::WrappedException.new(e)
+          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
-      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
+    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
-  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 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 close_incoming
-    r = ractor_incoming_queue.closed?
-    ractor_incoming_queue.close
-    r
-  end
+    def take
+      ractor_outgoing_queue.pop(ack: true)
+    end
 
-  def close_outgoing
-    r = ractor_outgoing_queue.closed?
-    ractor_outgoing_queue.close
-    r
-  end
+    def name
+      @ractor_name
+    end
 
-  private def receive
-    ractor_incoming_queue.pop
-  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:##{@id}",
+        name,
+        @ractor_origin,
+        state,
+      ].compact.join(' ')
+
+      "#<#{info}>"
+    end
 
-  private def receive_if(&block)
-    raise ArgumentError, 'no block given' unless block
-    ractor_incoming_queue.pop(&block)
-  end
+    def close_incoming
+      r = ractor_incoming_queue.closed?
+      ractor_incoming_queue.close
+      r
+    end
 
-  def [](key)
-    Ractor.current.ractor_locals[key]
-  end
+    def close_outgoing
+      r = ractor_outgoing_queue.closed?
+      ractor_outgoing_queue.close
+      r
+    end
 
-  def []=(key, value)
-    Ractor.current.ractor_locals[key] = value
-  end
+    private def receive
+      ractor_incoming_queue.pop
+    end
 
-  # @api private
-  def ractor_locals
-    @ractor_locals ||= {}.compare_by_identity
-  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'
+    def [](key)
+      Ractor.current.ractor_locals[key]
     end
 
-    def receive
-      current.__send__(:receive)
+    def []=(key, value)
+      Ractor.current.ractor_locals[key] = value
     end
-    alias_method :recv, :receive
 
-    def receive_if(&block)
-      current.__send__(:receive_if, &block)
+    # @api private
+    def ractor_locals
+      @ractor_locals ||= {}.compare_by_identity
     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
+    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
-      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`'
+
+      def receive
+        current.__send__(:receive)
       end
+      alias_method :recv, :receive
 
-      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
+      def receive_if(&block)
+        current.__send__(:receive_if, &block)
+      end
 
-        if out && out.num_waiting > 0
-          # Not quite atomic...
-          out.push(yield_value, ack: true)
-          return [:yield, nil]
+      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
 
-        sleep(0.001)
+        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
-    end
 
-    def make_shareable(obj)
-      return obj if ractor_check_shareability?(obj, true)
+      def make_shareable(obj)
+        return obj if ractor_check_shareability?(obj, true)
 
-      raise Ractor::Error, '#freeze does not freeze object correctly'
-    end
+        raise Ractor::Error, '#freeze does not freeze object correctly'
+      end
 
-    def shareable?(obj)
-      ractor_check_shareability?(obj, false)
-    end
+      def shareable?(obj)
+        ractor_check_shareability?(obj, false)
+      end
 
-    def current
-      Thread.current.thread_variable_get(:backports_ractor) ||
-        Thread.current.thread_variable_set(:backports_ractor, ractor_find_current)
-    end
+      def current
+        ::Thread.current.thread_variable_get(:backports_ractor) ||
+          ::Thread.current.thread_variable_set(:backports_ractor, ractor_find_current)
+      end
 
-    def count
-      ObjectSpace.each_object(Ractor).count(&:ractor_live?)
-    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)
+      # @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
+          th.kill
+          th.join
+        end
+        Ractor.current.ractor_incoming_queue.clear
       end
-      Ractor.current.ractor_incoming_queue.clear
-    end
 
-    attr_reader :main
+      # @api private
+      def ractor_next_id
+        @id ||= 0
+        @id += 1
+      end
 
-    private def ractor_init
-      @ractor_shareable = ::ObjectSpace::WeakMap.new
-      @main = Ractor.new { nil }
-      RactorThreadGroups[::ThreadGroup::Default] = @main
-    end
+      attr_reader :main
 
-    private def ractor_find_current
-      RactorThreadGroups[Thread.current.group]
+      private def ractor_init
+        @ractor_shareable = ::ObjectSpace::WeakMap.new
+        @main = Ractor.new { nil }
+        RactorThreadGroups[::ThreadGroup::Default] = @main
+      end
+
+      private def ractor_find_current
+        RactorThreadGroups[Thread.current.group]
+      end
     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
+    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
+    # @api private
+    attr_reader :ractor_outgoing_queue, :ractor_incoming_queue, :ractor_thread
 
-  ractor_init
+    ractor_init
+  end
 end

data/lib/backports/ractor/sharing.rb

@@ -1,92 +1,96 @@
-class Ractor
-  class << self
-    # @api private
-    def ractor_isolate(val, move = false)
-      return val if move
+# shareable_constant_value: literal
 
-      Cloner.deep_clone(val)
-    end
+module Backports
+  class Ractor
+    class << self
+      # @api private
+      def ractor_isolate(val, move = false)
+        return val if move
 
-    private def ractor_check_shareability?(obj, freeze_all)
-      ractor_shareable_self?(obj, freeze_all) do
-        visited = {}
+        Cloner.deep_clone(val)
+      end
 
-        return false unless ractor_shareable_parts?(obj, freeze_all, visited)
+      private def ractor_check_shareability?(obj, freeze_all)
+        ractor_shareable_self?(obj, freeze_all) do
+          visited = {}
 
-        ractor_mark_set_shareable(visited)
+          return false unless ractor_shareable_parts?(obj, freeze_all, visited)
 
-        true
-      end
-    end
+          ractor_mark_set_shareable(visited)
 
-    # 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
+          true
+        end
       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)
+      # 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
 
-      true
-    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
 
-    def ractor_mark_set_shareable(visited)
-      visited.each do |key|
-        @ractor_shareable[key] = Ractor
+        true
       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
+      def ractor_mark_set_shareable(visited)
+        visited.each do |key|
+          @ractor_shareable[key] = Ractor
         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)
+
+      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
-    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
+      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/version.rb

@@ -1,3 +1,3 @@
 module Backports
-  VERSION = "3.20.1" unless Backports.constants.include? :VERSION # the guard is against a redefinition warning that happens on Travis
+  VERSION = "3.20.2" 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.20.1
+  version: 3.20.2
 platform: ruby
 authors:
 - Marc-André Lafortune
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-03 00:00:00.000000000 Z
+date: 2021-01-27 00:00:00.000000000 Z
 dependencies: []
 description: Essential backports that enable many of the nice features of Ruby for
   earlier versions.
@@ -551,6 +551,7 @@ files:
 - lib/backports/latest.rb
 - lib/backports/ractor/cloner.rb
 - lib/backports/ractor/errors.rb
+- lib/backports/ractor/filtered_queue.rb
 - lib/backports/ractor/queues.rb
 - lib/backports/ractor/ractor.rb
 - lib/backports/ractor/sharing.rb
@@ -572,7 +573,6 @@ 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