ruby_protobuf 0.1.0 → 0.2.0

data/History.txt

@@ -1,6 +1,8 @@
-=== 0.1.0 / 2008-08-01
+=== 0.2.0 / 2008-08-05
 
-* 2 fixed a small bug
-* 1 major enhancement
+* 0.2.0 introduce descriptor (rev.75)
+  * Message structures can be restored from encoded data by means a descriptor object
+* 0.1.0 fixed a small bug
+* 0.0.1 major enhancement
   * Birthday!
 

data/Manifest.txt

@@ -3,26 +3,35 @@ Manifest.txt
 README.txt
 Rakefile
 bin/rprotoc
-bin/ruby_protobuf
-lib/protobuf/compiler.rb
-lib/protobuf/decoder.rb
-lib/protobuf/encoder.rb
-lib/protobuf/enum.rb
-lib/protobuf/extend.rb
-lib/protobuf/field.rb
-lib/protobuf/message.rb
-lib/protobuf/parser.y
-lib/protobuf/service.rb
-lib/protobuf/wire_type.rb
+lib/protobuf/common/wire_type.rb
+lib/protobuf/compiler/compiler.rb
+lib/protobuf/compiler/parser.y
+lib/protobuf/descriptor/descriptor.proto
+lib/protobuf/descriptor/descriptor.rb
+lib/protobuf/descriptor/descriptor_builder.rb
+lib/protobuf/descriptor/descriptor_proto.rb
+lib/protobuf/descriptor/enum_descriptor.rb
+lib/protobuf/descriptor/field_descriptor.rb
+lib/protobuf/descriptor/file_descriptor.rb
+lib/protobuf/message/decoder.rb
+lib/protobuf/message/encoder.rb
+lib/protobuf/message/enum.rb
+lib/protobuf/message/extend.rb
+lib/protobuf/message/field.rb
+lib/protobuf/message/message.rb
+lib/protobuf/message/service.rb
 lib/ruby_protobuf.rb
 test/addressbook.proto
 test/addressbook.rb
+test/check_unbuild.rb
 test/data/data.bin
+test/data/data2.bin
 test/data/data_source.py
 test/data/types.bin
 test/data/types_source.py
 test/test_addressbook.rb
 test/test_compiler.rb
+test/test_descriptor.rb
 test/test_message.rb
 test/test_parse.rb
 test/test_ruby_protobuf.rb

data/README.txt

@@ -14,7 +14,7 @@ Protocol Buffers for Ruby.
 
 == SYNOPSIS:
 
-  bin/rprotoc -I lib test/addressbook.proto
+  rprotoc test/addressbook.proto
 
 == REQUIREMENTS:
 

data/lib/protobuf/{compiler.rb → compiler/compiler.rb}

@@ -12,10 +12,10 @@ module Protobuf
     def initialize
       @indent_level = 0
       @ret = <<-eos
-require 'protobuf/message'
-require 'protobuf/enum'
-require 'protobuf/service'
-require 'protobuf/extend'
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
 
       eos
     end
@@ -33,7 +33,7 @@ require 'protobuf/extend'
     def compile(filename)
       File.open filename, 'r' do |file|
         file.each_line do |line|
-          line.sub! /^(.*)\/\/.*/, '\1'
+          line.sub!(/^(.*)\/\/.*/, '\1')
           line.strip!
           case line
           when /^package\s+(\w+(\.\w+)?)\s*;$/
@@ -42,7 +42,7 @@ require 'protobuf/extend'
               @indent_level += 1
             end
           when /^message\s+(\w+)\s*\{$/
-            putswi "class #{$1} < Protobuf::Message"
+            putswi "class #{$1} < ::Protobuf::Message"
             @indent_level += 1
           when /^(required|optional|repeated)\s+(\w+(\.\w+)?)\s+(\w+)\s*=\s*(\d+)\s*(\[\s*default\s*=\s*(\w+)\s*\])?\s*;$/
             rule, type, name, tag, default = $1, $2, $4, $5, $7
@@ -53,26 +53,26 @@ require 'protobuf/extend'
             end
             putswi "#{rule} :#{type}, :#{name}, #{tag}#{default}"
           when /^enum\s+(\w+)\s*\{$/
-            putswi "class #{$1} < Protobuf::Enum"
+            putswi "class #{$1} < ::Protobuf::Enum"
             @indent_level += 1
           when /^(\w+)\s*=\s*(\w+)\s*;$/
             putswi "#{$1} = #{$2}"
           when /^extensions\s+(\w+)\s+to\s+(\w+)\s*;/
             low, high = $1, $2
-            low = 'Protobuf::Extend.MIN' if low == 'min'
-            high = 'Protobuf::Extend.MAX' if high == 'max'
+            low = '::Protobuf::Extend.MIN' if low == 'min'
+            high = '::Protobuf::Extend.MAX' if high == 'max'
             putswi "extensions #{min}..#{max}"
           when /^extend\s+(\w+)\s*\{/
-            putswi "class #{$1} < Protobuf::Extend"
+            putswi "class #{$1} < ::Protobuf::Extend"
             @indent_level += 1
           when /^service\s+(\w+)\s*\{/
-            putswi "class #{$1} < Protobuf::Service"
+            putswi "class #{$1} < ::Protobuf::Service"
             @indent_level += 1
           when /^rpc\s+(\w+)\s+\(\s*(\w+)\s*\)\s+returns\s+\(\s*(\w+)\s*\)\s*;/
             putswi "rpc :#{$1} => :#{$2}, :#{$3} => :#{$4}"
           when /^option\s+(\w+)\s*=\s*(.+)\s*;/
-            putswi "Protobuf::OPTIONS[:#{$1}] = :#{$2}"
-          when /^\}$/
+            putswi "::Protobuf::OPTIONS[:#{$1}] = :#{$2}"
+          when /^\}\s*;?$/
             @indent_level -= 1
             putswi "end"
           when ''

data/lib/protobuf/descriptor/descriptor.proto

@@ -0,0 +1,286 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.
+// http://code.google.com/p/protobuf/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+
+package google.protobuf;
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DescriptorProtos";
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+option optimize_for = SPEED;
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+  optional string name = 1;       // file name, relative to root of source tree
+  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
+
+  // Names of files imported by this file.
+  repeated string dependency = 3;
+
+  // All top-level definitions in this file.
+  repeated DescriptorProto message_type = 4;
+  repeated EnumDescriptorProto enum_type = 5;
+  repeated ServiceDescriptorProto service = 6;
+  repeated FieldDescriptorProto extension = 7;
+
+  optional FileOptions options = 8;
+}
+
+// Describes a message type.
+message DescriptorProto {
+  optional string name = 1;
+
+  repeated FieldDescriptorProto field = 2;
+  repeated FieldDescriptorProto extension = 6;
+
+  repeated DescriptorProto nested_type = 3;
+  repeated EnumDescriptorProto enum_type = 4;
+
+  message ExtensionRange {
+    optional int32 start = 1;
+    optional int32 end = 2;
+  }
+  repeated ExtensionRange extension_range = 5;
+
+  optional MessageOptions options = 7;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+  enum 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.
+  };
+
+  enum Label {
+    // 0 is reserved for errors
+    LABEL_OPTIONAL      = 1;
+    LABEL_REQUIRED      = 2;
+    LABEL_REPEATED      = 3;
+    // TODO(sanjay): Should we add LABEL_MAP?
+  };
+
+  optional string name = 1;
+  optional int32 number = 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 string type_name = 6;
+
+  // For extensions, this is the name of the type being extended.  It is
+  // resolved in the same manner as type_name.
+  optional string extendee = 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.
+  // TODO(kenton):  Base-64 encode?
+  optional string default_value = 7;
+
+  optional FieldOptions options = 8;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  optional EnumOptions options = 3;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+  optional string name = 1;
+  repeated MethodDescriptorProto method = 2;
+
+  optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+message MethodDescriptorProto {
+  optional string name = 1;
+
+  // Input and output type names.  These are resolved in the same way as
+  // FieldDescriptorProto.type_name, but must refer to a message type.
+  optional string input_type = 2;
+  optional string output_type = 3;
+
+  optional MethodOptions options = 4;
+}
+
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached.  These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+
+// TODO(kenton):  Allow extensions to options.
+
+message FileOptions {
+
+  // Sets the Java package where classes generated from this .proto will be
+  // placed.  By default, the proto package is used, but this is often
+  // inappropriate because proto packages do not normally start with backwards
+  // domain names.
+  optional string java_package = 1;
+
+
+  // If set, all the classes from the .proto file are wrapped in a single
+  // outer class with the given name.  This applies to both Proto1
+  // (equivalent to the old "--one_java_file" option) and Proto2 (where
+  // a .proto always translates to a single class, but you may want to
+  // explicitly choose the class name).
+  optional string java_outer_classname = 8;
+
+  // If set true, then the Java code generator will generate a separate .java
+  // file for each top-level message, enum, and service defined in the .proto
+  // file.  Thus, these types will *not* be nested inside the outer class
+  // named by java_outer_classname.  However, the outer class will still be
+  // generated to contain the file's getDescriptor() method as well as any
+  // top-level extensions defined in the file.
+  optional bool java_multiple_files = 10 [default=false];
+
+  // Generated classes can be optimized for speed or code size.
+  enum OptimizeMode {
+    SPEED = 1;      // Generate complete code for parsing, serialization, etc.
+    CODE_SIZE = 2;  // Use ReflectionOps to implement these methods.
+  }
+  optional OptimizeMode optimize_for = 9 [default=CODE_SIZE];
+}
+
+message MessageOptions {
+  // Set true to use the old proto1 MessageSet wire format for extensions.
+  // This is provided for backwards-compatibility with the MessageSet wire
+  // format.  You should not use this for any other reason:  It's less
+  // efficient, has fewer features, and is more complicated.
+  //
+  // The message must be defined exactly as follows:
+  //   message Foo {
+  //     option message_set_wire_format = true;
+  //     extensions 4 to max;
+  //   }
+  // Note that the message cannot have any defined fields; MessageSets only
+  // have extensions.
+  //
+  // All extensions of your type must be singular messages; e.g. they cannot
+  // be int32s, enums, or repeated messages.
+  //
+  // Because this is an option, the above two restrictions are not enforced by
+  // the protocol compiler.
+  optional bool message_set_wire_format = 1 [default=false];
+}
+
+message FieldOptions {
+  // The ctype option instructs the C++ code generator to use a different
+  // representation of the field than it normally would.  See the specific
+  // options below.  This option is not yet implemented in the open source
+  // release -- sorry, we'll try to include it in a future version!
+  optional CType ctype = 1;
+  enum CType {
+    CORD = 1;
+
+    STRING_PIECE = 2;
+  }
+
+  // EXPERIMENTAL.  DO NOT USE.
+  // For "map" fields, the name of the field in the enclosed type that
+  // is the key for this map.  For example, suppose we have:
+  //   message Item {
+  //     required string name = 1;
+  //     required string value = 2;
+  //   }
+  //   message Config {
+  //     repeated Item items = 1 [experimental_map_key="name"];
+  //   }
+  // In this situation, the map key for Item will be set to "name".
+  // TODO: Fully-implement this, then remove the "experimental_" prefix.
+  optional string experimental_map_key = 9;
+}
+
+message EnumOptions {
+}
+
+message EnumValueOptions {
+}
+
+message ServiceOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+}
+
+message MethodOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+}

data/lib/protobuf/descriptor/descriptor.rb

@@ -0,0 +1,54 @@
+module Protobuf
+  module Descriptor
+    class Descriptor
+      def initialize(message_class)
+        @message_class = message_class
+      end
+
+      def proto_type
+        'Google::Protobuf::DescriptorProto'
+      end
+
+      def build(proto, opt={})
+        mod = opt[:module]
+        cls = mod.const_set proto.name, Class.new(@message_class)
+        proto.nested_type.each do |message_proto|
+          Protobuf::Message.descriptor.build message_proto, :module => cls
+        end
+        proto.enum_type.each do |enum_proto|
+          Protobuf::Enum.descriptor.build enum_proto, :module => cls
+        end
+        proto.field.each do |field_proto|
+          Protobuf::Field::BaseField.descriptor.build field_proto, :class => cls
+        end
+      end
+
+      def unbuild(parent_proto)
+        message_proto = Google::Protobuf::DescriptorProto.new
+        message_proto.name = @message_class.to_s.split('::').last
+        @message_class.fields.each do |tag, field|
+          field.descriptor.unbuild message_proto
+        end
+        ObjectSpace.each_object(Class) do |cls|
+          if innerclass? @message_class, cls
+            cls.descriptor.unbuild message_proto
+          end
+        end
+
+        case parent_proto
+        when Google::Protobuf::FileDescriptorProto
+          parent_proto.message_type << message_proto
+        when Google::Protobuf::DescriptorProto
+          parent_proto.nested_type << message_proto
+        else
+          raise TypeError.new(parent_proto.class.name)
+        end
+      end
+
+      def innerclass?(parent, child)
+        child.name =~ /::/ and child.name.split('::')[0..-2].join('::') == parent.name
+      end
+    end
+  end
+end
+