ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/cache.rb

@@ -1,161 +0,0 @@
-require 'thread'
-
-module ThreadSafe
-  autoload :JRubyCacheBackend,           'thread_safe/jruby_cache_backend'
-  autoload :MriCacheBackend,             'thread_safe/mri_cache_backend'
-  autoload :NonConcurrentCacheBackend,   'thread_safe/non_concurrent_cache_backend'
-  autoload :AtomicReferenceCacheBackend, 'thread_safe/atomic_reference_cache_backend'
-  autoload :SynchronizedCacheBackend,    'thread_safe/synchronized_cache_backend'
-
-  ConcurrentCacheBackend = if defined?(RUBY_ENGINE)
-    case RUBY_ENGINE
-    when 'jruby'; JRubyCacheBackend
-    when 'ruby';  MriCacheBackend
-    when 'rbx';   AtomicReferenceCacheBackend
-    else
-      warn 'ThreadSafe: unsupported Ruby engine, using a fully synchronized ThreadSafe::Cache implementation' if $VERBOSE
-      SynchronizedCacheBackend
-    end
-  else
-    MriCacheBackend
-  end
-
-  class Cache < ConcurrentCacheBackend
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
-
-      super(options)
-      @default_proc = block
-    end
-
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-      # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-      # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-      # would be returned)
-      # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
-      end
-    end
-
-    alias_method :get, :[]
-    alias_method :put, :[]=
-
-    def fetch(key, default_value = NULL)
-      if NULL != (value = get_or_default(key, NULL))
-        value
-      elsif block_given?
-        yield key
-      elsif NULL != default_value
-        default_value
-      else
-        raise_fetch_no_key
-      end
-    end
-
-    def fetch_or_store(key, default_value = NULL)
-      fetch(key) do
-        put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
-      end
-    end
-
-    def put_if_absent(key, value)
-      computed = false
-      result = compute_if_absent(key) do
-        computed = true
-        value
-      end
-      computed ? nil : result
-    end unless method_defined?(:put_if_absent)
-
-    def value?(value)
-      each_value do |v|
-        return true if value.equal?(v)
-      end
-      false
-    end unless method_defined?(:value?)
-
-    def keys
-      arr = []
-      each_pair {|k, v| arr << k}
-      arr
-    end unless method_defined?(:keys)
-
-    def values
-      arr = []
-      each_pair {|k, v| arr << v}
-      arr
-    end unless method_defined?(:values)
-
-    def each_key
-      each_pair {|k, v| yield k}
-    end unless method_defined?(:each_key)
-
-    def each_value
-      each_pair {|k, v| yield v}
-    end unless method_defined?(:each_value)
-
-    def key(value)
-      each_pair {|k, v| return k if v == value}
-      nil
-    end unless method_defined?(:key)
-    alias_method :index, :key if RUBY_VERSION < '1.9'
-
-    def empty?
-      each_pair {|k, v| return false}
-      true
-    end unless method_defined?(:empty?)
-
-    def size
-      count = 0
-      each_pair {|k, v| count += 1}
-      count
-    end unless method_defined?(:size)
-
-    def marshal_dump
-      raise TypeError, "can't dump hash with default proc" if @default_proc
-      h = {}
-      each_pair {|k, v| h[k] = v}
-      h
-    end
-
-    def marshal_load(hash)
-      initialize
-      populate_from(hash)
-    end
-
-    undef :freeze
-
-    private
-    def raise_fetch_no_key
-      raise KeyError, 'key not found'
-    end
-
-    def initialize_copy(other)
-      super
-      populate_from(other)
-    end
-
-    def populate_from(hash)
-      hash.each_pair {|k, v| self[k] = v}
-      self
-    end
-
-    def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(0.class) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive #{0.class}"
-      end
-      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
-        raise ArgumentError, ":load_factor must be a number between 0 and 1"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/mri_cache_backend.rb

@@ -1,60 +0,0 @@
-module ThreadSafe
-  class MriCacheBackend < NonConcurrentCacheBackend
-    # We can get away with a single global write lock (instead of a per-instance
-    # one) because of the GVL/green threads.
-    #
-    # NOTE: a neat idea of writing a c-ext to manually perform atomic
-    # put_if_absent, while relying on Ruby not releasing a GVL while calling a
-    # c-ext will not work because of the potentially Ruby implemented `#hash`
-    # and `#eql?` key methods.
-    WRITE_LOCK = Mutex.new
-
-    def []=(key, value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def compute_if_absent(key)
-      if stored_value = _get(key) # fast non-blocking path for the most likely case
-        stored_value
-      else
-        WRITE_LOCK.synchronize { super }
-      end
-    end
-
-    def compute_if_present(key)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def compute(key)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def merge_pair(key, value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def replace_pair(key, old_value, new_value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def replace_if_exists(key, new_value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def get_and_set(key, value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def delete(key)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def delete_pair(key, value)
-      WRITE_LOCK.synchronize { super }
-    end
-
-    def clear
-      WRITE_LOCK.synchronize { super }
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/non_concurrent_cache_backend.rb

@@ -1,135 +0,0 @@
-module ThreadSafe
-  class NonConcurrentCacheBackend
-    # WARNING: all public methods of the class must operate on the @backend
-    # directly without calling each other. This is important because of the
-    # SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance
-    # reasons.
-    def initialize(options = nil)
-      @backend = {}
-    end
-
-    def [](key)
-      @backend[key]
-    end
-
-    def []=(key, value)
-      @backend[key] = value
-    end
-
-    def compute_if_absent(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        stored_value
-      else
-        @backend[key] = yield
-      end
-    end
-
-    def replace_pair(key, old_value, new_value)
-      if pair?(key, old_value)
-        @backend[key] = new_value
-        true
-      else
-        false
-      end
-    end
-
-    def replace_if_exists(key, new_value)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = new_value
-        stored_value
-      end
-    end
-
-    def compute_if_present(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def compute(key)
-      store_computed_value(key, yield(@backend[key]))
-    end
-
-    def merge_pair(key, value)
-      if NULL == (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = value
-      else
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def get_and_set(key, value)
-      stored_value = @backend[key]
-      @backend[key] = value
-      stored_value
-    end
-
-    def key?(key)
-      @backend.key?(key)
-    end
-
-    def value?(value)
-      @backend.value?(value)
-    end
-
-    def delete(key)
-      @backend.delete(key)
-    end
-
-    def delete_pair(key, value)
-      if pair?(key, value)
-        @backend.delete(key)
-        true
-      else
-        false
-      end
-    end
-
-    def clear
-      @backend.clear
-      self
-    end
-
-    def each_pair
-      dupped_backend.each_pair do |k, v|
-        yield k, v
-      end
-      self
-    end
-
-    def size
-      @backend.size
-    end
-
-    def get_or_default(key, default_value)
-      @backend.fetch(key, default_value)
-    end
-
-    alias_method :_get, :[]
-    alias_method :_set, :[]=
-    private :_get, :_set
-    private
-    def initialize_copy(other)
-      super
-      @backend = {}
-      self
-    end
-
-    def dupped_backend
-      @backend.dup
-    end
-
-    def pair?(key, expected_value)
-      NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value)
-    end
-
-    def store_computed_value(key, new_value)
-      if new_value.nil?
-        @backend.delete(key)
-        nil
-      else
-        @backend[key] = new_value
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/synchronized_cache_backend.rb

@@ -1,77 +0,0 @@
-module ThreadSafe
-  class SynchronizedCacheBackend < NonConcurrentCacheBackend
-    require 'mutex_m'
-    include Mutex_m
-    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are
-    # not allowed to call each other.
-
-    def [](key)
-      synchronize { super }
-    end
-
-    def []=(key, value)
-      synchronize { super }
-    end
-
-    def compute_if_absent(key)
-      synchronize { super }
-    end
-
-    def compute_if_present(key)
-      synchronize { super }
-    end
-
-    def compute(key)
-      synchronize { super }
-    end
-
-    def merge_pair(key, value)
-      synchronize { super }
-    end
-
-    def replace_pair(key, old_value, new_value)
-      synchronize { super }
-    end
-
-    def replace_if_exists(key, new_value)
-      synchronize { super }
-    end
-
-    def get_and_set(key, value)
-      synchronize { super }
-    end
-
-    def key?(key)
-      synchronize { super }
-    end
-
-    def value?(value)
-      synchronize { super }
-    end
-
-    def delete(key)
-      synchronize { super }
-    end
-
-    def delete_pair(key, value)
-      synchronize { super }
-    end
-
-    def clear
-      synchronize { super }
-    end
-
-    def size
-      synchronize { super }
-    end
-
-    def get_or_default(key, default_value)
-      synchronize { super }
-    end
-
-    private
-    def dupped_backend
-      synchronize { super }
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/synchronized_delegator.rb

@@ -1,43 +0,0 @@
-require 'delegate'
-require 'monitor'
-
-# This class provides a trivial way to synchronize all calls to a given object
-# by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
-# around the delegated `#send`. Example:
-#
-#   array = [] # not thread-safe on many impls
-#   array = SynchronizedDelegator.new([]) # thread-safe
-#
-# A simple `Monitor` provides a very coarse-grained way to synchronize a given
-# object, in that it will cause synchronization for methods that have no need
-# for it, but this is a trivial way to get thread-safety where none may exist
-# currently on some implementations.
-#
-# This class is currently being considered for inclusion into stdlib, via
-# https://bugs.ruby-lang.org/issues/8556
-class SynchronizedDelegator < SimpleDelegator
-  def setup
-    @old_abort = Thread.abort_on_exception
-    Thread.abort_on_exception = true
-  end
-
-  def teardown
-    Thread.abort_on_exception = @old_abort
-  end
-
-  def initialize(obj)
-    __setobj__(obj)
-    @monitor = Monitor.new
-  end
-
-  def method_missing(method, *args, &block)
-    monitor = @monitor
-    begin
-      monitor.enter
-      super
-    ensure
-      monitor.exit
-    end
-  end
-
-end unless defined?(SynchronizedDelegator)

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/util/adder.rb

@@ -1,62 +0,0 @@
-module ThreadSafe
-  module Util
-    # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
-    # available in public domain.
-    #
-    # Original source code available here:
-    # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.8
-    #
-    # One or more variables that together maintain an initially zero
-    # sum. When updates (method +add+) are contended across threads,
-    # the set of variables may grow dynamically to reduce contention.
-    # Method +sum+ returns the current total combined across the
-    # variables maintaining the sum.
-    #
-    # This class is usually preferable to single +Atomic+ reference when
-    # multiple threads update a common sum that is used for purposes such
-    # as collecting statistics, not for fine-grained synchronization
-    # control.  Under low update contention, the two classes have similar
-    # characteristics. But under high contention, expected throughput of
-    # this class is significantly higher, at the expense of higher space
-    # consumption.
-    class Adder < Striped64
-      # Adds the given value.
-      def add(x)
-        if (current_cells = cells) || !cas_base_computed {|current_base| current_base + x}
-          was_uncontended = true
-          hash            = hash_code
-          unless current_cells && (cell = current_cells.volatile_get_by_hash(hash)) && (was_uncontended = cell.cas_computed {|current_value| current_value + x})
-            retry_update(x, hash, was_uncontended) {|current_value| current_value + x}
-          end
-        end
-      end
-
-      def increment
-        add(1)
-      end
-
-      def decrement
-        add(-1)
-      end
-
-      # Returns the current sum.  The returned value is _NOT_ an
-      # atomic snapshot: Invocation in the absence of concurrent
-      # updates returns an accurate result, but concurrent updates that
-      # occur while the sum is being calculated might not be
-      # incorporated.
-      def sum
-        x = base
-        if current_cells = cells
-          current_cells.each do |cell|
-            x += cell.value if cell
-          end
-        end
-        x
-      end
-
-      def reset
-        internal_reset(0)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/util/atomic_reference.rb

@@ -1,44 +0,0 @@
-module ThreadSafe
-  module Util
-    AtomicReference =
-      if defined?(Rubinius::AtomicReference)
-        # An overhead-less atomic reference.
-        Rubinius::AtomicReference
-      else
-        begin
-          require 'atomic'
-          defined?(Atomic::InternalReference) ? Atomic::InternalReference : Atomic
-        rescue LoadError, NameError
-          class FullLockingAtomicReference
-            def initialize(value = nil)
-              @___mutex = Mutex.new
-              @___value = value
-            end
-
-            def get
-              @___mutex.synchronize { @___value }
-            end
-            alias_method :value, :get
-
-            def set(new_value)
-              @___mutex.synchronize { @___value = new_value }
-            end
-            alias_method :value=, :set
-
-            def compare_and_set(old_value, new_value)
-              return false unless @___mutex.try_lock
-              begin
-                return false unless @___value.equal? old_value
-                @___value = new_value
-              ensure
-                @___mutex.unlock
-              end
-              true
-            end
-          end
-
-          FullLockingAtomicReference
-        end
-      end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/thread_safe-0.3.6/lib/thread_safe/util/cheap_lockable.rb

@@ -1,106 +0,0 @@
-module ThreadSafe
-  module Util
-    # Provides a cheapest possible (mainly in terms of memory usage) +Mutex+
-    # with the +ConditionVariable+ bundled in.
-    #
-    # Usage:
-    #   class A
-    #     include CheapLockable
-    #
-    #     def do_exlusively
-    #       cheap_synchronize { yield }
-    #     end
-    #
-    #     def wait_for_something
-    #       cheap_synchronize do
-    #         cheap_wait until resource_available?
-    #         do_something
-    #         cheap_broadcast # wake up others
-    #       end
-    #     end
-    #   end
-    module CheapLockable
-      private
-      engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      if engine == 'rbx'
-        # Making use of the Rubinius' ability to lock via object headers to avoid the overhead of the extra Mutex objects.
-        def cheap_synchronize
-          Rubinius.lock(self)
-          begin
-            yield
-          ensure
-            Rubinius.unlock(self)
-          end
-        end
-
-        def cheap_wait
-          wchan = Rubinius::Channel.new
-
-          begin
-            waiters = @waiters ||= []
-            waiters.push wchan
-            Rubinius.unlock(self)
-            signaled = wchan.receive_timeout nil
-          ensure
-            Rubinius.lock(self)
-
-            unless signaled or waiters.delete(wchan)
-              # we timed out, but got signaled afterwards (e.g. while waiting to
-              # acquire @lock), so pass that signal on to the next waiter
-              waiters.shift << true unless waiters.empty?
-            end
-          end
-
-          self
-        end
-
-        def cheap_broadcast
-          waiters = @waiters ||= []
-          waiters.shift << true until waiters.empty?
-          self
-        end
-      elsif engine == 'jruby'
-        # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid the overhead of the extra Mutex objects
-        require 'jruby'
-
-        def cheap_synchronize
-          JRuby.reference0(self).synchronized { yield }
-        end
-
-        def cheap_wait
-          JRuby.reference0(self).wait
-        end
-
-        def cheap_broadcast
-          JRuby.reference0(self).notify_all
-        end
-      else
-        require 'thread'
-
-        extend Volatile
-        attr_volatile :mutex
-
-        # Non-reentrant Mutex#syncrhonize
-        def cheap_synchronize
-          true until (my_mutex = mutex) || cas_mutex(nil, my_mutex = Mutex.new)
-          my_mutex.synchronize { yield }
-        end
-
-        # Releases this object's +cheap_synchronize+ lock and goes to sleep waiting for other threads to +cheap_broadcast+, reacquires the lock on wakeup.
-        # Must only be called in +cheap_broadcast+'s block.
-        def cheap_wait
-          conditional_variable = @conditional_variable ||= ConditionVariable.new
-          conditional_variable.wait(mutex)
-        end
-
-        # Wakes up all threads waiting for this object's +cheap_synchronize+ lock.
-        # Must only be called in +cheap_broadcast+'s block.
-        def cheap_broadcast
-          if conditional_variable = @conditional_variable
-            conditional_variable.broadcast
-          end
-        end
-      end
-    end
-  end
-end