sprokovuln 0.2.0

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

@@ -0,0 +1,157 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    module AbstractStruct
+
+      # @!visibility private
+      def initialize(*values)
+        super()
+        ns_initialize(*values)
+      end
+
+      # @!macro [attach] struct_length
+      #
+      #   Returns the number of struct members.
+      #
+      #   @return [Fixnum] the number of struct members
+      def length
+        self.class::MEMBERS.length
+      end
+      alias_method :size, :length
+
+      # @!macro [attach] struct_members
+      #
+      #   Returns the struct members as an array of symbols.
+      #
+      #   @return [Array] the struct members as an array of symbols
+      def members
+        self.class::MEMBERS.dup
+      end
+
+      protected
+
+      # @!macro struct_values
+      #
+      # @!visibility private
+      def ns_values
+        @values.dup
+      end
+
+      # @!macro struct_values_at
+      #
+      # @!visibility private
+      def ns_values_at(indexes)
+        @values.values_at(*indexes)
+      end
+
+      # @!macro struct_to_h
+      #
+      # @!visibility private
+      def ns_to_h
+        length.times.reduce({}){|memo, i| memo[self.class::MEMBERS[i]] = @values[i]; memo}
+      end
+
+      # @!macro struct_get
+      #
+      # @!visibility private
+      def ns_get(member)
+        if member.is_a? Integer
+          if member >= @values.length
+            raise IndexError.new("offset #{member} too large for struct(size:#{@values.length})")
+          end
+          @values[member]
+        else
+          send(member)
+        end
+      rescue NoMethodError
+        raise NameError.new("no member '#{member}' in struct")
+      end
+
+      # @!macro struct_equality
+      #
+      # @!visibility private
+      def ns_equality(other)
+        self.class == other.class && self.values == other.values
+      end
+
+      # @!macro struct_each
+      #
+      # @!visibility private
+      def ns_each
+        values.each{|value| yield value }
+      end
+
+      # @!macro struct_each_pair
+      #
+      # @!visibility private
+      def ns_each_pair
+        @values.length.times do |index|
+          yield self.class::MEMBERS[index], @values[index]
+        end
+      end
+
+      # @!macro struct_select
+      #
+      # @!visibility private
+      def ns_select
+        values.select{|value| yield value }
+      end
+
+      # @!macro struct_inspect
+      #
+      # @!visibility private
+      def ns_inspect
+        struct = pr_underscore(self.class.ancestors[1])
+        clazz = ((self.class.to_s =~ /^#<Class:/) == 0) ? '' : " #{self.class}"
+        "#<#{struct}#{clazz} #{ns_to_h}>"
+      end
+
+      # @!macro struct_merge
+      #
+      # @!visibility private
+      def ns_merge(other, &block)
+        self.class.new(*self.to_h.merge(other, &block).values)
+      end
+
+      # @!visibility private
+      def pr_underscore(clazz)
+        word = clazz.to_s
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      # @!visibility private
+      def self.define_struct_class(parent, base, name, members, &block)
+        clazz = Class.new(base || Object) do
+          include parent
+          self.const_set(:MEMBERS, members.collect{|member| member.to_s.to_sym}.freeze)
+          def ns_initialize(*values)
+            raise ArgumentError.new('struct size differs') if values.length > length
+            @values = values.fill(nil, values.length..length-1)
+          end
+        end
+        unless name.nil?
+          begin
+            parent.const_set(name, clazz)
+            parent.const_get(name)
+          rescue NameError
+            raise NameError.new("identifier #{name} needs to be constant")
+          end
+        end
+        members.each_with_index do |member, index|
+          clazz.send(:define_method, member) do
+            @values[index]
+          end
+        end
+        clazz.class_exec(&block) unless block.nil?
+        clazz
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Concurrent
+  module Synchronization
+    # TODO (pitr-ch 04-Dec-2016): should be in edge
+    class Condition < LockableObject
+      safe_initialization!
+
+      # TODO (pitr 12-Sep-2015): locks two objects, improve
+      # TODO (pitr 26-Sep-2015): study
+      # http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b132/java/util/concurrent/locks/AbstractQueuedSynchronizer.java#AbstractQueuedSynchronizer.Node
+
+      singleton_class.send :alias_method, :private_new, :new
+      private_class_method :new
+
+      def initialize(lock)
+        super()
+        @Lock = lock
+      end
+
+      def wait(timeout = nil)
+        @Lock.synchronize { ns_wait(timeout) }
+      end
+
+      def ns_wait(timeout = nil)
+        synchronize { super(timeout) }
+      end
+
+      def wait_until(timeout = nil, &condition)
+        @Lock.synchronize { ns_wait_until(timeout, &condition) }
+      end
+
+      def ns_wait_until(timeout = nil, &condition)
+        synchronize { super(timeout, &condition) }
+      end
+
+      def signal
+        @Lock.synchronize { ns_signal }
+      end
+
+      def ns_signal
+        synchronize { super }
+      end
+
+      def broadcast
+        @Lock.synchronize { ns_broadcast }
+      end
+
+      def ns_broadcast
+        synchronize { super }
+      end
+    end
+
+    class LockableObject < LockableObjectImplementation
+      def new_condition
+        Condition.private_new(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Concurrent
+  module Synchronization
+
+    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
+
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JRubyLockableObject < AbstractLockableObject
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Concurrent
+  module Synchronization
+
+    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
+
+      module JRubyAttrVolatile
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def attr_volatile(*names)
+            names.each do |name|
+
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  instance_variable_get_volatile(:#{ivar})
+                end
+
+                def #{name}=(value)
+                  instance_variable_set_volatile(:#{ivar}, value)
+                end
+              RUBY
+
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+        end
+      end
+
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JRubyObject < AbstractObject
+        include JRubyAttrVolatile
+
+        def initialize
+          # nothing to do
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Concurrent
+  module Synchronization
+    # TODO (pitr-ch 04-Dec-2016): should be in edge
+    class Lock < LockableObject
+      # TODO use JavaReentrantLock on JRuby
+
+      public :synchronize
+
+      def wait(timeout = nil)
+        synchronize { ns_wait(timeout) }
+      end
+
+      public :ns_wait
+
+      def wait_until(timeout = nil, &condition)
+        synchronize { ns_wait_until(timeout, &condition) }
+      end
+
+      public :ns_wait_until
+
+      def signal
+        synchronize { ns_signal }
+      end
+
+      public :ns_signal
+
+      def broadcast
+        synchronize { ns_broadcast }
+      end
+
+      public :ns_broadcast
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    LockableObjectImplementation = case
+                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
+                                     MriMonitorLockableObject
+                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
+                                     MriMutexLockableObject
+                                   when Concurrent.on_jruby?
+                                     JRubyLockableObject
+                                   when Concurrent.on_rbx?
+                                     RbxLockableObject
+                                   when Concurrent.on_truffle?
+                                     MriMutexLockableObject
+                                   else
+                                     warn 'Possibly unsupported Ruby implementation'
+                                     MriMonitorLockableObject
+                                   end
+    private_constant :LockableObjectImplementation
+
+    #   Safe synchronization under any Ruby implementation.
+    #   It provides methods like {#synchronize}, {#wait}, {#signal} and {#broadcast}.
+    #   Provides a single layer which can improve its implementation over time without changes needed to
+    #   the classes using it. Use {Synchronization::Object} not this abstract class.
+    #
+    #   @note this object does not support usage together with
+    #     [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
+    #     and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
+    #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
+    #     `Thread#wakeup` will not work on all platforms.
+    #
+    #   @see {Event} implementation as an example of this class use
+    #
+    #   @example simple
+    #     class AnClass < Synchronization::Object
+    #       def initialize
+    #         super
+    #         synchronize { @value = 'asd' }
+    #       end
+    #
+    #       def value
+    #         synchronize { @value }
+    #       end
+    #     end
+    #
+    # @!visibility private
+    class LockableObject < LockableObjectImplementation
+
+      # TODO (pitr 12-Sep-2015): make private for c-r, prohibit subclassing
+      # TODO (pitr 12-Sep-2015): we inherit too much ourselves :/
+
+      # @!method initialize(*args, &block)
+      #   @!macro synchronization_object_method_initialize
+
+      # @!method synchronize
+      #   @!macro synchronization_object_method_synchronize
+
+      # @!method wait_until(timeout = nil, &condition)
+      #   @!macro synchronization_object_method_ns_wait_until
+
+      # @!method wait(timeout = nil)
+      #   @!macro synchronization_object_method_ns_wait
+
+      # @!method signal
+      #   @!macro synchronization_object_method_ns_signal
+
+      # @!method broadcast
+      #   @!macro synchronization_object_method_ns_broadcast
+
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriLockableObject < AbstractLockableObject
+      protected
+
+      def ns_signal
+        @__condition__.signal
+        self
+      end
+
+      def ns_broadcast
+        @__condition__.broadcast
+        self
+      end
+    end
+
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriMutexLockableObject < MriLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__lock__      = ::Mutex.new
+        @__condition__ = ::ConditionVariable.new
+      end
+
+      protected
+
+      def synchronize
+        if @__lock__.owned?
+          yield
+        else
+          @__lock__.synchronize { yield }
+        end
+      end
+
+      def ns_wait(timeout = nil)
+        @__condition__.wait @__lock__, timeout
+        self
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriMonitorLockableObject < MriLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__lock__      = ::Monitor.new
+        @__condition__ = @__lock__.new_cond
+      end
+
+      protected
+
+      def synchronize # TODO may be a problem with lock.synchronize { lock.wait }
+        @__lock__.synchronize { yield }
+      end
+
+      def ns_wait(timeout = nil)
+        @__condition__.wait timeout
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Concurrent
+  module Synchronization
+
+    module MriAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def attr_volatile(*names)
+          names.each do |name|
+            ivar = :"@volatile_#{name}"
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                #{ivar}
+              end
+
+              def #{name}=(value)
+                #{ivar} = value
+              end
+            RUBY
+          end
+          names.map { |n| [n, :"#{n}="] }.flatten
+        end
+      end
+
+      def full_memory_barrier
+        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriObject < AbstractObject
+      include MriAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    ObjectImplementation = case
+                           when Concurrent.on_cruby?
+                             MriObject
+                           when Concurrent.on_jruby?
+                             JRubyObject
+                           when Concurrent.on_rbx?
+                             RbxObject
+                           when Concurrent.on_truffle?
+                             TruffleObject
+                           else
+                             MriObject
+                           end
+    private_constant :ObjectImplementation
+
+    # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
+    # - final instance variables see {Object.safe_initialization!}
+    # - volatile instance variables see {Object.attr_volatile}
+    # - volatile instance variables see {Object.attr_atomic}
+    class Object < ObjectImplementation
+      # TODO make it a module if possible
+
+      # @!method self.attr_volatile(*names)
+      #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
+      #   volatile (Java) semantic. The instance variable should be accessed oly through generated methods.
+      #
+      #   @param [Array<Symbol>] names of the instance variables to be volatile
+      #   @return [Array<Symbol>] names of defined method names
+
+      # Has to be called by children.
+      def initialize
+        super
+        initialize_volatile_with_cas
+      end
+
+      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
+      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+      # same behaviour as Java's final fields.
+      # @example
+      #   class AClass < Concurrent::Synchronization::Object
+      #     safe_initialization!
+      #
+      #     def initialize
+      #       @AFinalValue = 'value' # published safely, does not have to be synchronized
+      #     end
+      #   end
+      def self.safe_initialization!
+        # define only once, and not again in children
+        return if safe_initialization?
+
+        def self.new(*args, &block)
+          object = super(*args, &block)
+        ensure
+          object.full_memory_barrier if object
+        end
+
+        @safe_initialization = true
+      end
+
+      # @return [true, false] if this class is safely initialized.
+      def self.safe_initialization?
+        @safe_initialization = false unless defined? @safe_initialization
+        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
+      end
+
+      # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
+      # any instance variables with CamelCase names and isn't {.safe_initialization?}.
+      def self.ensure_safe_initialization_when_final_fields_are_present
+        Object.class_eval do
+          def self.new(*args, &block)
+            object = super(*args, &block)
+          ensure
+            has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
+            if has_final_field && !safe_initialization?
+              raise "there was an instance of #{object.class} with final field but not marked with safe_initialization!"
+            end
+          end
+        end
+      end
+
+      # Creates methods for reading and writing to a instance variable with
+      # volatile (Java) semantic as {.attr_volatile} does.
+      # The instance variable should be accessed oly through generated methods.
+      # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
+      # `swap_value(new_value) #=> old_value`,
+      # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
+      # @param [Array<Symbol>] names of the instance variables to be volatile with CAS.
+      # @return [Array<Symbol>] names of defined method names.
+      def self.attr_atomic(*names)
+        @volatile_cas_fields ||= []
+        @volatile_cas_fields += names
+        safe_initialization!
+        define_initialize_volatile_with_cas
+
+        names.each do |name|
+          ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              #{ivar}.get
+            end
+
+            def #{name}=(value)
+              #{ivar}.set value
+            end
+
+            def swap_#{name}(value)
+              #{ivar}.swap value
+            end
+
+            def compare_and_set_#{name}(expected, value)
+              #{ivar}.compare_and_set expected, value
+            end
+
+            def update_#{name}(&block)
+              #{ivar}.update(&block)
+            end
+          RUBY
+        end
+        names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
+      end
+
+      # @param [true,false] inherited should inherited volatile with CAS fields be returned?
+      # @return [Array<Symbol>] Returns defined volatile with CAS fields on this class.
+      def self.volatile_cas_fields(inherited = true)
+        @volatile_cas_fields ||= []
+        ((superclass.volatile_cas_fields if superclass.respond_to?(:volatile_cas_fields) && inherited) || []) +
+            @volatile_cas_fields
+      end
+
+      private
+
+      def self.define_initialize_volatile_with_cas
+        assignments = @volatile_cas_fields.map { |name| "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
+        class_eval <<-RUBY
+          def initialize_volatile_with_cas
+            super
+            #{assignments}
+          end
+        RUBY
+      end
+
+      private_class_method :define_initialize_volatile_with_cas
+
+      def initialize_volatile_with_cas
+      end
+
+    end
+  end
+end