skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/vendor/active_support/notifications/instrumenter.rb

@@ -1,72 +0,0 @@
-require 'securerandom'
-
-module ActiveSupport
-  module Notifications
-    # Instrumenters are stored in a thread local.
-    class Instrumenter
-      attr_reader :id
-
-      def initialize(notifier)
-        @id       = unique_id
-        @notifier = notifier
-      end
-
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block.
-      def instrument(name, payload={})
-        start name, payload
-        begin
-          yield payload
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          raise e
-        ensure
-          finish name, payload
-        end
-      end
-
-      # Send a start notification with +name+ and +payload+.
-      def start(name, payload)
-        @notifier.start name, @id, payload
-      end
-
-      # Send a finish notification with +name+ and +payload+.
-      def finish(name, payload)
-        @notifier.finish name, @id, payload
-      end
-
-      private
-
-      def unique_id
-        ::SecureRandom.hex(10)
-      end
-    end
-
-    class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
-
-      def initialize(name, start, ending, transaction_id, payload)
-        @name           = name
-        @payload        = payload.dup
-        @time           = start
-        @transaction_id = transaction_id
-        @end            = ending
-        @children       = []
-      end
-
-      def duration
-        1000.0 * (self.end - time)
-      end
-
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
-      end
-    end
-  end
-end

data/lib/skylight/vendor/active_support/per_thread_registry.rb

@@ -1,52 +0,0 @@
-module ActiveSupport
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    protected
-
-      def method_missing(name, *args, &block) # :nodoc:
-        # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          per_thread_registry_instance.public_send(name, *a, &b)
-        end
-
-        send(name, *args, &block)
-      end
-
-    private
-
-      def per_thread_registry_instance
-        Thread.current[name] ||= new
-      end
-  end
-end

data/lib/skylight/vendor/thread_safe.rb

@@ -1,126 +0,0 @@
-require 'thread'
-
-module ThreadSafe
-  autoload :NonConcurrentCacheBackend, 'skylight/vendor/thread_safe/non_concurrent_cache_backend'
-  autoload :SynchronizedCacheBackend,  'skylight/vendor/thread_safe/synchronized_cache_backend'
-
-  ConcurrentCacheBackend = SynchronizedCacheBackend
-
-  class Cache < ConcurrentCacheBackend
-    KEY_ERROR = defined?(KeyError) ? KeyError : IndexError # there is no KeyError in 1.8 mode
-
-    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
-        value
-      elsif @default_proc && !key?(key)
-        @default_proc.call(self, key)
-      else
-        value
-      end
-    end
-
-    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 KEY_ERROR, 'key not found'
-      end
-    end
-
-    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 unless method_defined?(:value?)
-
-    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)
-
-    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
-
-    private
-    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?(Fixnum) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
-      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/lib/skylight/vendor/thread_safe/non_concurrent_cache_backend.rb

@@ -1,133 +0,0 @@
-module ThreadSafe
-  class NonConcurrentCacheBackend
-    # WARNING: all public methods of the class must operate on the @backend directly without calling each other. This is important
-    # because of the SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance reasons.
-    def initialize(options = nil)
-      @backend = {}
-    end
-
-    def [](key)
-      @backend[key]
-    end
-
-    def []=(key, value)
-      @backend[key] = value
-    end
-
-    def compute_if_absent(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        stored_value
-      else
-        @backend[key] = yield
-      end
-    end
-
-    def replace_pair(key, old_value, new_value)
-      if pair?(key, old_value)
-        @backend[key] = new_value
-        true
-      else
-        false
-      end
-    end
-
-    def replace_if_exists(key, new_value)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = new_value
-        stored_value
-      end
-    end
-
-    def compute_if_present(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def compute(key)
-      store_computed_value(key, yield(@backend[key]))
-    end
-
-    def merge_pair(key, value)
-      if NULL == (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = value
-      else
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def get_and_set(key, value)
-      stored_value = @backend[key]
-      @backend[key] = value
-      stored_value
-    end
-
-    def key?(key)
-      @backend.key?(key)
-    end
-
-    def value?(value)
-      @backend.value?(value)
-    end
-
-    def delete(key)
-      @backend.delete(key)
-    end
-
-    def delete_pair(key, value)
-      if pair?(key, value)
-        @backend.delete(key)
-        true
-      else
-        false
-      end
-    end
-
-    def clear
-      @backend.clear
-      self
-    end
-
-    def each_pair
-      dupped_backend.each_pair do |k, v|
-        yield k, v
-      end
-      self
-    end
-
-    def size
-      @backend.size
-    end
-
-    def get_or_default(key, default_value)
-      @backend.fetch(key, default_value)
-    end
-
-    alias_method :_get, :[]
-    alias_method :_set, :[]=
-    private :_get, :_set
-    private
-    def initialize_copy(other)
-      super
-      @backend = {}
-      self
-    end
-
-    def dupped_backend
-      @backend.dup
-    end
-
-    def pair?(key, expected_value)
-      NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value)
-    end
-
-    def store_computed_value(key, new_value)
-      if new_value.nil?
-        @backend.delete(key)
-        nil
-      else
-        @backend[key] = new_value
-      end
-    end
-  end
-end

data/lib/skylight/vendor/thread_safe/synchronized_cache_backend.rb

@@ -1,76 +0,0 @@
-module ThreadSafe
-  class SynchronizedCacheBackend < NonConcurrentCacheBackend
-    require 'mutex_m'
-    include Mutex_m
-    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are not allowed to call each other.
-
-    def [](key)
-      synchronize { super }
-    end
-
-    def []=(key, value)
-      synchronize { super }
-    end
-
-    def compute_if_absent(key)
-      synchronize { super }
-    end
-
-    def compute_if_present(key)
-      synchronize { super }
-    end
-
-    def compute(key)
-      synchronize { super }
-    end
-
-    def merge_pair(key, value)
-      synchronize { super }
-    end
-
-    def replace_pair(key, old_value, new_value)
-      synchronize { super }
-    end
-
-    def replace_if_exists(key, new_value)
-      synchronize { super }
-    end
-
-    def get_and_set(key, value)
-      synchronize { super }
-    end
-
-    def key?(key)
-      synchronize { super }
-    end
-
-    def value?(value)
-      synchronize { super }
-    end
-
-    def delete(key)
-      synchronize { super }
-    end
-
-    def delete_pair(key, value)
-      synchronize { super }
-    end
-
-    def clear
-      synchronize { super }
-    end
-
-    def size
-      synchronize { super }
-    end
-
-    def get_or_default(key, default_value)
-      synchronize { super }
-    end
-
-    private
-    def dupped_backend
-      synchronize { super }
-    end
-  end
-end