{"id":18,"date":"2019-03-08T12:42:00","date_gmt":"2019-03-08T12:42:00","guid":{"rendered":""},"modified":"2019-03-12T21:45:27","modified_gmt":"2019-03-12T21:45:27","slug":"ruby-best-practice-implementing-operator-and-ensuring-it-doesnt-break","status":"publish","type":"post","link":"https:\/\/ntlx.org\/de\/2019\/03\/ruby-best-practice-implementing-operator-and-ensuring-it-doesnt-break.html","title":{"rendered":"Ruby best practice: Implementing operator == and ensuring it doesn’t break"},"content":{"rendered":"

In ruby, comparing hashes, strings and objects is a complicated topic. Should you use equal?<\/i>, eql?<\/i> or ==<\/i>? There is plenty of help on this topic, but in this post, we will focus on the interesting behavior of the ==<\/i> operator and how you can make it behave as you need it for your use case.<\/p>\n

When comparing Hashes in Ruby, the ==<\/i> operator compares the content of a hash recursively.<\/p>\n

\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20<\/pre>\n<\/td>\n
\n
my_hash = {\n    :sub_hash<\/span> => {\n        :value<\/span> => 42<\/span>\n    }\n}\n\nmy_second_hash = {\n    :sub_hash<\/span> => {\n        :value<\/span> => 42<\/span>\n    }\n}\n\nmy_third_hash = {\n    :sub_hash<\/span> => {\n        :value<\/span> => 21<\/span>\n    }\n}\n\nputs<\/span> \"my_hash == my_second_hash? <\/span>#{<\/span>my_hash == my_second_hash}<\/span>\"<\/span>\nputs<\/span> \"my_hash == my_third_hash? <\/span>#{<\/span>my_hash == my_third_hash}<\/span>\"<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
<\/p>\n
\n\n\n\n
\n
1\n2<\/pre>\n<\/td>\n
\n
my_hash == my_second_hash? true<\/span>\nmy_hash == my_third_hash? false<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Unfortunately, when comparing objects of arbitrary classes, the default operator only compares the object identity.<\/p>\n
\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10<\/pre>\n<\/td>\n
\n
class<\/span> MyClass<\/span>\n  def<\/span> initialize<\/span>(value)\n    @value<\/span> = value\n  end<\/span>\nend<\/span>\n\nmy_object = MyClass<\/span>.new(42<\/span>)\nmy_second_object = MyClass<\/span>.new(42<\/span>)\n\nputs<\/span> \"my_object == my_second_object? <\/span>#{<\/span>my_object == my_second_object}<\/span>\"<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
<\/p>\n
\n\n\n\n
\n
1<\/pre>\n<\/td>\n
\n
my_object == my_second_object? false<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
If you want to do a deep comparison of objects of your class, you need to implement your own operator ==<\/i> by overriding the existing operator.<\/p>\n
\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16<\/pre>\n<\/td>\n
\n
class<\/span> MyClass<\/span>\n  attr_reader<\/span> :value<\/span>\n\n  def<\/span> initialize<\/span>(value)\n    @value<\/span> = value\n  end<\/span>\n\n  def<\/span> ==<\/span>(other)\n    other.respond_to?(\"value\"<\/span>) && value == other.value\n  end<\/span>\nend<\/span>\n\nmy_object = MyClass<\/span>.new(42<\/span>)\nmy_second_object = MyClass<\/span>.new(42<\/span>)\n\nputs<\/span> \"my_object == my_second_object? <\/span>#{<\/span>my_object == my_second_object}<\/span>\"<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
<\/p>\n
\n\n\n\n
\n
1<\/pre>\n<\/td>\n
\n
my_object == my_second_object? true<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
That was easy. But imagine this was a bigger class and someone else needed to add a property, not being aware of the existence of this operator and some other code depending on it to ensure no public member of the object changed. How can you ensure such a change doesn’t sneak in unnoticed?<\/p>\n
I stumbled across the following solution when implementing an operator == for a class in the BOSH<\/a> code together with my colleague Max<\/a>.<\/p>\n
As BOSH code is written in TDD – and your code should be as well – writing a test that breaks with a change as the one described above should ensure the operator to keep working. But how can such a test look like?<\/p>\n
Consider the following change to our code above:<\/p>\n
\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18<\/pre>\n<\/td>\n
\n
class<\/span> MyClass<\/span>\n  attr_reader<\/span> :value<\/span>\n  attr_reader<\/span> :value_new<\/span>\n\n  def<\/span> initialize<\/span>(value)\n    @value<\/span> = value\n    @value_new<\/span> = value\n  end<\/span>\n\n  def<\/span> ==<\/span>(other)\n    other.respond_to?(\"value\"<\/span>) && value == other.value\n  end<\/span>\nend<\/span>\n\nmy_object = MyClass<\/span>.new(42<\/span>)\nmy_second_object = MyClass<\/span>.new(42<\/span>)\n\nputs<\/span> \"my_object == my_second_object? <\/span>#{<\/span>my_object == my_second_object}<\/span>\"<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
To detect the variable @value_new<\/i> has been added using rspec <\/i>can be done with a test like the following:<\/p>\n
\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32<\/pre>\n<\/td>\n
\n
require<\/span> '.\/object_compare_op'<\/span>\n\ndescribe :MyClass<\/span> do<\/span>\n  describe 'operator =='<\/span> do<\/span>\n    context 'when instance variables are modified'<\/span> do<\/span>\n      let :obj<\/span> do<\/span>\n        MyClass<\/span>.new(42<\/span>)\n      end<\/span>\n      let :other_obj<\/span> do<\/span>\n        MyClass<\/span>.new(42<\/span>)\n      end<\/span>\n\n      all_members = MyClass<\/span>.new(0<\/span>).instance_variables.map { |var| var.to_s.tr('@'<\/span>, ''<\/span>) }\n      all_members.each do<\/span> |member|\n        it \"returns false when <\/span>#{<\/span>member}<\/span> is modified\"<\/span> do<\/span>\n          eval<\/span> <<-END_EVAL<\/span>\n            class MyClass<\/span>\n              def modify_#{member}<\/span>\n               @#{member} = 'foo'<\/span>\n              end<\/span>\n            end<\/span>\n          END_EVAL<\/span>\n          obj.send(\"modify_<\/span>#{<\/span>member}<\/span>\"<\/span>)\n          expect(obj == other_obj).to(\n            equal(false<\/span>),\n            \"Modification of <\/span>#{<\/span>member}<\/span> not detected by == operator.\"<\/span>,\n          )\n        end<\/span>\n      end<\/span>\n    end<\/span>\n  end<\/span>\nend<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
The variable @value_new<\/i> only has an attribute reader, so we cannot simply assign a new value. But this doesn’t stop you from changing the value. Not in Ruby. Using the eval in the test, we add a method for all existing instance variables of MyClass<\/i> (one in each iteration) that modifies the member.<\/p>\n
Afterwards, the newly added method is called to change the value of the member and the expect checks if the operator detects the modification. And – for our code above – will fail. Hence, whenever someone adds a new member to MyClass<\/i>, he will be reminded to also it to the operator == by this test. Even if the code of test itself might not be as speaking, the output of the failing test is:<\/p>\n
 Modification of value_new not detected by == operator.<\/b><\/p>\n
In some situations you may want to exclude a member from this check as it is just internal or not important to the equality of two objects. To enable this, we added an exclude list for private members to the test. This adds a bit of complexity to adding new members to the class as the test will bother you and you also have to add the member to the exclude list, but it improves the safety of your operator ==.
\n<\/p>\n
\n\n\n\n
\n
 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34<\/pre>\n<\/td>\n
\n
require<\/span> '.\/object_compare_op'<\/span>\n\ndescribe :MyClass<\/span> do<\/span>\n  describe 'operator =='<\/span> do<\/span>\n    context 'when instance variables are modified'<\/span> do<\/span>\n      let :obj<\/span> do<\/span>\n        MyClass<\/span>.new(42<\/span>)\n      end<\/span>\n      let :other_obj<\/span> do<\/span>\n        MyClass<\/span>.new(42<\/span>)\n      end<\/span>\n\n      all_members = MyClass<\/span>.new(0<\/span>).instance_variables.map { |var| var.to_s.tr('@'<\/span>, ''<\/span>) }\n      private_members = %w[value_new]<\/span>\n      public_members = all_members - private_members\n      public_members.each do<\/span> |member|\n        it \"returns false when <\/span>#{<\/span>member}<\/span> is modified\"<\/span> do<\/span>\n          eval<\/span> <<-END_EVAL<\/span>\n            class MyClass<\/span>\n              def modify_#{member}<\/span>\n               @#{member} = 'foo'<\/span>\n              end<\/span>\n            end<\/span>\n          END_EVAL<\/span>\n          obj.send(\"modify_<\/span>#{<\/span>member}<\/span>\"<\/span>)\n          expect(obj == other_obj).to(\n            equal(false<\/span>),\n            \"Modification of <\/span>#{<\/span>member}<\/span> not detected by == operator.\"<\/span>,\n          )\n        end<\/span>\n      end<\/span>\n    end<\/span>\n  end<\/span>\nend<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
With this kind of test, you can easily implement comparison operators for your classes that check for object equality rather than identity and ensure you do not forget to add new members of the class also to the comparison.
\nYou can take a look at productive code in the BOSH code base here<\/a>. As you may see it’s not much different to what I presented here – it’s a universal approach to solve the problem.<\/p>\n","protected":false},"excerpt":{"rendered":"In ruby, comparing hashes, strings and objects is a complicated topic. Should you use equal?, eql? or ==? There is plenty of help on this topic, but in this post, we will focus on the interesting behavior of the == operator and how you can make it behave as you need it for your use… Artikel ansehen<\/a>","protected":false},"author":1,"featured_media":78,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[7,6,5],"_links":{"self":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/18"}],"collection":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/comments?post=18"}],"version-history":[{"count":2,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/18\/revisions"}],"predecessor-version":[{"id":79,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/18\/revisions\/79"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/media\/78"}],"wp:attachment":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/media?parent=18"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/categories?post=18"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/tags?post=18"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}