#monkeypatching

[ Dinle ]

Ruby Türkiye Ankara Buluşması #1 

Ruby Türkiye İstanbul Buluşması #3

Ruby 2.5.0-preview1 Released

Unsafe Object Deserialization Vulnerability in RubyGems

Introducing hanami-cli

Monkey Patching in Ruby - Real World Example

Rails 5.2 adds expiry option for signed and encrypted cookies and adds relative expiry time

7 Little-Known Ruby Methods To Help You Write Better Code

Upload Images to S3 in GraphQL Using Rails and Paperclip

Rails directory structure guide

Updating Deeply Nested Attributes with RSpec

Many times we do feel need to add a self desired functionality to ActiveRecord::Base and Monkey patching used to serve the purpose. Even though it worked just fine, there was no established structure to it. Often I’ve seen such monkey patches scattered all over the code-base adding to further confusion instead of providing any real value.

Rails 5 solves this by adding an abstract class ApplicationRecord to your app/models:

class ApplicationRecord < ActiveRecord::Base self.abstract_class = true end

Now, you can add your modifications to this class:

class ApplicationRecord < ActiveRecord::Base include CommonWellTestedMethods self.abstract_class = true end

Solution: When monkey patching a method, can you call the overridden method from the new implementation? #answer #solution #dev

When monkey patching a method, can you call the overridden method from the new implementation?

Say I am monkey patching a method in a class, how could I call the overridden method from the overriding method? I.e. Something a bit like super

E.g.

class Foo def bar() "Hello" end end class Foo def bar() super() + " World" end end >> Foo.new.bar == "Hello World"

Answer [by Veger]: When monkey…

Fixed Adding a Method to an Existing Object #dev #it #asnwer

Adding a Method to an Existing Object

I’ve read that it is possible to add a method to an existing object (e.g. not in the class definition) in python, I think this is called Monkey Patching (or in some cases Duck Punching). I understand that it’s not always a good decision to do so. But, how might one do this?

And if you don’t know python, can your language of choice do this? If so, how?

UPDATE…

How to: Adding a Method to an Existing Object

Adding a Method to an Existing Object

I’ve read that it is possible to add a method to an existing object (e.g. not in the class definition) in python, I think this is called Monkey Patching (or in some cases Duck Punching). I understand that it’s not always a good decision to do so. But, how might one do this?

And if you don’t know python, can your language of choice do this? If so, how?

UPDATE…

We started off with the first exercise by monkey patching the Array class to include our own implementation of Array#uniq. Two exercises into the day, we were faced with implementing our own Tower of Hanoi game in the command line. We went the object oriented route, creating Rod and Disc classes, and separating out the game logic. We ended up spending a majority of the morning getting it playable. You can check out the source here on github. 

We wrote a little stockpicker function, which took a history of stock prices by day, and told you on which days to buy and sell for maximum profit in the given range. And later we implemented the Caesar cipher using ASCII codes. The Caesar cipher, is a simple offset cipher. For example in a Caesar cipher which offsets by two: a => c, b => d, ... x => z, y => a, z => b. So 'hello' => 'jgnnq'. Luckily,  String#each_byte and Fixnum#chr came in handy when going from some character to the ASCII code and back. The only catch was dealing with characters that were offset past 'z', in which case we'd have to take the overflow and start back at 'a'. 

After implementing our own Set class using the functionality of Hash, we spent a majority of the afternoon working on learn_ruby's exercise 15 "in_words". The exercise monkeypatches Fixnum to include Fixnum#in_words, a method takes a number under one-quadrillion and converts it into a string representation. For example 1000013.in_words should return "one million thirteen" (I know, I know, it should be "one-million thirteen", but that wasn't in the spec). 

The exceptions in converting numbers to words were killer. We ended up taking blocks of three numbers at a time, converting the block to words, and then optionally tacking on a suffix like "million", depending on where the block occurred on the input number.

While it was a little bit messy, we ended up getting it to pass the test. I'd like to come through and refactor this code if I ever get the chance. But that's for another day.

We ended our first day by starting work on a maze solver. But sadly we weren't able to finish. Some other time perhaps.

Classes in Ruby are open; right. That means you can do anything with them, monkey patching around it. But stop doing it before you run into any trouble. I myself used to do it.

Reopening a class to redefine a method that’s been inherited. But it’s wrong as in future you or your colleague might end up asking question to yourself/himself “Why this method is behaving like this”. Because at that time you might or might not aware about that overriding.

Here I am trying to show how we can make it safer.

str.method says it’s coming from MyString; so you might think this method is overridden, But you may not want it. So you try to undefine this method from MyString,

but it does also undefine method inherited from String. That is dangerous. But we would have overcome from this situation if we had did it differently rather rightly.

str.method :empty? points you that this method is coming from a included module MonkeyPatch::MonkeyString. So we go ahead and remove this method from module MonkeyPatch::MonkeyString.

and our good'ol buddy empty? is back again in action.