lazy_record 0.2.1 → 0.2.2

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

@@ -1,98 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    class AbstractLockableObject < Synchronization::Object
-
-      protected
-
-      # @!macro [attach] synchronization_object_method_synchronize
-      #
-      #   @yield runs the block synchronized against this object,
-      #     equivalent of java's `synchronize(this) {}`
-      #   @note can by made public in descendants if required by `public :synchronize`
-      def synchronize
-        raise NotImplementedError
-      end
-
-      # @!macro [attach] synchronization_object_method_ns_wait_until
-      #
-      #   Wait until condition is met or timeout passes,
-      #   protects against spurious wake-ups.
-      #   @param [Numeric, nil] timeout in seconds, `nil` means no timeout
-      #   @yield condition to be met
-      #   @yieldreturn [true, false]
-      #   @return [true, false] if condition met
-      #   @note only to be used inside synchronized block
-      #   @note to provide direct access to this method in a descendant add method
-      #     ```
-      #     def wait_until(timeout = nil, &condition)
-      #       synchronize { ns_wait_until(timeout, &condition) }
-      #     end
-      #     ```
-      def ns_wait_until(timeout = nil, &condition)
-        if timeout
-          wait_until = Concurrent.monotonic_time + timeout
-          loop do
-            now              = Concurrent.monotonic_time
-            condition_result = condition.call
-            return condition_result if now >= wait_until || condition_result
-            ns_wait wait_until - now
-          end
-        else
-          ns_wait timeout until condition.call
-          true
-        end
-      end
-
-      # @!macro [attach] synchronization_object_method_ns_wait
-      #
-      #   Wait until another thread calls #signal or #broadcast,
-      #   spurious wake-ups can happen.
-      #
-      #   @param [Numeric, nil] timeout in seconds, `nil` means no timeout
-      #   @return [self]
-      #   @note only to be used inside synchronized block
-      #   @note to provide direct access to this method in a descendant add method
-      #     ```
-      #     def wait(timeout = nil)
-      #       synchronize { ns_wait(timeout) }
-      #     end
-      #     ```
-      def ns_wait(timeout = nil)
-        raise NotImplementedError
-      end
-
-      # @!macro [attach] synchronization_object_method_ns_signal
-      #
-      #   Signal one waiting thread.
-      #   @return [self]
-      #   @note only to be used inside synchronized block
-      #   @note to provide direct access to this method in a descendant add method
-      #     ```
-      #     def signal
-      #       synchronize { ns_signal }
-      #     end
-      #     ```
-      def ns_signal
-        raise NotImplementedError
-      end
-
-      # @!macro [attach] synchronization_object_method_ns_broadcast
-      #
-      #   Broadcast to all waiting threads.
-      #   @return [self]
-      #   @note only to be used inside synchronized block
-      #   @note to provide direct access to this method in a descendant add method
-      #     ```
-      #     def broadcast
-      #       synchronize { ns_broadcast }
-      #     end
-      #     ```
-      def ns_broadcast
-        raise NotImplementedError
-      end
-
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class AbstractObject
-
-      # @abstract has to be implemented based on Ruby runtime
-      def initialize
-        raise NotImplementedError
-      end
-
-      # @!visibility private
-      # @abstract
-      def full_memory_barrier
-        raise NotImplementedError
-      end
-
-      def self.attr_volatile(*names)
-        raise NotImplementedError
-      end
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-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/bundle/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/condition.rb

@@ -1,58 +0,0 @@
-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/bundle/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/jruby_lockable_object.rb

@@ -1,13 +0,0 @@
-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/bundle/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/jruby_object.rb

@@ -1,44 +0,0 @@
-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/bundle/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/lock.rb

@@ -1,34 +0,0 @@
-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/bundle/gems/concurrent-ruby-1.0.5/lib/concurrent/synchronization/lockable_object.rb

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