macks-ruby_protobuf 0.3.2.1

data/lib/protobuf/descriptor/descriptor_builder.rb

@@ -0,0 +1,144 @@
+require 'protobuf/descriptor/file_descriptor'
+
+module Protobuf
+  module Descriptor
+    def self.id2type(type_id)
+      require 'protobuf/descriptor/descriptor_proto'
+      case type_id
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE
+        :double
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FLOAT
+        :float
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64
+        :int64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64
+        :unit64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32
+        :int64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64
+        :fixed64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32
+        :fixed32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL
+        :bool
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
+        :string
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP
+        :group
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+        :message
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BYTES
+        :bytes
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32
+        :uint32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM
+        :enum
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32
+        :sfixed32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64
+        :sfixed64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32
+        :sint32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64
+        :sint64
+      else
+        raise ArgumentError.new("Invalid type: #{proto.type}")
+      end
+    end
+
+    def self.type2id(type)
+      require 'protobuf/descriptor/descriptor_proto'
+      case type
+      when :double
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE
+      when :float
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FLOAT
+      when :int64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64
+      when :unit64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64
+      when :int64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32
+      when :fixed64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64
+      when :fixed32
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL
+        :bool
+      when :string
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
+      when :group
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP
+      when :message
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+      when :bytes
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_BYTES
+      when :uint32
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32
+      when :enum
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM
+      when :sfixed32
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32
+      when :sfixed64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64
+      when :sint32
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32
+      when :sint64
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64
+      else
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+      end
+    end
+
+    def self.id2label(label_id)
+      require 'protobuf/descriptor/descriptor_proto'
+      case label_id
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED
+        :required
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL
+        :optional
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED
+        :repeated
+      else
+        raise ArgumentError.new("Invalid label: #{proto.label}")
+      end
+    end
+
+    def self.label2id(label)
+      require 'protobuf/descriptor/descriptor_proto'
+      case label
+      when :required
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED
+      when :optional
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL
+      when :repeated
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED
+      else
+        raise ArgumentError.new("Invalid label: #{label}")
+      end
+    end
+
+    class DescriptorBuilder
+      class <<self
+
+        def proto_type
+          nil
+        end
+
+        def build(proto, opt={})
+          acceptable_descriptor(proto).build proto
+        end
+
+        def acceptable_descriptor(proto)
+          Protobuf::Descriptor.constants.each do |class_name|
+            descriptor_class = Protobuf::Descriptor.const_get class_name
+            if descriptor_class.respond_to?(:proto_type) and 
+              descriptor_class.proto_type == proto.class.name
+              return descriptor_class
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/descriptor/descriptor_proto.rb

@@ -0,0 +1,119 @@
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+module Google
+  module Protobuf
+    ::Protobuf::OPTIONS[:java_package] = :"com.google.protobuf"
+    ::Protobuf::OPTIONS[:java_outer_classname] = :"DescriptorProtos"
+    ::Protobuf::OPTIONS[:optimize_for] = :SPEED
+    class FileDescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :string, :package, 2
+      repeated :string, :dependency, 3
+      repeated :DescriptorProto, :message_type, 4
+      repeated :EnumDescriptorProto, :enum_type, 5
+      repeated :ServiceDescriptorProto, :service, 6
+      repeated :FieldDescriptorProto, :extension, 7
+      optional :FileOptions, :options, 8
+    end
+    class DescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      repeated :FieldDescriptorProto, :field, 2
+      repeated :FieldDescriptorProto, :extension, 6
+      repeated :DescriptorProto, :nested_type, 3
+      repeated :EnumDescriptorProto, :enum_type, 4
+      class ExtensionRange < ::Protobuf::Message
+        optional :int32, :start, 1
+        optional :int32, :end, 2
+      end
+      repeated :ExtensionRange, :extension_range, 5
+      optional :MessageOptions, :options, 7
+    end
+    class FieldDescriptorProto < ::Protobuf::Message
+      class Type < ::Protobuf::Enum
+        TYPE_DOUBLE = 1
+        TYPE_FLOAT = 2
+        TYPE_INT64 = 3
+        TYPE_UINT64 = 4
+        TYPE_INT32 = 5
+        TYPE_FIXED64 = 6
+        TYPE_FIXED32 = 7
+        TYPE_BOOL = 8
+        TYPE_STRING = 9
+        TYPE_GROUP = 10
+        TYPE_MESSAGE = 11
+        TYPE_BYTES = 12
+        TYPE_UINT32 = 13
+        TYPE_ENUM = 14
+        TYPE_SFIXED32 = 15
+        TYPE_SFIXED64 = 16
+        TYPE_SINT32 = 17
+        TYPE_SINT64 = 18
+      end
+      class Label < ::Protobuf::Enum
+        LABEL_OPTIONAL = 1
+        LABEL_REQUIRED = 2
+        LABEL_REPEATED = 3
+      end
+      optional :string, :name, 1
+      optional :int32, :number, 3
+      optional :Label, :label, 4
+      optional :Type, :type, 5
+      optional :string, :type_name, 6
+      optional :string, :extendee, 2
+      optional :string, :default_value, 7
+      optional :FieldOptions, :options, 8
+    end
+    class EnumDescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      repeated :EnumValueDescriptorProto, :value, 2
+      optional :EnumOptions, :options, 3
+    end
+    class EnumValueDescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :int32, :number, 2
+      optional :EnumValueOptions, :options, 3
+    end
+    class ServiceDescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      repeated :MethodDescriptorProto, :method, 2
+      optional :ServiceOptions, :options, 3
+    end
+    class MethodDescriptorProto < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :string, :input_type, 2
+      optional :string, :output_type, 3
+      optional :MethodOptions, :options, 4
+    end
+    class FileOptions < ::Protobuf::Message
+      optional :string, :java_package, 1
+      optional :string, :java_outer_classname, 8
+      optional :bool, :java_multiple_files, 10, {:default => :false}
+      class OptimizeMode < ::Protobuf::Enum
+        SPEED = 1
+        CODE_SIZE = 2
+      end
+      optional :OptimizeMode, :optimize_for, 9, {:default => :CODE_SIZE}
+    end
+    class MessageOptions < ::Protobuf::Message
+      optional :bool, :message_set_wire_format, 1, {:default => :false}
+    end
+    class FieldOptions < ::Protobuf::Message
+      optional :CType, :ctype, 1
+      class CType < ::Protobuf::Enum
+        CORD = 1
+        STRING_PIECE = 2
+      end
+      optional :string, :experimental_map_key, 9
+    end
+    class EnumOptions < ::Protobuf::Message
+    end
+    class EnumValueOptions < ::Protobuf::Message
+    end
+    class ServiceOptions < ::Protobuf::Message
+    end
+    class MethodOptions < ::Protobuf::Message
+    end
+  end
+end

data/lib/protobuf/descriptor/enum_descriptor.rb

@@ -0,0 +1,33 @@
+module Protobuf
+  module Descriptor
+    class EnumDescriptor
+      def initialize(enum_class)
+        @enum_class = enum_class
+      end
+
+      def proto_type
+        Google::Protobuf::EnumDescriptorProto
+      end
+
+      def build(proto, opt)
+        mod = opt[:module]
+        cls = mod.const_set proto.name, Class.new(Protobuf::Enum)
+        proto.value.each do |value_proto|
+          cls.const_set value_proto.name, value_proto.number
+        end
+      end
+
+      def unbuild(parent_proto)
+        enum_proto = Google::Protobuf::EnumDescriptorProto.new
+        enum_proto.name = @enum_class.name.split('::').last
+        @enum_class.constants.each do |const|
+          enum_value_proto = Google::Protobuf::EnumValueDescriptorProto.new
+          enum_value_proto.name = const.to_s
+          enum_value_proto.number = @enum_class.const_get const
+          enum_proto.value << enum_value_proto
+        end
+        parent_proto.enum_type << enum_proto
+      end
+    end
+  end
+end

data/lib/protobuf/descriptor/field_descriptor.rb

@@ -0,0 +1,50 @@
+module Protobuf
+  module Descriptor
+    class FieldDescriptor
+      def initialize(field_instance=nil)
+        @field_instance = field_instance
+      end
+
+      def proto_type
+        'Google::Protobuf::FieldDescriptorProto'
+      end
+
+      def build(proto, opt={})
+        cls = opt[:class]
+        rule = Protobuf::Descriptor.id2label proto.label
+        type = Protobuf::Descriptor.id2type proto.type
+        type = proto.type_name.to_sym if [:message, :enum].include? type
+        opts = {}
+        opts[:default] = proto.default_value if proto.default_value
+        cls.define_field rule, type, proto.name, proto.number, opts
+      end
+
+      def unbuild(parent_proto, extension=false)
+        field_proto = Google::Protobuf::FieldDescriptorProto.new
+        field_proto.name = @field_instance.name.to_s
+        field_proto.number = @field_instance.tag
+        field_proto.label = Protobuf::Descriptor.label2id @field_instance.rule
+        field_proto.type = Protobuf::Descriptor.type2id @field_instance.type
+        if [Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE,
+          Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM].include? field_proto.type
+          field_proto.type_name = @field_instance.type.to_s.split('::').last 
+        end
+        field_proto.default_value = @field_instance.default.to_s if @field_instance.default
+
+        case parent_proto
+        when Google::Protobuf::FileDescriptorProto
+          parent_proto.extension << field_proto
+        when Google::Protobuf::DescriptorProto
+          if extension
+            parent_proto.extension << field_proto
+          else
+            parent_proto.field << field_proto
+          end
+        else
+          raise TypeError.new(parent_proto.class.name)
+        end
+      end
+    end
+  end
+end
+

data/lib/protobuf/descriptor/file_descriptor.rb

@@ -0,0 +1,38 @@
+module Protobuf
+  module Descriptor
+    class FileDescriptor
+      class <<self
+        def proto_type
+          'Google::Protobuf::FileDescriptorProto'
+        end
+
+        def build(proto, opt={})
+          mod = Object
+          if package = proto.package and not package.empty?
+            module_names = package.split '::'
+            module_names.each do |module_name|
+              mod = mod.const_set module_name, Module.new
+            end
+          end
+          proto.message_type.each do |message_proto|
+            Protobuf::Message.descriptor.build message_proto, :module => mod
+          end
+          proto.enum_type.each do |enum_proto|
+            Protobuf::Enum.descriptor.build enum_proto, :module => mod
+          end
+        end
+
+        def unbuild(messages)
+          messages = [messages] unless messages.is_a? Array
+          proto = Google::Protobuf::FileDescriptorProto.new
+          proto.package = messages.first.to_s.split('::')[0..-2].join('::') if messages.first.to_s =~ /::/
+          messages.each do |message|
+            message.descriptor.unbuild proto
+          end
+          proto
+        end
+      end
+    end
+  end
+end
+

data/lib/protobuf/message/decoder.rb

@@ -0,0 +1,93 @@
+require 'protobuf/common/wire_type'
+
+module Protobuf
+  class InvalidWireType < StandardError; end
+
+  class Decoder
+    class <<self
+      def decode(stream, message)
+        self.new(stream, message).decode
+      end
+    end
+
+    def initialize(stream=nil, message=nil)
+      @stream, @message = stream, message
+    end
+
+    def decode(stream=@stream, message=@message)
+      until stream.eof?
+        tag, wire_type = read_key stream
+        bytes =
+          case wire_type
+          when WireType::VARINT
+            read_varint stream
+          when WireType::FIXED64
+            read_fixed64 stream
+          when WireType::LENGTH_DELIMITED
+            read_length_delimited stream
+          when WireType::START_GROUP
+            read_start_group stream
+          when WireType::END_GROUP
+            read_end_group stream
+          when WireType::FIXED32
+            read_fixed32 stream
+          else
+            raise InvalidWireType.new(wire_type)
+          end
+        message.set_field tag, bytes
+      end
+      message
+    end
+
+    protected
+
+    def read_key(stream)
+      # TODO is there more clear way to do this?
+      bits = 0
+      bytes = read_varint stream
+      bytes.each_with_index do |byte, index|
+        byte &= 0b01111111
+        bits |= byte << (7 * index)
+      end
+      wire_type = bits & 0b00000111
+      tag = bits >> 3
+      [tag, wire_type]
+    end
+
+    def read_varint(stream)
+      read_method = stream.respond_to?(:readbyte) ? :readbyte : :readchar
+      bytes = []
+      begin
+        byte = stream.send(read_method)
+        bytes << (byte & 0b01111111)
+      end while byte >> 7 == 1
+      bytes
+    end
+
+    def read_fixed64(stream)
+      stream.read(8)
+    end
+
+    def read_length_delimited(stream)
+      bytes = read_varint stream
+      value_length = 0
+      bytes.each_with_index do |byte, index|
+        value_length |= byte << (7 * index)
+      end
+      value = stream.read value_length
+      value.unpack('C*')
+    end
+
+    def read_start_group(stream)
+      raise NotImplementedError.new('Group is duplecated.')
+    end
+ 
+    def read_end_group(stream)
+      raise NotImplementedError.new('Group is duplecated.')
+    end
+
+    def read_fixed32(stream)
+      stream.read(4)
+    end
+  end
+end

data/lib/protobuf/message/encoder.rb

@@ -0,0 +1,37 @@
+require 'protobuf/common/wire_type'
+
+module Protobuf
+  class Encoder
+    class <<self
+      def encode(stream, message)
+        self.new(stream, message).encode
+      end
+    end
+
+    def initialize(stream=nil, message=nil)
+      @stream, @message = stream, message
+    end
+
+    def encode(stream=@stream, message=@message)
+      message.each_field do |field, value|
+        next unless message.has_field?(field.name)
+
+        if field.repeated?
+          value.each do |val|
+            write_pair field, val, stream
+          end
+        else
+          write_pair field, value, stream
+        end
+      end
+    end
+
+    def write_pair(field, value, stream)
+      key = (field.tag << 3) | field.wire_type
+      key_bytes = Protobuf::Field::VarintField.get_bytes key
+      stream.write key_bytes
+      bytes = field.get value
+      stream.write bytes
+    end
+  end
+end

data/lib/protobuf/message/enum.rb

@@ -0,0 +1,28 @@
+require 'protobuf/descriptor/enum_descriptor'
+require 'protobuf/message/protoable'
+
+module Protobuf
+  class Enum
+    class <<self
+      include Protobuf::Protoable
+
+      def get_name_by_tag(tag)
+        constants.find do |name|
+          const_get(name) == tag
+        end
+      end
+
+      def valid_tag?(tag)
+        not get_name_by_tag(tag).nil?
+      end
+
+      def name_by_value(value)
+        constants.find {|c| const_get(c) == value}
+      end
+
+      def descriptor
+        @descriptor ||= Protobuf::Descriptor::EnumDescriptor.new(self)
+      end
+    end
+  end
+end

data/lib/protobuf/message/extend.rb

@@ -0,0 +1,8 @@
+require 'protobuf/message/message'
+
+module Protobuf
+  class Extend < Message
+    MIN = -1.0/0
+    MAX = 1.0/0
+  end
+end