protobuf 1.0.0

data/lib/protobuf/compiler/template/rpc_bin.erb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require '<%= underscored_name %>'
+
+<%= module_name %>::<%= service_name %>.new(:Port => <%= default_port %>).start

data/lib/protobuf/compiler/template/rpc_client.erb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'protobuf/rpc/client'
+require '<%= required_file %>'
+
+# build request
+request = <%= message_module %>::<%= request %>.new
+# TODO: setup a request
+raise StandardError, 'setup a request'
+
+# create blunk response
+response = <%= message_module %>::<%= response %>.new
+
+# execute rpc
+Protobuf::Rpc::Client.new('localhost', <%= default_port %>).call :<%= underscore name %>, request, response
+
+# show response
+puts response
+

data/lib/protobuf/compiler/template/rpc_service.erb

@@ -0,0 +1,25 @@
+require 'protobuf/rpc/server'
+require 'protobuf/rpc/handler'
+require '<%= required_file %>'
+
+<%- rpcs.each do |name, request, response| -%>
+class <%= module_name %>::<%= name %>Handler < Protobuf::Rpc::Handler
+  request <%= module_name %>::<%= request %>
+  response <%= module_name %>::<%= response %>
+
+  def self.process_request(request, response)
+    # TODO: edit this method
+  end
+end
+
+<%- end -%>
+class <%= module_name %>::<%= service_name %> < Protobuf::Rpc::Server
+  def setup_handlers
+    @handlers = {
+      <%- rpcs.each do |name, | -%>
+      :<%= underscore name %> => <%= module_name %>::<%= name %>Handler,
+      <%- end -%>
+    }
+  end
+end
+

data/lib/protobuf/compiler/template/rpc_service_implementation.erb

@@ -0,0 +1,42 @@
+<%-
+module_array = module_name.split('::')
+class_indent = '	'*(module_array.size)
+-%>
+require 'protobuf/rpc/service'
+require '<%= required_file %>'
+
+##	!! DO NOT EDIT THIS FILE !!
+## 
+##	To implement this service as defined by the protobuf, simply
+##	reopen <%= module_name %>::<%= service_name %> and implement each service method:
+## 
+<%- module_array.each_with_index do |m, i| -%>
+## <%= "#{"\t"*i}module #{m}" %>
+<%- end -%>
+## <%= class_indent %>class <%= service_name %>
+## <%= class_indent %>
+<%- rpcs.each do |name, request, response| -%>
+## <%= class_indent %>	# request -> <%= module_name %>::<%= request %>
+## <%= class_indent %>	# response -> <%= module_name %>::<%= response %>
+## <%= class_indent %>	def <%= underscore name %>
+## <%= class_indent %>		# TODO: implement <%= underscore name %>
+## <%= class_indent %>	end
+## <%= class_indent %>
+<%- end -%>
+## <%= class_indent %>end
+<%- (module_array.size-1).downto(0) do |i| -%>
+## <%= "#{"\t"*i}end" %>
+<%- end -%>
+##
+
+<%- module_array.each_with_index do |m, i| -%>
+<%= "#{"\t"*i}module #{m}" %>
+<%- end -%>
+<%= class_indent %>class <%= service_name %> < Protobuf::Rpc::Service
+<%- rpcs.each do |name, request, response| -%>
+<%= class_indent %>  rpc :<%= underscore name %>, <%= request %>, <%= response %>
+<%- end -%>
+<%= class_indent %>end
+<%- (module_array.size-1).downto(0) do |i| -%>
+<%= "#{"\t"*i}end" %>
+<%- end -%>

data/lib/protobuf/compiler/visitors.rb

@@ -0,0 +1,302 @@
+require 'erb'
+require 'fileutils'
+require 'protobuf/descriptor/descriptor_proto'
+
+module Protobuf
+  module Visitor
+    class Base
+      attr_reader :silent
+
+      def create_file_with_backup(filename, contents, executable=false)
+        if File.exist?(filename)
+          if File.read(filename) == contents
+            # do nothing
+            return
+          else
+            backup_filename = "#{filename}.#{Time.now.to_i}"
+            log_writing("#{backup_filename}", "backingup...")
+            FileUtils.copy(filename, backup_filename)
+          end
+        end
+
+        FileUtils.mkpath(File.dirname(filename))
+        File.open(filename, 'w') do |file|
+          log_writing(filename)
+          file.write(contents)
+        end
+        FileUtils.chmod(0755, filename) if executable
+      end
+
+      def log_writing(filename, message="wrote")
+        puts "#{message} #{filename}" unless silent
+      end
+    end
+
+    class CreateMessageVisitor < Base
+      attr_accessor :package, :indent, :context, :attach_proto, :proto_file
+
+      def initialize(proto_file=nil, proto_dir='.', out_dir='.')
+        @proto_dir, @out_dir = proto_dir, out_dir
+        @indent = 0
+        @context = []
+        @attach_proto = false
+        @proto_file = proto_file
+      end
+
+      def attach_proto?
+        @attach_proto
+      end
+
+      def commented_proto_contents
+        if proto_file
+          proto_filepath = if File.exist?(proto_file)
+                           then proto_file
+                           else "#{@proto_dir}/#{proto_file}"
+                           end
+          File.read(proto_filepath).gsub(/^/, '# ')
+        end
+      end
+
+      def write(str)
+        ruby << "#{'  ' * @indent}#{str}"
+      end
+
+      def increment
+        @indent += 1
+      end
+
+      def decrement
+        @indent -= 1
+      end
+
+      def close_ruby
+        while 0 < indent
+          decrement
+          write('end')
+        end
+      end
+
+      def ruby
+        @ruby ||= []
+      end
+
+      def to_s
+        @ruby.join("\n")
+      end
+
+      def in_context(klass, &block)
+        increment
+        context.push klass
+        block.call
+        context.pop
+        decrement
+      end
+
+      def visit(node)
+        node.accept_message_visitor(self)
+        self
+      end
+
+      def required_message_from_proto(proto_file)
+        rb_path = [
+          proto_file.sub(/\.proto\z/, '.pb.rb')
+        ].join('/').gsub(/\/{2,}/, '/')
+        
+        unless File.exist?(rb_path)
+          Compiler.compile(proto_file, @proto_dir, @out_dir)
+        end
+        
+        rb_path.sub(/\.rb$/, '')
+      end
+
+      def create_files(filename, out_dir, file_create)
+        begin
+          $: << File.expand_path(out_dir)
+          Class.new.class_eval(to_s) # check the message
+          $:.delete File.expand_path(out_dir)
+        rescue LoadError
+          puts "Error creating file #{filename}"
+          puts $!.message
+          exit 1
+        end
+        
+        file = File.basename(filename)
+        message_module = Util.module_to_path(package.map{|p| p.to_s.capitalize}.join('::'))
+        filename = "#{out_dir}/#{message_module}/#{file}"
+        
+        if file_create
+          log_writing(filename)
+          FileUtils.mkpath(File.dirname(filename))
+          File.open(filename, 'w') {|file| file.write(to_s) }
+        else
+          to_s
+        end
+      end
+    end
+
+    class CreateRpcVisitor < Base
+      attr_accessor :package, :services, :current_service, :file_contents
+
+      def initialize
+        @services = {}
+        @create_file = true
+        @file_contents = {}
+      end
+
+      def visit(node)
+        node.accept_rpc_visitor(self)
+        self
+      end
+
+      def add_rpc(name, request, response)
+        (@services[@current_service] ||= []) << [name, Util.moduleize(request), Util.moduleize(response)]
+      end
+
+      def create_files(message_file, out_dir, create_file=true)
+        @create_file = create_file
+        default_port = 9999
+        @services.each do |service_name, rpcs|
+          underscored_name = underscore service_name.to_s
+          message_module = package.map{|p| p.to_s.capitalize}.join('::')
+          required_file = [
+            Util.module_to_path(message_module),
+            File.basename(message_file.sub(/^\.\//, '').sub(/\.rb$/, ''))
+          ].join('/').gsub(/\/{2,}/, '/')
+
+          create_service(message_file, out_dir, underscored_name, message_module, service_name, default_port, rpcs, required_file)
+        end
+        @file_contents
+      end
+
+      def create_bin(out_dir, underscored_name, module_name, service_name, default_port)
+        bin_filename = "#{out_dir}/bin/start_#{underscored_name}"
+        bin_contents = template_erb('rpc_bin').result(binding)
+        create_file_with_backup(bin_filename, bin_contents, true) if @create_file
+        @file_contents[bin_filename] = bin_contents
+      end
+
+      def create_service(message_file, out_dir, underscored_name, module_name, service_name, default_port, rpcs, required_file)
+        service_filename = "#{out_dir}/#{Util.module_to_path(module_name)}/#{underscored_name}.rb"
+        service_contents = template_erb('rpc_service_implementation').result(binding)
+        create_file_with_backup(service_filename, service_contents) if @create_file
+        @file_contents[service_filename] = service_contents
+      end
+
+      def create_client(out_dir, underscored_name, default_port, name, request, response, message_module, required_file)
+        client_filename = "#{out_dir}/clients/#{Util.module_to_path(message_module)}_client_#{underscore name}.rb"
+        client_contents = template_erb('rpc_client').result binding
+        create_file_with_backup(client_filename, client_contents, true) if @create_file
+        @file_contents[client_filename] = client_contents
+      end
+
+      private
+
+      def underscore(str)
+        str.to_s.gsub(/\B[A-Z]/, '_\&').downcase
+      end
+
+      def template_erb(template)
+        ERB.new(File.read("#{File.dirname(__FILE__)}/template/#{template}.erb"), nil, '-')
+      end
+    end
+
+    class CreateDescriptorVisitor < Base
+      attr_reader :file_descriptor
+      attr_accessor :filename
+
+      def initialize(filename=nil)
+        @context = []
+        @filename = filename
+      end
+
+      def visit(node)
+        node.accept_descriptor_visitor(self)
+        self
+      end
+
+      def in_context(descriptor, &block)
+        @context.push descriptor
+        block.call
+        @context.pop
+      end
+
+      def current_descriptor
+        @context.last
+      end
+
+      def file_descriptor=(descriptor)
+       @file_descriptor = descriptor
+       @file_descriptor.name = @filename
+      end
+
+      def add_option(name, value)
+        options =
+          case current_descriptor
+          when Google::Protobuf::FileDescriptorProto
+            Google::Protobuf::FileOptions.new
+          when Google::Protobuf::DescriptorProto
+            Google::Protobuf::MessageOptions.new
+          when Google::Protobuf::FieldDescriptorProto
+            Google::Protobuf::FieldOptions.new
+          when Google::Protobuf::EnumDescriptorProto
+            Google::Protobuf::EnumOptions.new
+          when Google::Protobuf::EnumValueDescriptorProto
+            Google::Protobuf::EnumValueOptions.new
+          when Google::Protobuf::ServiceDescriptorProto
+            Google::Protobuf::ServiceOptions.new
+          when Google::Protobuf::MethodDescriptorProto
+            Google::Protobuf::MethodOptions.new
+          else
+            raise ArgumentError, 'Invalid context'
+          end
+        #TODO how should options be handled?
+        #current_descriptor.options << option
+      end
+
+      def descriptor=(descriptor)
+        case current_descriptor
+        when Google::Protobuf::FileDescriptorProto
+          current_descriptor.message_type << descriptor
+        when Google::Protobuf::DescriptorProto
+          current_descriptor.nested_type << descriptor
+        else
+          raise ArgumentError, 'Invalid context'
+        end
+      end
+      alias message_descriptor= descriptor=
+
+      def enum_descriptor=(descriptor)
+        current_descriptor.enum_type << descriptor
+      end
+
+      def enum_value_descriptor=(descriptor)
+        current_descriptor.value << descriptor
+      end
+
+      def service_descriptor=(descriptor)
+        current_descriptor.service << descriptor
+      end
+
+      def method_descriptor=(descriptor)
+        current_descriptor.method << descriptor
+      end
+
+      def field_descriptor=(descriptor)
+        case current_descriptor
+        when Google::Protobuf::FileDescriptorProto
+          current_descriptor.extension << descriptor
+        when Google::Protobuf::DescriptorProto
+          current_descriptor.field << descriptor
+          #TODO: how should i distiguish between field and extension
+          #current_descriptor.extension << descriptor
+        else
+          raise ArgumentError, 'Invalid context'
+        end
+      end
+
+      def extension_range_descriptor=(descriptor)
+        current_descriptor.extension_range << descriptor
+      end
+    end
+  end
+end

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.
+}