protip 0.18.5 → 0.18.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8aa9bb432c7fae05ac9e7f790545b1f50868bba1
-  data.tar.gz: d1abe3cf1d8a52ca3a13002ec89e520831cc8ed6
+  metadata.gz: a9c25de6d9f409c5bb8c1659951ecc4fa10a5aa4
+  data.tar.gz: aab7d4182c10f0a540dd5762ea3921dac899c2b1
 SHA512:
-  metadata.gz: 207674ca4d193805cab007b1ec73303d3ec3701186f3471245cd86f366fd6d967b25ad44982d02fcc5e0b44e1257e7bac93501db953de5acc1ae2047b5ca079a
-  data.tar.gz: 136aca0f48b4d564370bfe6674758ea8e67d2c32b29c2cc9d922e240d70cf9ccd4400ca590a2aed8eaa234a7d9a8bcd318a49cbcc1686b514d38bfb485391750
+  metadata.gz: 530e2c08bf013f25afea7d4be6eb254b85b192fb8ca374ceb09ef48ce3e9e703926ca07335bac5396edcacc129f29710cb2cb9e1b619508210ba39c8170335f9
+  data.tar.gz: d65a08e07c0365afadfdf614f731bcf5939deed2e463f4e3d4159f70b0691e1d9735567f33dd1edcf0d7c893f919a128f01e0e634aceec33c4761422aa502e81

data/lib/protip/resource.rb

@@ -132,12 +132,13 @@ module Protip
           end
 
           define_method "#{field.name}=" do |new_value|
-            old_wrapped_value = @wrapper.send(field.name)
+            old_value = self.message[field.name] # Only compare the raw values
             @wrapper.send("#{field.name}=", new_value)
-            new_wrapped_value = @wrapper.send(field.name)
+            new_value = self.message[field.name]
 
-            # needed for ActiveModel::Dirty
-            send("#{field.name}_will_change!") if new_wrapped_value != old_wrapped_value
+            # Need to check that types are the same first, otherwise protobuf gets mad comparing
+            # messages with non-messages
+            send("#{field.name}_will_change!") unless new_value.class == old_value.class && new_value == old_value
           end
 
           # needed for ActiveModel::Dirty
@@ -263,8 +264,23 @@ module Protip
     end
 
     def assign_attributes(attributes)
-      # the resource needs to call its own setters so that fields get marked as dirty
-      attributes.each { |field_name, value| send("#{field_name}=", value) }
+      old_attributes = {}
+      descriptor = message.class.descriptor
+      attributes.keys.each do |key|
+        field = descriptor.lookup(key.to_s)
+        value = message[key.to_s]
+        # If the current value is a message, we need to clone it to get a reasonable comparison later,
+        # since we might just assign attributes to the current instance of the message directly
+        old_attributes[key] = field && field.type == :message && value ? value.clone : value
+      end
+      @wrapper.assign_attributes attributes
+      attributes.keys.each do |key|
+        old_value = old_attributes[key]
+        new_value = message[key.to_s]
+        unless old_value.class == new_value.class && old_value == new_value
+          send "#{key}_will_change!"
+        end
+      end
       nil # return nil to match ActiveRecord behavior
     end
 

data/lib/protip/wrapper.rb

@@ -115,17 +115,11 @@ module Protip
         field = message.class.descriptor.lookup(field_name.to_s) ||
           (raise ArgumentError.new("Unrecognized field: #{field_name}"))
 
-        # For inconvertible nested messages, the value should be either a hash or a message
-        if field.type == :message && !converter.convertible?(field.subtype.msgclass)
-          if value.is_a?(field.subtype.msgclass) # If a message, set it directly
-            set(field, value)
-          elsif value.is_a?(Hash) # If a hash, pass it through to the nested message
-            wrapper = get(field) || build(field.name) # Create the field if it doesn't already exist
-            wrapper.assign_attributes value
-          else # If value is a simple type (e.g. nil), set the value directly
-            set(field, value)
-          end
-        # Otherwise, if the field is a convertible message or a simple type, we set the value directly
+        # For inconvertible nested messages, we allow a hash to be passed in with nested attributes
+        if field.type == :message && !converter.convertible?(field.subtype.msgclass) && value.is_a?(Hash)
+          wrapper = get(field) || build(field.name) # Create the field if it doesn't already exist
+          wrapper.assign_attributes value
+        # Otherwise, if the field is a message (convertible or not) or a simple type, we set the value directly
         else
           set(field, value)
         end
@@ -224,7 +218,7 @@ module Protip
         elsif nested_resources.has_key?(field.name.to_sym)
           value.message
         else
-          raise ArgumentError.new "Cannot convert from Ruby object: \"#{field}\""
+          raise ArgumentError.new "Cannot convert from Ruby object: \"#{field.name}\""
         end
       elsif field.type == :enum
         value.is_a?(Fixnum) ? value : value.to_sym

data/test/unit/protip/resource_test.rb

@@ -515,9 +515,97 @@ module Protip::ResourceTest # Namespace for internal constants
           attrs = {id: 2}
           assert_equal resource_message_class.new(attrs), resource_class.new(attrs).message
         end
+
+        it 'allows nested attributes to be given' do
+          attrs = {
+            nested_message: {
+              number: 3
+            }
+          }
+          assert_equal nested_message_class.new(number: 3), resource_class.new(attrs).message.nested_message
+        end
       end
     end
 
+    # Shared behavior for direct setters and #assign_attributes. The setter object must be able to be
+    # initialized as +setter_class.new(resource)+, and must respond to +setter.set({field => value, field2 => value2})+
+    # by performing the appropriate operation (e.g. +.field=+ or +.assign_attributes+).
+    def self.describe_dirty_attributes_setter(setter_class)
+
+      describe 'dirty attributes' do
+        let :converter do
+          Class.new do
+            include Protip::Converter
+          end.new
+        end
+
+        let :resource do
+          resource_class.new resource_message_class.new({
+                                                          string: 'foo',
+                                                          nested_message: nested_message_class.new(number: 32)
+                                                        })
+        end
+
+        let :setter do
+          setter_class.new(resource)
+        end
+
+        before do
+          resource_class.converter = converter
+          raise 'sanity check failed' if resource.changed? || resource.string_changed? || resource.nested_message_changed?
+        end
+
+        it 'recognizes changes in scalar values' do
+          setter.set string: 'bar'
+          assert resource.changed?, 'resource was not marked as changed'
+          assert resource.string_changed?, 'field was not marked as changed'
+        end
+
+        it 'recognizes when scalar values do not change' do
+          setter.set string: 'foo'
+          refute resource.changed?, 'resource was marked as changed'
+          refute resource.string_changed?, 'field was marked as changed'
+        end
+
+        describe '(message attributes)' do
+          before do
+            converter.stubs(:convertible?).with(nested_message_class).returns(true)
+            converter.stubs(:to_message).with(42, nested_message_class).returns(nested_message_class.new(number: 52))
+            converter.stubs(:to_object).with(nested_message_class.new(number: 52)).returns(42)
+            converter.stubs(:to_object).with(nested_message_class.new(number: 62)).returns(72)
+          end
+          it 'marks convertible messages as changed if they are changed as Ruby values' do
+            setter.set nested_message: 42
+            assert resource.changed?, 'resource was not marked as changed'
+            assert resource.nested_message_changed?, 'field was not marked as changed'
+          end
+          it 'marks sub-messages as changed if they are changed as messages' do
+            setter.set nested_message: nested_message_class.new(number: 62)
+            assert resource.changed?, 'resource was not marked as changed'
+            assert resource.nested_message_changed?, 'field was not marked as changed'
+          end
+          it 'marks sub-messages as changed when they are nullified' do
+            setter.set nested_message: nil
+            assert resource.changed?, 'resource was not marked as changed'
+            assert resource.nested_message_changed?, 'field was not marked as changed'
+          end
+          it 'recognizes when convertible messages are not changed when set as Ruby values' do
+            resource.message.nested_message.number = 52
+            raise 'sanity check failed' if resource.changed? || resource.nested_message_changed?
+            setter.set nested_message: 42
+            refute resource.changed?, 'resource was marked as changed'
+            refute resource.string_changed?, 'field was marked as changed'
+          end
+          it 'recognizes when sub-messages are not changed when set as messages' do
+            setter.set nested_message: nested_message_class.new(number: 32)
+            refute resource.changed?, 'resource was marked as changed'
+            refute resource.string_changed?, 'field was marked as changed'
+          end
+        end
+      end
+    end
+
+
     describe 'attribute writer' do
       before do
         resource_class.class_exec(resource_message_class) do |resource_message_class|
@@ -532,24 +620,11 @@ module Protip::ResourceTest # Namespace for internal constants
         resource.string = test_string
       end
 
-      it 'marks the resource and attribute as changed if the value is changed' do
-        resource = resource_class.new string: 'original'
-        resource.string = 'new'
-        assert resource.changed?, 'resource should be marked as changed'
-        assert resource.string_changed?, 'string field should be marked as changed'
-      end
-
-      it 'does not mark the resource and attribute as changed if the value is not changed' do
-        resource = resource_class.new string: 'original'
-        resource.send :changes_applied # clear the changes
-        # establish that the changes were cleared
-        assert !resource.changed?, 'resource should be not marked as changed'
-        assert !resource.string_changed?, 'string field should not be marked as changed'
-
-        resource.string = 'original'
-        assert !resource.changed?, 'resource should be not marked as changed'
-        assert !resource.string_changed?, 'string field should not be marked as changed'
+      setter_class = Class.new do
+        def initialize(resource) ; @resource = resource ; end
+        def set(attributes) ; attributes.each{|attribute, value| @resource.public_send(:"#{attribute}=", value)} ; end
       end
+      describe_dirty_attributes_setter(setter_class)
     end
 
     describe '#assign_attributes' do
@@ -559,15 +634,55 @@ module Protip::ResourceTest # Namespace for internal constants
         end
       end
 
-      it 'calls the attribute writer for each attribute' do
-        resource = resource_class.new
-        test_string = 'whodunnit'
-        resource.expects(:string=).with(test_string)
-        resource.assign_attributes(string: test_string)
+      let :resource do
+        resource_class.new
+      end
+
+      it 'delegates to #assign_attributes on the wrapper' do
+        # Instantiate the resource before setting the expectation, since assign_attributes is allowed to be
+        # called during #initialize as well
+        resource
+
+        Protip::Wrapper.any_instance.expects(:assign_attributes).with(string: 'foo')
+        resource.assign_attributes string: 'foo'
+      end
+
+      setter_class = Class.new do
+        def initialize(resource) ; @resource = resource ; end
+        def set(attributes) ; @resource.assign_attributes attributes ; end
+      end
+      describe_dirty_attributes_setter setter_class
+      describe 'dirty attributes (nested hashes)' do
+
+        it 'marks nested hashes as changed if they set a new field' do
+          resource.assign_attributes nested_message: {number: 52}
+          assert resource.changed?, 'resource was not marked as changed'
+          assert resource.nested_message_changed?, 'field was not marked as changed'
+        end
+
+        describe '(when a nested message has an initial value)' do
+          before do
+            resource.nested_message = nested_message_class.new(number: 32)
+            resource.send(:changes_applied) # Clear the list of changes
+            # Sanity check
+            raise 'unexpected' if resource.changed? || resource.string_changed? || resource.nested_message_changed?
+          end
+
+          it 'marks nested hashes as changed if they change a field' do
+            resource.assign_attributes nested_message: {number: 42}
+            assert resource.changed?, 'resource was not marked as changed'
+            assert resource.nested_message_changed?, 'field was not marked as changed'
+          end
+
+          it 'does not mark nested hashes as changed if they do not change the underlying message' do
+            resource.assign_attributes nested_message: {number: 32}
+            refute resource.changed?, 'resource was marked as changed'
+            refute resource.nested_message_changed?, 'field was marked as changed'
+          end
+        end
       end
 
       it 'returns nil' do
-        resource = resource_class.new
         assert_nil resource.assign_attributes(string: 'asdf')
       end
     end

data/test/unit/protip/wrapper_test.rb

@@ -255,7 +255,7 @@ module Protip::WrapperTest # namespace for internal constants
           wrapper.assign_attributes inner: {value: 50, note: 'noted'}
         end
 
-        it "sets message fields to nil when they're assigned nil" do
+        it 'sets message fields to nil when they\'re assigned nil' do
           wrapped_message.inner = inner_message_class.new(value: 60)
           assert wrapped_message.inner
           wrapper.assign_attributes inner: nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protip
 version: !ruby/object:Gem::Version
-  version: 0.18.5
+  version: 0.18.6
 platform: ruby
 authors:
 - AngelList
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel