sprokovuln 0.2.0

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/map.rb

@@ -0,0 +1,240 @@
+require 'thread'
+require 'concurrent/constants'
+require 'concurrent/synchronization'
+
+module Concurrent
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    MapImplementation = if Concurrent.java_extensions_loaded?
+                          # noinspection RubyResolve
+                          JRubyMapBackend
+                        elsif defined?(RUBY_ENGINE)
+                          case RUBY_ENGINE
+                          when 'ruby'
+                            require 'concurrent/collection/map/mri_map_backend'
+                            MriMapBackend
+                          when 'rbx'
+                            require 'concurrent/collection/map/atomic_reference_map_backend'
+                            AtomicReferenceMapBackend
+                          when 'jruby+truffle'
+                            require 'concurrent/collection/map/atomic_reference_map_backend'
+                            AtomicReferenceMapBackend
+                          else
+                            warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation' if $VERBOSE
+                            require 'concurrent/collection/map/synchronized_map_backend'
+                            SynchronizedMapBackend
+                          end
+                        else
+                          MriMapBackend
+                        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.
+  #
+  # > require 'concurrent'
+  # >
+  # > map = Concurrent::Map.new
+  class Map < Collection::MapImplementation
+
+    # @!macro [new] map_method_is_atomic
+    #   This method is atomic. Atomic methods of `Map` which accept a block
+    #   do not allow the `self` instance to be used within the block. Doing
+    #   so will cause a deadlock.
+
+    # @!method put_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_present
+    #   @!macro map_method_is_atomic
+
+    # @!method compute
+    #   @!macro map_method_is_atomic
+
+    # @!method merge_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_if_exists
+    #   @!macro map_method_is_atomic
+
+    # @!method get_and_set
+    #   @!macro map_method_is_atomic
+
+    # @!method delete
+    #   @!macro map_method_is_atomic
+
+    # @!method delete_pair
+    #   @!macro map_method_is_atomic
+
+    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, :[]=
+
+    # @!macro [attach] map_method_not_atomic
+    #   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
+
+    # @!macro map_method_not_atomic
+    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
+
+    # @!macro map_method_is_atomic
+    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
+
+    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)
+
+    alias_method :each, :each_pair unless method_defined?(:each)
+
+    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
+
+    # @!visibility private
+    DEFAULT_OBJ_ID_STR_WIDTH = 0.size == 4 ? 7 : 14 # we want to look "native", 7 for 32-bit, 14 for 64-bit
+    # override default #inspect() method: firstly, we don't want to be spilling our guts (i-vars), secondly, MRI backend's
+    # #inspect() call on its @backend i-var will bump @backend's iter level while possibly yielding GVL
+    def inspect
+      id_str = (object_id << 1).to_s(16).rjust(DEFAULT_OBJ_ID_STR_WIDTH, '0')
+      "#<#{self.class.name}:0x#{id_str} entries=#{size} default_proc=#{@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/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/maybe.rb

@@ -0,0 +1,229 @@
+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

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/mutable_struct.rb

@@ -0,0 +1,228 @@
+require 'concurrent/synchronization/abstract_struct'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # An thread-safe variation of Ruby's standard `Struct`. Values can be set at
+  # construction or safely changed at any time during the object's lifecycle.
+  #
+  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  module MutableStruct
+    include Synchronization::AbstractStruct
+
+    # @!macro [new] struct_new
+    #
+    #   Factory for creating new struct classes.
+    #
+    #   ```
+    #   new([class_name] [, member_name]+>) -> StructClass click to toggle source
+    #   new([class_name] [, member_name]+>) {|StructClass| block } -> StructClass
+    #   new(value, ...) -> obj
+    #   StructClass[value, ...] -> obj
+    #   ```
+    #
+    #   The first two forms are used to create a new struct subclass `class_name`
+    #   that can contain a value for each   member_name . This subclass can be
+    #   used to create instances of the structure like any other  Class .
+    #
+    #   If the `class_name` is omitted an anonymous struct class will be created.
+    #   Otherwise, the name of this struct will appear as a constant in the struct class,
+    #   so it must be unique for all structs under this base class and must start with a
+    #   capital letter. Assigning a struct class to a constant also gives the class
+    #   the name of the constant.
+    #
+    #   If a block is given it will be evaluated in the context of `StructClass`, passing
+    #   the created class as a parameter. This is the recommended way to customize a struct.
+    #   Subclassing an anonymous struct creates an extra anonymous class that will never be used.
+    #
+    #   The last two forms create a new instance of a struct subclass. The number of value
+    #   parameters must be less than or equal to the number of attributes defined for the
+    #   struct. Unset parameters default to nil. Passing more parameters than number of attributes
+    #   will raise an `ArgumentError`.
+    #
+    #   @see http://ruby-doc.org/core-2.2.0/Struct.html#method-c-new Ruby standard library `Struct#new`
+
+    # @!macro [attach] struct_values
+    #
+    #   Returns the values for this struct as an Array.
+    #
+    #   @return [Array] the values for this struct
+    #
+    def values
+      synchronize { ns_values }
+    end
+    alias_method :to_a, :values
+
+    # @!macro [attach] struct_values_at
+    #
+    #   Returns the struct member values for each selector as an Array.
+    #
+    #   A selector may be either an Integer offset or a Range of offsets (as in `Array#values_at`).
+    #
+    #   @param [Fixnum, Range] indexes the index(es) from which to obatin the values (in order)
+    def values_at(*indexes)
+      synchronize { ns_values_at(indexes) }
+    end
+
+    # @!macro [attach] struct_inspect
+    #
+    #   Describe the contents of this struct in a string.
+    #
+    #   @return [String] the contents of this struct in a string
+    def inspect
+      synchronize { ns_inspect }
+    end
+    alias_method :to_s, :inspect
+
+    # @!macro [attach] struct_merge
+    #
+    #   Returns a new struct containing the contents of `other` and the contents
+    #   of `self`. If no block is specified, the value for entries with duplicate
+    #   keys will be that of `other`. Otherwise the value for each duplicate key
+    #   is determined by calling the block with the key, its value in `self` and
+    #   its value in `other`.
+    #
+    #   @param [Hash] other the hash from which to set the new values
+    #   @yield an options block for resolving duplicate keys
+    #   @yieldparam [String, Symbol] member the name of the member which is duplicated
+    #   @yieldparam [Object] selfvalue the value of the member in `self`
+    #   @yieldparam [Object] othervalue the value of the member in `other`
+    #
+    #   @return [Synchronization::AbstractStruct] a new struct with the new values
+    #
+    #   @raise [ArgumentError] of given a member that is not defined in the struct
+    def merge(other, &block)
+      synchronize { ns_merge(other, &block) }
+    end
+
+    # @!macro [attach] struct_to_h
+    #
+    #   Returns a hash containing the names and values for the struct’s members.
+    #
+    #   @return [Hash] the names and values for the struct’s members
+    def to_h
+      synchronize { ns_to_h }
+    end
+
+    # @!macro [attach] struct_get
+    #
+    #   Attribute Reference
+    #
+    #   @param [Symbol, String, Integer] member the string or symbol name of the memeber
+    #     for which to obtain the value or the member's index
+    #
+    #   @return [Object] the value of the given struct member or the member at the given index.
+    #
+    #   @raise [NameError] if the member does not exist
+    #   @raise [IndexError] if the index is out of range.
+    def [](member)
+      synchronize { ns_get(member) }
+    end
+
+    # @!macro [attach] struct_equality
+    #
+    #   Equality
+    #
+    #   @return [Boolean] true if other has the same struct subclass and has
+    #     equal member values (according to `Object#==`)
+    def ==(other)
+      synchronize { ns_equality(other) }
+    end
+
+    # @!macro [attach] struct_each
+    #
+    #   Yields the value of each struct member in order. If no block is given
+    #   an enumerator is returned.
+    #
+    #   @yield the operation to be performed on each struct member
+    #   @yieldparam [Object] value each struct value (in order)
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      synchronize { ns_each(&block) }
+    end
+
+    # @!macro [attach] struct_each_pair
+    #
+    #   Yields the name and value of each struct member in order. If no block is
+    #   given an enumerator is returned.
+    #
+    #   @yield the operation to be performed on each struct member/value pair
+    #   @yieldparam [Object] member each struct member (in order)
+    #   @yieldparam [Object] value each struct value (in order)
+    def each_pair(&block)
+      return enum_for(:each_pair) unless block_given?
+      synchronize { ns_each_pair(&block) }
+    end
+
+    # @!macro [attach] struct_select
+    #
+    #   Yields each member value from the struct to the block and returns an Array
+    #   containing the member values from the struct for which the given block
+    #   returns a true value (equivalent to `Enumerable#select`).
+    #
+    #   @yield the operation to be performed on each struct member
+    #   @yieldparam [Object] value each struct value (in order)
+    #
+    #   @return [Array] an array containing each value for which the block returns true
+    def select(&block)
+      return enum_for(:select) unless block_given?
+      synchronize { ns_select(&block) }
+    end
+
+    # @!macro [new] struct_set
+    #
+    #   Attribute Assignment
+    #
+    #   Sets the value of the given struct member or the member at the given index.
+    #
+    #   @param [Symbol, String, Integer] member the string or symbol name of the memeber
+    #     for which to obtain the value or the member's index
+    #
+    #   @return [Object] the value of the given struct member or the member at the given index.
+    #
+    #   @raise [NameError] if the name does not exist
+    #   @raise [IndexError] if the index is out of range.
+    def []=(member, value)
+      if member.is_a? Integer
+        length = synchronize { @values.length }
+        if member >= length
+          raise IndexError.new("offset #{member} too large for struct(size:#{length})")
+        end
+        synchronize { @values[member] = value }
+      else
+        send("#{member}=", value)
+      end
+    rescue NoMethodError
+      raise NameError.new("no member '#{member}' in struct")
+    end
+
+    # @!macro struct_new
+    def self.new(*args, &block)
+      clazz_name = nil
+      if args.length == 0
+        raise ArgumentError.new('wrong number of arguments (0 for 1+)')
+      elsif args.length > 0 && args.first.is_a?(String)
+        clazz_name = args.shift
+      end
+      FACTORY.define_struct(clazz_name, args, &block)
+    end
+
+    FACTORY = Class.new(Synchronization::LockableObject) do
+      def define_struct(name, members, &block)
+        synchronize do
+          clazz = Synchronization::AbstractStruct.define_struct_class(MutableStruct, Synchronization::LockableObject, name, members, &block)
+          members.each_with_index do |member, index|
+            clazz.send(:define_method, member) do
+              synchronize { @values[index] }
+            end
+            clazz.send(:define_method, "#{member}=") do |value|
+              synchronize { @values[index] = value }
+            end
+          end
+          clazz
+        end
+      end
+    end.new
+    private_constant :FACTORY
+  end
+end