sprokovuln 0.2.0

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/at_exit.rb

@@ -0,0 +1,97 @@
+require 'logger'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # Provides ability to add and remove handlers to be run at `Kernel#at_exit`, order is undefined.
+  # Each handler is executed at most once.
+  #
+  # @!visibility private
+  class AtExitImplementation < Synchronization::LockableObject
+    include Logger::Severity
+
+    def initialize(*args)
+      super()
+      synchronize { ns_initialize(*args) }
+    end
+
+    # Add a handler to be run at `Kernel#at_exit`
+    # @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
+    # @yield the handler
+    # @return id of the handler
+    def add(handler_id = nil, &handler)
+      id = handler_id || handler.object_id
+      synchronize { @handlers[id] = handler }
+      id
+    end
+
+    # Delete a handler by handler_id
+    # @return [true, false]
+    def delete(handler_id)
+      !!synchronize { @handlers.delete handler_id }
+    end
+
+    # Is handler with handler_id rpesent?
+    # @return [true, false]
+    def handler?(handler_id)
+      synchronize { @handlers.key? handler_id }
+    end
+
+    # @return copy of the handlers
+    def handlers
+      synchronize { @handlers }.clone
+    end
+
+    # install `Kernel#at_exit` callback to execute added handlers
+    def install
+      synchronize do
+        @installed ||= begin
+                         at_exit { runner }
+                         true
+                       end
+        self
+      end
+    end
+
+    # Will it run during `Kernel#at_exit`
+    def enabled?
+      synchronize { @enabled }
+    end
+
+    # Configure if it runs during `Kernel#at_exit`
+    def enabled=(value)
+      synchronize { @enabled = value }
+    end
+
+    # run the handlers manually
+    # @return ids of the handlers
+    def run
+      handlers, _ = synchronize { handlers, @handlers = @handlers, {} }
+      handlers.each do |_, handler|
+        begin
+          handler.call
+        rescue => error
+          Concurrent.global_logger.call(ERROR, error)
+        end
+      end
+      handlers.keys
+    end
+
+    private
+
+    def ns_initialize(enabled = true)
+      @handlers = {}
+      @enabled  = enabled
+    end
+
+    def runner
+      run if synchronize { @enabled }
+    end
+  end
+
+  private_constant :AtExitImplementation
+
+  # @see AtExitImplementation
+  # @!visibility private
+  AtExit = AtExitImplementation.new.install
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/engine.rb

@@ -0,0 +1,56 @@
+module Concurrent
+  module Utility
+
+    # @!visibility private
+    module EngineDetector
+      def on_jruby?
+        ruby_engine == 'jruby'
+      end
+
+      def on_jruby_9000?
+        on_jruby? && ruby_version(:>=, 9, 0, 0, JRUBY_VERSION)
+      end
+
+      def on_cruby?
+        ruby_engine == 'ruby'
+      end
+
+      def on_rbx?
+        ruby_engine == 'rbx'
+      end
+
+      def on_truffle?
+        ruby_engine == 'jruby+truffle'
+      end
+
+      def on_windows?
+        !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
+      end
+
+      def on_osx?
+        !(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
+      end
+
+      def on_linux?
+        !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
+      end
+
+      def ruby_engine
+        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+      end
+
+      def ruby_version(comparison, major, minor, patch, version = RUBY_VERSION)
+        result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
+        comparisons = { :== => [0],
+                        :>= => [1, 0],
+                        :<= => [-1, 0],
+                        :>  => [1],
+                        :<  => [-1] }
+        comparisons.fetch(comparison).include? result
+      end
+    end
+  end
+
+  # @!visibility private
+  extend Utility::EngineDetector
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/monotonic_time.rb

@@ -0,0 +1,58 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  class_definition = Class.new(Synchronization::LockableObject) do
+    def initialize
+      @last_time = Time.now.to_f
+      super()
+    end
+
+    if defined?(Process::CLOCK_MONOTONIC)
+      # @!visibility private
+      def get_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    elsif Concurrent.on_jruby?
+      # @!visibility private
+      def get_time
+        java.lang.System.nanoTime() / 1_000_000_000.0
+      end
+    else
+
+      # @!visibility private
+      def get_time
+        synchronize do
+          now = Time.now.to_f
+          if @last_time < now
+            @last_time = now
+          else # clock has moved back in time
+            @last_time += 0.000_001
+          end
+        end
+      end
+
+    end
+  end
+
+  # Clock that cannot be set and represents monotonic time since
+  # some unspecified starting point.
+  #
+  # @!visibility private
+  GLOBAL_MONOTONIC_CLOCK = class_definition.new
+  private_constant :GLOBAL_MONOTONIC_CLOCK
+
+  # @!macro [attach] monotonic_get_time
+  #
+  #   Returns the current time a tracked by the application monotonic clock.
+  #
+  #   @return [Float] The current monotonic time when `since` not given else
+  #     the elapsed monotonic time between `since` and the current time
+  #
+  #   @!macro monotonic_clock_warning
+  def monotonic_time
+    GLOBAL_MONOTONIC_CLOCK.get_time
+  end
+
+  module_function :monotonic_time
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_extension_loader.rb

@@ -0,0 +1,73 @@
+require 'concurrent/utility/engine'
+
+module Concurrent
+
+  module Utility
+
+    # @!visibility private
+    module NativeExtensionLoader
+
+      def allow_c_extensions?
+        Concurrent.on_cruby?
+      end
+
+      def c_extensions_loaded?
+        @c_extensions_loaded ||= false
+      end
+
+      def java_extensions_loaded?
+        @java_extensions_loaded ||= false
+      end
+
+      def set_c_extensions_loaded
+        @c_extensions_loaded = true
+      end
+
+      def set_java_extensions_loaded
+        @java_extensions_loaded = true
+      end
+
+      def load_native_extensions
+        unless defined? Synchronization::AbstractObject
+          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
+        end
+
+        if Concurrent.on_cruby? && !c_extensions_loaded?
+          tries = [
+            lambda do
+              require 'concurrent/extension'
+              set_c_extensions_loaded
+            end,
+            lambda do
+              # may be a Windows cross-compiled native gem
+              require "concurrent/#{RUBY_VERSION[0..2]}/extension"
+              set_c_extensions_loaded
+            end]
+
+          tries.each do |try|
+            begin
+              try.call
+              break
+            rescue LoadError
+              next
+            end
+          end
+        end
+
+        if Concurrent.on_jruby? && !java_extensions_loaded?
+          begin
+            require 'concurrent_ruby_ext'
+            set_java_extensions_loaded
+          rescue LoadError
+            # move on with pure-Ruby implementations
+            raise 'On JRuby but Java extensions failed to load.'
+          end
+        end
+      end
+    end
+  end
+
+  # @!visibility private
+  extend Utility::NativeExtensionLoader
+end
+

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_integer.rb

@@ -0,0 +1,53 @@
+module Concurrent
+  module Utility
+    # @private
+    module NativeInteger
+      # http://stackoverflow.com/questions/535721/ruby-max-integer
+      MIN_VALUE = -(2**(0.size * 8 - 2))
+      MAX_VALUE = (2**(0.size * 8 - 2) - 1)
+
+      def ensure_upper_bound(value)
+        if value > MAX_VALUE
+          raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
+        end
+        value
+      end
+
+      def ensure_lower_bound(value)
+        if value < MIN_VALUE
+          raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
+        end
+        value
+      end
+
+      def ensure_integer(value)
+        unless value.is_a?(Integer)
+          raise ArgumentError.new("#{value} is not an Integer")
+        end
+        value
+      end
+
+      def ensure_integer_and_bounds(value)
+        ensure_integer value
+        ensure_upper_bound value
+        ensure_lower_bound value
+      end
+
+      def ensure_positive(value)
+        if value < 0
+          raise ArgumentError.new("#{value} cannot be negative")
+        end
+        value
+      end
+
+      def ensure_positive_and_no_zero(value)
+        if value < 1
+          raise ArgumentError.new("#{value} cannot be negative or zero")
+        end
+        value
+      end
+
+      extend self
+    end
+  end
+end

data/vendor/ruby/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/processor_counter.rb

@@ -0,0 +1,160 @@
+require 'rbconfig'
+require 'concurrent/delay'
+
+module Concurrent
+  module Utility
+
+    # @!visibility private
+    class ProcessorCounter
+      def initialize
+        @processor_count          = Delay.new { compute_processor_count }
+        @physical_processor_count = Delay.new { compute_physical_processor_count }
+      end
+
+      # Number of processors seen by the OS and used for process scheduling. For
+      # performance reasons the calculated value will be memoized on the first
+      # call.
+      #
+      # When running under JRuby the Java runtime call
+      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
+      # to the Java documentation this "value may change during a particular
+      # invocation of the virtual machine... [applications] should therefore
+      # occasionally poll this property." Subsequently the result will NOT be
+      # memoized under JRuby.
+      #
+      # On Windows the Win32 API will be queried for the
+      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
+      # total number "logical processors for the current instance of the
+      # processor", which taked into account hyperthreading.
+      #
+      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
+      # * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
+      # * BSD: /sbin/sysctl
+      # * Cygwin: /proc/cpuinfo
+      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
+      # * HP-UX: /usr/sbin/ioscan
+      # * IRIX: /usr/sbin/sysconf
+      # * Linux: /proc/cpuinfo
+      # * Minix 3+: /proc/cpuinfo
+      # * Solaris: /usr/sbin/psrinfo
+      # * Tru64 UNIX: /usr/sbin/psrinfo
+      # * UnixWare: /usr/sbin/psrinfo
+      #
+      # @return [Integer] number of processors seen by the OS or Java runtime
+      #
+      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+      #
+      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
+      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+      def processor_count
+        @processor_count.value
+      end
+
+      # Number of physical processor cores on the current system. For performance
+      # reasons the calculated value will be memoized on the first call.
+      #
+      # On Windows the Win32 API will be queried for the `NumberOfCores from
+      # Win32_Processor`. This will return the total number "of cores for the
+      # current instance of the processor." On Unix-like operating systems either
+      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
+      # returned value will be used. In the rare case where none of these methods
+      # work or an exception is raised the function will simply return 1.
+      #
+      # @return [Integer] number physical processor cores on the current system
+      #
+      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+      #
+      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
+      # @see http://linux.die.net/man/8/sysctl
+      def physical_processor_count
+        @physical_processor_count.value
+      end
+
+      private
+
+      def compute_processor_count
+        if Concurrent.on_jruby?
+          java.lang.Runtime.getRuntime.availableProcessors
+        elsif Concurrent.on_truffle?
+          Truffle::Primitive.logical_processors
+        else
+          os_name = RbConfig::CONFIG["target_os"]
+          if os_name =~ /mingw|mswin/
+            require 'win32ole'
+            result = WIN32OLE.connect("winmgmts://").ExecQuery(
+              "select NumberOfLogicalProcessors from Win32_Processor")
+            result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
+          elsif File.readable?("/proc/cpuinfo") && (cpuinfo_count = IO.read("/proc/cpuinfo").scan(/^processor/).size) > 0
+            cpuinfo_count
+          elsif File.executable?("/usr/bin/nproc")
+            IO.popen("/usr/bin/nproc --all", &:read).to_i
+          elsif File.executable?("/usr/bin/hwprefs")
+            IO.popen("/usr/bin/hwprefs thread_count", &:read).to_i
+          elsif File.executable?("/usr/sbin/psrinfo")
+            IO.popen("/usr/sbin/psrinfo", &:read).scan(/^.*on-*line/).size
+          elsif File.executable?("/usr/sbin/ioscan")
+            IO.popen("/usr/sbin/ioscan -kC processor", &:read).scan(/^.*processor/).size
+          elsif File.executable?("/usr/sbin/pmcycles")
+            IO.popen("/usr/sbin/pmcycles -m", &:read).count("\n")
+          elsif File.executable?("/usr/sbin/lsdev")
+            IO.popen("/usr/sbin/lsdev -Cc processor -S 1", &:read).count("\n")
+          elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
+            IO.popen("/usr/sbin/sysconf NPROC_ONLN", &:read).to_i
+          elsif File.executable?("/usr/sbin/sysctl")
+            IO.popen("/usr/sbin/sysctl -n hw.ncpu", &:read).to_i
+          elsif File.executable?("/sbin/sysctl")
+            IO.popen("/sbin/sysctl -n hw.ncpu", &:read).to_i
+          else
+            # TODO (pitr-ch 05-Nov-2016): warn about failures
+            1
+          end
+        end
+      rescue
+        return 1
+      end
+
+      def compute_physical_processor_count
+        ppc = case RbConfig::CONFIG["target_os"]
+              when /darwin1/
+                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
+              when /linux/
+                cores = {} # unique physical ID / core ID combinations
+                phy   = 0
+                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
+                  if ln.start_with?("physical")
+                    phy = ln[/\d+/]
+                  elsif ln.start_with?("core")
+                    cid        = phy + ":" + ln[/\d+/]
+                    cores[cid] = true if not cores[cid]
+                  end
+                end
+                cores.count
+              when /mswin|mingw/
+                require 'win32ole'
+                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
+                  "select NumberOfCores from Win32_Processor")
+                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
+              else
+                processor_count
+              end
+        # fall back to logical count if physical info is invalid
+        ppc > 0 ? ppc : processor_count
+      rescue
+        return 1
+      end
+    end
+  end
+
+  # create the default ProcessorCounter on load
+  @processor_counter = Utility::ProcessorCounter.new
+  singleton_class.send :attr_reader, :processor_counter
+
+  def self.processor_count
+    processor_counter.processor_count
+  end
+
+  def self.physical_processor_count
+    processor_counter.physical_processor_count
+  end
+end

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

@@ -0,0 +1,4 @@
+module Concurrent
+  VERSION      = '1.0.5'
+  EDGE_VERSION = '0.3.1'
+end

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

@@ -0,0 +1,130 @@
+require 'concurrent/version'
+require 'concurrent/constants'
+require 'concurrent/errors'
+require 'concurrent/configuration'
+
+require 'concurrent/atomics'
+require 'concurrent/executors'
+require 'concurrent/synchronization'
+
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/agent'
+require 'concurrent/atom'
+require 'concurrent/array'
+require 'concurrent/hash'
+require 'concurrent/map'
+require 'concurrent/tuple'
+require 'concurrent/async'
+require 'concurrent/dataflow'
+require 'concurrent/delay'
+require 'concurrent/exchanger'
+require 'concurrent/future'
+require 'concurrent/immutable_struct'
+require 'concurrent/ivar'
+require 'concurrent/maybe'
+require 'concurrent/mutable_struct'
+require 'concurrent/mvar'
+require 'concurrent/promise'
+require 'concurrent/scheduled_task'
+require 'concurrent/settable_struct'
+require 'concurrent/timer_task'
+require 'concurrent/tvar'
+
+require 'concurrent/thread_safe/synchronized_delegator'
+require 'concurrent/thread_safe/util'
+
+require 'concurrent/options'
+
+# @!macro [new] internal_implementation_note
+#
+#   @note **Private Implementation:** This abstraction is a private, internal
+#     implementation detail. It should never be used directly.
+
+# @!macro [new] monotonic_clock_warning
+#
+#   @note Time calculations one all platforms and languages are sensitive to
+#     changes to the system clock. To alleviate the potential problems
+#     associated with changing the system clock while an application is running,
+#     most modern operating systems provide a monotonic clock that operates
+#     independently of the system clock. A monotonic clock cannot be used to
+#     determine human-friendly clock times. A monotonic clock is used exclusively
+#     for calculating time intervals. Not all Ruby platforms provide access to an
+#     operating system monotonic clock. On these platforms a pure-Ruby monotonic
+#     clock will be used as a fallback. An operating system monotonic clock is both
+#     faster and more reliable than the pure-Ruby implementation. The pure-Ruby
+#     implementation should be fast and reliable enough for most non-realtime
+#     operations. At this time the common Ruby platforms that provide access to an
+#     operating system monotonic clock are MRI 2.1 and above and JRuby (all versions).
+#
+#   @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3)
+
+# @!macro [new] copy_options
+#
+#   ## Copy Options
+#
+#   Object references in Ruby are mutable. This can lead to serious
+#   problems when the {#value} of an object is a mutable reference. Which
+#   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
+#   "primitive" data type. Each instance can be configured with a few
+#   options that can help protect the program from potentially dangerous
+#   operations. Each of these options can be optionally set when the object
+#   instance is created:
+#
+#   * `:dup_on_deref` When true the object will call the `#dup` method on
+#     the `value` object every time the `#value` method is called
+#     (default: false)
+#   * `:freeze_on_deref` When true the object will call the `#freeze`
+#     method on the `value` object every time the `#value` method is called
+#     (default: false)
+#   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
+#     every time   the `#value` method is called. The `Proc` will be given
+#     the current `value` as its only argument and the result returned by
+#     the block will be the return   value of the `#value` call. When `nil`
+#     this option will be ignored (default: nil)
+#
+#   When multiple deref options are set the order of operations is strictly defined.
+#   The order of deref operations is:
+#   * `:copy_on_deref`
+#   * `:dup_on_deref`
+#   * `:freeze_on_deref`
+#
+#   Because of this ordering there is no need to `#freeze` an object created by a
+#   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
+#   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
+#   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
+#   or Haskell) as we are likely to get in Ruby.
+
+# @!macro [attach] deref_options
+#
+#   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
+#     returning the data from {#value}
+#   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
+#     returning the data from {#value}
+#   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
+#     method, call the given proc passing the internal value as the sole
+#     argument then return the new value returned from the proc.
+
+# @!macro [attach] executor_and_deref_options
+#
+#   @param [Hash] opts the options used to define the behavior at update and deref
+#     and to specify the executor on which to perform actions
+#   @option opts [Executor] :executor when set use the given `Executor` instance.
+#     Three special values are also supported: `:task` returns the global task pool,
+#     `:operation` returns the global operation pool, and `:immediate` returns a new
+#     `ImmediateExecutor` object.
+#   @!macro deref_options
+
+# Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
+# F#, C#, Java, and classic concurrency patterns.
+#
+# The design goals of this gem are:
+#
+# * Stay true to the spirit of the languages providing inspiration
+# * But implement in a way that makes sense for Ruby
+# * Keep the semantics as idiomatic Ruby as possible
+# * Support features that make sense in Ruby
+# * Exclude features that don't make sense in Ruby
+# * Be small, lean, and loosely coupled
+module Concurrent
+
+end

data/vendor/ruby/gems/rack-2.0.5/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2007-2016 Christian Neukirchen <purl.org/net/chneukirchen>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.