ruby-protocol-buffers 1.4.1 → 1.5.0.beta1

data/README.md

@@ -143,6 +143,8 @@ end
 * imports
 * nested types
 * passing on unknown fields when re-serializing a message
+* groups
+* RPC stubbing
 
 ### Unsupported Features
 
@@ -152,8 +154,6 @@ end
 
 ### Probably Never to be Supported
 
-* RPC stubbing
-* deprecated protocol features (e.g. groups)
 * the unsupported options (java_*, optimize_for, message_set_wire_format, deprecated)
 
 ## Authors

data/lib/protocol_buffers.rb

@@ -13,3 +13,5 @@ end
 
 require 'protocol_buffers/version'
 require 'protocol_buffers/runtime/message'
+require 'protocol_buffers/runtime/enum'
+require 'protocol_buffers/runtime/service'

data/lib/protocol_buffers/compiler/file_descriptor_to_ruby.rb

@@ -36,10 +36,14 @@ HEADER
     @io.write("\n") unless descriptor.dependency.empty?
 
     in_namespace("module", @package_modules) do
-      declare(descriptor.message_type, descriptor.enum_type)
+      declare(descriptor.package, descriptor.message_type, descriptor.enum_type)
 
       descriptor.message_type.each do |message|
-        dump_message(message)
+        dump_message(descriptor.package, message)
+      end
+
+      descriptor.service.each do |service|
+        dump_service(descriptor.package, service)
       end
     end
     
@@ -47,7 +51,7 @@ HEADER
 
   protected
 
-  def declare(messages, enums)
+  def declare(package, messages, enums)
     return if messages.empty? && enums.empty?
 
     line %{# forward declarations}
@@ -61,7 +65,7 @@ HEADER
       line
       line %{# enums}
       enums.each do |enum|
-        dump_enum(enum)
+        dump_enum(package, enum)
       end
     end
   end
@@ -119,12 +123,16 @@ HEADER
     TYPE_SINT64 => ":sint64",
   }
 
-  def dump_message(message)
+  def dump_message(package, message)
     in_namespace("class", message.name, " < ::ProtocolBuffers::Message") do
-      declare(message.nested_type, message.enum_type)
+      fully_qualified_name = fully_qualified_name(package, message.name)
+      declare(fully_qualified_name, message.nested_type, message.enum_type)
+
+      line %{set_fully_qualified_name "#{fully_qualified_name}"}
+      line
 
       line %{# nested messages} unless message.nested_type.empty?
-      message.nested_type.each { |inner| dump_message(inner) }
+      message.nested_type.each { |inner| dump_message(fully_qualified_name, inner) }
 
       message.field.each do |field|
         typename = field_typename(field)
@@ -147,9 +155,14 @@ HEADER
     line
   end
 
-  def dump_enum(enum)
+  def dump_enum(package, enum)
     in_namespace("module", enum.name) do
       line %{include ::ProtocolBuffers::Enum}
+      line
+
+      line %{set_fully_qualified_name "#{fully_qualified_name(package, enum.name)}"}
+      line
+
       enum.value.each do |value|
         line %{#{capfirst(value.name)} = #{value.number}}
       end
@@ -157,8 +170,23 @@ HEADER
     line
   end
 
+  def dump_service(package, service)
+    in_namespace("class", service.name, " < ::ProtocolBuffers::Service") do
+      fully_qualified_name = fully_qualified_name(package, service.name)
+      line %{set_fully_qualified_name "#{fully_qualified_name}"}
+      line
+      service.method.each do |method|
+        line %{rpc :#{underscore(method.name)}, "#{method.name}", #{service_typename(method.input_type)}, #{service_typename(method.output_type)}}
+      end
+    end
+  end
+
   def field_typename(field)
-    TYPE_MAPPING[field.type] || field.type_name.split(".").map { |t| camelize(t) }.join("::")
+    TYPE_MAPPING[field.type] || service_typename(field.type_name)
+  end
+
+  def service_typename(type_name)
+    type_name.split(".").map { |t| camelize(t) }.join("::")
   end
 
   # TODO: this probably doesn't work for all default values, expand
@@ -176,6 +204,10 @@ HEADER
     end
   end
 
+  def fully_qualified_name(package, name)
+    package == nil || package.empty? ? name : "#{package}.#{name}"
+  end
+
   def capfirst(s)
     "#{s[0,1].capitalize}#{s[1..-1]}" if s
   end
@@ -184,4 +216,15 @@ HEADER
     lower_case_and_underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
   end
 
+  def underscore(camelized_word)
+    word = camelized_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/(?:([A-Za-z\d])|^)((?=\a)\b)(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
 end

data/lib/protocol_buffers/runtime/enum.rb

@@ -1,4 +1,36 @@
 module ProtocolBuffers
-  module Enum # :nodoc:
+  module Enum
+    def self.included(clazz)
+      clazz.extend(EnumClassMethods)
+    end
+  end
+
+  module EnumClassMethods
+    def set_fully_qualified_name(fully_qualified_name)
+      @fully_qualified_name = fully_qualified_name.dup.freeze
+    end
+
+    def fully_qualified_name
+      @fully_qualified_name
+    end
+
+    def value_to_names_map
+      @value_to_names_map ||= self.constants.inject(Hash.new) do |hash, constant|
+        # values do not have to be unique
+        value = self.const_get(constant)
+        hash[value] ||= Array.new
+        hash[value] << constant.to_sym
+        hash
+      end
+      @value_to_names_map
+    end
+
+    def name_to_value_map
+      @name_to_value_map ||= self.constants.inject(Hash.new) do |hash, constant|
+        hash[constant.to_sym] = self.const_get(constant)
+        hash
+      end
+      @name_to_value_map
+    end
   end
 end

data/lib/protocol_buffers/runtime/field.rb

@@ -151,26 +151,26 @@ module ProtocolBuffers
     def add_writer_to(klass)
       if repeated?
         klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{name}=(value)
-            if value.nil?
+          def #{name}=(__value)
+            if __value.nil?
               #{name}.clear
             else
               #{name}.clear
-              value.each { |i| @#{name}.push i }
+              __value.each { |i| @#{name}.push i }
             end
           end
         EOF
       else
         klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{name}=(value)
+          def #{name}=(__value)
             field = fields[#{tag}]
-            if value.nil?
+            if __value.nil?
               @set_fields[#{tag}] = false
               @#{name} = field.default_value
             else
-              field.check_valid(value)
+              field.check_valid(__value)
               @set_fields[#{tag}] = true
-              @#{name} = value
+              @#{name} = __value
               if @parent_for_notify
                 @parent_for_notify.default_changed(@tag_for_notify)
                 @parent_for_notify = @tag_for_notify = nil

data/lib/protocol_buffers/runtime/message.rb

@@ -257,6 +257,22 @@ module ProtocolBuffers
     end
     alias_method :to_s, :serialize_to_string
 
+    def to_hash
+      self.class.to_hash(self)
+    end
+
+    def self.to_hash(message)
+      return nil if message == nil
+      return message.is_a?(String) ? message.dup : message unless message.is_a?(::ProtocolBuffers::Message)
+      message.fields.select do |tag, field|
+        message.value_for_tag?(tag)
+      end.inject(Hash.new) do |hash, (tag, field)|
+        value = message.value_for_tag(tag)
+        hash[field.name] = value.is_a?(::ProtocolBuffers::RepeatedField) ? value.map { |elem| to_hash(elem) } : to_hash(value)
+        hash
+      end
+    end
+
     # Parse a Message of this class from the given IO/String. Since Protocol
     # Buffers are not length delimited, this will read until the end of the
     # stream.
@@ -447,6 +463,18 @@ module ProtocolBuffers
       end
     end
 
+    def self.set_fully_qualified_name(name)
+      @fully_qualified_name = name.dup.freeze
+    end
+
+    def self.fully_qualified_name
+      @fully_qualified_name
+    end
+
+    def fully_qualified_name
+      self.class.fully_qualified_name
+    end
+
     def valid?
       self.class.valid?(self)
     end

data/lib/protocol_buffers/runtime/rpc.rb

@@ -0,0 +1,23 @@
+module ProtocolBuffers
+  class Rpc
+    attr_reader :name, :proto_name, :request_class, :response_class, :service_class
+
+    def initialize(name, proto_name, request_class, response_class, service_class)
+      @name = name
+      @proto_name = proto_name.dup.freeze
+      @request_class = request_class
+      @response_class = response_class
+      @service_class = service_class
+    end
+
+    def to_s
+      {
+        :name => name,
+        :proto_name => proto_name,
+        :request_class_name => request_class.name,
+        :response_class_name => response_class.name,
+        :service_class_name => service_class.name
+      }.to_s
+    end
+  end
+end

data/lib/protocol_buffers/runtime/service.rb

@@ -1 +1,27 @@
-# TODO
+require 'protocol_buffers/runtime/rpc'
+
+module ProtocolBuffers
+  class Service
+
+    private_class_method :new
+
+    def self.set_fully_qualified_name(name)
+      @fully_qualified_name = name.dup.freeze
+    end
+
+    def self.fully_qualified_name
+      @fully_qualified_name
+    end
+
+    def self.rpcs
+      @rpcs
+    end
+
+    def self.rpc(name, proto_name, request_type, response_type)
+      @rpcs ||= Array.new
+      @rpcs = @rpcs.dup
+      @rpcs << Rpc.new(name.to_sym, proto_name, request_type, response_type, self).freeze
+      @rpcs.freeze
+    end
+  end
+end

data/lib/protocol_buffers/version.rb

@@ -1,3 +1,3 @@
 module ProtocolBuffers
-  VERSION = "1.4.1"
+  VERSION = "1.5.0.beta1"
 end

data/ruby-protocol-buffers.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.license       = 'BSD'
+
   gem.extra_rdoc_files << "Changelog.md"
 
   gem.add_development_dependency "autotest-standalone"

data/spec/proto_files/enums.pb.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Enums
+  # forward declarations
+  class FooMessage < ::ProtocolBuffers::Message; end
+
+  # enums
+  module FooEnum
+    include ::ProtocolBuffers::Enum
+
+    set_fully_qualified_name "enums.FooEnum"
+
+    ONE = 1
+    TWO = 2
+    THREE = 3
+  end
+
+  module BarEnum
+    include ::ProtocolBuffers::Enum
+
+    # purposefully removing qualified name to make sure that nothing breaks
+    #set_fully_qualified_name "enums.BarEnum"
+
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+  end
+
+  class FooMessage < ::ProtocolBuffers::Message
+    # forward declarations
+
+    # enums
+    module NestedFooEnum
+      include ::ProtocolBuffers::Enum
+
+      set_fully_qualified_name "enums.FooMessage.NestedFooEnum"
+
+      SEVEN = 7
+      EIGHT = 8
+    end
+
+    module NestedBarEnum
+      include ::ProtocolBuffers::Enum
+
+      # purposefully removing qualified name to make sure that nothing breaks
+      #set_fully_qualified_name "enums.FooMessage.NestedBarEnum"
+
+      NINE = 9
+      TEN = 10
+    end
+
+    set_fully_qualified_name "enums.FooMessage"
+
+    optional ::Enums::FooMessage::NestedFooEnum, :nested_foo_enum, 1
+    optional ::Enums::FooMessage::NestedBarEnum, :nested_bar_enum, 2
+  end
+
+end

data/spec/proto_files/enums.proto

@@ -0,0 +1,26 @@
+package enums;
+
+enum FooEnum {
+  ONE = 1;
+  TWO = 2;
+  THREE = 3;
+}
+
+enum BarEnum {
+  FOUR = 4;
+  FIVE = 5;
+  SIX = 6;
+}
+
+message FooMessage {
+  enum NestedFooEnum {
+    SEVEN = 7;
+    EIGHT = 8;
+  }
+  enum NestedBarEnum {
+    NINE = 9;
+    TEN = 10;
+  }
+  optional NestedFooEnum nested_foo_enum = 1;
+  optional NestedBarEnum nested_bar_enum = 2;
+}

data/spec/proto_files/no_package.pb.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+# forward declarations
+class A < ::ProtocolBuffers::Message; end
+class C < ::ProtocolBuffers::Message; end
+
+class A < ::ProtocolBuffers::Message
+  # forward declarations
+  class B < ::ProtocolBuffers::Message; end
+
+  set_fully_qualified_name "A"
+
+  # nested messages
+  class B < ::ProtocolBuffers::Message
+    set_fully_qualified_name "A.B"
+
+  end
+
+  optional ::A::B, :b, 1
+end
+
+class C < ::ProtocolBuffers::Message
+  # purposefully removing qualified name to make sure that nothing breaks
+  #set_fully_qualified_name "C"
+
+  optional ::A::B, :b, 1
+end
+

data/spec/proto_files/services.pb.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Services
+  # forward declarations
+  class FooRequest < ::ProtocolBuffers::Message; end
+  class FooResponse < ::ProtocolBuffers::Message; end
+  class BarRequest < ::ProtocolBuffers::Message; end
+  class BarResponse < ::ProtocolBuffers::Message; end
+
+  class FooRequest < ::ProtocolBuffers::Message
+    set_fully_qualified_name "services.FooRequest"
+
+    optional :sint64, :one, 1
+  end
+
+  class FooResponse < ::ProtocolBuffers::Message
+    set_fully_qualified_name "services.FooResponse"
+
+    optional :uint64, :two, 1
+  end
+
+  class BarRequest < ::ProtocolBuffers::Message
+    set_fully_qualified_name "services.BarRequest"
+
+    optional :string, :three, 1
+  end
+
+  class BarResponse < ::ProtocolBuffers::Message
+    set_fully_qualified_name "services.BarResponse"
+
+    optional :bytes, :four, 1
+  end
+
+  class FooBarService < ::ProtocolBuffers::Service
+    set_fully_qualified_name "services.FooBarService"
+
+    rpc :get_foo, "GetFoo", ::Services::FooRequest, ::Services::FooResponse
+    rpc :get_bar, "GetBar", ::Services::BarRequest, ::Services::BarResponse
+  end
+  class NoNameFooBarService < ::ProtocolBuffers::Service
+    # purposefully removing qualified name to make sure that nothing breaks
+    #set_fully_qualified_name "services.NoNameFooBarService"
+
+    rpc :get_foo, "GetFoo", ::Services::FooRequest, ::Services::FooResponse
+    rpc :get_bar, "GetBar", ::Services::BarRequest, ::Services::BarResponse
+  end
+end

data/spec/proto_files/services.proto

@@ -0,0 +1,27 @@
+package services;
+
+message FooRequest {
+  optional sint64 one = 1;
+}
+
+message FooResponse {
+  optional uint64 two = 1;
+}
+
+message BarRequest {
+  optional string three = 1;
+}
+
+message BarResponse {
+  optional bytes four = 1;
+}
+
+service FooBarService {
+  rpc GetFoo(FooRequest) returns (FooResponse);
+  rpc GetBar(BarRequest) returns (BarResponse);
+}
+
+service NoNameFooBarService {
+  rpc GetFoo(FooRequest) returns (FooResponse);
+  rpc GetBar(BarRequest) returns (BarResponse);
+}

data/spec/proto_files/simple.pb.rb

@@ -10,13 +10,20 @@ module Simple
   class Bar < ::ProtocolBuffers::Message; end
 
   class Test1 < ::ProtocolBuffers::Message
+    set_fully_qualified_name "simple.Test1"
+
     optional :string, :test_field, 1
   end
 
   class Foo < ::ProtocolBuffers::Message
+    set_fully_qualified_name "simple.Foo"
+
   end
 
   class Bar < ::ProtocolBuffers::Message
+    # purposefully removing qualified name to make sure that nothing breaks
+    #set_fully_qualified_name "simple.Bar"
+
     optional ::Simple::Foo, :foo, 1
   end
 

data/spec/runtime_spec.rb

@@ -11,12 +11,12 @@ require 'protocol_buffers/compiler'
 describe ProtocolBuffers, "runtime" do
   before(:each) do
     # clear our namespaces
-    %w( Simple Featureful Foo Packed TehUnknown TehUnknown2 TehUnknown3 ).each do |klass|
+    %w( Simple Featureful Foo Packed TehUnknown TehUnknown2 TehUnknown3 Enums A C Services).each do |klass|
       Object.send(:remove_const, klass.to_sym) if Object.const_defined?(klass.to_sym)
     end
 
     # load test protos
-    %w( simple featureful packed ).each do |proto|
+    %w( simple featureful packed enums no_package services).each do |proto|
       load File.join(File.dirname(__FILE__), "proto_files", "#{proto}.pb.rb")
     end
   end
@@ -105,13 +105,48 @@ describe ProtocolBuffers, "runtime" do
     msg2.should == msg1
   end
 
+  it "correctly unsets fields" do
+    msg1 = Simple::Test1.new
+    msg1.has_test_field?.should == false
+    msg1.test_field.should == ""
+    msg1.to_s.should == ""
+
+    msg1.test_field = "zomgkittenz"
+    msg1.has_test_field?.should == true
+    msg1.test_field.should == "zomgkittenz"
+    msg1.to_s.should_not == ""
+
+    msg1.test_field = nil
+    msg1.has_test_field?.should == false
+    msg1.test_field.should == ""
+    msg1.to_s.should == ""
+  end
+
   it "doesn't serialize unset fields" do
     msg1 = Simple::Test1.new
+    msg1.has_test_field?.should == false
+    msg1.test_field.should == ""
+    msg1.to_s.should == ""
+
+    msg2 = Simple::Test1.parse(ProtocolBuffers.bin_sio(msg1.to_s))
+    msg2.has_test_field?.should == false
+    msg2.test_field.should == ""
+    msg2.to_s.should == ""
+
+    msg1 = Simple::Test1.new
+    msg1.has_test_field?.should == false
     msg1.test_field.should == ""
     msg1.to_s.should == ""
 
     msg1.test_field = "zomgkittenz"
     msg1.to_s.should_not == ""
+
+    msg1.test_field = nil
+
+    msg2 = Simple::Test1.parse(ProtocolBuffers.bin_sio(msg1.to_s))
+    msg2.has_test_field?.should == false
+    msg2.test_field.should == ""
+    msg2.to_s.should == ""
   end
 
   it "flags values that have been set" do
@@ -646,4 +681,181 @@ describe ProtocolBuffers, "runtime" do
     msg.i.should == 805059
   end
 
+  it "correctly converts to a hash" do
+    f = Featureful::A.new
+    f.i1 = [1, 2, 3]
+    f.i3 = 4
+    sub11 = Featureful::A::Sub.new
+    sub11.payload = "sub11payload"
+    sub11.payload_type = Featureful::A::Sub::Payloads::P1
+    sub11.subsub1.subsub_payload = "sub11subsubpayload"
+    sub12 = Featureful::A::Sub.new
+    sub12.payload = "sub12payload"
+    sub12.payload_type = Featureful::A::Sub::Payloads::P2
+    sub12.subsub1.subsub_payload = "sub12subsubpayload"
+    f.sub1 = [sub11, sub12]
+    f.sub3.payload = "sub3payload"
+    f.sub3.payload_type = Featureful::A::Sub::Payloads::P1
+    f.sub3.subsub1.subsub_payload = "sub3subsubpayload"
+    f.group3.i1 = 1
+
+    f.valid?.should == true
+    f.to_hash.should == {
+      :i1 => [1, 2, 3],
+      :i3 => 4,
+      :sub1 => [
+        {
+          :payload => "sub11payload",
+          :payload_type => 0,
+          :subsub1 => {
+            :subsub_payload => "sub11subsubpayload"
+          }
+        },
+        {
+          :payload => "sub12payload",
+          :payload_type => 1,
+          :subsub1 => {
+            :subsub_payload => "sub12subsubpayload"
+          }
+        }
+      ],
+      :sub3 => {
+        :payload => "sub3payload",
+        :payload_type => 0,
+        :subsub1 => {
+          :subsub_payload => "sub3subsubpayload"
+        }
+      },
+      :group1 => [],
+      :group3 => {
+        :i1 => 1,
+        :subgroup => []
+      }
+    }
+
+  end
+
+  it "correctly handles fully qualified names on Messages" do
+    Simple::Test1.fully_qualified_name.should == "simple.Test1"
+    Simple::Foo.fully_qualified_name.should == "simple.Foo"
+    Simple::Bar.fully_qualified_name.should == nil
+  end
+
+  it "correctly handles fully qualified names on Messages with no package" do
+    A.fully_qualified_name.should == "A"
+    A::B.fully_qualified_name.should == "A.B"
+    C.fully_qualified_name.should == nil
+  end
+
+  it "has only Enum values as constants" do
+    Enums::FooEnum.constants.map(&:to_sym).should =~ [:ONE, :TWO, :THREE]
+    Enums::BarEnum.constants.map(&:to_sym).should =~ [:FOUR, :FIVE, :SIX]
+    Enums::FooMessage::NestedFooEnum.constants.map(&:to_sym).should =~ [:SEVEN, :EIGHT]
+    Enums::FooMessage::NestedBarEnum.constants.map(&:to_sym).should =~ [:NINE, :TEN]
+  end
+
+  it "correctly populates the maps between name and values for Enums" do
+    Enums::FooEnum.value_to_names_map.should == {
+      1 => [:ONE],
+      2 => [:TWO],
+      3 => [:THREE]
+    }
+    Enums::BarEnum.value_to_names_map.should == {
+      4 => [:FOUR],
+      5 => [:FIVE],
+      6 => [:SIX]
+    }
+    Enums::FooEnum.name_to_value_map.should == {
+      :ONE => 1,
+      :TWO => 2,
+      :THREE => 3
+    }
+    Enums::BarEnum.name_to_value_map.should == {
+      :FOUR => 4,
+      :FIVE => 5,
+      :SIX => 6
+    }
+    Enums::FooMessage::NestedFooEnum.value_to_names_map.should == {
+      7 => [:SEVEN],
+      8 => [:EIGHT],
+    }
+    Enums::FooMessage::NestedBarEnum.value_to_names_map.should == {
+      9 => [:NINE],
+      10 => [:TEN],
+    }
+    Enums::FooMessage::NestedFooEnum.name_to_value_map.should == {
+      :SEVEN => 7,
+      :EIGHT => 8,
+    }
+    Enums::FooMessage::NestedBarEnum.name_to_value_map.should == {
+      :NINE => 9,
+      :TEN => 10,
+    }
+  end
+
+  it "correctly handles fully qualified names on Enums" do
+    Enums::FooEnum.fully_qualified_name.should == "enums.FooEnum"
+    Enums::BarEnum.fully_qualified_name.should == nil
+    Enums::FooMessage::NestedFooEnum.fully_qualified_name.should == "enums.FooMessage.NestedFooEnum"
+    Enums::FooMessage::NestedBarEnum.fully_qualified_name.should == nil
+  end
+
+  it "correctly handles service definitions" do
+    get_foo_rpc, get_bar_rpc = get_rpcs
+
+    get_foo_rpc.name.should == :get_foo
+    get_foo_rpc.proto_name.should == "GetFoo"
+    get_foo_rpc.request_class.should == Services::FooRequest
+    get_foo_rpc.response_class.should == Services::FooResponse
+    get_foo_rpc.service_class.should == Services::FooBarService
+
+    get_bar_rpc.name.should == :get_bar
+    get_bar_rpc.proto_name.should == "GetBar"
+    get_bar_rpc.request_class.should == Services::BarRequest
+    get_bar_rpc.response_class.should == Services::BarResponse
+    get_bar_rpc.service_class.should == Services::FooBarService
+  end
+
+  it "correctly handles == for Rpcs" do
+    get_foo_rpc, get_bar_rpc = get_rpcs
+
+    get_foo_rpc.should == get_foo_rpc
+    get_bar_rpc.should == get_bar_rpc
+    get_foo_rpc.should_not == get_bar_rpc
+  end
+
+  it "correctly freezes rpcs" do
+    get_foo_rpc, get_bar_rpc = get_rpcs
+
+    get_foo_rpc.frozen?.should == true
+    get_bar_rpc.frozen?.should == true
+    get_foo_rpc.proto_name.frozen?.should == true
+    get_bar_rpc.proto_name.frozen?.should == true
+
+    # make sure to_s is still possible when frozen
+    get_foo_rpc.to_s
+    get_bar_rpc.to_s
+
+    Services::FooBarService.rpcs.frozen?.should == true
+  end
+
+  it "correctly handles fully qualified names on Services" do
+    Services::FooBarService.fully_qualified_name.should == "services.FooBarService"
+    Services::NoNameFooBarService.fully_qualified_name.should == nil
+  end
+
+  def get_rpcs
+    Services::FooBarService.rpcs.size.should == 2
+    first_rpc = Services::FooBarService.rpcs[0]
+    second_rpc = Services::FooBarService.rpcs[1]
+    case first_rpc.name
+    when :get_foo
+      second_rpc.name.should == :get_bar
+      return first_rpc, second_rpc
+    when :get_bar
+      first_rpc.name.should == :get_bar
+      return second_rpc, first_rpc
+    else raise ArgumentError.new(first_rpc.name)
+    end
+  end
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: ruby-protocol-buffers
 version: !ruby/object:Gem::Version
-  version: 1.4.1
-  prerelease: 
+  version: 1.5.0.beta1
+  prerelease: 6
 platform: ruby
 authors:
 - Brian Palmer
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-19 00:00:00.000000000 Z
+date: 2013-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autotest-standalone
@@ -170,6 +170,7 @@ files:
 - lib/protocol_buffers/runtime/extend.rb
 - lib/protocol_buffers/runtime/field.rb
 - lib/protocol_buffers/runtime/message.rb
+- lib/protocol_buffers/runtime/rpc.rb
 - lib/protocol_buffers/runtime/service.rb
 - lib/protocol_buffers/runtime/varint.rb
 - lib/protocol_buffers/version.rb
@@ -180,12 +181,17 @@ files:
 - spec/nil_bugs_spec.rb
 - spec/proto_files/depends.proto
 - spec/proto_files/dotted_package.proto
+- spec/proto_files/enums.pb.rb
+- spec/proto_files/enums.proto
 - spec/proto_files/featureful.pb.rb
 - spec/proto_files/featureful.proto
 - spec/proto_files/nested/child.proto
+- spec/proto_files/no_package.pb.rb
 - spec/proto_files/no_package.proto
 - spec/proto_files/packed.pb.rb
 - spec/proto_files/packed.proto
+- spec/proto_files/services.pb.rb
+- spec/proto_files/services.proto
 - spec/proto_files/simple.pb.rb
 - spec/proto_files/simple.proto
 - spec/proto_files/top_level_enum.proto
@@ -197,7 +203,8 @@ files:
 - tasks/rspec.rake
 - tasks/yard.rake
 homepage: https://github.com/codekitchen/ruby-protocol-buffers
-licenses: []
+licenses:
+- BSD
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -210,16 +217,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -833684518850791827
+      hash: -2340940649634800505
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -833684518850791827
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -233,12 +237,17 @@ test_files:
 - spec/nil_bugs_spec.rb
 - spec/proto_files/depends.proto
 - spec/proto_files/dotted_package.proto
+- spec/proto_files/enums.pb.rb
+- spec/proto_files/enums.proto
 - spec/proto_files/featureful.pb.rb
 - spec/proto_files/featureful.proto
 - spec/proto_files/nested/child.proto
+- spec/proto_files/no_package.pb.rb
 - spec/proto_files/no_package.proto
 - spec/proto_files/packed.pb.rb
 - spec/proto_files/packed.proto
+- spec/proto_files/services.pb.rb
+- spec/proto_files/services.proto
 - spec/proto_files/simple.pb.rb
 - spec/proto_files/simple.proto
 - spec/proto_files/top_level_enum.proto