prepor-beefcake 1.0.0

data/lib/beefcake/buffer.rb

@@ -0,0 +1,2 @@
+require 'beefcake/buffer/encode'
+require 'beefcake/buffer/decode'

data/lib/beefcake/buffer/base.rb

@@ -0,0 +1,111 @@
+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
+
+    WIRES = {
+      :int32    => 0,
+      :uint32   => 0,
+      :sint32   => 0,
+      :int64    => 0,
+      :uint64   => 0,
+      :sint64   => 0,
+      :bool     => 0,
+      :fixed64  => 1,
+      :sfixed64 => 1,
+      :double   => 1,
+      :string   => 2,
+      :bytes    => 2,
+      :fixed32  => 5,
+      :sfixed32 => 5,
+      :float    => 5,
+    }
+
+    def self.wire_for(type)
+      wire = WIRES[type]
+
+      if wire
+        wire
+      elsif Class === type && encodable?(type)
+        2
+      elsif Module === type
+        0
+      else
+        raise UnknownType, type
+      end
+    end
+
+    def self.encodable?(type)
+      return false if ! type.is_a?(Class)
+      type.public_method_defined?(:encode)
+    end
+
+    attr_reader :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="")
+      self.buf = buf
+    end
+
+    def buf=(new_buf)
+      @buf = new_buf.force_encoding('BINARY')
+      @cursor = 0
+    end
+
+    def length
+      remain = buf.slice(@cursor..-1)
+      remain.bytesize
+    end
+
+    def <<(bytes)
+      bytes = bytes.force_encoding('BINARY') if bytes.respond_to? :force_encoding
+      buf << bytes
+    end
+
+    def read(n)
+      case n
+      when Class
+        n.decode(read_string)
+      when Symbol
+        __send__("read_#{n}")
+      when Module
+        read_uint64
+      else
+        read_slice = buf.byteslice(@cursor, n)
+        @cursor += n
+        return read_slice
+      end
+    end
+
+  end
+
+end

data/lib/beefcake/buffer/decode.rb

@@ -0,0 +1,105 @@
+require 'beefcake/buffer/base'
+
+module Beefcake
+
+  class Buffer
+
+    def read_info
+      n    = read_uint64
+      fn   = n >> 3
+      wire = n & 0x7
+
+      [fn, wire]
+    end
+
+    def read_bytes
+      read(read_uint64)
+    end
+
+    def read_string
+      read_bytes.force_encoding Encoding.find('utf-8')
+    end
+
+    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 = read(1).ord
+
+        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

data/lib/beefcake/buffer/encode.rb

@@ -0,0 +1,125 @@
+require 'beefcake/buffer/base'
+
+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)
+      actual_string = thaw_string s
+      encoded = actual_string.force_encoding 'binary'
+      append_uint64(encoded.length)
+      self << encoded
+    end
+    alias :append_bytes :append_string
+
+
+    private
+    def thaw_string(s)
+      if s.frozen?
+        s = s.dup
+      end
+      s.to_s
+    end
+  end
+
+end

data/lib/beefcake/generator.rb

@@ -0,0 +1,313 @@
+# encoding: ASCII-8BIT
+# The above line allows concatenation of constant strings like ".pb.rb" to
+# maintain the internal format of the buffers, rather than converting the
+# buffer to US-ASCII
+
+require 'beefcake'
+require 'stringio'
+
+class CodeGeneratorRequest
+  include Beefcake::Message
+
+
+  class FieldDescriptorProto
+    include Beefcake::Message
+
+    module Type
+      ## 0 is reserved for errors.
+      ## Order is weird for historical reasons.
+      TYPE_DOUBLE         = 1
+      TYPE_FLOAT          = 2
+      TYPE_INT64          = 3   ## Not ZigZag encoded.  Negative numbers
+      ## take 10 bytes.  Use TYPE_SINT64 if negative
+      ## values are likely.
+      TYPE_UINT64         = 4
+      TYPE_INT32          = 5   ## Not ZigZag encoded.  Negative numbers
+      ## take 10 bytes.  Use TYPE_SINT32 if negative
+      ## values are likely.
+      TYPE_FIXED64        = 6
+      TYPE_FIXED32        = 7
+      TYPE_BOOL           = 8
+      TYPE_STRING         = 9
+      TYPE_GROUP          = 10 ## Tag-delimited aggregate.
+      TYPE_MESSAGE        = 11 ## Length-delimited aggregate.
+
+      ## New in version 2.
+      TYPE_BYTES          = 12
+      TYPE_UINT32         = 13
+      TYPE_ENUM           = 14
+      TYPE_SFIXED32       = 15
+      TYPE_SFIXED64       = 16
+      TYPE_SINT32         = 17 ## Uses ZigZag encoding.
+      TYPE_SINT64         = 18 ## Uses ZigZag encoding.
+    end
+
+    module Label
+      LABEL_OPTIONAL      = 1
+      LABEL_REQUIRED      = 2
+      LABEL_REPEATED      = 3
+    end
+
+    optional :name,   :string, 1
+    optional :number, :int32,  3
+    optional :label,  Label,  4
+
+    ## If type_name is set, this need not be set.  If both this and type_name
+    ## are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
+    optional :type, Type, 5
+
+    ## For message and enum types, this is the name of the type.  If the name
+    ## starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+    ## rules are used to find the type (i.e. first the nested types within this
+    ## message are searched, then within the parent, on up to the root
+    ## namespace).
+    optional :type_name, :string, 6
+
+    ## For extensions, this is the name of the type being extended.  It is
+    ## resolved in the same manner as type_name.
+    optional :extended, :string, 2
+
+    ## For numeric types, contains the original text representation of the value.
+    ## For booleans, "true" or "false".
+    ## For strings, contains the default text contents (not escaped in any way).
+    ## For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+    optional :default_value, :string, 7
+  end
+
+
+  class EnumValueDescriptorProto
+    include Beefcake::Message
+
+    optional :name,   :string, 1
+    optional :number, :int32,  2
+    # optional EnumValueOptions options = 3;
+  end
+
+  class EnumDescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1
+    repeated :value, EnumValueDescriptorProto, 2
+    # optional :options, EnumOptions, 3
+  end
+
+  class DescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1
+
+    repeated :field,       FieldDescriptorProto, 2
+    repeated :extended,    FieldDescriptorProto, 6
+    repeated :nested_type, DescriptorProto,      3
+    repeated :enum_type,   EnumDescriptorProto,  4
+  end
+
+
+  class FileDescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1       # file name, relative to root of source tree
+    optional :package, :string, 2    # e.g. "foo", "foo.bar", etc.
+
+    repeated :message_type, DescriptorProto,     4;
+    repeated :enum_type,    EnumDescriptorProto, 5;
+  end
+
+
+  repeated :file_to_generate, :string, 1
+  optional :parameter, :string, 2
+
+  repeated :proto_file, FileDescriptorProto, 15
+end
+
+class CodeGeneratorResponse
+  include Beefcake::Message
+
+  class File
+    include Beefcake::Message
+
+    optional :name,    :string, 1
+    optional :content, :string, 15
+  end
+
+  repeated :file, File, 15
+end
+
+module Beefcake
+  class Generator
+
+    L = CodeGeneratorRequest::FieldDescriptorProto::Label
+    T = CodeGeneratorRequest::FieldDescriptorProto::Type
+
+
+    def self.compile(ns, req)
+      file = req.proto_file.map do |file|
+        g = new(StringIO.new)
+        g.compile(ns, file)
+
+        g.c.rewind
+        CodeGeneratorResponse::File.new(
+          :name => File.basename(file.name, ".proto") + ".pb.rb",
+          :content => g.c.read
+        )
+      end
+
+      CodeGeneratorResponse.new(:file => file)
+    end
+
+    attr_reader :c
+
+    def initialize(c)
+      @c = c
+      @n = 0
+    end
+
+    def indent(&blk)
+      @n += 1
+      blk.call
+      @n -= 1
+    end
+
+    def indent!(n)
+      @n = n
+    end
+
+    def define!(mt)
+      puts
+      puts "class #{mt.name}"
+
+      indent do
+        puts "include Beefcake::Message"
+
+        ## Enum Types
+        Array(mt.enum_type).each do |et|
+          enum!(et)
+        end
+
+        ## Nested Types
+        Array(mt.nested_type).each do |nt|
+          define!(nt)
+        end
+      end
+      puts "end"
+    end
+
+    def message!(pkg, mt)
+      puts
+      puts "class #{mt.name}"
+
+      indent do
+        ## Generate Types
+        Array(mt.nested_type).each do |nt|
+          message!(pkg, nt)
+        end
+
+        ## Generate Fields
+        Array(mt.field).each do |f|
+          field!(pkg, f)
+        end
+      end
+
+      puts "end"
+    end
+
+    def enum!(et)
+      puts
+      puts "module #{et.name}"
+      indent do
+        et.value.each do |v|
+          puts "%s = %d" % [v.name, v.number]
+        end
+      end
+      puts "end"
+    end
+
+    def field!(pkg, f)
+      # Turn the label into Ruby
+      label = name_for(f, L, f.label)
+
+      # Turn the name into a Ruby
+      name = ":#{f.name}"
+
+      # Determine the type-name and convert to Ruby
+      type = if f.type_name
+        t = f.type_name.gsub(/^\.*/, "").split('.').map { |v| camelize(v) } * '::'
+      else
+        ":#{name_for(f, T, f.type)}"
+      end
+
+      # Finally, generate the declaration
+      out = "%s %s, %s, %d" % [label, name, type, f.number]
+
+      if f.default_value
+        v = case f.type
+        when T::TYPE_ENUM
+          "%s::%s" % [type, f.default_value]
+        when T::TYPE_STRING, T::TYPE_BYTES
+          '"%s"' % [f.default_value.gsub('"', '\"')]
+        else
+          f.default_value
+        end
+
+        out += ", :default => #{v}"
+      end
+
+      puts out
+    end
+
+    # Determines the name for a
+    def name_for(b, mod, val)
+      b.name_for(mod, val).to_s.gsub(/.*_/, "").downcase
+    end
+
+    def compile(file)
+      package_part = file.package ? "for #{file.package}" : ''
+      puts "## Generated from #{file.name} #{package_part}".strip
+      puts "require \"beefcake\""
+      puts
+
+      ns!(package.split('.').map { |v| camelize(v) }) do
+        Array(file.enum_type).each do |et|
+          enum!(et)
+        end
+
+        file.message_type.each do |mt|
+          define! mt
+        end
+
+        file.message_type.each do |mt|
+          message!(file.package, mt)
+        end
+      end
+    end
+
+    def ns!(modules, &blk)
+      if modules.empty?
+        blk.call
+      else
+        puts "module #{modules.first}"
+        indent do
+          ns!(modules[1..-1], &blk)
+        end
+        puts "end"
+      end
+    end
+
+    def puts(msg=nil)
+      if msg
+        c.puts(("  " * @n) + msg)
+      else
+        c.puts
+      end
+    end
+
+    def camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+
+  end
+end