protobuf-activerecord 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 976fc954c82761944381e6445e9b603cf2a38e4e
-  data.tar.gz: b5a1ae6b0afb8cc61075460b8ad24c2ee2fc0cb0
+  metadata.gz: a352c983607d34d912b75e84b87cfaade5fb40eb
+  data.tar.gz: a656aa395f61f5e6f5f3da5aa7ff2e5aa01172ca
 SHA512:
-  metadata.gz: 8d8219bf86dafaa0c0046811b2d729b079175213320ba376f5aae07efae283312097019ce5492119b0c50e83cdcce0bc0f66b43a068e94bc472f860619a818e8
-  data.tar.gz: 6dc72951231be8f28e1f520f996896ee6e6677a4b3f008c33c893509ec5c8e91a8da53a0d831bcec7b6a4d3e28aab56e08e1f8c88157bdbbff0db33f385bb5be
+  metadata.gz: 120872dfa9ea6f4532d14de413a2e4b911e3f96c6663398f15ff18b78e3956669583420bb3bcc0aaceeec649e14d5fc1e72f67495526a4b9b16df9869bc96545
+  data.tar.gz: dd907e242f10564144ef5117e916ec58915abb9f5cbda7a972ab6558c9aff23b5158b90de3702c75b55a861bbc476e8755f526c533520e5f8ff70b132ee0ae88

data/.rspec

@@ -1,3 +1,4 @@
 --colour
---format RSpec::Pride
+--require rspec/pride
+--format PrideFormatter
 --order rand

data/.travis.yml

@@ -0,0 +1,8 @@
+---
+language: ruby
+rvm:
+  - 2.2.2
+#  - jruby
+sudo: false
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/README.md

@@ -1,3 +1,6 @@
+[![Gem Version](https://badge.fury.io/rb/protobuf-activerecord.svg)](http://badge.fury.io/rb/protobuf-activerecord)
+[![Build Status](https://travis-ci.org/liveh2o/protobuf-activerecord.svg?branch=master)](https://travis-ci.org/liveh2o/protobuf-activerecord)
+
 # Protobuf ActiveRecord
 
 Protobuf Active Record provides the ability to create and update Active Record objects from protobuf messages and to serialize Active Record objects to protobuf messages.
@@ -128,6 +131,15 @@ class User < ActiveRecord::Base
 end
 ```
 
+On the chance you want to exclude deprecated fields, but also include a specfic one, simply pass the `:include` option:
+
+```Ruby
+class User < ActiveRecord::Base
+  # Passing :deprecated => false configures Protobuf Active Record to exclude deprecated fields.
+  protobuf_message :user_message, :deprecated => false, :include => :a_specific_deprecated_field
+end
+```
+
 ### Field transformers
 
 Field transformers are used when serializing objects to protobuf messages. Regular field mapping and conversions will be handled out of the box, but for those times when fields don't map directly to attributes or custom behavior is needed, use `field_from_record` method.
@@ -155,6 +167,38 @@ class User < ActiveRecord::Base
   attribute_from_proto :account_id, lambda { |protobuf_message| # Some custom transformation... }
 end
 ```
+
+### Setting attributes to nil
+
+The protocol buffers specification does not allow for the transport of 'null' or 'nil' values for a field.  In fact, in order to keep messages small and lightweight this is desireable behavior.  Fields are that are not set to a value will not be sent over the wire, but we cannot assume given a message has an absent value for a field that we should set the our attributes to nil.
+
+In order to solve this problem, Protobuf::ActiveRecord has a convention that tells it when to set an attribute to nil.  A message must define a repeated string field named 'nullify'.  If an attribute has the same name as an element in the 'nullify' field, this attribute will be set to nil.
+
+Example:
+```
+message UserMessage {
+  optional string name = 1;
+  repeated string nullify = 2;
+}
+
+```
+```ruby
+m = UserMessage.new(:nullify => [:name])
+# When Protobuf::ActiveRecord maps this message, it will set the name attribute to nil overwriting any value that is set.
+```
+
+For attribute transformers, the field name will not match the attribute name so we need to give the attribute transformer a hint to instruct it on how to nullify a given attribute.  When declaring an attribute transformer, you can specify a :nullify_on option.  This indicates for the given attribute, if the value of 'nullify_on' is present in the nullify field, set this attribute to nil.
+
+Example:
+```Ruby
+class User < ActiveRecord::Base
+  # When 'account_guid' is present in the nullify array, our 'account_id' attribute will be set to nil
+  attribute_from_proto :account_id, :nullify_on => :account_guid do
+    # transform
+  end
+end
+```
+
 #### Searching
 
 Protobuf Active Record's `search_scope` method takes the protobuf message and builds ARel scopes from it.

data/lib/protobuf/active_record/serialization.rb

@@ -150,10 +150,14 @@ module Protobuf
 
         fields = self.class.protobuf_message.all_fields.map do |field|
           next if field.nil?
-          next if exclude_deprecated && field.deprecated?
+          next if field.deprecated? && exclude_deprecated
+
           field.name.to_sym
         end
+        fields += [ options.fetch(:include, nil) ]
+        fields.flatten!
         fields.compact!
+        fields.uniq!
 
         fields
       end

data/lib/protobuf/active_record/transformation.rb

@@ -1,5 +1,6 @@
 require 'active_support/concern'
 require 'heredity/inheritable_class_instance_variables'
+require 'protobuf/active_record/transformer'
 
 module Protobuf
   module ActiveRecord
@@ -93,20 +94,31 @@ module Protobuf
         #     # Do some blocky stuff...
         #   end
         #
-        def attribute_from_proto(attribute, transformer = nil, &block)
-          transformer ||= block
+        #   attribute_from_proto :status, lambda { |proto| nil }, :nullify_on => :status
+        #   attribute_from_proto :status, :nullify_on => :status do |proto|
+        #     nil
+        #   end
+        #
+        def attribute_from_proto(attribute, *args, &block)
+          options = args.extract_options!
+          symbol_or_block = args.first || block
 
-          if transformer.is_a?(Symbol)
-            callable = lambda { |value| self.__send__(transformer, value) }
+          if symbol_or_block.is_a?(Symbol)
+            callable = lambda { |value| self.__send__(symbol_or_block, value) }
           else
-            callable = transformer
+            raise AttributeTransformerError unless symbol_or_block.respond_to?(:call)
+            callable = symbol_or_block
           end
 
-          unless callable.respond_to?(:call)
-            raise AttributeTransformerError
+          if options[:nullify_on]
+            field = protobuf_message.get_field(:nullify)
+            unless field && field.is_a?(::Protobuf::Field::StringField) && field.repeated?
+              ::Protobuf::Logging.logger.warn "Message: #{protobuf_message} is not compatible with :nullify_on option"
+            end
           end
 
-          _protobuf_attribute_transformers[attribute.to_sym] = callable
+          transformer = ::Protobuf::ActiveRecord::Transformer.new(callable, options)
+          _protobuf_attribute_transformers[attribute.to_sym] = transformer
         end
 
 
@@ -120,8 +132,10 @@ module Protobuf
 
           attributes = attribute_fields.inject({}) do |hash, (key, value)|
             if _protobuf_attribute_transformers.has_key?(key)
-              attribute = _protobuf_attribute_transformers[key].call(proto)
+              transformer = _protobuf_attribute_transformers[key]
+              attribute = transformer.call(proto)
               hash[key] = attribute unless attribute.nil?
+              hash[key] = nil if transformer.nullify?(proto)
             else
               hash[key] = _protobuf_convert_fields_to_attributes(key, value)
             end
@@ -129,6 +143,12 @@ module Protobuf
             hash
           end
 
+          return attributes unless proto.field?(:nullify) && proto.nullify.is_a?(Array)
+
+          proto.nullify.each do |attribute_name|
+            attributes[attribute_name.to_sym] = nil if attribute_names.include?(attribute_name.to_s)
+          end
+
           attributes
         end
 
@@ -155,4 +175,4 @@ module Protobuf
       end
     end
   end
-end
+end

data/lib/protobuf/active_record/transformer.rb

@@ -0,0 +1,23 @@
+module Protobuf
+  module ActiveRecord
+    class Transformer
+      attr_accessor :callable, :options
+
+      def initialize(callable, options = {})
+        @callable = callable
+        @options = options
+      end
+
+      def call(proto)
+        callable.call(proto)
+      end
+
+      def nullify?(proto)
+        return false unless options[:nullify_on]
+        return false unless proto.field?(:nullify) && proto.nullify.is_a?(Array)
+
+        proto.nullify.include?(options[:nullify_on].to_s)
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "3.1.1"
+    VERSION = "3.2.0"
   end
 end

data/protobuf-activerecord.gemspec

@@ -30,8 +30,8 @@ Gem::Specification.new do |spec|
   # Development dependencies
   #
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rspec-pride"
+  spec.add_development_dependency "rspec", ">= 3.3.0"
+  spec.add_development_dependency "rspec-pride", ">= 3.1.0"
   spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "sqlite3"

data/spec/protobuf/active_record/columns_spec.rb

@@ -19,31 +19,30 @@ describe Protobuf::ActiveRecord::Columns do
       }
 
       it "maps columns by name" do
-        User._protobuf_columns.should eq expected_column_names
+        expect(User._protobuf_columns).to eq expected_column_names
       end
 
       it "maps column names by column type" do
-        User._protobuf_column_types.should eq expected_column_types
+        expect(User._protobuf_column_types).to eq expected_column_types
       end
     end
   end
 
   context "column type predicates" do
-    before { User.stub(:_protobuf_column_types).and_return(Hash.new) }
-    after { User.unstub(:_protobuf_column_types) }
+    before { allow(User).to receive(:_protobuf_column_types).and_return(Hash.new) }
 
     describe "._protobuf_date_column?" do
       before { User._protobuf_column_types[:date] = [ :foo_date ] }
 
       context "when the column type is :date" do
         it "is true" do
-          User._protobuf_date_column?(:foo_date).should be_true
+          expect(User._protobuf_date_column?(:foo_date)).to be true
         end
       end
 
       context "when the column type is not :date" do
         it "is false" do
-          User._protobuf_date_column?(:bar_date).should be_false
+          expect(User._protobuf_date_column?(:bar_date)).to be false
         end
       end
     end
@@ -53,13 +52,13 @@ describe Protobuf::ActiveRecord::Columns do
 
       context "when the column type is :datetime" do
         it "is true" do
-          User._protobuf_datetime_column?(:foo_datetime).should be_true
+          expect(User._protobuf_datetime_column?(:foo_datetime)).to be true
         end
       end
 
       context "when the column type is not :datetime" do
         it "is false" do
-          User._protobuf_datetime_column?(:bar_datetime).should be_false
+          expect(User._protobuf_datetime_column?(:bar_datetime)).to be false
         end
       end
     end
@@ -69,13 +68,13 @@ describe Protobuf::ActiveRecord::Columns do
 
       context "when the column type is :time" do
         it "is true" do
-          User._protobuf_time_column?(:foo_time).should be_true
+          expect(User._protobuf_time_column?(:foo_time)).to be true
         end
       end
 
       context "when the column type is not :time" do
         it "is false" do
-          User._protobuf_time_column?(:bar_time).should be_false
+          expect(User._protobuf_time_column?(:bar_time)).to be false
         end
       end
     end
@@ -85,13 +84,13 @@ describe Protobuf::ActiveRecord::Columns do
 
       context "when the column type is :timestamp" do
         it "is true" do
-          User._protobuf_timestamp_column?(:foo_timestamp).should be_true
+          expect(User._protobuf_timestamp_column?(:foo_timestamp)).to be true
         end
       end
 
       context "when the column type is not :timestamp" do
         it "is false" do
-          User._protobuf_timestamp_column?(:bar_timestamp).should be_false
+          expect(User._protobuf_timestamp_column?(:bar_timestamp)).to be false
         end
       end
     end

data/spec/protobuf/active_record/persistence_spec.rb

@@ -8,24 +8,24 @@ describe Protobuf::ActiveRecord::Persistence do
 
   describe ".create" do
     it "accepts a protobuf message" do
-      User.any_instance.should_receive(:save)
+      expect_any_instance_of(User).to receive(:save)
       User.create(proto)
     end
 
     it "accepts a hash" do
-      User.any_instance.should_receive(:save)
+      expect_any_instance_of(User).to receive(:save)
       User.create(user_attributes)
     end
   end
 
   describe ".create!" do
     it "accepts a protobuf message" do
-      User.any_instance.should_receive(:save!)
+      expect_any_instance_of(User).to receive(:save!)
       User.create!(proto)
     end
 
     it "accepts a hash" do
-      User.any_instance.should_receive(:save!)
+      expect_any_instance_of(User).to receive(:save!)
       User.create!(user_attributes)
     end
   end
@@ -35,35 +35,35 @@ describe Protobuf::ActiveRecord::Persistence do
 
     it "accepts a protobuf message" do
       user.assign_attributes(proto)
-      user.changed?.should be_true
+      expect(user.changed?).to be true
     end
 
     it "accepts a hash" do
       user.assign_attributes(user_attributes)
-      user.changed?.should be_true
+      expect(user.changed?).to be true
     end
   end
 
   describe "#update_attributes" do
     it "accepts a protobuf message" do
-      User.any_instance.should_receive(:save)
+      expect_any_instance_of(User).to receive(:save)
       user.update_attributes(proto)
     end
 
     it "accepts a hash" do
-      User.any_instance.should_receive(:save)
+      expect_any_instance_of(User).to receive(:save)
       user.update_attributes(user_attributes)
     end
   end
 
   describe "#update_attributes!" do
     it "accepts a protobuf message" do
-      User.any_instance.should_receive(:save!)
+      expect_any_instance_of(User).to receive(:save!)
       user.update_attributes!(proto)
     end
 
     it "accepts a hash" do
-      User.any_instance.should_receive(:save!)
+      expect_any_instance_of(User).to receive(:save!)
       user.update_attributes!(user_attributes)
     end
   end

data/spec/protobuf/active_record/scope_spec.rb

@@ -16,24 +16,24 @@ describe Protobuf::ActiveRecord::Scope do
     let(:request) { UserSearchMessage.new(:guid => ["foo"], :email => ["foo@test.co"]) }
 
     before {
-      User.stub(:searchable_field_parsers).and_return({ :email => proc { |val| val } })
+      allow(User).to receive(:searchable_field_parsers).and_return({ :email => proc { |val| val } })
     }
 
     it "builds scopes for searchable fields" do
-      User.stub(:searchable_fields).and_return({ :email =>  :by_email })
-      User.search_scope(request).should eq User.by_email("foo@test.co")
+      allow(User).to receive(:searchable_fields).and_return({ :email =>  :by_email })
+      expect(User.search_scope(request)).to eq User.by_email("foo@test.co")
     end
 
     it "is chainable" do
-      User.limit(1).search_scope(request).order(:email).should eq User.limit(1).order(:email)
+      expect(User.limit(1).search_scope(request).order(:email)).to eq User.limit(1).order(:email)
     end
 
     context "when a searchable field does not have a value" do
       let(:request) { UserSearchMessage.new(:email => ["foo@test.co"]) }
 
       it "doesn't build a scope from that field" do
-        User.stub(:searchable_fields).and_return({ :email =>  :by_email })
-        User.search_scope(request).should eq User.by_email("foo@test.co")
+        allow(User).to receive(:searchable_fields).and_return({ :email =>  :by_email })
+        expect(User.search_scope(request)).to eq User.by_email("foo@test.co")
       end
     end
 
@@ -41,7 +41,7 @@ describe Protobuf::ActiveRecord::Scope do
       let(:request) { UserSearchMessage.new(:email => ["foo@test.co"]) }
 
       it "raises an exception" do
-        User.stub(:searchable_fields).and_return({ :email =>  :by_hullabaloo })
+        allow(User).to receive(:searchable_fields).and_return({ :email =>  :by_hullabaloo })
         expect { User.search_scope(request) }.to raise_exception(/Undefined scope :by_hullabaloo/)
       end
     end
@@ -51,28 +51,28 @@ describe Protobuf::ActiveRecord::Scope do
     context "when :scope is not defined" do
       it "defines the given field as searchable using the `by_[:field]` as the scope" do
         User.field_scope :guid
-        User.searchable_fields[:guid].should eq :by_guid
+        expect(User.searchable_fields[:guid]).to eq :by_guid
       end
     end
 
     context "when :scope is defined" do
       it "defines the given field as searchable using the given :scope" do
         User.field_scope :guid, :scope => :custom_scope
-        User.searchable_fields[:guid].should eq :custom_scope
+        expect(User.searchable_fields[:guid]).to eq :custom_scope
       end
     end
 
     context "when :parser is not defined" do
       it "doesn't define the given field as parseable" do
         User.field_scope :guid
-        User.searchable_field_parsers[:guid].should eq nil
+        expect(User.searchable_field_parsers[:guid]).to eq nil
       end
     end
 
     context "when :parser is defined" do
       it "defines the given field as parseable using the given :parser" do
         User.field_scope :guid, :parser => :parser
-        User.searchable_field_parsers[:guid].should eq :parser
+        expect(User.searchable_field_parsers[:guid]).to eq :parser
       end
     end
   end
@@ -83,7 +83,7 @@ describe Protobuf::ActiveRecord::Scope do
       proto = UserMessage.new(:email => "the.email@test.in")
 
       User.field_scope :email
-      User.parse_search_values(proto, :email).should eq ["the.email@test.in"]
+      expect(User.parse_search_values(proto, :email)).to eq ["the.email@test.in"]
     end
 
     context "when a field parser is defined" do
@@ -91,20 +91,11 @@ describe Protobuf::ActiveRecord::Scope do
 
       let(:proto) { UserSearchMessage.new(:guid => ["foo"]) }
 
-      context "and the parser responds to :to_sym" do
-        let(:parser) { double('parser', :to_sym => :parser_to_sym) }
-
-        it "passes the value to the parser" do
-          User.should_receive(:parser_to_sym).with([ "foo" ])
-          User.parse_search_values(proto, :guid)
-        end
-      end
-
       context "and the parser does not respond to :to_sym" do
         let(:parser) { double('parser') }
 
         it "passes the value to the parser" do
-          parser.should_receive(:call).with(["foo"])
+          expect(parser).to receive(:call).with(["foo"])
           User.parse_search_values(proto, :guid)
         end
       end
@@ -121,7 +112,7 @@ describe Protobuf::ActiveRecord::Scope do
         end
 
         proto = TheMessage.new(:the_enum_value => TheEnum::VALUE)
-        User.parse_search_values(proto, :the_enum_value)[0].should be 1
+        expect(User.parse_search_values(proto, :the_enum_value)[0]).to be 1
       end
     end
   end

data/spec/protobuf/active_record/serialization_spec.rb

@@ -13,10 +13,10 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:date) { Date.current }
       let(:integer) { date.to_time.to_i }
 
-      before { User.stub(:_protobuf_date_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_date_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_date, date).should eq integer
+        expect(User._protobuf_convert_attributes_to_fields(:foo_date, date)).to eq integer
       end
     end
 
@@ -24,10 +24,10 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:datetime) { DateTime.current }
       let(:integer) { datetime.to_time.to_i }
 
-      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_datetime_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_datetime, datetime).should eq integer
+        expect(User._protobuf_convert_attributes_to_fields(:foo_datetime, datetime)).to eq integer
       end
     end
 
@@ -35,10 +35,10 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:time) { Time.current }
       let(:integer) { time.to_time.to_i }
 
-      before { User.stub(:_protobuf_time_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_time_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_time, time).should eq integer
+        expect(User._protobuf_convert_attributes_to_fields(:foo_time, time)).to eq integer
       end
     end
 
@@ -46,10 +46,10 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:timestamp) { Time.current }
       let(:integer) { timestamp.to_time.to_i }
 
-      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_timestamp_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_timestamp, timestamp).should eq integer
+        expect(User._protobuf_convert_attributes_to_fields(:foo_timestamp, timestamp)).to eq integer
       end
     end
 
@@ -57,7 +57,7 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:value) { "Foo" }
 
       it "returns the given value" do
-        User._protobuf_convert_attributes_to_fields(:foo, value).should eq value
+        expect(User._protobuf_convert_attributes_to_fields(:foo, value)).to eq value
       end
     end
   end
@@ -69,7 +69,7 @@ describe Protobuf::ActiveRecord::Serialization do
       before { User.field_from_record :first_name, :extract_first_name }
 
       it "creates a callable method object from the converter" do
-        User.should_receive(:extract_first_name)
+        expect(User).to receive(:extract_first_name)
         User._protobuf_field_transformers[:first_name].call(1)
       end
     end
@@ -84,12 +84,13 @@ describe Protobuf::ActiveRecord::Serialization do
       let(:callable) { lambda { |proto| nil } }
 
       before {
-        User.stub(:_protobuf_field_transformers).and_return(Hash.new)
+        allow(User).to receive(:_protobuf_field_transformers).and_return(Hash.new)
         User.field_from_record :account_id, callable
       }
 
-      it "adds the given converter to the list of protobuf field transformers" do
+      it "adds the given converter to the list of protobuf field transformers", :pending => 'missing expectation?' do
         User._protobuf_field_transformers[:account_id] = callable
+        fail
       end
     end
   end
@@ -102,18 +103,18 @@ describe Protobuf::ActiveRecord::Serialization do
 
     context "given a value" do
       it "defines #to_proto" do
-        User.allocate.should respond_to :to_proto
+        expect(User.allocate).to respond_to :to_proto
       end
     end
 
     context "given options" do
       it "merges them with protobuf field options" do
-        User._protobuf_field_options.should eq options
+        expect(User._protobuf_field_options).to eq options
       end
     end
 
     it "returns the protobuf message for this object" do
-      User.protobuf_message.should eq protobuf_message
+      expect(User.protobuf_message).to eq protobuf_message
     end
   end
 
@@ -126,28 +127,35 @@ describe Protobuf::ActiveRecord::Serialization do
     describe "#_filter_field_attributes" do
       context "when options has :only" do
         it "only returns the given field(s)" do
-          fields = user._filter_field_attributes(:only => :name).should
-          fields.should eq [ :name ]
+          fields = user._filter_field_attributes(:only => :name)
+          expect(fields).to eq [ :name ]
         end
       end
 
       context "when options has :except" do
         it "returns all except the given field(s)" do
-          fields = user._filter_field_attributes(:except => :name).should
-          fields.should eq [ :guid, :email, :email_domain, :password ]
+          fields = user._filter_field_attributes(:except => :name)
+          expect(fields).to eq [ :guid, :email, :email_domain, :password, :nullify ]
         end
       end
     end
 
     describe "#_filtered_fields" do
       it "returns protobuf fields" do
-        user._filtered_fields.should eq [ :guid, :name, :email, :email_domain, :password ]
+        expect(user._filtered_fields).to eq [ :guid, :name, :email, :email_domain, :password, :nullify ]
       end
 
       context "given :deprecated => false" do
         it "filters all deprecated fields" do
-          fields = user._filtered_fields(:deprecated => false).should
-          fields.should eq [ :guid, :name, :email, :password ]
+          fields = user._filtered_fields(:deprecated => false)
+          expect(fields).to eq [ :guid, :name, :email, :password, :nullify ]
+        end
+
+        context 'and :include => :email_domain' do
+          it 'includes deprecated fields that have been explicitly specified' do
+            fields = user._filtered_fields(:deprecated => false, :include => :email_domain)
+            expect(fields).to match_array([ :guid, :name, :email, :email_domain, :password, :nullify ])
+          end
         end
       end
     end
@@ -159,7 +167,7 @@ describe Protobuf::ActiveRecord::Serialization do
         before { User.protobuf_message(protobuf_message, options) }
 
         it "returns the class's protobuf field options" do
-          User.allocate._normalize_options({}).should eq options
+          expect(User.allocate._normalize_options({})).to eq options
         end
       end
 
@@ -168,7 +176,7 @@ describe Protobuf::ActiveRecord::Serialization do
 
         it "merges them with the class's protobuf field options" do
           normalized_options = User.allocate._normalize_options(options)
-          normalized_options[:only].should eq options[:only]
+          expect(normalized_options[:only]).to eq options[:only]
         end
       end
 
@@ -177,7 +185,7 @@ describe Protobuf::ActiveRecord::Serialization do
 
         it "ensures that :except exists" do
           normalized_options = User.allocate._normalize_options(options)
-          normalized_options[:except].should eq []
+          expect(normalized_options[:except]).to eq []
         end
       end
 
@@ -188,7 +196,7 @@ describe Protobuf::ActiveRecord::Serialization do
 
         it "ensures that :only exists" do
           normalized_options = User.allocate._normalize_options(options)
-          normalized_options[:only].should eq []
+          expect(normalized_options[:only]).to eq []
         end
       end
     end
@@ -204,27 +212,27 @@ describe Protobuf::ActiveRecord::Serialization do
       }
 
       context "when a transformer is defined for the field" do
-        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => 'test.co', :password => nil } }
+        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => 'test.co', :password => nil, :nullify => nil } }
         let(:transformer) { { :email_domain => lambda { |record| record.email.split('@').last } } }
 
         before {
-          User.stub(:_protobuf_field_transformers).and_return(transformer)
+          allow(User).to receive(:_protobuf_field_transformers).and_return(transformer)
         }
 
         it "gets the field from the transformer" do
-          user.fields_from_record.should eq fields_from_record
+          expect(user.fields_from_record).to eq fields_from_record
         end
       end
 
       context "when a transformer is not defined for the field" do
-        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => nil, :password => nil } }
+        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => nil, :password => nil, :nullify => nil } }
 
         it "returns a hash of protobuf fields that this object has getters for" do
-          user.fields_from_record.should eq fields_from_record
+          expect(user.fields_from_record).to eq fields_from_record
         end
 
         it "converts attributes values for protobuf messages" do
-          user.stub(:_protobuf_convert_attributes_to_fields)
+          expect(user).to receive(:_protobuf_convert_attributes_to_fields).at_least(:once)
           user.fields_from_record
         end
       end
@@ -232,7 +240,7 @@ describe Protobuf::ActiveRecord::Serialization do
       context "given options with :include" do
         it "adds the given field to the list of serialized fields" do
           fields = user.fields_from_record(:include => :token)
-          fields.include?(:token).should be_true
+          expect(fields).to include(:token)
         end
       end
     end
@@ -242,10 +250,10 @@ describe Protobuf::ActiveRecord::Serialization do
         let(:proto) { protobuf_message.new(proto_hash) }
         let(:proto_hash) { { :name => "foo" } }
 
-        before { user.stub(:fields_from_record).and_return(proto_hash) }
+        before { allow(user).to receive(:fields_from_record).and_return(proto_hash) }
 
         it "intializes a new protobuf message with attributes from #to_proto_hash" do
-          user.to_proto.should eq proto
+          expect(user.to_proto).to eq proto
         end
       end
 

data/spec/protobuf/active_record/transformation_spec.rb

@@ -9,23 +9,23 @@ describe Protobuf::ActiveRecord::Transformation do
   describe "._filter_attribute_fields" do
     it "includes fields that have values" do
       attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields[:email].should eq proto_hash[:email]
+      expect(attribute_fields[:email]).to eq proto_hash[:email]
     end
 
     it "filters repeated fields" do
       attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:tags).should be_false
+      expect(attribute_fields.has_key?(:tags)).to be false
     end
 
     it "includes attributes that aren't fields, but have attribute transformers" do
-      User.stub(:_protobuf_attribute_transformers).and_return({ :account_id => :fetch_account_id })
+      allow(User).to receive(:_protobuf_attribute_transformers).and_return({ :account_id => :fetch_account_id })
       attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:account_id).should be_true
+      expect(attribute_fields.has_key?(:account_id)).to be true
     end
 
     it "includes fields that aren't attributes, but have attribute transformers" do
       attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:password).should be_true
+      expect(attribute_fields.has_key?(:password)).to be true
     end
   end
 
@@ -34,10 +34,10 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:date) { Date.current }
       let(:value) { date.to_time.to_i }
 
-      before { User.stub(:_protobuf_date_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_date_column?).and_return(true) }
 
       it "converts the given value to a Date object" do
-        User._protobuf_convert_fields_to_attributes(:foo_date, value).should eq date
+        expect(User._protobuf_convert_fields_to_attributes(:foo_date, value)).to eq date
       end
     end
 
@@ -45,14 +45,14 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:datetime) { DateTime.current }
       let(:value) { datetime.to_i }
 
-      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_datetime_column?).and_return(true) }
 
       it "converts the given value to a DateTime object" do
-        User._protobuf_convert_fields_to_attributes(:foo_datetime, value).should be_a(DateTime)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_datetime, value)).to be_a(DateTime)
       end
 
       it "converts the given value to a DateTime object of the same value" do
-        User._protobuf_convert_fields_to_attributes(:foo_datetime, value).should be_within(1).of(datetime)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_datetime, value)).to be_within(1).of(datetime)
       end
     end
 
@@ -60,14 +60,14 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:time) { Time.current }
       let(:value) { time.to_i }
 
-      before { User.stub(:_protobuf_time_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_time_column?).and_return(true) }
 
       it "converts the given value to a Time object" do
-        User._protobuf_convert_fields_to_attributes(:foo_time, value).should be_a(Time)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to be_a(Time)
       end
 
       it "converts the given value to a Time object of the same value" do
-        User._protobuf_convert_fields_to_attributes(:foo_time, value).should be_within(1).of(time)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to be_within(1).of(time)
       end
     end
 
@@ -75,14 +75,14 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:time) { Time.current }
       let(:value) { time.to_i }
 
-      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
+      before { allow(User).to receive(:_protobuf_timestamp_column?).and_return(true) }
 
       it "converts the given value to a Time object" do
-        User._protobuf_convert_fields_to_attributes(:foo_time, value).should be_a(Time)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to be_a(Time)
       end
 
       it "converts the given value to a Time object of the same value" do
-        User._protobuf_convert_fields_to_attributes(:foo_timestamp, value).should be_within(1).of(time)
+        expect(User._protobuf_convert_fields_to_attributes(:foo_timestamp, value)).to be_within(1).of(time)
       end
     end
 
@@ -90,57 +90,80 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:value) { "Foo" }
 
       it "returns the given value" do
-        User._protobuf_convert_fields_to_attributes(:foo, value).should eq value
+        expect(User._protobuf_convert_fields_to_attributes(:foo, value)).to eq value
       end
     end
   end
 
   describe ".attributes_from_proto" do
+    let(:callable) { lambda { |proto| 1 } }
+    let(:transformer) { ::Protobuf::ActiveRecord::Transformer.new(callable) }
+
     context "when a transformer is defined for the attribute" do
       it "transforms the field value" do
         attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields[:first_name].should eq user_attributes[:first_name]
+        expect(attribute_fields[:first_name]).to eq user_attributes[:first_name]
       end
     end
 
     context "when a transformer is a callable that returns nil" do
+      let(:callable) { lambda { |proto| nil } }
+
+      before do
+        transformers = User._protobuf_attribute_transformers
+        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
+          {:account_id => transformer}.merge(transformers)
+        )
+      end
+
+      it "does not set the attribute" do
+        attribute_fields = User.attributes_from_proto(proto)
+        expect(attribute_fields).to eq user_attributes
+      end
+    end
+
+    context 'when the transformer has a nullify_on option' do
+      let(:callable) { lambda { |proto| nil } }
+      let(:transformer) { ::Protobuf::ActiveRecord::Transformer.new(callable, :nullify_on => :account_id) }
+      let(:proto_hash) { { :name => 'foo bar', :email => 'foo@test.co', :nullify => [:account_id] } }
+
       before do
         transformers = User._protobuf_attribute_transformers
-        User.stub(:_protobuf_attribute_transformers).and_return(
-          {:account_id => lambda { |proto| nil }}.merge(transformers)
+        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
+          {:account_id => transformer}.merge(transformers)
         )
       end
 
       it "does not set the attribute" do
         attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes
+        expect(attribute_fields).to include(:account_id => nil)
       end
     end
 
     context "when a transformer is a callable that returns a value" do
       before do
         transformers = User._protobuf_attribute_transformers
-        User.stub(:_protobuf_attribute_transformers).and_return(
-          {:account_id => lambda { |proto| 1 }}.merge(transformers)
+        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
+          {:account_id => transformer}.merge(transformers)
         )
       end
 
       it "sets the attribute" do
         attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes.merge(:account_id => 1)
+        expect(attribute_fields).to eq user_attributes.merge(:account_id => 1)
       end
     end
 
     context "when a transformer is not defined for the attribute" do
       before {
-        User.stub(:_protobuf_convert_fields_to_attributes) do |key, value|
+        allow(User).to receive(:_protobuf_convert_fields_to_attributes) do |key, value|
           value
         end
       }
 
       it "converts the field value" do
         attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes
+        expect(attribute_fields).to eq user_attributes
       end
     end
   end
@@ -152,7 +175,7 @@ describe Protobuf::ActiveRecord::Transformation do
       before { User.attribute_from_proto :first_name, :extract_first_name }
 
       it "creates a callable method object from the converter" do
-        User.should_receive(:extract_first_name)
+        expect(User).to receive(:extract_first_name)
         User._protobuf_attribute_transformers[:first_name].call(1)
       end
     end
@@ -167,12 +190,13 @@ describe Protobuf::ActiveRecord::Transformation do
       let(:callable) { lambda { |proto| nil } }
 
       before {
-        User.stub(:_protobuf_attribute_transformers).and_return(Hash.new)
+        allow(User).to receive(:_protobuf_attribute_transformers).and_return(Hash.new)
         User.attribute_from_proto :account_id, callable
       }
 
-      it "adds the given converter to the list of protobuf field transformers" do
+      it "adds the given converter to the list of protobuf field transformers", :pending => 'missing expectation?' do
         User._protobuf_attribute_transformers[:account_id] = callable
+        fail
       end
     end
   end
@@ -183,7 +207,7 @@ describe Protobuf::ActiveRecord::Transformation do
 
     it "initializes a new Date object from the value" do
       Timecop.freeze(Date.current) do
-        User.convert_int64_to_date(int64).should eq date
+        expect(User.convert_int64_to_date(int64)).to eq date
       end
     end
   end
@@ -196,7 +220,7 @@ describe Protobuf::ActiveRecord::Transformation do
       Timecop.freeze(DateTime.current) do
         expected_datetime = Time.at(datetime.to_i)
         converted_datetime = User.convert_int64_to_datetime(int64)
-        converted_datetime.should eq expected_datetime
+        expect(converted_datetime).to eq expected_datetime
       end
     end
   end
@@ -207,14 +231,14 @@ describe Protobuf::ActiveRecord::Transformation do
 
     it "initializes a new Time object from the value" do
       Timecop.freeze(Time.current) do
-        User.convert_int64_to_time(int64).should be_within(1).of(time)
+        expect(User.convert_int64_to_time(int64)).to be_within(1).of(time)
       end
     end
   end
 
   describe "#attributes_from_proto" do
     it "gets attributes from the given protobuf message" do
-      User.should_receive(:attributes_from_proto).with(proto)
+      expect(User).to receive(:attributes_from_proto).with(proto)
       user.attributes_from_proto(proto)
     end
   end

data/spec/protobuf/active_record/transformer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ::Protobuf::ActiveRecord::Transformer do
+  let(:callable) { lambda { |proto| proto.name } }
+  let(:proto) { ::UserMessage.new(:name => 'test', :nullify => ['name']) }
+  let(:options) { {} }
+
+  subject { described_class.new(callable, options) }
+
+  describe '#call' do
+    it 'calls the callable' do
+      result = subject.call(proto)
+      expect(result).to eq('test')
+    end
+  end
+
+  describe '#nullify?' do
+    context 'no nullify_on set' do
+      it 'returns false' do
+        expect(subject.nullify?(proto)).to eq(false)
+      end
+    end
+
+    context 'nullify_on name' do
+      let(:options) { { :nullify_on => :name } }
+
+      context 'invalid message' do
+        let(:proto) { ::UserSearchMessage.new }
+
+        it 'returns false' do
+          expect(subject.nullify?(proto)).to eq(false)
+        end
+      end
+
+      context 'valid message' do
+        it 'returns true' do
+          expect(subject.nullify?(proto)).to eq(true)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,4 +10,18 @@ Bundler.require(:default, :development, :test)
 
 require 'support/db'
 require 'support/models'
-require 'support/protobuf'
+require 'support/protobuf'
+
+# Silence protobuf's logger
+::Protobuf::Logging.logger.level = ::Logger::FATAL
+
+RSpec.configure do |config|
+  # Turn deprecation warnings into errors with full backtrace.
+  config.raise_errors_for_deprecations!
+
+  # Verifies the existance of any stubbed methods, replaces better_receive and better_stub
+  # https://www.relishapp.com/rspec/rspec-mocks/v/3-1/docs/verifying-doubles/partial-doubles
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/support/definitions/user.proto

@@ -4,6 +4,7 @@ message UserMessage {
   optional string email        = 3;
   optional string email_domain = 4 [deprecated = true];
   optional string password     = 5;
+  repeated string nullify      = 6;
 }
 
 message UserSearchMessage {

data/spec/support/protobuf/user.pb.rb

@@ -20,6 +20,7 @@ class UserMessage
   optional :string, :email, 3
   optional :string, :email_domain, 4, :deprecated => true
   optional :string, :password, 5
+  repeated :string, :nullify, 6
 end
 
 class UserSearchMessage

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Adam Hutchison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-19 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -86,28 +86,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.0
 - !ruby/object:Gem::Dependency
   name: rspec-pride
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: pry-nav
   requirement: !ruby/object:Gem::Requirement
@@ -174,6 +174,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -195,6 +196,7 @@ files:
 - lib/protobuf/active_record/scope.rb
 - lib/protobuf/active_record/serialization.rb
 - lib/protobuf/active_record/transformation.rb
+- lib/protobuf/active_record/transformer.rb
 - lib/protobuf/active_record/validations.rb
 - lib/protobuf/active_record/version.rb
 - protobuf-activerecord.gemspec
@@ -203,6 +205,7 @@ files:
 - spec/protobuf/active_record/scope_spec.rb
 - spec/protobuf/active_record/serialization_spec.rb
 - spec/protobuf/active_record/transformation_spec.rb
+- spec/protobuf/active_record/transformer_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb
@@ -231,7 +234,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Google Protocol Buffers integration for Active Record
@@ -241,6 +244,7 @@ test_files:
 - spec/protobuf/active_record/scope_spec.rb
 - spec/protobuf/active_record/serialization_spec.rb
 - spec/protobuf/active_record/transformation_spec.rb
+- spec/protobuf/active_record/transformer_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb