skylight 0.2.7 → 0.3.0.rc.3

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

@@ -1,119 +0,0 @@
-module Skylight
-  module Beefcake
-    class Buffer
-      MinUint32 =  0
-      MaxUint32 =  (1<<32)-1
-      MinInt32  = -(1<<31)
-      MaxInt32  =  (1<<31)-1
-
-      MinUint64 =  0
-      MaxUint64 =  (1<<64)-1
-      MinInt64  = -(1<<63)
-      MaxInt64  =  (1<<63)-1
-
-      MaxFixnum =  (1 << (1.size * 8 - 2) - 1)
-
-      def self.wire_for(type)
-        case type
-        when Class
-          if encodable?(type)
-            2
-          else
-            raise UnknownType, type
-          end
-        when :int32, :uint32, :sint32, :int64, :uint64, :sint64, :bool, Module
-          0
-        when :fixed64, :sfixed64, :double
-          1
-        when :string, :bytes
-          2
-        when :fixed32, :sfixed32, :float
-          5
-        else
-          raise UnknownType, type
-        end
-      end
-
-      def self.encodable?(type)
-        return false if ! type.is_a?(Class)
-        type < Message
-      end
-
-      attr_accessor :buf
-
-      alias :to_s   :buf
-      alias :to_str :buf
-
-      class OutOfRangeError < StandardError
-        def initialize(n)
-          super("Value of of range: %d" % [n])
-        end
-      end
-
-      class BufferOverflowError < StandardError
-        def initialize(s)
-          super("Too many bytes read for %s" % [s])
-        end
-      end
-
-      class UnknownType < StandardError
-        def initialize(s)
-          super("Unknown type '%s'" % [s])
-        end
-      end
-
-      def initialize(buf="")
-        unless String === buf
-          raise ArgumentError, "buf must be a string"
-        end
-
-        self.buf = buf
-      end
-
-      if ''.respond_to?(:force_encoding)
-        def buf=(buf)
-          @buf = buf.force_encoding(BINARY)
-        end
-      end
-
-      def length
-        @buf.respond_to?(:bytesize) ? @buf.bytesize : @buf.length
-      end
-
-      BINARY = 'BINARY'.freeze
-
-      # Detect a ruby encodings bug, as far as I know, this exists in
-      # most versions fo JRuby as well as 1.9.2
-      def self.current_ruby_has_encoding_bug?
-        base = "\0\1".force_encoding('BINARY')
-        base << "BUG".encode("UTF-8")
-        base.encoding.to_s == 'UTF-8'
-      end
-
-      if ''.respond_to?(:force_encoding) && current_ruby_has_encoding_bug?
-        def <<(bytes)
-          buf << bytes
-          buf.force_encoding(BINARY)
-          buf
-        end
-      else
-        def <<(bytes)
-          buf << bytes
-        end
-      end
-
-      def read(n)
-        case n
-        when Class
-          n.decode(read_string)
-        when Symbol
-          __send__("read_#{n}")
-        when Module
-          read_uint64
-        else
-          buf.slice!(0, n)
-        end
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-require 'skylight/vendor/beefcake/buffer'
-
-module Skylight
-  module Beefcake
-    class Buffer
-
-      def read_info
-        n    = read_uint64
-        fn   = n >> 3
-        wire = n & 0x7
-
-        [fn, wire]
-      end
-
-      def read_string
-        read(read_uint64)
-      end
-      alias :read_bytes :read_string
-
-      def read_fixed32
-        bytes = read(4)
-        bytes.unpack("V").first
-      end
-
-      def read_fixed64
-        bytes = read(8)
-        x, y = bytes.unpack("VV")
-        x + (y << 32)
-      end
-
-      def read_int64
-        n = read_uint64
-        if n > MaxInt64
-          n -= (1 << 64)
-        end
-        n
-      end
-      alias :read_int32 :read_int64
-
-      def read_uint64
-        n = shift = 0
-        while true
-          if shift >= 64
-            raise BufferOverflowError, "varint"
-          end
-          b = buf.slice!(0)
-
-          ## 1.8.6 to 1.9 Compat
-          if b.respond_to?(:ord)
-            b = b.ord
-          end
-
-          n |= ((b & 0x7F) << shift)
-          shift += 7
-          if (b & 0x80) == 0
-            return n
-          end
-        end
-      end
-      alias :read_uint32 :read_uint64
-
-      def read_sint64
-        decode_zigzag(read_uint64)
-      end
-      alias :read_sint32 :read_sint64
-
-      def read_sfixed32
-        decode_zigzag(read_fixed32)
-      end
-
-      def read_sfixed64
-        decode_zigzag(read_fixed64)
-      end
-
-      def read_float
-        bytes = read(4)
-        bytes.unpack("e").first
-      end
-
-      def read_double
-        bytes = read(8)
-        bytes.unpack("E").first
-      end
-
-      def read_bool
-        read_int32 != 0
-      end
-
-      def skip(wire)
-        case wire
-        when 0 then read_uint64
-        when 1 then read_fixed64
-        when 2 then read_string
-        when 5 then read_fixed32
-        end
-      end
-
-
-      private
-
-      def decode_zigzag(n)
-        (n >> 1) ^ -(n & 1)
-      end
-
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-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__(HANDLERS[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 uint64?(n)
-          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 uint64?(n)
-        if n < MinUint64
-          false
-        elsif n < MaxFixnum
-          true
-        else
-          n <= MaxUint64
-        end
-      end
-
-      def append_uint64(n)
-        unless uint64?(n)
-          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
-
-      HANDLERS = instance_methods.reduce({}) do |hash, meth|
-        if meth.to_s =~ /^append_(.*)$/
-          hash[$1.to_sym] = meth
-        end
-
-        hash
-      end
-    end
-  end
-end