protobuf 3.3.6 → 3.4.0

data/spec/lib/protobuf/field/float_field_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protobuf::Field::FloatField do
+RSpec.describe Protobuf::Field::FloatField do
 
   class SomeFloatMessage < ::Protobuf::Message
     optional :float, :some_float, 1
@@ -44,7 +44,7 @@ describe Protobuf::Field::FloatField do
     end
 
     context 'when set with something that is not a float' do
-      let(:value) { [ 1, 2, 3 ] }
+      let(:value) { [1, 2, 3] }
 
       it 'throws an error' do
         expect { subject }.to raise_error(TypeError)

data/spec/lib/protobuf/field/int32_field_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protobuf::Field::Int32Field do
+RSpec.describe Protobuf::Field::Int32Field do
 
   it_behaves_like :packable_field, described_class
 

data/spec/lib/protobuf/field/string_field_spec.rb

@@ -2,24 +2,24 @@
 
 require 'spec_helper'
 
-describe ::Protobuf::Field::StringField do
+RSpec.describe ::Protobuf::Field::StringField do
 
   describe '#encode' do
     context 'when a repeated string field contains frozen strings' do
       it 'does not raise an encoding error' do
-        expect {
-          frozen_strings = [ "foo".freeze, "bar".freeze, "baz".freeze ]
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
           ::Test::ResourceFindRequest.encode(:name => 'resource', :widgets => frozen_strings)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
     context 'when a repeated bytes field contains frozen strings' do
       it 'does not raise an encoding error' do
-        expect {
-          frozen_strings = [ "foo".freeze, "bar".freeze, "baz".freeze ]
+        expect do
+          frozen_strings = ["foo".freeze, "bar".freeze, "baz".freeze]
           ::Test::ResourceFindRequest.encode(:name => 'resource', :widget_bytes => frozen_strings)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
@@ -42,5 +42,4 @@ describe ::Protobuf::Field::StringField do
     end
   end
 
-
 end

data/spec/lib/protobuf/field_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'protobuf/field'
 
-describe ::Protobuf::Field do
+RSpec.describe ::Protobuf::Field do
 
   describe '.build' do
     pending
@@ -148,7 +148,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a string field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::StringField
@@ -159,7 +158,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a bytes field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::BytesField
@@ -170,7 +168,6 @@ describe ::Protobuf::Field do
       end
     end
 
-
     context 'when type is a bool field class or symbol' do
       it 'returns that class' do
         expected_field = ::Protobuf::Field::BoolField
@@ -183,9 +180,9 @@ describe ::Protobuf::Field do
 
     context 'when type is not mapped' do
       it 'raises an ArgumentError' do
-        expect {
+        expect do
           subject.field_class("boom")
-        }.to raise_error
+        end.to raise_error
       end
     end
 

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

@@ -3,14 +3,14 @@ require 'spec_helper'
 require 'protobuf/code_generator'
 require 'protobuf/generators/base'
 
-describe ::Protobuf::Generators::Base do
+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' ]) }
+    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
 
@@ -68,17 +68,17 @@ describe ::Protobuf::Generators::Base 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])
+        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])
+        described_class.validate_tags("FooBar", [1, 2, 4, 5])
       end
     end
   end
 
 end
-

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

@@ -2,43 +2,49 @@ require 'spec_helper'
 
 require 'protobuf/generators/enum_generator'
 
-describe ::Protobuf::Generators::EnumGenerator do
+RSpec.describe ::Protobuf::Generators::EnumGenerator do
 
-  let(:values) {
+  let(:values) do
     [
       { :name => 'FOO', :number => 1 },
       { :name => 'BAR', :number => 2 },
-      { :name => 'BAZ', :number => 3 }
+      { :name => 'BAZ', :number => 3 },
     ]
-  }
+  end
   let(:options) { nil }
-  let(:enum_fields) { { :name => 'TestEnum',
-                        :value => values,
-                        :options => options } }
+  let(:enum_fields) do
+    {
+      :name => 'TestEnum',
+      :value => values,
+      :options => options,
+    }
+  end
 
   let(:enum) { ::Google::Protobuf::EnumDescriptorProto.new(enum_fields) }
 
   subject { described_class.new(enum) }
 
   describe '#compile' do
-    let(:compiled) {
-      %q{class TestEnum < ::Protobuf::Enum
+    let(:compiled) do
+      <<-RUBY
+class TestEnum < ::Protobuf::Enum
   define :FOO, 1
   define :BAR, 2
   define :BAZ, 3
 end
 
-}
-    }
+      RUBY
+    end
 
-    it 'compiles the enum and it\'s field values' do
+    it 'compiles the enum and its field values' do
       subject.compile
       expect(subject.to_s).to eq(compiled)
     end
 
     context 'when allow_alias option is set' do
-      let(:compiled) {
-        %q{class TestEnum < ::Protobuf::Enum
+      let(:compiled) do
+        <<-RUBY
+class TestEnum < ::Protobuf::Enum
   set_option :allow_alias
 
   define :FOO, 1
@@ -46,8 +52,8 @@ end
   define :BAZ, 3
 end
 
-}
-    }
+        RUBY
+      end
 
       let(:options) { { :allow_alias => true } }
 
@@ -65,4 +71,3 @@ end
   end
 
 end
-

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

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

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'protobuf/generators/field_generator'
 
-describe ::Protobuf::Generators::FieldGenerator do
+RSpec.describe ::Protobuf::Generators::FieldGenerator do
 
   let(:label_enum) { :LABEL_OPTIONAL }
   let(:name) { 'foo_bar' }
@@ -13,14 +13,18 @@ describe ::Protobuf::Generators::FieldGenerator do
   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_fields) do
+    {
+      :label => label_enum,
+      :name => name,
+      :number => number,
+      :type => type_enum,
+      :type_name => type_name,
+      :default_value => default_value,
+      :extendee => extendee,
+      :options => field_options,
+    }
+  end
 
   let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
 
@@ -53,7 +57,7 @@ describe ::Protobuf::Generators::FieldGenerator do
         let(:type_enum) { :TYPE_STRING }
         let(:default_value) { "a default \"string\"" }
 
-        specify { expect(subject).to eq %Q{optional :string, :foo_bar, 3, :default => "a default \"string\""\n} }
+        specify { expect(subject).to eq "optional :string, :foo_bar, 3, :default => \"a default \"string\"\"\n" }
       end
 
       context 'when float or double field type' do
@@ -96,4 +100,3 @@ describe ::Protobuf::Generators::FieldGenerator do
   end
 
 end
-

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'protobuf/generators/file_generator'
 
-describe ::Protobuf::Generators::FileGenerator do
+RSpec.describe ::Protobuf::Generators::FileGenerator do
 
   let(:base_descriptor_fields) { { :name => 'test/foo.proto' } }
   let(:descriptor_fields) { base_descriptor_fields }
@@ -13,8 +13,12 @@ describe ::Protobuf::Generators::FileGenerator do
 
   describe '#print_import_requires' do
     let(:descriptor_fields) do
-      base_descriptor_fields.merge!({ :dependency => [ 'test/bar.proto',
-                                                       'test/baz.proto' ] })
+      base_descriptor_fields.merge(
+        :dependency => [
+          'test/bar.proto',
+          'test/baz.proto',
+        ],
+      )
     end
 
     it 'prints a ruby require for each dependency' do
@@ -26,4 +30,3 @@ describe ::Protobuf::Generators::FileGenerator do
   end
 
 end
-

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

@@ -2,30 +2,34 @@ require 'spec_helper'
 
 require 'protobuf/generators/service_generator'
 
-describe ::Protobuf::Generators::ServiceGenerator do
+RSpec.describe ::Protobuf::Generators::ServiceGenerator do
 
-  let(:methods) {
+  let(:methods) do
     [
       { :name => 'Search', :input_type => 'FooRequest', :output_type => 'FooResponse' },
-      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' }
+      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' },
     ]
-  }
-  let(:service_fields) { { :name => 'TestService',
-                           :method => methods } }
+  end
+  let(:service_fields) do
+    {
+      :name => 'TestService',
+      :method => methods,
+    }
+  end
 
   let(:service) { ::Google::Protobuf::ServiceDescriptorProto.new(service_fields) }
 
   subject { described_class.new(service) }
 
   describe '#compile' do
-    let(:compiled) {
-      %q{class TestService < ::Protobuf::Rpc::Service
+    let(:compiled) do
+      'class TestService < ::Protobuf::Rpc::Service
   rpc :search, FooRequest, FooResponse
   rpc :foo_bar, ::Foo::Request, ::Bar::Response
 end
 
-}
-    }
+'
+    end
 
     it 'compiles the service and it\'s rpc methods' do
       subject.compile
@@ -40,4 +44,3 @@ end
   end
 
 end
-

data/spec/lib/protobuf/lifecycle_spec.rb

@@ -1,10 +1,15 @@
 require 'spec_helper'
 require 'protobuf/lifecycle'
 
-describe ::Protobuf::Lifecycle do
+RSpec.describe ::Protobuf::Lifecycle do
   subject { described_class }
 
-  before(:each) do
+  around do |example|
+    # this entire class is deprecated
+    ::Protobuf.deprecator.silence(&example)
+  end
+
+  before do
     ::ActiveSupport::Notifications.notifier = ::ActiveSupport::Notifications::Fanout.new
   end
 
@@ -14,9 +19,9 @@ describe ::Protobuf::Lifecycle do
   end
 
   it "only registers blocks for event callbacks" do
-    expect {
+    expect do
       subject.register("something")
-    }.to raise_error( /block/ )
+    end.to raise_error(/block/)
   end
 
   it "calls the registered block when triggered" do

data/spec/lib/protobuf/message_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Protobuf::Message do
+RSpec.describe Protobuf::Message do
 
   describe '.decode' do
     let(:message) { ::Test::Resource.new(:name => "Jim") }
@@ -54,18 +54,18 @@ describe Protobuf::Message do
 
       context 'with a repeated field' do
         it 'treats the field as if it was unset when decoding' do
-          newer = newer_message.new(:enum_list => [ :HOORAY ]).serialize
+          newer = newer_message.new(:enum_list => [:HOORAY]).serialize
 
           expect(older_message.decode(newer).enum_list).to eq([])
         end
 
         it 'rejects an unknown value when using the constructor' do
-          expect { older_message.new(:enum_list => [ :HOORAY ]) }.to raise_error
+          expect { older_message.new(:enum_list => [:HOORAY]) }.to raise_error
         end
 
         it 'rejects an unknown value when the setter' do
           older = older_message.new
-          expect { older.enum_field = [ :HOORAY ] }.to raise_error
+          expect { older.enum_field = [:HOORAY] }.to raise_error
         end
       end
     end
@@ -74,47 +74,47 @@ describe Protobuf::Message do
   describe 'defining a new field' do
     context 'when defining a field with a tag that has already been used' do
       it 'raises a TagCollisionError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :bar, 1
           end
-        }.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
+        end.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
       end
     end
 
     context 'when defining an extension field with a tag that has already been used' do
       it 'raises a TagCollisionError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             extensions 100...110
             optional ::Protobuf::Field::Int32Field, :foo, 100
             optional ::Protobuf::Field::Int32Field, :bar, 100, :extension => true
           end
-        }.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
+        end.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
       end
     end
 
     context 'when defining a field with a name that has already been used' do
       it 'raises a DuplicateFieldNameError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :foo, 2
           end
-        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+        end.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
     end
 
     context 'when defining an extension field with a name that has already been used' do
       it 'raises a DuplicateFieldNameError' do
-        expect {
+        expect do
           Class.new(Protobuf::Message) do
             extensions 100...110
             optional ::Protobuf::Field::Int32Field, :foo, 1
             optional ::Protobuf::Field::Int32Field, :foo, 100, :extension => true
           end
-        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+        end.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
       end
     end
   end
@@ -246,9 +246,9 @@ describe Protobuf::Message do
       let(:message) { ::Test::ResourceWithRequiredField.new }
 
       it "raises a 'message not initialized' error" do
-        expect {
+        expect do
           message.encode
-        }.to raise_error(Protobuf::SerializationError, /required/i)
+        end.to raise_error(Protobuf::SerializationError, /required/i)
       end
     end
 
@@ -256,10 +256,10 @@ describe Protobuf::Message do
       let(:message) { ::Test::Resource.new(:name => "something") }
 
       it "does not raise an error when repeated fields are []" do
-        expect {
+        expect do
           message.repeated_enum = []
           message.encode
-        }.to_not raise_error
+        end.to_not raise_error
       end
 
       it "sets the value to nil when empty array is passed" do
@@ -280,9 +280,9 @@ describe Protobuf::Message do
       end
 
       it "raises TypeError when a non-array replaces it" do
-        expect {
+        expect do
           message.repeated_enum = 2
-        }.to raise_error(/value of type/)
+        end.to raise_error(/value of type/)
       end
     end
   end
@@ -359,11 +359,34 @@ describe Protobuf::Message do
 
   end
 
+  describe '#inspect' do
+    let(:klass) do
+      Class.new(Protobuf::Message) do |klass|
+        enum_class = Class.new(Protobuf::Enum) do
+          define :YAY, 1
+        end
+
+        klass.const_set(:EnumKlass, enum_class)
+
+        optional :string, :name, 1
+        repeated :int32, :counts, 2
+        optional enum_class, :enum, 3
+      end
+    end
+
+    before { stub_const('MyMessage', klass) }
+
+    it 'lists the fields' do
+      proto = klass.new(:name => 'wooo', :counts => [1, 2, 3], :enum => klass::EnumKlass::YAY)
+      expect(proto.inspect).to eq('#<MyMessage name="wooo" counts=[1, 2, 3] enum=#<Protobuf::Enum(MyMessage::EnumKlass)::YAY=1>>')
+    end
+  end
+
   describe '#to_hash' do
     context 'generating values for an ENUM field' do
       it 'converts the enum to its tag representation' do
         hash = Test::EnumTestMessage.new(:non_default_enum => :TWO).to_hash
-        expect(hash).to eq({ :non_default_enum => 2 })
+        expect(hash).to eq(:non_default_enum => 2)
       end
 
       it 'does not populate default values' do
@@ -372,33 +395,38 @@ describe Protobuf::Message do
       end
 
       it 'converts repeated enum fields to an array of the tags' do
-        hash = Test::EnumTestMessage.new(:repeated_enums => [ :ONE, :TWO, :TWO, :ONE ]).to_hash
-        expect(hash).to eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
+        hash = Test::EnumTestMessage.new(:repeated_enums => [:ONE, :TWO, :TWO, :ONE]).to_hash
+        expect(hash).to eq(:repeated_enums => [1, 2, 2, 1])
       end
     end
 
     context 'generating values for a Message field' do
       it 'recursively hashes field messages' do
-        hash = Test::Nested.new({ :resource => { :name => 'Nested' } }).to_hash
-        expect(hash).to eq({ :resource => { :name => 'Nested' } })
+        hash = Test::Nested.new(:resource => { :name => 'Nested' }).to_hash
+        expect(hash).to eq(:resource => { :name => 'Nested' })
       end
 
       it 'recursively hashes a repeated set of messages' do
-        proto = Test::Nested.new(:multiple_resources => [
-          Test::Resource.new(:name => 'Resource 1'),
-          Test::Resource.new(:name => 'Resource 2')
-        ])
-
-        expect(proto.to_hash).to eq({ :multiple_resources => [ { :name => 'Resource 1' },
-                                                           { :name => 'Resource 2' } ] })
-
+        proto = Test::Nested.new(
+          :multiple_resources => [
+            Test::Resource.new(:name => 'Resource 1'),
+            Test::Resource.new(:name => 'Resource 2'),
+          ],
+        )
+
+        expect(proto.to_hash).to eq(
+          :multiple_resources => [
+            { :name => 'Resource 1' },
+            { :name => 'Resource 2' },
+          ],
+        )
       end
     end
   end
 
   describe '#to_json' do
     subject do
-      ::Test::ResourceFindRequest.new({ :name => 'Test Name', :active => false })
+      ::Test::ResourceFindRequest.new(:name => 'Test Name', :active => false)
     end
 
     specify { expect(subject.to_json).to eq '{"name":"Test Name","active":false}' }
@@ -406,11 +434,11 @@ describe Protobuf::Message do
 
   describe '.to_json' do
     it 'returns the class name of the message for use in json encoding' do
-      expect {
+      expect do
         ::Timeout.timeout(0.1) do
           expect(::Test::Resource.to_json).to eq("Test::Resource")
         end
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -422,7 +450,7 @@ describe Protobuf::Message do
     end
 
     it "does not allow string fields to be set to Numeric" do
-      expect { subject.name = 1}.to raise_error(/name/)
+      expect { subject.name = 1 }.to raise_error(/name/)
     end
   end