skylight 0.0.16 → 0.1.0.alpha1

data/lib/skylight/vendor/beefcake/encode.rb

@@ -0,0 +1,115 @@
+require 'skylight/vendor/beefcake/buffer'
+
+module Skylight
+  module Beefcake
+    class Buffer
+
+      def append(type, val, fn)
+        if fn != 0
+          wire = Buffer.wire_for(type)
+          append_info(fn, wire)
+        end
+
+        __send__("append_#{type}", val)
+      end
+
+      def append_info(fn, wire)
+        append_uint32((fn << 3) | wire)
+      end
+
+      def append_fixed32(n, tag=false)
+        if n < MinUint32 || n > MaxUint32
+          raise OutOfRangeError, n
+        end
+
+        self << [n].pack("V")
+      end
+
+      def append_fixed64(n)
+        if n < MinUint64 || n > MaxUint64
+          raise OutOfRangeError, n
+        end
+
+        self << [n & 0xFFFFFFFF, n >> 32].pack("VV")
+      end
+
+      def append_int32(n)
+        if n < MinInt32 || n > MaxInt32
+          raise OutOfRangeError, n
+        end
+
+        append_int64(n)
+      end
+
+      def append_uint32(n)
+        if n < MinUint32 || n > MaxUint32
+          raise OutOfRangeError, n
+        end
+
+        append_uint64(n)
+      end
+
+      def append_int64(n)
+        if n < MinInt64 || n > MaxInt64
+          raise OutOfRangeError, n
+        end
+
+        if n < 0
+          n += (1 << 64)
+        end
+
+        append_uint64(n)
+      end
+
+      def append_sint32(n)
+        append_uint32((n << 1) ^ (n >> 31))
+      end
+
+      def append_sfixed32(n)
+        append_fixed32((n << 1) ^ (n >> 31))
+      end
+
+      def append_sint64(n)
+        append_uint64((n << 1) ^ (n >> 63))
+      end
+
+      def append_sfixed64(n)
+        append_fixed64((n << 1) ^ (n >> 63))
+      end
+
+      def append_uint64(n)
+        if n < MinUint64 || n > MaxUint64
+          raise OutOfRangeError, n
+        end
+
+        while true
+          bits = n & 0x7F
+          n >>= 7
+          if n == 0
+            return self << bits
+          end
+          self << (bits | 0x80)
+        end
+      end
+
+      def append_float(n)
+        self << [n].pack("e")
+      end
+
+      def append_double(n)
+        self << [n].pack("E")
+      end
+
+      def append_bool(n)
+        append_int64(n ? 1 : 0)
+      end
+
+      def append_string(s)
+        append_uint64(s.length)
+        self << s
+      end
+      alias :append_bytes :append_string
+
+    end
+  end
+end

data/lib/skylight/vendor/thread_safe.rb

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

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