honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb

@@ -1,128 +0,0 @@
-require 'concurrent/synchronization/lockable_object'
-require 'concurrent/utility/native_integer'
-
-module Concurrent
-
-  # A synchronization aid that allows a set of threads to all wait for each
-  # other to reach a common barrier point.
-  # @example
-  #   barrier = Concurrent::CyclicBarrier.new(3)
-  #   jobs    = Array.new(3) { |i| -> { sleep i; p done: i } }
-  #   process = -> (i) do
-  #     # waiting to start at the same time
-  #     barrier.wait
-  #     # execute job
-  #     jobs[i].call
-  #     # wait for others to finish
-  #     barrier.wait
-  #   end
-  #   threads = 2.times.map do |i|
-  #     Thread.new(i, &process)
-  #   end
-  #
-  #   # use main as well
-  #   process.call 2
-  #
-  #   # here we can be sure that all jobs are processed
-  class CyclicBarrier < Synchronization::LockableObject
-
-    # @!visibility private
-    Generation = Struct.new(:status)
-    private_constant :Generation
-
-    # Create a new `CyclicBarrier` that waits for `parties` threads
-    #
-    # @param [Fixnum] parties the number of parties
-    # @yield an optional block that will be executed that will be executed after
-    #  the last thread arrives and before the others are released
-    #
-    # @raise [ArgumentError] if `parties` is not an integer or is less than zero
-    def initialize(parties, &block)
-      Utility::NativeInteger.ensure_integer_and_bounds parties
-      Utility::NativeInteger.ensure_positive_and_no_zero parties
-
-      super(&nil)
-      synchronize { ns_initialize parties, &block }
-    end
-
-    # @return [Fixnum] the number of threads needed to pass the barrier
-    def parties
-      synchronize { @parties }
-    end
-
-    # @return [Fixnum] the number of threads currently waiting on the barrier
-    def number_waiting
-      synchronize { @number_waiting }
-    end
-
-    # Blocks on the barrier until the number of waiting threads is equal to
-    # `parties` or until `timeout` is reached or `reset` is called
-    # If a block has been passed to the constructor, it will be executed once by
-    #  the last arrived thread before releasing the others
-    # @param [Fixnum] timeout the number of seconds to wait for the counter or
-    #  `nil` to block indefinitely
-    # @return [Boolean] `true` if the `count` reaches zero else false on
-    #  `timeout` or on `reset` or if the barrier is broken
-    def wait(timeout = nil)
-      synchronize do
-
-        return false unless @generation.status == :waiting
-
-        @number_waiting += 1
-
-        if @number_waiting == @parties
-          @action.call if @action
-          ns_generation_done @generation, :fulfilled
-          true
-        else
-          generation = @generation
-          if ns_wait_until(timeout) { generation.status != :waiting }
-            generation.status == :fulfilled
-          else
-            ns_generation_done generation, :broken, false
-            false
-          end
-        end
-      end
-    end
-
-    # resets the barrier to its initial state
-    # If there is at least one waiting thread, it will be woken up, the `wait`
-    # method will return false and the barrier will be broken
-    # If the barrier is broken, this method restores it to the original state
-    #
-    # @return [nil]
-    def reset
-      synchronize { ns_generation_done @generation, :reset }
-    end
-
-    # A barrier can be broken when:
-    # - a thread called the `reset` method while at least one other thread was waiting
-    # - at least one thread timed out on `wait` method
-    #
-    # A broken barrier can be restored using `reset` it's safer to create a new one
-    # @return [Boolean] true if the barrier is broken otherwise false
-    def broken?
-      synchronize { @generation.status != :waiting }
-    end
-
-    protected
-
-    def ns_generation_done(generation, status, continue = true)
-      generation.status = status
-      ns_next_generation if continue
-      ns_broadcast
-    end
-
-    def ns_next_generation
-      @generation     = Generation.new(:waiting)
-      @number_waiting = 0
-    end
-
-    def ns_initialize(parties, &block)
-      @parties = parties
-      @action  = block
-      ns_next_generation
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/event.rb

@@ -1,109 +0,0 @@
-require 'thread'
-require 'concurrent/synchronization/lockable_object'
-
-module Concurrent
-
-  # Old school kernel-style event reminiscent of Win32 programming in C++.
-  #
-  # When an `Event` is created it is in the `unset` state. Threads can choose to
-  # `#wait` on the event, blocking until released by another thread. When one
-  # thread wants to alert all blocking threads it calls the `#set` method which
-  # will then wake up all listeners. Once an `Event` has been set it remains set.
-  # New threads calling `#wait` will return immediately. An `Event` may be
-  # `#reset` at any time once it has been set.
-  #
-  # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
-  # @example
-  #   event = Concurrent::Event.new
-  #
-  #   t1 = Thread.new do
-  #     puts "t1 is waiting"
-  #     event.wait(1)
-  #     puts "event occurred"
-  #   end
-  #
-  #   t2 = Thread.new do
-  #     puts "t2 calling set"
-  #     event.set
-  #   end
-  #
-  #   [t1, t2].each(&:join)
-  #
-  #   # prints:
-  #   # t1 is waiting
-  #   # t2 calling set
-  #   # event occurred
-  class Event < Synchronization::LockableObject
-
-    # Creates a new `Event` in the unset state. Threads calling `#wait` on the
-    # `Event` will block.
-    def initialize
-      super
-      synchronize { ns_initialize }
-    end
-
-    # Is the object in the set state?
-    #
-    # @return [Boolean] indicating whether or not the `Event` has been set
-    def set?
-      synchronize { @set }
-    end
-
-    # Trigger the event, setting the state to `set` and releasing all threads
-    # waiting on the event. Has no effect if the `Event` has already been set.
-    #
-    # @return [Boolean] should always return `true`
-    def set
-      synchronize { ns_set }
-    end
-
-    def try?
-      synchronize { @set ? false : ns_set }
-    end
-
-    # Reset a previously set event back to the `unset` state.
-    # Has no effect if the `Event` has not yet been set.
-    #
-    # @return [Boolean] should always return `true`
-    def reset
-      synchronize do
-        if @set
-          @set       = false
-          @iteration +=1
-        end
-        true
-      end
-    end
-
-    # Wait a given number of seconds for the `Event` to be set by another
-    # thread. Will wait forever when no `timeout` value is given. Returns
-    # immediately if the `Event` has already been set.
-    #
-    # @return [Boolean] true if the `Event` was set before timeout else false
-    def wait(timeout = nil)
-      synchronize do
-        unless @set
-          iteration = @iteration
-          ns_wait_until(timeout) { iteration < @iteration || @set }
-        else
-          true
-        end
-      end
-    end
-
-    protected
-
-    def ns_set
-      unless @set
-        @set = true
-        ns_broadcast
-      end
-      true
-    end
-
-    def ns_initialize
-      @set       = false
-      @iteration = 0
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb

@@ -1,109 +0,0 @@
-require 'concurrent/constants'
-require_relative 'locals'
-
-module Concurrent
-
-  # A `FiberLocalVar` is a variable where the value is different for each fiber.
-  # Each variable may have a default value, but when you modify the variable only
-  # the current fiber will ever see that change.
-  #
-  # This is similar to Ruby's built-in fiber-local variables (`Thread.current[:name]`),
-  # but with these major advantages:
-  # * `FiberLocalVar` has its own identity, it doesn't need a Symbol.
-  # * Each Ruby's built-in fiber-local variable leaks some memory forever (it's a Symbol held forever on the fiber),
-  #   so it's only OK to create a small amount of them.
-  #   `FiberLocalVar` has no such issue and it is fine to create many of them.
-  # * Ruby's built-in fiber-local variables leak forever the value set on each fiber (unless set to nil explicitly).
-  #   `FiberLocalVar` automatically removes the mapping for each fiber once the `FiberLocalVar` instance is GC'd.
-  #
-  # @example
-  #   v = FiberLocalVar.new(14)
-  #   v.value #=> 14
-  #   v.value = 2
-  #   v.value #=> 2
-  #
-  # @example
-  #   v = FiberLocalVar.new(14)
-  #
-  #   Fiber.new do
-  #     v.value #=> 14
-  #     v.value = 1
-  #     v.value #=> 1
-  #   end.resume
-  #
-  #   Fiber.new do
-  #     v.value #=> 14
-  #     v.value = 2
-  #     v.value #=> 2
-  #   end.resume
-  #
-  #   v.value #=> 14
-  class FiberLocalVar
-    LOCALS = FiberLocals.new
-
-    # Creates a fiber local variable.
-    #
-    # @param [Object] default the default value when otherwise unset
-    # @param [Proc] default_block Optional block that gets called to obtain the
-    #   default value for each fiber
-    def initialize(default = nil, &default_block)
-      if default && block_given?
-        raise ArgumentError, "Cannot use both value and block as default value"
-      end
-
-      if block_given?
-        @default_block = default_block
-        @default = nil
-      else
-        @default_block = nil
-        @default = default
-      end
-
-      @index = LOCALS.next_index(self)
-    end
-
-    # Returns the value in the current fiber's copy of this fiber-local variable.
-    #
-    # @return [Object] the current value
-    def value
-      LOCALS.fetch(@index) { default }
-    end
-
-    # Sets the current fiber's copy of this fiber-local variable to the specified value.
-    #
-    # @param [Object] value the value to set
-    # @return [Object] the new value
-    def value=(value)
-      LOCALS.set(@index, value)
-    end
-
-    # Bind the given value to fiber local storage during
-    # execution of the given block.
-    #
-    # @param [Object] value the value to bind
-    # @yield the operation to be performed with the bound variable
-    # @return [Object] the value
-    def bind(value)
-      if block_given?
-        old_value = self.value
-        self.value = value
-        begin
-          yield
-        ensure
-          self.value = old_value
-        end
-      end
-    end
-
-    protected
-
-    # @!visibility private
-    def default
-      if @default_block
-        self.value = @default_block.call
-      else
-        @default
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb

@@ -1,43 +0,0 @@
-if Concurrent.on_jruby?
-  require 'concurrent/utility/native_extension_loader'
-
-  module Concurrent
-
-    # @!macro count_down_latch
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaCountDownLatch
-
-      # @!macro count_down_latch_method_initialize
-      def initialize(count = 1)
-        Utility::NativeInteger.ensure_integer_and_bounds(count)
-        Utility::NativeInteger.ensure_positive(count)
-        @latch = java.util.concurrent.CountDownLatch.new(count)
-      end
-
-      # @!macro count_down_latch_method_wait
-      def wait(timeout = nil)
-        result = nil
-        if timeout.nil?
-          Synchronization::JRuby.sleep_interruptibly { @latch.await }
-          result = true
-        else
-          Synchronization::JRuby.sleep_interruptibly do
-            result = @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
-          end
-        end
-        result
-      end
-
-      # @!macro count_down_latch_method_count_down
-      def count_down
-        @latch.countDown
-      end
-
-      # @!macro count_down_latch_method_count
-      def count
-        @latch.getCount
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/locals.rb

@@ -1,189 +0,0 @@
-require 'fiber'
-require 'concurrent/utility/engine'
-require 'concurrent/constants'
-
-module Concurrent
-  # @!visibility private
-  # @!macro internal_implementation_note
-  #
-  # An abstract implementation of local storage, with sub-classes for
-  # per-thread and per-fiber locals.
-  #
-  # Each execution context (EC, thread or fiber) has a lazily initialized array
-  # of local variable values. Each time a new local variable is created, we
-  # allocate an "index" for it.
-  #
-  # For example, if the allocated index is 1, that means slot #1 in EVERY EC's
-  # locals array will be used for the value of that variable.
-  #
-  # The good thing about using a per-EC structure to hold values, rather than
-  # a global, is that no synchronization is needed when reading and writing
-  # those values (since the structure is only ever accessed by a single
-  # thread).
-  #
-  # Of course, when a local variable is GC'd, 1) we need to recover its index
-  # for use by other new local variables (otherwise the locals arrays could
-  # get bigger and bigger with time), and 2) we need to null out all the
-  # references held in the now-unused slots (both to avoid blocking GC of those
-  # objects, and also to prevent "stale" values from being passed on to a new
-  # local when the index is reused).
-  #
-  # Because we need to null out freed slots, we need to keep references to
-  # ALL the locals arrays, so we can null out the appropriate slots in all of
-  # them. This is why we need to use a finalizer to clean up the locals array
-  # when the EC goes out of scope.
-  class AbstractLocals
-    def initialize
-      @free = []
-      @lock = Mutex.new
-      @all_arrays = {}
-      @next = 0
-    end
-
-    def synchronize
-      @lock.synchronize { yield }
-    end
-
-    if Concurrent.on_cruby?
-      def weak_synchronize
-        yield
-      end
-    else
-      alias_method :weak_synchronize, :synchronize
-    end
-
-    def next_index(local)
-      index = synchronize do
-        if @free.empty?
-          @next += 1
-        else
-          @free.pop
-        end
-      end
-
-      # When the local goes out of scope, we should free the associated index
-      # and all values stored into it.
-      ObjectSpace.define_finalizer(local, local_finalizer(index))
-
-      index
-    end
-
-    def free_index(index)
-      weak_synchronize do
-        # The cost of GC'ing a TLV is linear in the number of ECs using local
-        # variables. But that is natural! More ECs means more storage is used
-        # per local variable. So naturally more CPU time is required to free
-        # more storage.
-        #
-        # DO NOT use each_value which might conflict with new pair assignment
-        # into the hash in #set method.
-        @all_arrays.values.each do |locals|
-          locals[index] = nil
-        end
-
-        # free index has to be published after the arrays are cleared:
-        @free << index
-      end
-    end
-
-    def fetch(index)
-      locals = self.locals
-      value = locals ? locals[index] : nil
-
-      if nil == value
-        yield
-      elsif NULL.equal?(value)
-        nil
-      else
-        value
-      end
-    end
-
-    def set(index, value)
-      locals = self.locals!
-      locals[index] = (nil == value ? NULL : value)
-
-      value
-    end
-
-    private
-
-    # When the local goes out of scope, clean up that slot across all locals currently assigned.
-    def local_finalizer(index)
-      proc do
-        free_index(index)
-      end
-    end
-
-    # When a thread/fiber goes out of scope, remove the array from @all_arrays.
-    def thread_fiber_finalizer(array_object_id)
-      proc do
-        weak_synchronize do
-          @all_arrays.delete(array_object_id)
-        end
-      end
-    end
-
-    # Returns the locals for the current scope, or nil if none exist.
-    def locals
-      raise NotImplementedError
-    end
-
-    # Returns the locals for the current scope, creating them if necessary.
-    def locals!
-      raise NotImplementedError
-    end
-  end
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  # An array-backed storage of indexed variables per thread.
-  class ThreadLocals < AbstractLocals
-    def locals
-      Thread.current.thread_variable_get(:concurrent_thread_locals)
-    end
-
-    def locals!
-      thread = Thread.current
-      locals = thread.thread_variable_get(:concurrent_thread_locals)
-
-      unless locals
-        locals = thread.thread_variable_set(:concurrent_thread_locals, [])
-        weak_synchronize do
-          @all_arrays[locals.object_id] = locals
-        end
-        # When the thread goes out of scope, we should delete the associated locals:
-        ObjectSpace.define_finalizer(thread, thread_fiber_finalizer(locals.object_id))
-      end
-
-      locals
-    end
-  end
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  # An array-backed storage of indexed variables per fiber.
-  class FiberLocals < AbstractLocals
-    def locals
-      Thread.current[:concurrent_fiber_locals]
-    end
-
-    def locals!
-      thread = Thread.current
-      locals = thread[:concurrent_fiber_locals]
-
-      unless locals
-        locals = thread[:concurrent_fiber_locals] = []
-        weak_synchronize do
-          @all_arrays[locals.object_id] = locals
-        end
-        # When the fiber goes out of scope, we should delete the associated locals:
-        ObjectSpace.define_finalizer(Fiber.current, thread_fiber_finalizer(locals.object_id))
-      end
-
-      locals
-    end
-  end
-
-  private_constant :AbstractLocals, :ThreadLocals, :FiberLocals
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb

@@ -1,28 +0,0 @@
-require 'concurrent/utility/engine'
-require_relative 'fiber_local_var'
-require_relative 'thread_local_var'
-
-module Concurrent
-  # @!visibility private
-  def self.mutex_owned_per_thread?
-    return false if Concurrent.on_jruby? || Concurrent.on_truffleruby?
-
-    mutex = Mutex.new
-    # Lock the mutex:
-    mutex.synchronize do
-      # Check if the mutex is still owned in a child fiber:
-      Fiber.new { mutex.owned? }.resume
-    end
-  end
-
-  if mutex_owned_per_thread?
-    LockLocalVar = ThreadLocalVar
-  else
-    LockLocalVar = FiberLocalVar
-  end
-
-  # Either {FiberLocalVar} or {ThreadLocalVar} depending on whether Mutex (and Monitor)
-  # are held, respectively, per Fiber or per Thread.
-  class LockLocalVar
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/concurrent-ruby-1.2.2/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb

@@ -1,68 +0,0 @@
-require 'concurrent/synchronization/safe_initialization'
-
-module Concurrent
-
-  # @!macro atomic_boolean
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class MutexAtomicBoolean
-    extend Concurrent::Synchronization::SafeInitialization
-
-    # @!macro atomic_boolean_method_initialize
-    def initialize(initial = false)
-      super()
-      @Lock = ::Mutex.new
-      @value = !!initial
-    end
-
-    # @!macro atomic_boolean_method_value_get
-    def value
-      synchronize { @value }
-    end
-
-    # @!macro atomic_boolean_method_value_set
-    def value=(value)
-      synchronize { @value = !!value }
-    end
-
-    # @!macro atomic_boolean_method_true_question
-    def true?
-      synchronize { @value }
-    end
-
-    # @!macro atomic_boolean_method_false_question
-    def false?
-      synchronize { !@value }
-    end
-
-    # @!macro atomic_boolean_method_make_true
-    def make_true
-      synchronize { ns_make_value(true) }
-    end
-
-    # @!macro atomic_boolean_method_make_false
-    def make_false
-      synchronize { ns_make_value(false) }
-    end
-
-    protected
-
-    # @!visibility private
-    def synchronize
-      if @Lock.owned?
-        yield
-      else
-        @Lock.synchronize { yield }
-      end
-    end
-
-    private
-
-    # @!visibility private
-    def ns_make_value(value)
-      old = @value
-      @value = value
-      old != @value
-    end
-  end
-end