protobuf 2.8.0.beta9 → 2.8.0

data/protobuf.gemspec

@@ -1,44 +1,35 @@
 # encoding: UTF-8
-$:.push File.expand_path("./lib", File.dirname(__FILE__))
+$:.push ::File.expand_path("../lib", __FILE__)
 require "protobuf/version"
 
-Gem::Specification.new do |s|
+::Gem::Specification.new do |s|
   s.name          = 'protobuf'
-  s.version       = Protobuf::VERSION
-  s.date          = Time.now.strftime('%Y-%m-%d')
+  s.version       = ::Protobuf::VERSION
+  s.date          = ::Time.now.strftime('%Y-%m-%d')
+  s.license       = 'WTFPL'
 
-  s.authors       = ['BJ Neilsen', 'Brandon Dewitt']
-  s.email         = ["bj.neilsen+protobuf@gmail.com", "brandonsdewitt+protobuf@gmail.com"]
-  s.homepage      = "https://github.com/localshred/protobuf"
-  s.summary       = "Google Protocol Buffers v#{Protobuf::PROTOC_VERSION} Serialization and RPC implementation for Ruby."
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen']
+  s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com']
+  s.homepage      = 'https://github.com/localshred/protobuf'
+  s.summary       = "Google Protocol Buffers serialization and RPC implementation for Ruby."
   s.description   = s.summary
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  unless ENV['WITHOUT_PROTO_COMPILER']
-    if defined?(JRUBY_VERSION)
-      s.platform = 'java'
-    else
-      s.extensions << File.join('ext', 'ruby_generator', 'extconf.rb')
-    end
-  end
-
-  s.add_dependency 'activesupport'
-  s.add_dependency 'ffi'
+  s.add_dependency 'activesupport', '< 4.0'
   s.add_dependency 'multi_json'
   s.add_dependency 'thor'
 
   s.add_development_dependency 'eventmachine'
   s.add_development_dependency 'ffi-rzmq'
-  # s.add_development_dependency 'perftools.rb'
-  s.add_development_dependency 'pry'
   s.add_development_dependency 'pry-nav'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rake-compiler'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
+  # s.add_development_dependency 'perftools.rb'
 end

data/spec/bin/protoc-gen-ruby_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+describe 'protoc-gen-ruby' do
+  let(:binpath) { ::File.expand_path('../../../bin/protoc-gen-ruby', __FILE__) }
+  let(:request_bytes) { ::Google::Protobuf::Compiler::CodeGeneratorRequest.new(:file_to_generate => [ "test/foo.proto" ]) }
+  let(:expected_file) { ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => 'test/foo.pb.rb') }
+  let(:expected_response_bytes) { ::Google::Protobuf::Compiler::CodeGeneratorRequest.encode(:files => [ expected_file ]) }
+
+  it 'reads the serialized request bytes and outputs serialized response bytes' do
+    ::IO.popen(binpath, 'w+') do |pipe|
+      pipe.write(request_bytes)
+      pipe.read(expected_response_bytes.size).should eq expected_response_bytes
+    end
+  end
+end
+

data/spec/data/data.bin

@@ -0,0 +1,3 @@
+
+John Doe�	jdoe@example.com"
+555-4321

data/spec/encoding/all_types_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe ::Protobuf do
+  it "correctly encodes all types" do
+    message = GoogleUnittest::TestAllTypes.new(
+      optional_int32:    101,
+      optional_int64:    102,
+      optional_uint32:   103,
+      optional_uint64:   104,
+      optional_sint32:   105,
+      optional_sint64:   106,
+      optional_fixed32:  107,
+      optional_fixed64:  108,
+      optional_sfixed32: 109,
+      optional_sfixed64: 110,
+      optional_float:    111,
+      optional_double:   112,
+      optional_bool:     true,
+      optional_string:   "115",
+      optional_bytes:    "116",
+      optional_nested_message: GoogleUnittest::TestAllTypes::NestedMessage.new(bb: 118),
+      optional_foreign_message: GoogleUnittest::ForeignMessage.new(c: 119),
+      optional_import_message: GoogleUnittestImport::ImportMessage.new(d: 120),
+      optional_nested_enum: GoogleUnittest::TestAllTypes::NestedEnum::BAZ,
+      optional_foreign_enum: GoogleUnittest::ForeignEnum::FOREIGN_BAZ,
+      optional_import_enum: GoogleUnittestImport::ImportEnum::IMPORT_BAZ,
+      optional_string_piece: "124",
+      optional_cord: "125",
+      optional_public_import_message: GoogleUnittestImport::PublicImportMessage.new(e: 126),
+      optional_lazy_message: GoogleUnittest::TestAllTypes::NestedMessage.new(bb: 127),
+      repeated_int32:    [201, 301],
+      repeated_int64:    [202, 302],
+      repeated_uint32:   [203, 303],
+      repeated_uint64:   [204, 304],
+      repeated_sint32:   [205, 305],
+      repeated_sint64:   [206, 306],
+      repeated_fixed32:  [207, 307],
+      repeated_fixed64:  [208, 308],
+      repeated_sfixed32: [209, 309],
+      repeated_sfixed64: [210, 310],
+      repeated_float:    [211, 311],
+      repeated_double:   [212, 312],
+      repeated_bool:     [true, false],
+      repeated_string:   ["215", "315"],
+      repeated_bytes:    ["216", "316"],
+      repeated_nested_message: [::GoogleUnittest::TestAllTypes::NestedMessage.new(bb: 218),
+                                ::GoogleUnittest::TestAllTypes::NestedMessage.new(bb: 318)],
+      repeated_foreign_message: [::GoogleUnittest::ForeignMessage.new(c: 219),
+                                 ::GoogleUnittest::ForeignMessage.new(c: 319)],
+      repeated_import_message: [::GoogleUnittestImport::ImportMessage.new(d: 220),
+                                ::GoogleUnittestImport::ImportMessage.new(d: 320)],
+      repeated_nested_enum: [::GoogleUnittest::TestAllTypes::NestedEnum::BAR,
+                             ::GoogleUnittest::TestAllTypes::NestedEnum::BAZ],
+      repeated_foreign_enum: [::GoogleUnittest::ForeignEnum::FOREIGN_BAR,
+                              ::GoogleUnittest::ForeignEnum::FOREIGN_BAZ],
+      repeated_import_enum: [::GoogleUnittestImport::ImportEnum::IMPORT_BAR,
+                             ::GoogleUnittestImport::ImportEnum::IMPORT_BAZ],
+      repeated_string_piece: ["224", "324"],
+      repeated_cord: ["225", "325"],
+      repeated_lazy_message: [::GoogleUnittest::TestAllTypes::NestedMessage.new(bb:227),
+                              ::GoogleUnittest::TestAllTypes::NestedMessage.new(bb:327)],
+      default_int32: 401,
+      default_int64: 402,
+      default_uint32: 403,
+      default_uint64: 404,
+      default_sint32: 405,
+      default_sint64: 406,
+      default_fixed32: 407,
+      default_fixed64: 408,
+      default_sfixed32: 409,
+      default_sfixed64: 410,
+      default_float: 411,
+      default_double: 412,
+      default_bool: false,
+      default_string: "415",
+      default_bytes: "416",
+      default_nested_enum: ::GoogleUnittest::TestAllTypes::NestedEnum::FOO,
+      default_foreign_enum: ::GoogleUnittest::ForeignEnum::FOREIGN_FOO,
+      default_import_enum: ::GoogleUnittestImport::ImportEnum::IMPORT_FOO,
+      default_string_piece: "424",
+      default_cord: "425",
+    )
+
+    data_file_path = File.expand_path('../../support/test/all_types.data.bin', __FILE__)
+    data = File.open(data_file_path, 'rb') do |file|
+      file.read
+    end
+
+    data.should eq message.serialize_to_string
+  end
+end

data/spec/lib/protobuf/code_generator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+describe ::Protobuf::CodeGenerator do
+
+  # Some constants to shorten things up
+  DESCRIPTOR = ::Google::Protobuf
+  COMPILER = ::Google::Protobuf::Compiler
+
+  describe '#response_bytes' do
+    let(:input_file1) { DESCRIPTOR::FileDescriptorProto.new(:name => 'test/foo.proto') }
+    let(:input_file2) { DESCRIPTOR::FileDescriptorProto.new(:name => 'test/bar.proto') }
+
+    let(:output_file1) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/foo.pb.rb') }
+    let(:output_file2) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/bar.pb.rb') }
+
+    let(:file_generator1) { mock('file generator 1', :generate_output_file => output_file1) }
+    let(:file_generator2) { mock('file generator 2', :generate_output_file => output_file2) }
+
+    let(:request_bytes) do
+      COMPILER::CodeGeneratorRequest.encode(:proto_file => [ input_file1, input_file2 ])
+    end
+
+    let(:expected_response_bytes) do
+      COMPILER::CodeGeneratorResponse.encode(:file => [ output_file1, output_file2 ])
+    end
+
+    before do
+      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file1).and_return(file_generator1)
+      ::Protobuf::Generators::FileGenerator.should_receive(:new).with(input_file2).and_return(file_generator2)
+    end
+
+    it 'returns the serialized CodeGeneratorResponse which contains the generated file contents' do
+      generator = described_class.new(request_bytes)
+      generator.response_bytes.should eq expected_response_bytes
+    end
+  end
+
+  context 'class-level printing methods' do
+    describe '.fatal' do
+      it 'raises a CodeGeneratorFatalError error' do
+        expect {
+          described_class.fatal("something is wrong")
+        }.to raise_error(
+          ::Protobuf::CodeGenerator::CodeGeneratorFatalError,
+          "something is wrong"
+        )
+      end
+    end
+
+    describe '.warn' do
+      it 'prints a warning to stderr' do
+        STDERR.should_receive(:puts).with("[WARN] a warning")
+        described_class.warn("a warning")
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/generators/base_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/base'
+
+describe ::Protobuf::Generators::Base do
+
+  subject { described_class.new(mock) }
+
+  context 'namespaces' do
+    let(:descriptor) { mock(:name => 'Baz') }
+    subject { described_class.new(descriptor, 0, :namespace => [ :foo, :bar ]) }
+    its(:type_namespace) { should eq [ :foo, :bar, 'Baz' ] }
+    its(:fully_qualified_type_namespace) { should eq '.foo.bar.Baz' }
+  end
+
+  describe '#run_once' do
+    it 'protects the block from being entered more than once' do
+      foo = 0
+      bar = 0
+
+      test_run_once = lambda do
+        bar += 1
+        subject.run_once(:foo_test) do
+          foo += 1
+        end
+      end
+
+      10.times { test_run_once.call }
+      expect(foo).to eq(1)
+      expect(bar).to eq(10)
+    end
+
+    it 'always returns the same object' do
+      rv = subject.run_once(:foo_test) do
+        "foo bar"
+      end
+      expect(rv).to eq("foo bar")
+
+      rv = subject.run_once(:foo_test) do
+        "baz quux"
+      end
+      expect(rv).to eq("foo bar")
+    end
+  end
+
+  describe '#to_s' do
+    before do
+      class ToStringTest < ::Protobuf::Generators::Base
+        def compile
+          run_once(:compile) do
+            puts "this is a test"
+          end
+        end
+      end
+    end
+
+    subject { ToStringTest.new(mock) }
+
+    it 'compiles and returns the contents' do
+      10.times do
+        expect(subject.to_s).to eq("this is a test\n")
+      end
+    end
+  end
+
+  describe '#validate_tags' do
+    context 'when tags are duplicated' do
+      it 'fails with a GeneratorFatalError' do
+        ::Protobuf::CodeGenerator.should_receive(:fatal)
+                                  .with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
+
+        described_class.validate_tags("FooBar", [1,2,2,3])
+      end
+    end
+
+    context 'when tags are missing in the range' do
+      it 'prints a warning' do
+        ::Protobuf::CodeGenerator.should_receive(:warn)
+                                  .with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
+        described_class.validate_tags("FooBar", [1,2,4,5])
+      end
+    end
+  end
+
+end
+

data/spec/lib/protobuf/generators/enum_generator_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'protobuf/generators/enum_generator'
+
+describe ::Protobuf::Generators::EnumGenerator do
+
+  let(:values) {
+    [
+      { :name => 'FOO', :number => 1 },
+      { :name => 'BAR', :number => 2 },
+      { :name => 'BAZ', :number => 3 }
+    ]
+  }
+  let(:enum_fields) { { :name => 'TestEnum',
+                        :value => values } }
+
+  let(:enum) { ::Google::Protobuf::EnumDescriptorProto.new(enum_fields) }
+
+  subject { described_class.new(enum) }
+
+  describe '#compile' do
+    let(:compiled) {
+      %q{class TestEnum < ::Protobuf::Enum
+  define :FOO, 1
+  define :BAR, 2
+  define :BAZ, 3
+end
+
+}
+    }
+
+    it 'compiles the enum and it\'s field values' do
+      subject.compile
+      subject.to_s.should eq(compiled)
+    end
+  end
+
+  describe '#build_value' do
+    it 'returns a string identifying the given enum value' do
+      subject.build_value(enum.value.first).should eq("define :FOO, 1")
+    end
+  end
+
+end
+

data/spec/lib/protobuf/generators/extension_generator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/extension_generator'
+
+describe ::Protobuf::Generators::ExtensionGenerator do
+
+  let(:field_descriptors) {
+    [
+      mock('field descriptor 1', :to_s => "  field 1\n"),
+      mock('field descriptor 2', :to_s => "  field 2\n"),
+      mock('field descriptor 3', :to_s => "  field 3\n")
+    ]
+  }
+  let(:message_type) { 'FooBar' }
+
+  before do
+    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[0], 1).and_return(field_descriptors[0])
+    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[1], 1).and_return(field_descriptors[1])
+    ::Protobuf::Generators::FieldGenerator.should_receive(:new).with(field_descriptors[2], 1).and_return(field_descriptors[2])
+  end
+
+  subject { described_class.new(message_type, field_descriptors, 0) }
+
+  describe '#compile' do
+    let(:compiled) {
+      %q{class FooBar < ::Protobuf::Message
+  field 1
+  field 2
+  field 3
+end
+
+}
+    }
+
+    it 'compiles the a class with the extension fields' do
+      subject.compile
+      subject.to_s.should eq(compiled)
+    end
+  end
+
+end
+

data/spec/lib/protobuf/generators/field_generator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+require 'protobuf/generators/field_generator'
+
+describe ::Protobuf::Generators::FieldGenerator do
+
+  let(:label_enum) { :LABEL_OPTIONAL }
+  let(:name) { 'foo_bar' }
+  let(:number) { 3 }
+  let(:type_enum) { :TYPE_STRING }
+  let(:type_name) { nil }
+  let(:default_value) { nil }
+  let(:extendee) { nil }
+  let(:field_options) { {} }
+
+  let(:field_fields) { { :label => label_enum,
+                         :name => name,
+                         :number => number,
+                         :type => type_enum,
+                         :type_name => type_name,
+                         :default_value => default_value,
+                         :extendee => extendee,
+                         :options => field_options } }
+
+  let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
+
+  describe '#compile' do
+    subject { described_class.new(field).to_s }
+
+    it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3\n" }
+
+    context 'when the type is another message' do
+      let(:type_enum) { :TYPE_MESSAGE }
+      let(:type_name) { '.foo.bar.Baz' }
+
+      it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
+    end
+
+    context 'when a default value is used' do
+      let(:type_enum) { :TYPE_INT32 }
+      let(:default_value) { '42' }
+      it { should eq "optional ::Protobuf::Field::Int32Field, :foo_bar, 3, :default => 42\n" }
+
+      context 'when type is an enum' do
+        let(:type_enum) { :TYPE_ENUM }
+        let(:type_name) { '.foo.bar.Baz' }
+        let(:default_value) { 'QUUX' }
+
+        it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+      end
+
+      context 'when the type is a string' do
+        let(:type_enum) { :TYPE_STRING }
+        let(:default_value) { "a default \"string\"" }
+
+        it { should eq %Q{optional ::Protobuf::Field::StringField, :foo_bar, 3, :default => "a default \"string\""\n} }
+      end
+
+      context 'when float or double field type' do
+        let(:type_enum) { :TYPE_DOUBLE }
+
+        context 'when the default value is "nan"' do
+          let(:default_value) { 'nan' }
+          it { should match(/::Float::NAN/) }
+        end
+
+        context 'when the default value is "inf"' do
+          let(:default_value) { 'inf' }
+          it { should match(/::Float::INFINITY/) }
+        end
+
+        context 'when the default value is "-inf"' do
+          let(:default_value) { '-inf' }
+          it { should match(/-::Float::INFINITY/) }
+        end
+      end
+    end
+
+    context 'when the field is an extension' do
+      let(:extendee) { 'foo.bar.Baz' }
+
+      it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3, :extension => true\n" }
+    end
+
+    context 'when field is packed' do
+      let(:field_options) { { :packed => true } }
+
+      it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3, :packed => true\n" }
+    end
+
+    context 'when field is deprecated' do
+      let(:field_options) { { :deprecated => true } }
+
+      it { should eq "optional ::Protobuf::Field::StringField, :foo_bar, 3, :deprecated => true\n" }
+    end
+  end
+
+end
+