lazy_record 0.2.1 → 0.2.2

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

@@ -1,188 +0,0 @@
-require 'thread'
-require 'concurrent/delay'
-require 'concurrent/errors'
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/concern/logging'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/utility/at_exit'
-require 'concurrent/utility/processor_counter'
-
-module Concurrent
-  extend Concern::Logging
-
-  autoload :Options, 'concurrent/options'
-  autoload :TimerSet, 'concurrent/executor/timer_set'
-  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
-
-  # @return [Logger] Logger with provided level and output.
-  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
-    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
-    lambda do |severity, progname, message = nil, &block|
-      return false if severity < level
-
-      message           = block ? block.call : message
-      formatted_message = case message
-                          when String
-                            message
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   message.message, message.class, (message.backtrace || []).join("\n")
-                          else
-                            message.inspect
-                          end
-
-      output.print format "[%s] %5s -- %s: %s\n",
-                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
-                          Logger::SEV_LABEL[severity],
-                          progname,
-                          formatted_message
-      true
-    end
-  end
-
-  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
-  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_simple_logger level, output
-  end
-
-  # @return [Logger] Logger with provided level and output.
-  # @deprecated
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    logger           = Logger.new(output)
-    logger.level     = level
-    logger.formatter = lambda do |severity, datetime, progname, msg|
-      formatted_message = case msg
-                          when String
-                            msg
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
-                          else
-                            msg.inspect
-                          end
-      format "[%s] %5s -- %s: %s\n",
-             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-             severity,
-             progname,
-             formatted_message
-    end
-
-    lambda do |loglevel, progname, message = nil, &block|
-      logger.add loglevel, message, progname, &block
-    end
-  end
-
-  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
-  # @deprecated
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_stdlib_logger level, output
-  end
-
-  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
-
-  # Suppresses all output when used for logging.
-  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
-
-  # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
-  private_constant :GLOBAL_LOGGER
-
-  def self.global_logger
-    GLOBAL_LOGGER.value
-  end
-
-  def self.global_logger=(value)
-    GLOBAL_LOGGER.value = value
-  end
-
-  # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
-  private_constant :GLOBAL_FAST_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
-  private_constant :GLOBAL_IO_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
-  private_constant :GLOBAL_TIMER_SET
-
-  # @!visibility private
-  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
-  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
-
-  # Disables AtExit handlers including pool auto-termination handlers.
-  # When disabled it will be the application programmer's responsibility
-  # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
-  #
-  # @note this option should be needed only because of `at_exit` ordering
-  #   issues which may arise when running some of the testing frameworks.
-  #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
-  #   executes after the pools are already terminated. Then auto termination
-  #   needs to be disabled and called manually after test-suite ends.
-  # @note This method should *never* be called
-  #   from within a gem. It should *only* be used from within the main
-  #   application and even then it should be used only when necessary.
-  # @see AtExit
-  def self.disable_at_exit_handlers!
-    AtExit.enabled = false
-  end
-
-  # Global thread pool optimized for short, fast *operations*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_fast_executor
-    GLOBAL_FAST_EXECUTOR.value
-  end
-
-  # Global thread pool optimized for long, blocking (IO) *tasks*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_io_executor
-    GLOBAL_IO_EXECUTOR.value
-  end
-
-  def self.global_immediate_executor
-    GLOBAL_IMMEDIATE_EXECUTOR
-  end
-
-  # Global thread pool user for global *timers*.
-  #
-  # @return [Concurrent::TimerSet] the thread pool
-  def self.global_timer_set
-    GLOBAL_TIMER_SET.value
-  end
-
-  # General access point to global executors.
-  # @param [Symbol, Executor] executor_identifier symbols:
-  #   - :fast - {Concurrent.global_fast_executor}
-  #   - :io - {Concurrent.global_io_executor}
-  #   - :immediate - {Concurrent.global_immediate_executor}
-  # @return [Executor]
-  def self.executor(executor_identifier)
-    Options.executor(executor_identifier)
-  end
-
-  def self.new_fast_executor(opts = {})
-    FixedThreadPool.new(
-        [2, Concurrent.processor_count].max,
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
-    )
-  end
-
-  def self.new_io_executor(opts = {})
-    ThreadPoolExecutor.new(
-        min_threads:     [2, Concurrent.processor_count].max,
-        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-        # max_threads:     1000,
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
-    )
-  end
-end

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

@@ -1,8 +0,0 @@
-module Concurrent
-
-  # Various classes within allows for +nil+ values to be stored,
-  # so a special +NULL+ token is required to indicate the "nil-ness".
-  # @!visibility private
-  NULL = Object.new
-
-end

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

@@ -1,80 +0,0 @@
-require 'concurrent/future'
-require 'concurrent/atomic/atomic_fixnum'
-
-module Concurrent
-
-  # @!visibility private
-  class DependencyCounter # :nodoc:
-
-    def initialize(count, &block)
-      @counter = AtomicFixnum.new(count)
-      @block = block
-    end
-
-    def update(time, value, reason)
-      if @counter.decrement == 0
-        @block.call
-      end
-    end
-  end
-
-  # {include:file:doc/dataflow.md}
-  #
-  # @param [Future] inputs zero or more `Future` operations that this dataflow depends upon
-  #
-  # @yield The operation to perform once all the dependencies are met
-  # @yieldparam [Future] inputs each of the `Future` inputs to the dataflow
-  # @yieldreturn [Object] the result of the block operation
-  #
-  # @return [Object] the result of all the operations
-  #
-  # @raise [ArgumentError] if no block is given
-  # @raise [ArgumentError] if any of the inputs are not `IVar`s
-  def dataflow(*inputs, &block)
-    dataflow_with(Concurrent.global_io_executor, *inputs, &block)
-  end
-  module_function :dataflow
-
-  def dataflow_with(executor, *inputs, &block)
-    call_dataflow(:value, executor, *inputs, &block)
-  end
-  module_function :dataflow_with
-
-  def dataflow!(*inputs, &block)
-    dataflow_with!(Concurrent.global_io_executor, *inputs, &block)
-  end
-  module_function :dataflow!
-
-  def dataflow_with!(executor, *inputs, &block)
-    call_dataflow(:value!, executor, *inputs, &block)
-  end
-  module_function :dataflow_with!
-
-  private
-
-  def call_dataflow(method, executor, *inputs, &block)
-    raise ArgumentError.new('an executor must be provided') if executor.nil?
-    raise ArgumentError.new('no block given') unless block_given?
-    unless inputs.all? { |input| input.is_a? IVar }
-      raise ArgumentError.new("Not all dependencies are IVars.\nDependencies: #{ inputs.inspect }")
-    end
-
-    result = Future.new(executor: executor) do
-      values = inputs.map { |input| input.send(method) }
-      block.call(*values)
-    end
-
-    if inputs.empty?
-      result.execute
-    else
-      counter = DependencyCounter.new(inputs.size) { result.execute }
-
-      inputs.each do |input|
-        input.add_observer counter
-      end
-    end
-
-    result
-  end
-  module_function :call_dataflow
-end

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

@@ -1,197 +0,0 @@
-require 'thread'
-require 'concurrent/concern/obligation'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # This file has circular require issues. It must be autoloaded here.
-  autoload :Options, 'concurrent/options'
-
-  # Lazy evaluation of a block yielding an immutable result. Useful for
-  # expensive operations that may never be needed. It may be non-blocking,
-  # supports the `Concern::Obligation` interface, and accepts the injection of
-  # custom executor upon which to execute the block. Processing of
-  # block will be deferred until the first time `#value` is called.
-  # At that time the caller can choose to return immediately and let
-  # the block execute asynchronously, block indefinitely, or block
-  # with a timeout.
-  #
-  # When a `Delay` is created its state is set to `pending`. The value and
-  # reason are both `nil`. The first time the `#value` method is called the
-  # enclosed opration will be run and the calling thread will block. Other
-  # threads attempting to call `#value` will block as well. Once the operation
-  # is complete the *value* will be set to the result of the operation or the
-  # *reason* will be set to the raised exception, as appropriate. All threads
-  # blocked on `#value` will return. Subsequent calls to `#value` will immediately
-  # return the cached value. The operation will only be run once. This means that
-  # any side effects created by the operation will only happen once as well.
-  #
-  # `Delay` includes the `Concurrent::Concern::Dereferenceable` mixin to support thread
-  # safety of the reference returned by `#value`.
-  #
-  # @!macro copy_options
-  #
-  # @!macro [attach] delay_note_regarding_blocking
-  #   @note The default behavior of `Delay` is to block indefinitely when
-  #     calling either `value` or `wait`, executing the delayed operation on
-  #     the current thread. This makes the `timeout` value completely
-  #     irrelevant. To enable non-blocking behavior, use the `executor`
-  #     constructor option. This will cause the delayed operation to be
-  #     execute on the given executor, allowing the call to timeout.
-  #
-  # @see Concurrent::Concern::Dereferenceable
-  class Delay < Synchronization::LockableObject
-    include Concern::Obligation
-
-    # NOTE: Because the global thread pools are lazy-loaded with these objects
-    # there is a performance hit every time we post a new task to one of these
-    # thread pools. Subsequently it is critical that `Delay` perform as fast
-    # as possible post-completion. This class has been highly optimized using
-    # the benchmark script `examples/lazy_and_delay.rb`. Do NOT attempt to
-    # DRY-up this class or perform other refactoring with running the
-    # benchmarks and ensuring that performance is not negatively impacted.
-
-    # Create a new `Delay` in the `:pending` state.
-    #
-    # @!macro executor_and_deref_options
-    #
-    # @yield the delayed operation to perform
-    #
-    # @raise [ArgumentError] if no block is given
-    def initialize(opts = {}, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      super(&nil)
-      synchronize { ns_initialize(opts, &block) }
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception this method will return nil. The execption object
-    # can be accessed via the `#reason` method.
-    #
-    # @param [Numeric] timeout the maximum number of seconds to wait
-    # @return [Object] the current value of the object
-    #
-    # @!macro delay_note_regarding_blocking
-    def value(timeout = nil)
-      if @executor # TODO (pitr 12-Sep-2015): broken unsafe read?
-        super
-      else
-        # this function has been optimized for performance and
-        # should not be modified without running new benchmarks
-        synchronize do
-          execute = @computing = true unless @computing
-          if execute
-            begin
-              set_state(true, @task.call, nil)
-            rescue => ex
-              set_state(false, nil, ex)
-            end
-          end
-        end
-        if @do_nothing_on_deref
-          @value
-        else
-          apply_deref_options(@value)
-        end
-      end
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception, this method will raise that exception (even when)
-    # the operation has already been executed).
-    #
-    # @param [Numeric] timeout the maximum number of seconds to wait
-    # @return [Object] the current value of the object
-    # @raise [Exception] when `#rejected?` raises `#reason`
-    #
-    # @!macro delay_note_regarding_blocking
-    def value!(timeout = nil)
-      if @executor
-        super
-      else
-        result = value
-        raise @reason if @reason
-        result
-      end
-    end
-
-    # Return the value this object represents after applying the options
-    # specified by the `#set_deref_options` method.
-    #
-    # @param [Integer] timeout (nil) the maximum number of seconds to wait for
-    #   the value to be computed. When `nil` the caller will block indefinitely.
-    #
-    # @return [Object] self
-    #
-    # @!macro delay_note_regarding_blocking
-    def wait(timeout = nil)
-      if @executor
-        execute_task_once
-        super(timeout)
-      else
-        value
-      end
-      self
-    end
-
-    # Reconfigures the block returning the value if still `#incomplete?`
-    #
-    # @yield the delayed operation to perform
-    # @return [true, false] if success
-    def reconfigure(&block)
-      synchronize do
-        raise ArgumentError.new('no block given') unless block_given?
-        unless @computing
-          @task = block
-          true
-        else
-          false
-        end
-      end
-    end
-
-    protected
-
-    def ns_initialize(opts, &block)
-      init_obligation
-      set_deref_options(opts)
-      @executor = opts[:executor]
-
-      @task      = block
-      @state     = :pending
-      @computing = false
-    end
-
-    private
-
-    # @!visibility private
-    def execute_task_once # :nodoc:
-      # this function has been optimized for performance and
-      # should not be modified without running new benchmarks
-      execute = task = nil
-      synchronize do
-        execute = @computing = true unless @computing
-        task    = @task
-      end
-
-      if execute
-        executor = Options.executor_from_options(executor: @executor)
-        executor.post do
-          begin
-            result  = task.call
-            success = true
-          rescue => ex
-            reason = ex
-          end
-          synchronize do
-            set_state(success, result, reason)
-            event.set
-          end
-        end
-      end
-    end
-  end
-end