beefcake-spanx 0.3.4.1

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,98 @@
+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
+
+    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)
+      pims = type.public_instance_methods
+      pims.include?(:encode) || pims.include?("encode")
+    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="")
+      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
+
+    def <<(bytes)
+      buf << bytes
+    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

data/lib/beefcake/buffer/decode.rb

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

data/lib/beefcake/buffer/encode.rb

@@ -0,0 +1,116 @@
+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)
+      #self << ((fn << 3) | 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

data/lib/beefcake/generator.rb

@@ -0,0 +1,288 @@
+# 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;
+  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 file!(file)
+      puts "## Generated from #{file.name} for #{file.package}"
+
+      file.message_type.each do |mt|
+        message!("", mt)
+      end
+    end
+
+    def indent(&blk)
+      @n += 1
+      blk.call
+      @n -= 1
+    end
+
+    def indent!(n)
+      @n = n
+    end
+
+    def message!(pkg, mt)
+      puts
+      puts "class #{mt.name}"
+
+      indent do
+        puts "include Beefcake::Message"
+        puts
+
+        Array(mt.enum_type).each do |et|
+          enum!(et)
+        end
+
+        ## Generate Types
+        Array(mt.nested_type).each do |nt|
+          message!(pkg, nt)
+        end
+        puts
+
+        ## Generate fields
+        Array(mt.field).each do |f|
+          field!(pkg, f)
+        end
+        puts
+      end
+
+      puts "end"
+    end
+
+    def enum!(et)
+      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
+        # We have a type_name so we will use it after converting to a
+        # Ruby friendly version
+        t = f.type_name
+        t = t.gsub(pkg, "") # Remove the leading package name
+        t = t.gsub(/^\.*/, "")       # Remove leading `.`s
+
+        t.gsub(".", "::")  # Convert to Ruby namespacing syntax
+      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
+        out += ", :default => #{f.default_value}"
+      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(ns, file)
+      puts "## Generated from #{file.name} for #{file.package}"
+      puts "require \"beefcake\""
+      puts
+
+      ns!(ns) do
+        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
+
+  end
+end