logstash-output-scalyr 0.1.4 → 0.1.9

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/map.rb

@@ -1,337 +0,0 @@
-require 'thread'
-require 'concurrent/constants'
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
-
-module Concurrent
-  # @!visibility private
-  module Collection
-
-    # @!visibility private
-    MapImplementation = case
-                        when Concurrent.on_jruby?
-                          # noinspection RubyResolve
-                          JRubyMapBackend
-                        when Concurrent.on_cruby?
-                          require 'concurrent/collection/map/mri_map_backend'
-                          MriMapBackend
-                        when Concurrent.on_rbx? || Concurrent.on_truffleruby?
-                          require 'concurrent/collection/map/atomic_reference_map_backend'
-                          AtomicReferenceMapBackend
-                        else
-                          warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'
-                          require 'concurrent/collection/map/synchronized_map_backend'
-                          SynchronizedMapBackend
-                        end
-  end
-
-  # `Concurrent::Map` is a hash-like object and should have much better performance
-  # characteristics, especially under high concurrency, than `Concurrent::Hash`.
-  # However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
-  # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
-  # does. For most uses it should do fine though, and we recommend you consider
-  # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
-  class Map < Collection::MapImplementation
-
-    # @!macro map.atomic_method
-    #   This method is atomic.
-
-    # @!macro map.atomic_method_with_block
-    #   This method is atomic.
-    #   @note Atomic methods taking a block do not allow the `self` instance
-    #     to be used within the block. Doing so will cause a deadlock.
-
-    # @!method compute_if_absent(key)
-    #   Compute and store new value for key if the key is absent.
-    #   @param [Object] key
-    #   @yield new value
-    #   @yieldreturn [Object] new value
-    #   @return [Object] new value or current value
-    #   @!macro map.atomic_method_with_block
-
-    # @!method compute_if_present(key)
-    #   Compute and store new value for key if the key is present.
-    #   @param [Object] key
-    #   @yield new value
-    #   @yieldparam old_value [Object]
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method compute(key)
-    #   Compute and store new value for key.
-    #   @param [Object] key
-    #   @yield compute new value from old one
-    #   @yieldparam old_value [Object, nil] old_value, or nil when key is absent
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method merge_pair(key, value)
-    #   If the key is absent, the value is stored, otherwise new value is
-    #   computed with a block.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @yield compute new value from old one
-    #   @yieldparam old_value [Object] old value
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method replace_pair(key, old_value, new_value)
-    #   Replaces old_value with new_value if key exists and current value
-    #   matches old_value
-    #   @param [Object] key
-    #   @param [Object] old_value
-    #   @param [Object] new_value
-    #   @return [true, false] true if replaced
-    #   @!macro map.atomic_method
-
-    # @!method replace_if_exists(key, new_value)
-    #   Replaces current value with new_value if key exists
-    #   @param [Object] key
-    #   @param [Object] new_value
-    #   @return [Object, nil] old value or nil
-    #   @!macro map.atomic_method
-
-    # @!method get_and_set(key, value)
-    #   Get the current value under key and set new value.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @return [Object, nil] old value or nil when the key was absent
-    #   @!macro map.atomic_method
-
-    # @!method delete(key)
-    #   Delete key and its value.
-    #   @param [Object] key
-    #   @return [Object, nil] old value or nil when the key was absent
-    #   @!macro map.atomic_method
-
-    # @!method delete_pair(key, value)
-    #   Delete pair and its value if current value equals the provided value.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @return [true, false] true if deleted
-    #   @!macro map.atomic_method
-
-
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
-
-      super(options)
-      @default_proc = block
-    end
-
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    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, :[]
-    # TODO (pitr-ch 30-Oct-2018): doc
-    alias_method :put, :[]=
-
-    # Get a value with key, or default_value when key is absent,
-    # or fail when no default_value is given.
-    # @param [Object] key
-    # @param [Object] default_value
-    # @yield default value for a key
-    # @yieldparam key [Object]
-    # @yieldreturn [Object] default value
-    # @return [Object] the value or default value
-    # @raise [KeyError] when key is missing and no default_value is provided
-    # @!macro map_method_not_atomic
-    #   @note The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
-    #     to be use as a concurrency primitive with strong happens-before
-    #     guarantees. It is not intended to be used as a high-level abstraction
-    #     supporting complex operations. All read and write operations are
-    #     thread safe, but no guarantees are made regarding race conditions
-    #     between the fetch operation and yielding to the block. Additionally,
-    #     this method does not support recursion. This is due to internal
-    #     constraints that are very unlikely to change in the near future.
-    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
-
-    # Fetch value with key, or store default value when key is absent,
-    # or fail when no default_value is given. This is a two step operation,
-    # therefore not atomic. The store can overwrite other concurrently
-    # stored value.
-    # @param [Object] key
-    # @param [Object] default_value
-    # @yield default value for a key
-    # @yieldparam key [Object]
-    # @yieldreturn [Object] default value
-    # @return [Object] the value or default value
-    # @!macro map.atomic_method_with_block
-    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
-
-    # Insert value into map with key if key is absent in one atomic step.
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object, nil] the previous value when key was present or nil when there was no key
-    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)
-
-    # Is the value stored in the map. Iterates over all values.
-    # @param [Object] value
-    # @return [true, false]
-    def value?(value)
-      each_value do |v|
-        return true if value.equal?(v)
-      end
-      false
-    end
-
-    # All keys
-    # @return [::Array<Object>] keys
-    def keys
-      arr = []
-      each_pair { |k, v| arr << k }
-      arr
-    end unless method_defined?(:keys)
-
-    # All values
-    # @return [::Array<Object>] values
-    def values
-      arr = []
-      each_pair { |k, v| arr << v }
-      arr
-    end unless method_defined?(:values)
-
-    # Iterates over each key.
-    # @yield for each key in the map
-    # @yieldparam key [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_key
-      each_pair { |k, v| yield k }
-    end unless method_defined?(:each_key)
-
-    # Iterates over each value.
-    # @yield for each value in the map
-    # @yieldparam value [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_value
-      each_pair { |k, v| yield v }
-    end unless method_defined?(:each_value)
-
-    # Iterates over each key value pair.
-    # @yield for each key value pair in the map
-    # @yieldparam key [Object]
-    # @yieldparam value [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_pair
-      return enum_for :each_pair unless block_given?
-      super
-    end
-
-    alias_method :each, :each_pair unless method_defined?(:each)
-
-    # Find key of a value.
-    # @param [Object] value
-    # @return [Object, nil] key or nil when not found
-    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'
-
-    # Is map empty?
-    # @return [true, false]
-    def empty?
-      each_pair { |k, v| return false }
-      true
-    end unless method_defined?(:empty?)
-
-    # The size of map.
-    # @return [Integer] size
-    def size
-      count = 0
-      each_pair { |k, v| count += 1 }
-      count
-    end unless method_defined?(:size)
-
-    # @!visibility private
-    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
-
-    # @!visibility private
-    def marshal_load(hash)
-      initialize
-      populate_from(hash)
-    end
-
-    undef :freeze
-
-    # @!visibility private
-    def inspect
-      format '%s entries=%d default_proc=%s>', to_s[0..-2], size.to_s, @default_proc.inspect
-    end
-
-    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?(Integer) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Integer"
-      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/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/maybe.rb

@@ -1,229 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # A `Maybe` encapsulates an optional value. A `Maybe` either contains a value
-  # of (represented as `Just`), or it is empty (represented as `Nothing`). Using
-  # `Maybe` is a good way to deal with errors or exceptional cases without
-  # resorting to drastic measures such as exceptions.
-  #
-  # `Maybe` is a replacement for the use of `nil` with better type checking.
-  #
-  # For compatibility with {Concurrent::Concern::Obligation} the predicate and
-  # accessor methods are aliased as `fulfilled?`, `rejected?`, `value`, and
-  # `reason`.
-  #
-  # ## Motivation
-  #
-  # A common pattern in languages with pattern matching, such as Erlang and
-  # Haskell, is to return *either* a value *or* an error from a function
-  # Consider this Erlang code:
-  #
-  # ```erlang
-  # case file:consult("data.dat") of
-  #   {ok, Terms} -> do_something_useful(Terms);
-  #   {error, Reason} -> lager:error(Reason)
-  # end.
-  # ```
-  #
-  # In this example the standard library function `file:consult` returns a
-  # [tuple](http://erlang.org/doc/reference_manual/data_types.html#id69044)
-  # with two elements: an [atom](http://erlang.org/doc/reference_manual/data_types.html#id64134)
-  # (similar to a ruby symbol) and a variable containing ancillary data. On
-  # success it returns the atom `ok` and the data from the file. On failure it
-  # returns `error` and a string with an explanation of the problem. With this
-  # pattern there is no ambiguity regarding success or failure. If the file is
-  # empty the return value cannot be misinterpreted as an error. And when an
-  # error occurs the return value provides useful information.
-  #
-  # In Ruby we tend to return `nil` when an error occurs or else we raise an
-  # exception. Both of these idioms are problematic. Returning `nil` is
-  # ambiguous because `nil` may also be a valid value. It also lacks
-  # information pertaining to the nature of the error. Raising an exception
-  # is both expensive and usurps the normal flow of control. All of these
-  # problems can be solved with the use of a `Maybe`.
-  #
-  # A `Maybe` is unambiguous with regard to whether or not it contains a value.
-  # When `Just` it contains a value, when `Nothing` it does not. When `Just`
-  # the value it contains may be `nil`, which is perfectly valid. When
-  # `Nothing` the reason for the lack of a value is contained as well. The
-  # previous Erlang example can be duplicated in Ruby in a principled way by
-  # having functions return `Maybe` objects:
-  #
-  # ```ruby
-  # result = MyFileUtils.consult("data.dat") # returns a Maybe
-  # if result.just?
-  #   do_something_useful(result.value)      # or result.just
-  # else
-  #   logger.error(result.reason)            # or result.nothing
-  # end
-  # ```
-  #
-  # @example Returning a Maybe from a Function
-  #   module MyFileUtils
-  #     def self.consult(path)
-  #       file = File.open(path, 'r')
-  #       Concurrent::Maybe.just(file.read)
-  #     rescue => ex
-  #       return Concurrent::Maybe.nothing(ex)
-  #     ensure
-  #       file.close if file
-  #     end
-  #   end
-  #
-  #   maybe = MyFileUtils.consult('bogus.file')
-  #   maybe.just?    #=> false
-  #   maybe.nothing? #=> true
-  #   maybe.reason   #=> #<Errno::ENOENT: No such file or directory @ rb_sysopen - bogus.file>
-  #
-  #   maybe = MyFileUtils.consult('README.md')
-  #   maybe.just?    #=> true
-  #   maybe.nothing? #=> false
-  #   maybe.value    #=> "# Concurrent Ruby\n[![Gem Version..."
-  #
-  # @example Using Maybe with a Block
-  #   result = Concurrent::Maybe.from do
-  #     Client.find(10) # Client is an ActiveRecord model
-  #   end
-  #
-  #   # -- if the record was found
-  #   result.just? #=> true
-  #   result.value #=> #<Client id: 10, first_name: "Ryan">
-  #
-  #   # -- if the record was not found
-  #   result.just?  #=> false
-  #   result.reason #=> ActiveRecord::RecordNotFound
-  #
-  # @example Using Maybe with the Null Object Pattern
-  #   # In a Rails controller...
-  #   result = ClientService.new(10).find    # returns a Maybe
-  #   render json: result.or(NullClient.new)
-  #
-  # @see https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html Haskell Data.Maybe
-  # @see https://github.com/purescript/purescript-maybe/blob/master/docs/Data.Maybe.md PureScript Data.Maybe
-  class Maybe < Synchronization::Object
-    include Comparable
-    safe_initialization!
-
-    # Indicates that the given attribute has not been set.
-    # When `Just` the {#nothing} getter will return `NONE`.
-    # When `Nothing` the {#just} getter will return `NONE`.
-    NONE = ::Object.new.freeze
-
-    # The value of a `Maybe` when `Just`. Will be `NONE` when `Nothing`.
-    attr_reader :just
-
-    # The reason for the `Maybe` when `Nothing`. Will be `NONE` when `Just`.
-    attr_reader :nothing
-
-    private_class_method :new
-
-    # Create a new `Maybe` using the given block.
-    #
-    # Runs the given block passing all function arguments to the block as block
-    # arguments. If the block runs to completion without raising an exception
-    # a new `Just` is created with the value set to the return value of the
-    # block. If the block raises an exception a new `Nothing` is created with
-    # the reason being set to the raised exception.
-    #
-    # @param [Array<Object>] args Zero or more arguments to pass to the block.
-    # @yield The block from which to create a new `Maybe`.
-    # @yieldparam [Array<Object>] args Zero or more block arguments passed as
-    #   arguments to the function.
-    #
-    # @return [Maybe] The newly created object.
-    #
-    # @raise [ArgumentError] when no block given.
-    def self.from(*args)
-      raise ArgumentError.new('no block given') unless block_given?
-      begin
-        value = yield(*args)
-        return new(value, NONE)
-      rescue => ex
-        return new(NONE, ex)
-      end
-    end
-
-    # Create a new `Just` with the given value.
-    #
-    # @param [Object] value The value to set for the new `Maybe` object.
-    #
-    # @return [Maybe] The newly created object.
-    def self.just(value)
-      return new(value, NONE)
-    end
-
-    # Create a new `Nothing` with the given (optional) reason.
-    #
-    # @param [Exception] error The reason to set for the new `Maybe` object.
-    #   When given a string a new `StandardError` will be created with the
-    #   argument as the message. When no argument is given a new
-    #   `StandardError` with an empty message will be created.
-    #
-    # @return [Maybe] The newly created object.
-    def self.nothing(error = '')
-      if error.is_a?(Exception)
-        nothing = error
-      else
-        nothing = StandardError.new(error.to_s)
-      end
-      return new(NONE, nothing)
-    end
-
-    # Is this `Maybe` a `Just` (successfully fulfilled with a value)?
-    #
-    # @return [Boolean] True if `Just` or false if `Nothing`.
-    def just?
-      ! nothing?
-    end
-    alias :fulfilled? :just?
-
-    # Is this `Maybe` a `nothing` (rejected with an exception upon fulfillment)?
-    #
-    # @return [Boolean] True if `Nothing` or false if `Just`.
-    def nothing?
-      @nothing != NONE
-    end
-    alias :rejected? :nothing?
-
-    alias :value :just
-
-    alias :reason :nothing
-
-    # Comparison operator.
-    #
-    # @return [Integer] 0 if self and other are both `Nothing`;
-    #   -1 if self is `Nothing` and other is `Just`;
-    #   1 if self is `Just` and other is nothing;
-    #   `self.just <=> other.just` if both self and other are `Just`.
-    def <=>(other)
-      if nothing?
-        other.nothing? ? 0 : -1
-      else
-        other.nothing? ? 1 : just <=> other.just
-      end
-    end
-
-    # Return either the value of self or the given default value.
-    #
-    # @return [Object] The value of self when `Just`; else the given default.
-    def or(other)
-      just? ? just : other
-    end
-
-    private
-
-    # Create a new `Maybe` with the given attributes.
-    #
-    # @param [Object] just The value when `Just` else `NONE`.
-    # @param [Exception, Object] nothing The exception when `Nothing` else `NONE`.
-    #
-    # @return [Maybe] The new `Maybe`.
-    #
-    # @!visibility private
-    def initialize(just, nothing)
-      @just = just
-      @nothing = nothing
-    end
-  end
-end