protobuffy 3.6.0 → 4.0.0

data/protobuffy.gemspec

@@ -1,14 +1,14 @@
 # encoding: UTF-8
-$:.push ::File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push ::File.expand_path("../lib", __FILE__)
 require "protobuf/version"
 
 ::Gem::Specification.new do |s|
   s.name          = 'protobuffy'
   s.version       = ::Protobuf::VERSION
   s.date          = ::Time.now.strftime('%Y-%m-%d')
-  s.license       = 'WTFPL'
+  s.license       = 'MIT'
 
-  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen', 'Adam Hutchison', 'R. Tyler Croy',]
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen', 'Adam Hutchison', 'R. Tyler Croy']
   s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com', 'liveh2o@gmail.com', 'tyler@monkeypox.org']
   s.homepage      = 'https://github.com/lookout/protobuffy'
   s.summary       = "Google Protocol Buffers serialization and RPC implementation for Ruby."
@@ -19,26 +19,39 @@ require "protobuf/version"
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  if RUBY_VERSION =~ /^2/
-    s.add_dependency 'activesupport'
-  else
-    s.add_dependency 'activesupport', '< 5'
-  end
-
+  # Hack, as Rails 5 requires Ruby version >= 2.2.2.
+  active_support_max_version = "< 5" if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.2.2")
+  s.add_dependency "activesupport", '>= 3.2', active_support_max_version
   s.add_dependency 'middleware'
-  s.add_dependency 'multi_json', '~> 1.0'
   s.add_dependency 'thor'
-  s.add_dependency 'json', '< 2.0'
+  s.add_dependency 'thread_safe'
 
+  s.add_development_dependency 'ffi-rzmq'
+  s.add_development_dependency 'rake', '< 11.0' # Rake 11.0.1 removes the last_comment method which rspec-core (< 3.4.4) uses
   s.add_development_dependency 'rack', '~> 1.0'
   s.add_development_dependency 'faraday'
-  s.add_development_dependency 'ffi-rzmq'
-  s.add_development_dependency 'pry-nav'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '2.99.0'
+  s.add_development_dependency 'rspec', '>= 3.0'
+  s.add_development_dependency "rubocop", "~> 0.38.0"
+  s.add_development_dependency "parser", "2.3.0.6" # Locked this down since 2.3.0.7 causes issues. https://github.com/bbatsov/rubocop/pull/2984
   s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'yard'
   s.add_development_dependency 'timecop'
+  s.add_development_dependency 'yard'
+
+  # debuggers only work in MRI
+  if RUBY_ENGINE.to_sym == :ruby
+    # we don't support MRI < 1.9.3
+    pry_debugger = if RUBY_VERSION < '2.0.0'
+                     'pry-debugger'
+                   else
+                     'pry-byebug'
+                   end
+
+    s.add_development_dependency pry_debugger
+    s.add_development_dependency 'pry-stack_explorer'
 
-  s.add_development_dependency 'ruby-prof' if RUBY_ENGINE.to_sym == :ruby
+    s.add_development_dependency 'varint'
+    s.add_development_dependency 'ruby-prof'
+  else
+    s.add_development_dependency 'pry'
+  end
 end

data/spec/benchmark/tasks.rb

@@ -1,7 +1,9 @@
 require 'benchmark'
+require 'protobuf'
 require 'protobuf/socket'
 require 'support/all'
-require 'support/test/resource_service'
+require 'spec_helper'
+require SUPPORT_PATH.join('resource_service')
 
 case RUBY_ENGINE.to_sym
 when :ruby
@@ -15,8 +17,8 @@ end
 # Including a way to turn on debug logger for spec runs
 if ENV["DEBUG"]
   puts 'debugging'
-  debug_log = File.expand_path('../debug_bench.log', File.dirname(__FILE__) )
-  Protobuf::Logger.configure(:file => debug_log, :level => ::Logger::DEBUG)
+  debug_log = File.expand_path('../../../debug_bench.log', __FILE__)
+  Protobuf::Logging.initialize_logger(debug_log, ::Logger::DEBUG)
 end
 
 namespace :benchmark do
@@ -34,12 +36,14 @@ namespace :benchmark do
   def sock_client_sock_server(number_tests, test_length, global_bench = nil)
     load "protobuf/socket.rb"
 
-    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
-      client = ::Test::ResourceService.client(:port => 9399)
+    port = 1000 + Kernel.rand(2**16 - 1000)
+
+    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => port) do
+      client = ::Test::ResourceService.client(:port => port)
 
       benchmark_wrapper(global_bench) do |bench|
         bench.report("SS / SC") do
-          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          Integer(number_tests).times { client.find(:name => "Test Name" * Integer(test_length), :active => true) }
         end
       end
     end
@@ -47,26 +51,28 @@ namespace :benchmark do
 
   def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
     load "protobuf/zmq.rb"
-    StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server|
-      client = ::Test::ResourceService.client(:port => 9399)
+
+    port = 1000 + Kernel.rand(2**16 - 1000)
+
+    StubServer.new(:port => port, :server => Protobuf::Rpc::Zmq::Server) do
+      client = ::Test::ResourceService.client(:port => port)
 
       benchmark_wrapper(global_bench) do |bench|
         bench.report("ZS / ZC") do
-          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          Integer(number_tests).times { client.find(:name => "Test Name" * Integer(test_length), :active => true) }
         end
       end
-      server.stop
     end
   end
 
   desc "benchmark ZMQ client with ZMQ server"
-  task :zmq_client_zmq_server, [:number, :length] do |t, args|
+  task :zmq_client_zmq_server, [:number, :length] do |_task, args|
     args.with_defaults(:number => 1000, :length => 100)
     zmq_client_zmq_server(args[:number], args[:length])
   end
 
   desc "benchmark ZMQ client with ZMQ server and profile"
-  task :zmq_profile, [:number, :length, :profile_output] do |t, args|
+  task :zmq_profile, [:number, :length, :profile_output] do |_task, args|
     args.with_defaults(:number => 1000, :length => 100, :profile_output => "/tmp/zmq_profiler_#{Time.now.to_i}")
     profile_code(args[:profile_output]) do
       zmq_client_zmq_server(args[:number], args[:length])
@@ -76,22 +82,22 @@ namespace :benchmark do
   end
 
   desc "benchmark Protobuf Message #new"
-  task :profile_protobuf_new, [:number, :profile_output] do |t, args|
+  task :profile_protobuf_new, [:number, :profile_output] do |_task, args|
     args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
     create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
     profile_code(args[:profile_output]) do
-      args[:number].to_i.times { Test::Resource.new(create_params) }
+      Integer(args[:number]).times { Test::Resource.new(create_params) }
     end
 
     puts args[:profile_output]
   end
 
   desc "benchmark Protobuf Message #serialize"
-  task :profile_protobuf_serialize, [:number, :profile_output] do |t, args|
+  task :profile_protobuf_serialize, [:number, :profile_output] do |_task, args|
     args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
     create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
     profile_code(args[:profile_output]) do
-      args[:number].to_i.times { Test::Resource.new(create_params).serialize }
+      Integer(args[:number]).times { Test::Resource.decode(Test::Resource.new(create_params).serialize) }
     end
 
     puts args[:profile_output]
@@ -101,7 +107,9 @@ namespace :benchmark do
     case RUBY_ENGINE.to_sym
     when :ruby
       profile_data = RubyProf.profile(&block)
-      RubyProf::FlatPrinter.new(profile_data).print(:path => output)
+      ::File.open(output, "w") do |output_file|
+        RubyProf::FlatPrinter.new(profile_data).print(output_file)
+      end
     when :rbx
       profiler = Rubinius::Profiler::Instrumenter.new
       profiler.profile(false, &block)
@@ -117,13 +125,13 @@ namespace :benchmark do
   end
 
   desc "benchmark Socket client with Socket server"
-  task :sock_client_sock_server, [:number, :length] do |t, args|
+  task :sock_client_sock_server, [:number, :length] do |_task, args|
     args.with_defaults(:number => 1000, :length => 100)
     sock_client_sock_server(args[:number], args[:length])
   end
 
   desc "benchmark server performance"
-  task :servers, [:number, :length] do |t, args|
+  task :servers, [:number, :length] do |_task, args|
     args.with_defaults(:number => 1000, :length => 100)
 
     Benchmark.bm(10) do |bench|

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

@@ -2,17 +2,22 @@ require 'spec_helper'
 
 require 'protobuf/code_generator'
 
-describe 'protoc-gen-ruby' do
+RSpec.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 ]) }
+  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.read(expected_response_bytes.size).should eq expected_response_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/encoding/all_types_spec.rb

@@ -1,91 +1,103 @@
 require 'spec_helper'
+require PROTOS_PATH.join('google_unittest.pb')
 
-describe ::Protobuf do
+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",
+    message = Protobuf_unittest::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 => Protobuf_unittest::TestAllTypes::NestedMessage.new(:bb => 118),
+      :optional_foreign_message => Protobuf_unittest::ForeignMessage.new(:c => 119),
+      :optional_import_message => Protobuf_unittest_import::ImportMessage.new(:d => 120),
+      :optional_nested_enum => Protobuf_unittest::TestAllTypes::NestedEnum::BAZ,
+      :optional_foreign_enum => Protobuf_unittest::ForeignEnum::FOREIGN_BAZ,
+      :optional_import_enum => Protobuf_unittest_import::ImportEnum::IMPORT_BAZ,
+      :optional_string_piece => "124",
+      :optional_cord => "125",
+      :optional_public_import_message => Protobuf_unittest_import::PublicImportMessage.new(:e => 126),
+      :optional_lazy_message => Protobuf_unittest::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 => [
+        ::Protobuf_unittest::TestAllTypes::NestedMessage.new(:bb => 218),
+        ::Protobuf_unittest::TestAllTypes::NestedMessage.new(:bb => 318),
+      ],
+      :repeated_foreign_message => [
+        ::Protobuf_unittest::ForeignMessage.new(:c => 219),
+        ::Protobuf_unittest::ForeignMessage.new(:c => 319),
+      ],
+      :repeated_import_message => [
+        ::Protobuf_unittest_import::ImportMessage.new(:d => 220),
+        ::Protobuf_unittest_import::ImportMessage.new(:d => 320),
+      ],
+      :repeated_nested_enum => [
+        ::Protobuf_unittest::TestAllTypes::NestedEnum::BAR,
+        ::Protobuf_unittest::TestAllTypes::NestedEnum::BAZ,
+      ],
+      :repeated_foreign_enum => [
+        ::Protobuf_unittest::ForeignEnum::FOREIGN_BAR,
+        ::Protobuf_unittest::ForeignEnum::FOREIGN_BAZ,
+      ],
+      :repeated_import_enum => [
+        ::Protobuf_unittest_import::ImportEnum::IMPORT_BAR,
+        ::Protobuf_unittest_import::ImportEnum::IMPORT_BAZ,
+      ],
+      :repeated_string_piece => ["224", "324"],
+      :repeated_cord => ["225", "325"],
+      :repeated_lazy_message => [
+        ::Protobuf_unittest::TestAllTypes::NestedMessage.new(:bb => 227),
+        ::Protobuf_unittest::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 => ::Protobuf_unittest::TestAllTypes::NestedEnum::FOO,
+      :default_foreign_enum => ::Protobuf_unittest::ForeignEnum::FOREIGN_FOO,
+      :default_import_enum => ::Protobuf_unittest_import::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
+    data_file_path = PROTOS_PATH.join('all_types.data.bin')
+    data = File.open(data_file_path, 'rb', &:read)
+    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_PATH.join('resource_service')
+
+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