protobuf-core 3.5.0

data/proto/rpc.proto

@@ -0,0 +1,62 @@
+// Copyright (c) 2009 Shardul Deo
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// Authors: Shardul Deo, BJ Neilsen
+//
+// Protobufs needed for socket rpcs.
+
+package protobuf.socketrpc;
+
+message Request
+{
+  required string service_name = 1;             // Fully- qualified Service class name
+  required string method_name = 2;              // Service method to invoke
+  optional bytes request_proto = 3;             // Serialized request bytes
+  optional string caller = 4;                   // Calling hostname or address
+}
+
+message Response
+{
+  optional bytes response_proto = 1;            // Serialized response
+  optional string error = 2;                    // Error message, if any
+  optional bool callback = 3 [default = false]; // Was callback invoked (not sure what this is for)
+  optional ErrorReason error_reason = 4;        // Error Reason
+}
+
+// Possible error reasons
+// The server-side errors are returned in the response from the server.
+// The client-side errors are returned by the client-side code when it doesn't
+// have a response from the server.
+enum ErrorReason
+{
+  // Server-side errors
+  BAD_REQUEST_DATA = 0;                         // Server received bad request data
+  BAD_REQUEST_PROTO = 1;                        // Server received bad request proto
+  SERVICE_NOT_FOUND = 2;                        // Service not found on server
+  METHOD_NOT_FOUND = 3;                         // Method not found on server
+  RPC_ERROR = 4;                                // Rpc threw exception on server
+  RPC_FAILED = 5;                               // Rpc failed on server
+
+  // Client-side errors (these are returned by the client-side code)
+  INVALID_REQUEST_PROTO = 6;                    // Rpc was called with invalid request proto
+  BAD_RESPONSE_PROTO = 7;                       // Server returned a bad response proto
+  UNKNOWN_HOST = 8;                             // Could not find supplied host
+  IO_ERROR = 9;                                 // I/O error while communicating with server
+}

data/protobuf-core.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'protobuf/core/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "protobuf-core"
+  spec.version       = Protobuf::Core::VERSION
+  spec.authors       = ["BJ Neilsen", "Brandon Dewitt", "Devin Christensen", "Adam Hutchison", "Michael Ries"]
+  spec.email         = ["bj.neilsen+protobuf@gmail.com", "brandonsdewitt+protobuf@gmail.com", "quixoten@gmail.com", "liveh2o@gmail.com", "michael@riesd.com"]
+
+  spec.summary       = "Google Protocol Buffers serialization and compiler implementation for Ruby."
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/ruby-protobuf/protobuf-core"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", ">= 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", ">= 3.2"
+  spec.add_development_dependency 'ruby-prof' if RUBY_ENGINE.to_sym == :ruby
+  spec.add_development_dependency "timecop"
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+RSpec.describe 'protoc-gen-ruby' do
+  let(:binpath) { ::File.expand_path('../../../bin/protoc-gen-ruby', __FILE__) }
+  let(:package) { 'test' }
+  let(:request_bytes) do
+    ::Google::Protobuf::Compiler::CodeGeneratorRequest.encode(
+      :proto_file => [{ :package => package }],
+    )
+  end
+
+  it 'reads the serialized request bytes and outputs serialized response bytes' do
+    ::IO.popen(binpath, 'w+') do |pipe|
+      pipe.write(request_bytes)
+      pipe.close_write # needed so we can implicitly read until EOF
+      response_bytes = pipe.read
+      response = ::Google::Protobuf::Compiler::CodeGeneratorResponse.decode(response_bytes)
+      expect(response.file.first.content).to include("module #{package.titleize}")
+    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,105 @@
+require 'spec_helper'
+
+RSpec.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
+
+    expect(data).to eq(message.serialize_to_string)
+  end
+end

data/spec/functional/class_inheritance_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'support/test/resource.pb'
+
+RSpec.describe 'works through class inheritance' do
+  module Corp
+    module Protobuf
+      class Error < ::Protobuf::Message
+        required :string, :foo, 1
+      end
+    end
+  end
+  module Corp
+    class ErrorHandler < Corp::Protobuf::Error
+    end
+  end
+
+  let(:args) { { :foo => 'bar' } }
+  let(:parent_class) { Corp::Protobuf::Error }
+  let(:inherited_class) { Corp::ErrorHandler }
+
+  specify '#encode' do
+    expected_result = "\n\x03bar"
+    expected_result.force_encoding(Encoding::BINARY)
+    expect(parent_class.new(args).encode).to eq(expected_result)
+    expect(inherited_class.new(args).encode).to eq(expected_result)
+  end
+
+  specify '#to_hash' do
+    expect(parent_class.new(args).to_hash).to eq(args)
+    expect(inherited_class.new(args).to_hash).to eq(args)
+  end
+
+  specify '#to_json' do
+    expect(parent_class.new(args).to_json).to eq(args.to_json)
+    expect(inherited_class.new(args).to_json).to eq(args.to_json)
+  end
+
+  specify '.encode' do
+    expected_result = "\n\x03bar"
+    expected_result.force_encoding(Encoding::BINARY)
+    expect(parent_class.encode(args)).to eq(expected_result)
+    expect(inherited_class.encode(args)).to eq(expected_result)
+  end
+
+  specify '.decode' do
+    raw_value = "\n\x03bar"
+    raw_value.force_encoding(Encoding::BINARY)
+    expect(parent_class.decode(raw_value).to_hash).to eq(args)
+    expect(inherited_class.decode(raw_value).to_hash).to eq(args)
+  end
+
+end

data/spec/functional/compile_and_require_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe 'can compile and load a class' do
+  before(:context) do
+    proto_path = File.expand_path('../../support/test/bacon.proto', __FILE__)
+    ruby_path = proto_path.sub('.proto','.pb.rb')
+    proto_load_path = File.dirname(proto_path)
+    File.unlink(ruby_path) if File.file?(ruby_path)
+    `protoc --plugin=./bin/protoc-gen-ruby --ruby_out=#{proto_load_path} -I #{proto_load_path} #{proto_path}`
+    require(ruby_path)
+  end
+
+  after(:context) do
+    Object.send(:remove_const, :Bacon) if defined?(Bacon)
+  end
+
+  it 'compiles a Bacon class' do
+    expect(defined?(Bacon)).to eq 'constant'
+  end
+
+  it 'has getters and setters' do
+    bacon = Bacon.new
+    bacon.deliciousness = 10
+    bacon.texture = Texture::CRUNCHY
+
+    expect(bacon.deliciousness).to eq 10
+    expect(bacon.texture).to eq Texture::CRUNCHY
+  end
+end

data/spec/lib/protobuf/base_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+require 'protobuf/generators/base'
+
+RSpec.describe ::Protobuf::Generators::Base do
+
+  subject { described_class.new(double) }
+
+  context 'namespaces' do
+    let(:descriptor) { double(:name => 'Baz') }
+    subject { described_class.new(descriptor, 0, :namespace => [:foo, :bar]) }
+    specify { expect(subject.type_namespace).to eq([:foo, :bar, 'Baz']) }
+    specify { expect(subject.fully_qualified_type_namespace).to 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(double) }
+
+    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
+        expect(::Protobuf::CodeGenerator).to 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
+        expect(::Protobuf::CodeGenerator).to receive(:print_tag_warning_suppress)
+        expect(::Protobuf::CodeGenerator).to 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/code_generator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+RSpec.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) { double('file generator 1', :generate_output_file => output_file1) }
+    let(:file_generator2) { double('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
+      expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file1).and_return(file_generator1)
+      expect(::Protobuf::Generators::FileGenerator).to 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)
+      expect(generator.response_bytes).to eq expected_response_bytes
+    end
+  end
+
+  context 'class-level printing methods' do
+    describe '.fatal' do
+      it 'raises a CodeGeneratorFatalError error' do
+        expect do
+          described_class.fatal("something is wrong")
+        end.to raise_error(
+          ::Protobuf::CodeGenerator::CodeGeneratorFatalError,
+          "something is wrong",
+        )
+      end
+    end
+
+    describe '.warn' do
+      it 'prints a warning to stderr' do
+        expect(STDERR).to receive(:puts).with("[WARN] a warning")
+        described_class.warn("a warning")
+      end
+    end
+  end
+
+end