ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atomic/abstract_thread_local_var.rb

@@ -1,66 +0,0 @@
-require 'concurrent/constants'
-
-module Concurrent
-
-  # @!macro thread_local_var
-  # @!macro internal_implementation_note
-  # @!visibility private
-  class AbstractThreadLocalVar
-
-    # @!macro thread_local_var_method_initialize
-    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
-
-      allocate_storage
-    end
-
-    # @!macro thread_local_var_method_get
-    def value
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_bind
-    def bind(value, &block)
-      if block_given?
-        old_value = self.value
-        begin
-          self.value = value
-          yield
-        ensure
-          self.value = old_value
-        end
-      end
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      raise NotImplementedError
-    end
-
-    # @!visibility private
-    def default
-      if @default_block
-        self.value = @default_block.call
-      else
-        @default
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb

@@ -1,126 +0,0 @@
-require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro atomic_boolean_method_initialize
-  #
-  #   Creates a new `AtomicBoolean` with the given initial value.
-  #
-  #   @param [Boolean] initial the initial value
-
-  # @!macro atomic_boolean_method_value_get
-  #
-  #   Retrieves the current `Boolean` value.
-  #
-  #   @return [Boolean] the current value
-
-  # @!macro atomic_boolean_method_value_set
-  #
-  #   Explicitly sets the value.
-  #
-  #   @param [Boolean] value the new value to be set
-  #
-  #   @return [Boolean] the current value
-
-  # @!macro atomic_boolean_method_true_question
-  #
-  #   Is the current value `true`
-  #
-  #   @return [Boolean] true if the current value is `true`, else false
-
-  # @!macro atomic_boolean_method_false_question
-  #
-  #   Is the current value `false`
-  #
-  #   @return [Boolean] true if the current value is `false`, else false
-
-  # @!macro atomic_boolean_method_make_true
-  #
-  #   Explicitly sets the value to true.
-  #
-  #   @return [Boolean] true if value has changed, otherwise false
-
-  # @!macro atomic_boolean_method_make_false
-  #
-  #   Explicitly sets the value to false.
-  #
-  #   @return [Boolean] true if value has changed, otherwise false
-
-  ###################################################################
-
-  # @!macro atomic_boolean_public_api
-  #
-  #   @!method initialize(initial = false)
-  #     @!macro  atomic_boolean_method_initialize
-  #
-  #   @!method value
-  #     @!macro  atomic_boolean_method_value_get
-  #
-  #   @!method value=(value)
-  #     @!macro  atomic_boolean_method_value_set
-  #
-  #   @!method true?
-  #     @!macro  atomic_boolean_method_true_question
-  #
-  #   @!method false?
-  #     @!macro  atomic_boolean_method_false_question
-  #
-  #   @!method make_true
-  #     @!macro  atomic_boolean_method_make_true
-  #
-  #   @!method make_false
-  #     @!macro  atomic_boolean_method_make_false
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  AtomicBooleanImplementation = case
-                                when defined?(JavaAtomicBoolean)
-                                  JavaAtomicBoolean
-                                when defined?(CAtomicBoolean)
-                                  CAtomicBoolean
-                                else
-                                  MutexAtomicBoolean
-                                end
-  private_constant :AtomicBooleanImplementation
-
-  # @!macro atomic_boolean
-  #
-  #   A boolean value that can be updated atomically. Reads and writes to an atomic
-  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
-  #   briefly but no explicit locking is required.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   Performance:
-  #
-  #   ```
-  #   Testing with ruby 2.1.2
-  #   Testing with Concurrent::MutexAtomicBoolean...
-  #     2.790000   0.000000   2.790000 (  2.791454)
-  #   Testing with Concurrent::CAtomicBoolean...
-  #     0.740000   0.000000   0.740000 (  0.740206)
-  #
-  #   Testing with jruby 1.9.3
-  #   Testing with Concurrent::MutexAtomicBoolean...
-  #     5.240000   2.520000   7.760000 (  3.683000)
-  #   Testing with Concurrent::JavaAtomicBoolean...
-  #     3.340000   0.010000   3.350000 (  0.855000)
-  #   ```
-  #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
-  #
-  # @!macro atomic_boolean_public_api
-  class AtomicBoolean < AtomicBooleanImplementation
-    # @return [String] Short string representation.
-    def to_s
-      format '%s value:%s>', super[0..-2], value
-    end
-
-    alias_method :inspect, :to_s
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb

@@ -1,143 +0,0 @@
-require 'concurrent/atomic/mutex_atomic_fixnum'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro atomic_fixnum_method_initialize
-  #
-  #   Creates a new `AtomicFixnum` with the given initial value.
-  #
-  #   @param [Fixnum] initial the initial value
-  #   @raise [ArgumentError] if the initial value is not a `Fixnum`
-
-  # @!macro atomic_fixnum_method_value_get
-  #
-  #   Retrieves the current `Fixnum` value.
-  #
-  #   @return [Fixnum] the current value
-
-  # @!macro atomic_fixnum_method_value_set
-  #
-  #   Explicitly sets the value.
-  #
-  #   @param [Fixnum] value the new value to be set
-  #
-  #   @return [Fixnum] the current value
-  #
-  #   @raise [ArgumentError] if the new value is not a `Fixnum`
-
-  # @!macro atomic_fixnum_method_increment
-  #
-  #   Increases the current value by the given amount (defaults to 1).
-  #
-  #   @param [Fixnum] delta the amount by which to increase the current value
-  #
-  #   @return [Fixnum] the current value after incrementation
-
-  # @!macro atomic_fixnum_method_decrement
-  #
-  #   Decreases the current value by the given amount (defaults to 1).
-  #
-  #   @param [Fixnum] delta the amount by which to decrease the current value
-  #
-  #   @return [Fixnum] the current value after decrementation
-
-  # @!macro atomic_fixnum_method_compare_and_set
-  #
-  #   Atomically sets the value to the given updated value if the current
-  #   value == the expected value.
-  #
-  #   @param [Fixnum] expect the expected value
-  #   @param [Fixnum] update the new value
-  #
-  #   @return [Boolean] true if the value was updated else false
-
-  # @!macro atomic_fixnum_method_update
-  #
-  #   Pass the current value to the given block, replacing it
-  #   with the block's result. May retry if the value changes
-  #   during the block's execution.
-  #
-  #   @yield [Object] Calculate a new value for the atomic reference using
-  #     given (old) value
-  #   @yieldparam [Object] old_value the starting value of the atomic reference
-  #
-  #   @return [Object] the new value
-
-  ###################################################################
-
-  # @!macro atomic_fixnum_public_api
-  #
-  #   @!method initialize(initial = 0)
-  #     @!macro atomic_fixnum_method_initialize
-  #
-  #   @!method value
-  #     @!macro atomic_fixnum_method_value_get
-  #
-  #   @!method value=(value)
-  #     @!macro atomic_fixnum_method_value_set
-  #
-  #   @!method increment(delta = 1)
-  #     @!macro atomic_fixnum_method_increment
-  #
-  #   @!method decrement(delta = 1)
-  #     @!macro atomic_fixnum_method_decrement
-  #
-  #   @!method compare_and_set(expect, update)
-  #     @!macro atomic_fixnum_method_compare_and_set
-  #
-  #   @!method update
-  #     @!macro atomic_fixnum_method_update
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  AtomicFixnumImplementation = case
-                               when defined?(JavaAtomicFixnum)
-                                 JavaAtomicFixnum
-                               when defined?(CAtomicFixnum)
-                                 CAtomicFixnum
-                               else
-                                 MutexAtomicFixnum
-                               end
-  private_constant :AtomicFixnumImplementation
-
-  # @!macro atomic_fixnum
-  #
-  #   A numeric value that can be updated atomically. Reads and writes to an atomic
-  #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
-  #   briefly but no explicit locking is required.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   Performance:
-  #
-  #   ```
-  #   Testing with ruby 2.1.2
-  #   Testing with Concurrent::MutexAtomicFixnum...
-  #     3.130000   0.000000   3.130000 (  3.136505)
-  #   Testing with Concurrent::CAtomicFixnum...
-  #     0.790000   0.000000   0.790000 (  0.785550)
-  #
-  #   Testing with jruby 1.9.3
-  #   Testing with Concurrent::MutexAtomicFixnum...
-  #     5.460000   2.460000   7.920000 (  3.715000)
-  #   Testing with Concurrent::JavaAtomicFixnum...
-  #     4.520000   0.030000   4.550000 (  1.187000)
-  #   ```
-  #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
-  #
-  # @!macro atomic_fixnum_public_api
-  class AtomicFixnum < AtomicFixnumImplementation
-    # @return [String] Short string representation.
-    def to_s
-      format '%s value:%s>', super[0..-2], value
-    end
-
-    alias_method :inspect, :to_s
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb

@@ -1,164 +0,0 @@
-module Concurrent
-  # An atomic reference which maintains an object reference along with a mark bit
-  # that can be updated atomically.
-  #
-  # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html
-  #   java.util.concurrent.atomic.AtomicMarkableReference
-  class AtomicMarkableReference < ::Concurrent::Synchronization::Object
-
-    attr_atomic(:reference)
-    private :reference, :reference=, :swap_reference, :compare_and_set_reference, :update_reference
-
-    def initialize(value = nil, mark = false)
-      super()
-      self.reference = immutable_array(value, mark)
-    end
-
-    # Atomically sets the value and mark to the given updated value and
-    # mark given both:
-    #   - the current value == the expected value &&
-    #   - the current mark == the expected mark
-    #
-    # @param [Object] expected_val the expected value
-    # @param [Object] new_val the new value
-    # @param [Boolean] expected_mark the expected mark
-    # @param [Boolean] new_mark the new mark
-    #
-    # @return [Boolean] `true` if successful. A `false` return indicates
-    # that the actual value was not equal to the expected value or the
-    # actual mark was not equal to the expected mark
-    def compare_and_set(expected_val, new_val, expected_mark, new_mark)
-      # Memoize a valid reference to the current AtomicReference for
-      # later comparison.
-      current             = reference
-      curr_val, curr_mark = current
-
-      # Ensure that that the expected marks match.
-      return false unless expected_mark == curr_mark
-
-      if expected_val.is_a? Numeric
-        # If the object is a numeric, we need to ensure we are comparing
-        # the numerical values
-        return false unless expected_val == curr_val
-      else
-        # Otherwise, we need to ensure we are comparing the object identity.
-        # Theoretically, this could be incorrect if a user monkey-patched
-        # `Object#equal?`, but they should know that they are playing with
-        # fire at that point.
-        return false unless expected_val.equal? curr_val
-      end
-
-      prospect = immutable_array(new_val, new_mark)
-
-      compare_and_set_reference current, prospect
-    end
-
-    alias_method :compare_and_swap, :compare_and_set
-
-    # Gets the current reference and marked values.
-    #
-    # @return [Array] the current reference and marked values
-    def get
-      reference
-    end
-
-    # Gets the current value of the reference
-    #
-    # @return [Object] the current value of the reference
-    def value
-      reference[0]
-    end
-
-    # Gets the current marked value
-    #
-    # @return [Boolean] the current marked value
-    def mark
-      reference[1]
-    end
-
-    alias_method :marked?, :mark
-
-    # _Unconditionally_ sets to the given value of both the reference and
-    # the mark.
-    #
-    # @param [Object] new_val the new value
-    # @param [Boolean] new_mark the new mark
-    #
-    # @return [Array] both the new value and the new mark
-    def set(new_val, new_mark)
-      self.reference = immutable_array(new_val, new_mark)
-    end
-
-    # Pass the current value and marked state to the given block, replacing it
-    # with the block's results. May retry if the value changes during the
-    # block's execution.
-    #
-    # @yield [Object] Calculate a new value and marked state for the atomic
-    #   reference using given (old) value and (old) marked
-    # @yieldparam [Object] old_val the starting value of the atomic reference
-    # @yieldparam [Boolean] old_mark the starting state of marked
-    #
-    # @return [Array] the new value and new mark
-    def update
-      loop do
-        old_val, old_mark = reference
-        new_val, new_mark = yield old_val, old_mark
-
-        if compare_and_set old_val, new_val, old_mark, new_mark
-          return immutable_array(new_val, new_mark)
-        end
-      end
-    end
-
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Raise an exception if the update
-    # fails.
-    #
-    # @yield [Object] Calculate a new value and marked state for the atomic
-    #   reference using given (old) value and (old) marked
-    # @yieldparam [Object] old_val the starting value of the atomic reference
-    # @yieldparam [Boolean] old_mark the starting state of marked
-    #
-    # @return [Array] the new value and marked state
-    #
-    # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_val, old_mark = reference
-      new_val, new_mark = yield old_val, old_mark
-
-      unless compare_and_set old_val, new_val, old_mark, new_mark
-        fail ::Concurrent::ConcurrentUpdateError,
-             'AtomicMarkableReference: Update failed due to race condition.',
-             'Note: If you would like to guarantee an update, please use ' +
-                 'the `AtomicMarkableReference#update` method.'
-      end
-
-      immutable_array(new_val, new_mark)
-    end
-
-    # Pass the current value to the given block, replacing it with the
-    # block's result. Simply return nil if update fails.
-    #
-    # @yield [Object] Calculate a new value and marked state for the atomic
-    #   reference using given (old) value and (old) marked
-    # @yieldparam [Object] old_val the starting value of the atomic reference
-    # @yieldparam [Boolean] old_mark the starting state of marked
-    #
-    # @return [Array] the new value and marked state, or nil if
-    # the update failed
-    def try_update
-      old_val, old_mark = reference
-      new_val, new_mark = yield old_val, old_mark
-
-      return unless compare_and_set old_val, new_val, old_mark, new_mark
-
-      immutable_array(new_val, new_mark)
-    end
-
-    private
-
-    def immutable_array(*args)
-      args.freeze
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb

@@ -1,204 +0,0 @@
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-# Shim for TruffleRuby::AtomicReference
-if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
-  # @!visibility private
-  module TruffleRuby
-    AtomicReference = Truffle::AtomicReference
-  end
-end
-
-module Concurrent
-
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro atomic_reference_method_update
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. May retry if the value changes
-    #   during the block's execution.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @return [Object] the new value
-    def update
-      true until compare_and_set(old_value = get, new_value = yield(old_value))
-      new_value
-    end
-
-    # @!macro atomic_reference_method_try_update
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. Return nil if the update fails.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @note This method was altered to avoid raising an exception by default.
-    #     Instead, this method now returns `nil` in case of failure. For more info,
-    #     please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro atomic_reference_method_try_update!
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. Raise an exception if the update
-    #   fails.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @note This behavior mimics the behavior of the original
-    #     `AtomicReference#try_update` API. The reason this was changed was to
-    #     avoid raising exceptions (which are inherently slow) by default. For more
-    #     info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @return [Object] the new value
-    #   @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_value = get
-      new_value = yield old_value
-      unless compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-
-  require 'concurrent/atomic_reference/mutex_atomic'
-
-  # @!macro atomic_reference
-  #
-  #   An object reference that may be updated atomically. All read and write
-  #   operations have java volatile semantic.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
-  #
-  #   @!method initialize(value = nil)
-  #     @!macro atomic_reference_method_initialize
-  #       @param [Object] value The initial value.
-  #
-  #   @!method get
-  #     @!macro atomic_reference_method_get
-  #       Gets the current value.
-  #       @return [Object] the current value
-  #
-  #   @!method set(new_value)
-  #     @!macro atomic_reference_method_set
-  #       Sets to the given value.
-  #       @param [Object] new_value the new value
-  #       @return [Object] the new value
-  #
-  #   @!method get_and_set(new_value)
-  #     @!macro atomic_reference_method_get_and_set
-  #       Atomically sets to the given value and returns the old value.
-  #       @param [Object] new_value the new value
-  #       @return [Object] the old value
-  #
-  #   @!method compare_and_set(old_value, new_value)
-  #     @!macro atomic_reference_method_compare_and_set
-  #
-  #       Atomically sets the value to the given updated value if
-  #       the current value == the expected value.
-  #
-  #       @param [Object] old_value the expected value
-  #       @param [Object] new_value the new value
-  #
-  #       @return [Boolean] `true` if successful. A `false` return indicates
-  #       that the actual value was not equal to the expected value.
-  #
-  #   @!method update
-  #     @!macro atomic_reference_method_update
-  #
-  #   @!method try_update
-  #     @!macro atomic_reference_method_try_update
-  #
-  #   @!method try_update!
-  #     @!macro atomic_reference_method_try_update!
-
-
-  # @!macro internal_implementation_note
-  class ConcurrentUpdateError < ThreadError
-    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-  end
-
-  # @!macro internal_implementation_note
-  AtomicReferenceImplementation = case
-                                  when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class CAtomicReference
-                                      include AtomicDirectUpdate
-                                      include AtomicNumericCompareAndSetWrapper
-                                      alias_method :compare_and_swap, :compare_and_set
-                                    end
-                                    CAtomicReference
-                                  when Concurrent.on_jruby?
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class JavaAtomicReference
-                                      include AtomicDirectUpdate
-                                    end
-                                    JavaAtomicReference
-                                  when Concurrent.on_truffleruby?
-                                    class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
-                                      include AtomicDirectUpdate
-                                      alias_method :value, :get
-                                      alias_method :value=, :set
-                                      alias_method :compare_and_swap, :compare_and_set
-                                      alias_method :swap, :get_and_set
-                                    end
-                                  when Concurrent.on_rbx?
-                                    # @note Extends `Rubinius::AtomicReference` version adding aliases
-                                    #   and numeric logic.
-                                    #
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class RbxAtomicReference < Rubinius::AtomicReference
-                                      alias_method :_compare_and_set, :compare_and_set
-                                      include AtomicDirectUpdate
-                                      include AtomicNumericCompareAndSetWrapper
-                                      alias_method :value, :get
-                                      alias_method :value=, :set
-                                      alias_method :swap, :get_and_set
-                                      alias_method :compare_and_swap, :compare_and_set
-                                    end
-                                    RbxAtomicReference
-                                  else
-                                    MutexAtomicReference
-                                  end
-  private_constant :AtomicReferenceImplementation
-
-  # @!macro atomic_reference
-  class AtomicReference < AtomicReferenceImplementation
-
-    # @return [String] Short string representation.
-    def to_s
-      format '%s value:%s>', super[0..-2], get
-    end
-
-    alias_method :inspect, :to_s
-  end
-end