protobuf 1.0.0

data/examples/addressbook.proto

@@ -0,0 +1,24 @@
+package tutorial;
+
+message Person {
+  required string name = 1;
+  required int32 id = 2;
+  optional string email = 3;
+
+  enum PhoneType {
+    MOBILE = 0;
+    HOME = 1;
+    WORK = 2;
+  }
+
+  message PhoneNumber {
+    required string number = 1;
+    optional PhoneType type = 2 [default = HOME];
+  }
+
+  repeated PhoneNumber phone = 4;
+}
+
+message AddressBook {
+  repeated Person person = 1;
+}

data/examples/reading_a_message.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'addressbook.pb'
+
+def list_people(address_book)
+  address_book.person.each do |person|
+    puts "Person ID: #{person.id}"
+    puts "  Name: #{person.name}"
+    puts "  E-mail: #{person.email}" unless person.email.empty?
+    person.phone.each do |phone_number|
+      print(case phone_number.type
+            when Tutorial::Person::PhoneType::MOBILE
+              '  Mobile phone #: '
+            when Tutorial::Person::PhoneType::HOME
+              '  Home phone #: '
+            when Tutorial::Person::PhoneType::WORK
+              '  Work phone #: '
+            end)
+      puts phone_number.number
+    end
+  end
+end
+
+unless ARGV.size == 1
+  puts "Usage: #{$0} ADDRESS_BOOK_FILE"
+  exit
+end
+
+address_book = Tutorial::AddressBook.new
+address_book.parse_from_file ARGV[0]
+
+list_people address_book

data/examples/writing_a_message.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require 'addressbook.pb'
+
+def prompt_for_address(person)
+  print 'Enter person ID number: '
+  person.id = STDIN.gets.strip.to_i
+  print 'Enter name: '
+  person.name = STDIN.gets.strip
+  print 'Enter email address (blank for none): '
+  email = STDIN.gets.strip
+  person.email = email unless email.empty?
+
+  loop do
+    print 'Enter a phone number (or leave blank to finish): '
+    break if (number = STDIN.gets.strip).empty?
+
+    person.phone << Tutorial::Person::PhoneNumber.new
+    person.phone.last.number = number
+
+    print 'Is this a mobile, home, or work phone? '
+    person.phone.last.type = 
+      case type = STDIN.gets.strip
+      when 'mobile'
+        Tutorial::Person::PhoneType::MOBILE
+      when 'home'
+        Tutorial::Person::PhoneType::HOME
+      when 'work'
+        Tutorial::Person::PhoneType::WORK
+      else
+        puts 'Unknown phone type; leaving as default value.'
+        nil
+      end
+  end
+end
+
+unless ARGV.size == 1
+  puts "Usage: #{$0} ADDRESS_BOOK_FILE" 
+  exit
+end
+
+address_book = Tutorial::AddressBook.new
+address_book.parse_from_file ARGV[0] if File.exist? ARGV[0]
+address_book.person << Tutorial::Person.new
+prompt_for_address address_book.person.last
+address_book.serialize_to_file ARGV[0]

data/lib/protobuf.rb

@@ -0,0 +1,6 @@
+module Protobuf
+end
+
+require 'protobuf/rpc/client'
+require 'protobuf/rpc/server'
+require 'protobuf/rpc/service'

data/lib/protobuf/common/exceptions.rb

@@ -0,0 +1,11 @@
+module Protobuf
+
+  class Error < StandardError; end
+
+  class InvalidWireType < Error; end
+
+  class NotInitializedError < Error; end
+
+  class TagCollisionError < Error; end
+
+end

data/lib/protobuf/common/logger.rb

@@ -0,0 +1,64 @@
+require 'logger'
+
+module Protobuf
+  class Logger < ::Logger
+    
+    class << self
+      attr_accessor :file, :level
+      
+      # One-line file/level configuration
+      def configure options
+        self.file = options[:file] if options[:file]
+        self.level = options[:level] if options[:level]
+      end
+      
+      def configured?
+        ! instance.nil?
+      end
+      
+      # Use to reset the instance
+      def reset_device!
+        self.file = self.level = @__instance = nil
+      end
+      
+      # Singleton instance
+      def instance
+        @__instance ||= begin
+          log = nil
+          if @file and @level
+            log = new(self.file)
+            log.level = self.level
+          end
+          log
+        end
+      end
+      
+      # Stub out the log methods for Protobuf::Logger as singleton methods
+      [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
+        define_method(m) do |*params, &block|
+          instance && instance.__send__(m, *params, &block)
+        end
+      end
+    end
+    
+    # 
+    # LogMethods module for log method including, e.g.:
+    # 
+    # class MyClass
+    #   include Protobuf::Logger::LogMethods
+    #   ...
+    # end
+    # 
+    # Produce a module to allow "include" in other classes to avoid
+    # cluttering the namespace of the including class with the other methods defined above
+    # 
+    module LogMethods
+      [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
+        define_method("log_#{m}") do |*params, &block|
+          Protobuf::Logger.__send__(m, *params, &block)
+        end
+      end
+    end
+    
+  end
+end

data/lib/protobuf/common/util.rb

@@ -0,0 +1,59 @@
+module Protobuf
+  module Util
+    module_function
+
+    # Takes a string or symbol and camelizes it:
+    # Expects: some_long_name
+    # Returns: SomeLongName
+    def camelize(str)
+      if (str.is_a? Array)
+        str.map{|p| camelize(p.to_s) }.join('::')
+      else
+        str.to_s.gsub(/(?:\A|_)(\w)/) { $1.upcase }
+      end
+    end
+
+    # Expects: SomeLongName
+    # Returns: some_long_name
+    def underscore(str)
+      str.to_s.gsub(/\B[A-Z]/, '_\&').downcase
+    end
+  
+    # Expects: SomeModule::Path
+    # Returns: some_module/path
+    def module_to_path(str)
+      pkg = str.to_s.split('::')
+      pkg.map{|e| underscore(e) }.join('/')
+    end
+  
+    # Expects: PackageA.PackageB
+    # Returns: package_a/package_b
+    def package_to_path(str)
+      str.to_s.split('.').map{|e| underscore(e) }.join('/')
+    end
+  
+    # Takes a class constant and converts it to a string resembling a java package path
+    # Expects: ModA::ModB::MyService
+    # Returns: mod_a.mod_b.MyService
+    def packagize(klass)
+      klass = klass.to_s.split('::') unless klass.is_a? Array
+      klass_name = klass.pop
+      klass.map{|e| underscore(e) }.join('.') + ".#{klass_name}"
+    end
+  
+    # The reverse of packagize. Takes a string resembling a java package path
+    # and converts it into a module constant
+    # Expects: mod_a.mod_b.MyService
+    # Returns: ModA::ModB::MyService
+    def moduleize(str)
+      str = str.join('.') if str.is_a? Array
+      str.split('.').map{|e| camelize(e) }.join('::')
+    end
+  
+    def constantize(klass)
+      constants = moduleize(klass).split('::')
+      constants.inject(Module.const_get(constants.shift)) {|const, obj| const.const_get(obj) }
+    end
+  
+  end
+end

data/lib/protobuf/common/wire_type.rb

@@ -0,0 +1,10 @@
+module Protobuf
+  module WireType
+    VARINT           = 0
+    FIXED64          = 1
+    LENGTH_DELIMITED = 2
+    START_GROUP      = 3
+    END_GROUP        = 4
+    FIXED32          = 5
+  end
+end

data/lib/protobuf/compiler/compiler.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'protobuf/compiler/proto_parser'
+require 'protobuf/compiler/nodes'
+require 'protobuf/compiler/visitors'
+
+module Protobuf
+  class Compiler
+    def self.compile(proto_file, proto_dir='.', out_dir='.', file_create=true)
+      self.new.compile(proto_file, proto_dir, out_dir, file_create)
+    end
+
+    def compile(proto_file, proto_dir='.', out_dir='.', file_create=true)
+      create_message(proto_file, proto_dir, out_dir, file_create)
+      create_rpc(proto_file, proto_dir, out_dir, file_create)
+    end
+
+    def create_message(proto_file, proto_dir='.', out_dir='.', file_create=true)
+      rb_file = File.join(out_dir, File.basename(proto_file).sub(/\.[^\0]*\z/, '') + '.pb.rb')
+      proto_path = validate_existence(proto_file, proto_dir)
+
+      message_visitor = Visitor::CreateMessageVisitor.new(proto_file, proto_dir, out_dir)
+      File.open(proto_path) do |file|
+        message_visitor.visit(ProtoParser.new.parse(file))
+      end
+      message_visitor.create_files(rb_file, out_dir, file_create)
+    end
+
+    def create_rpc(proto_file, proto_dir='.', out_dir='.', file_create=true)
+      message_file = File.join(out_dir, File.basename(proto_file).sub(/\.[^\0]*\z/, '') + '.pb.rb')
+      proto_path = validate_existence(proto_file, proto_dir)
+
+      rpc_visitor = Visitor::CreateRpcVisitor.new
+      File.open(proto_path) do |file|
+        rpc_visitor.visit(ProtoParser.new.parse(file))
+      end
+      rpc_visitor.create_files(message_file, out_dir, file_create)
+    end
+
+    def validate_existence(path, base_dir)
+      if File.exist?(path)
+        path
+      else
+        newpath = File.join(base_dir, path)
+        if File.exist?(newpath)
+          newpath
+        else
+          raise ArgumentError, "File does not exist: #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/compiler/nodes.rb

@@ -0,0 +1,323 @@
+require 'protobuf/common/util'
+require 'protobuf/descriptor/descriptor_proto'
+
+module Protobuf
+  module Node
+    class Base
+      def define_in_the_file(visitor)
+        visitor.write("defined_in __FILE__") if visitor.attach_proto?
+      end
+
+      def accept_message_visitor(visitor)
+      end
+
+      def accept_rpc_visitor(vistor)
+      end
+
+      def accept_descriptor_visitor(visitor)
+      end
+    end
+
+    class ProtoNode < Base
+      attr_reader :children
+
+      def initialize(children)
+        @children = children || []
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write('### Generated by rprotoc. DO NOT EDIT!')
+        visitor.write("### <proto file: #{visitor.proto_file}>") if visitor.attach_proto?
+        visitor.write(visitor.commented_proto_contents) if visitor.attach_proto?
+        visitor.write(<<-EOS)
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/extend'
+        EOS
+        @children.each {|child| child.accept_message_visitor(visitor) }
+        visitor.close_ruby
+      end
+
+      def accept_rpc_visitor(visitor)
+        @children.each {|child| child.accept_rpc_visitor(visitor) }
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::FileDescriptorProto.new(:name => visitor.filename)
+        visitor.file_descriptor = descriptor
+        visitor.in_context(descriptor) do
+          @children.each {|child| child.accept_descriptor_visitor(visitor) }
+        end
+      end
+    end
+
+    class ImportNode < Base
+      def initialize(path)
+        @path = path
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write("require '#{visitor.required_message_from_proto(@path)}'")
+      end
+
+      def accept_descriptor_visitor(visitor)
+        visitor.current_descriptor.dependency << @path
+      end
+    end
+
+    class PackageNode < Base
+      def initialize(path_list)
+        @path_list = path_list
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.package = @path_list.dup
+        @path_list.each do |path|
+          visitor.write("module #{Util.camelize(path)}")
+          visitor.increment
+        end
+      end
+
+      def accept_rpc_visitor(visitor)
+        visitor.package = @path_list.dup
+      end
+
+      def accept_descriptor_visitor(visitor)
+        visitor.current_descriptor.package = @path_list.join('.')
+      end
+    end
+
+    class OptionNode < Base
+      def initialize(name_list, value)
+        @name_list, @value = name_list, value
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write("::Protobuf::OPTIONS[:#{@name_list.join('.').inspect}] = #{@value.inspect}")
+      end
+
+      def accept_descriptor_visitor(visitor)
+        visitor.add_option(@name_list.join('.'), @value)
+      end
+    end
+
+    class MessageNode < Base
+      def initialize(name, children)
+        @name, @children = name, children
+      end
+
+      def accept_message_visitor(visitor)
+        class_name = @name.to_s
+        class_name.gsub!(/\A[a-z]/) {|c| c.upcase}
+        visitor.write("class #{class_name} < ::Protobuf::Message")
+        visitor.in_context(self.class) do
+          define_in_the_file(visitor)
+          @children.each {|child| child.accept_message_visitor(visitor) }
+        end
+        visitor.write('end')
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::DescriptorProto.new(:name => @name.to_s)
+        visitor.descriptor = descriptor
+        visitor.in_context(descriptor) do
+          @children.each {|child| child.accept_descriptor_visitor(visitor) }
+        end
+      end
+    end
+
+    class ExtendNode < Base
+      def initialize(name, children)
+        @name, @children = name, children
+      end
+
+      def accept_message_visitor(visitor)
+        name = @name.is_a?(Array) ? @name.join : name.to_s
+        visitor.write("class #{name} < ::Protobuf::Message")
+        visitor.in_context(self.class) do
+          define_in_the_file(visitor)
+          @children.each {|child| child.accept_message_visitor(visitor) }
+        end
+        visitor.write('end')
+      end
+
+      def accept_descriptor_visitor(visitor)
+        # TODO: how should i handle this?
+      end
+    end
+
+    class EnumNode < Base
+      def initialize(name, children)
+        @name, @children = name, children
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write("class #{@name} < ::Protobuf::Enum")
+        visitor.in_context(self.class) do
+          define_in_the_file(visitor)
+          @children.each {|child| child.accept_message_visitor(visitor) }
+        end
+        visitor.write('end')
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::EnumDescriptorProto.new(:name => @name.to_s)
+        visitor.enum_descriptor = descriptor
+        visitor.in_context(descriptor) do
+          @children.each {|child| child.accept_descriptor_visitor(visitor) }
+        end
+      end
+    end
+
+    class EnumFieldNode < Base
+      def initialize(name, value)
+        @name, @value = name, value
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write("define :#{@name}, #{@value}")
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::EnumValueDescriptorProto.new(:name => @name.to_s, :number => @value)
+        visitor.enum_value_descriptor = descriptor
+      end
+    end
+
+    class ServiceNode < Base
+      def initialize(name, children)
+        @name, @children = name, children
+      end
+
+      def accept_message_visitor(visitor)
+        # do nothing
+      end
+
+      def accept_rpc_visitor(visitor)
+        visitor.current_service = @name
+        @children.each {|child| child.accept_rpc_visitor(visitor) }
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::ServiceDescriptorProto.new(:name => @name.to_s)
+        visitor.service_descriptor = descriptor
+        visitor.in_context(descriptor) do
+          @children.each {|child| child.accept_descriptor_visitor(visitor) }
+        end
+      end
+    end
+
+    class RpcNode < Base
+      def initialize(name, request, response)
+        @name, @request, @response = name, request, response
+      end
+
+      def accept_message_visitor(visitor)
+        # do nothing
+      end
+
+      def accept_rpc_visitor(visitor)
+        visitor.add_rpc(@name, @request, @response)
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::MethodDescriptorProto.new(:name => @name.to_s, :input_type => @request.to_s, :output_type => @response.to_s)
+        visitor.method_descriptor = descriptor
+      end
+    end
+
+    class GroupNode < Base
+      def initialize(label, name, value, children)
+        @label, @name, @value, @children = label, name, value, children
+      end
+
+      def accept_message_visitor(visitor)
+        raise NotImplementedError
+      end
+
+      def accept_descriptor_visitor(visitor)
+        raise NotImplementedError
+      end
+    end
+
+    class FieldNode < Base
+      def initialize(label, type, name, value, opts={})
+        @label, @type, @name, @value, @opts = label, type, name, value, opts
+      end
+
+      def accept_message_visitor(visitor)
+        opts = @opts.empty? ? '' : ", #{@opts.map{|k, v| ":#{k} => #{v.inspect}" }.join(', ')}"
+        if visitor.context.first == ExtendNode
+          opts << ', :extension => true'
+        end
+        type = if @type.is_a?(Array)
+               then (@type.size > 1) ? "'#{@type.map{|e| Util.camelize(e) }.join('::')}'" : @type[0]
+               else @type
+               end
+        visitor.write("#{@label} :#{type}, :#{@name}, #{@value}#{opts}")
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::FieldDescriptorProto.new(:name => @name.to_s, :number => @value)
+        descriptor.label = Google::Protobuf::FieldDescriptorProto::Label.const_get("LABEL_#{@label.to_s.upcase}")
+        descriptor.type = Google::Protobuf::FieldDescriptorProto::Type.const_get("TYPE_#{@type.to_s.upcase}") if predefined_type?
+        descriptor.type_name = @type.is_a?(Array) ? @type.join : @type.to_s
+        @opts.each do |key, val|
+          case key.to_sym
+          when :default
+            descriptor.default_value = val.to_s
+          end
+        end
+        visitor.field_descriptor = descriptor
+      end
+
+      private
+
+      def predefined_type?
+        # TODO: constantize
+        %w{double float int64 uint64 int32 fixed64 fixed32 bool string group message bytes uint32 enum sfixed32 sfixed64 sint32 sint64}.include?(@type.to_s)
+      end
+    end
+
+    class ExtensionsNode < Base
+      def initialize(range)
+        @range = range
+      end
+
+      def accept_message_visitor(visitor)
+        visitor.write("extensions #{@range.first.to_s}")
+      end
+
+      def accept_descriptor_visitor(visitor)
+        descriptor = Google::Protobuf::DescriptorProto::ExtensionRange.new(:start => @range.first.low)
+        case @range.first.high
+        when NilClass then # ignore
+        when :max     then descriptor.end = 1
+        else               descriptor.end = @range.first.high
+        end
+        visitor.extension_range_descriptor = descriptor
+      end
+    end
+
+    class ExtensionRangeNode < Base
+      attr_reader :low, :high
+
+      def initialize(low, high=nil)
+        @low, @high = low, high
+      end
+
+      #def accept_message_visitor(visitor)
+      #end
+
+      def to_s
+        if @high.nil?
+          @low.to_s
+        elsif @high == :max
+          "#{@low}..::Protobuf::Extend::MAX"
+        else
+          "#{@low}..#{@high}"
+        end
+      end
+    end
+  end
+end