{"id":113,"date":"2020-12-20T07:05:43","date_gmt":"2020-12-20T07:05:43","guid":{"rendered":"https:\/\/manishshrivastava.com\/blog\/?p=113"},"modified":"2020-12-20T07:29:47","modified_gmt":"2020-12-20T07:29:47","slug":"write-awesome-code-ruby-on-rails","status":"publish","type":"post","link":"https:\/\/manishshrivastava.com\/blog\/write-awesome-code-ruby-on-rails\/","title":{"rendered":"How to Write Awesome code – Ruby on Rails – V1"},"content":{"rendered":"\n

Everyone wish to write the better code, But How, Is there any pattern \/ behaviour? Can anyone point to your code what can be improved?<\/h2>\n\n\n\n

The answer is YES<\/strong>, There is pattern you should follow the OOPS<\/a> way by it’s core. I have written SOLID principle<\/a> before this, Please check this too. I am going to write more series in this topic as it’s really interesting and helpful to everyone.<\/p>\n\n\n\n

\"focus
Focus on one thing in a Class<\/figcaption><\/figure>\n\n\n\n

In Ruby it’s damn easy but we don’t understand what mistake we are doing, so chances of improvement is less. So, Let’s take an example of below MyClass<\/em> in code1 as below.<\/p>\n\n\n\n

Code1:<\/p>\n\n\n\n

class MyClass\n  attr_reader :input\n  \n  def initialize(input)\n    @input = input\n  end\n\n  def double\n    case input\n      when Numeric  then target . 2 \n      when String   then target.next    # lazy fail ex\n      when Array    then target.collect {|o| MyClass.new(o).double}\n      else\n        raise \u201cdon\u2019t know how to double #{input.class} #{input.inspect}\u201d\n    end\n  end\nend<\/code><\/pre>\n\n\n\n
<\/p>\n\n\n\n
The result of the code1 is Output1 as below:
<\/p>\n\n\n\n
>> MyClass.new(\u2018aaa\u2019).double\n=> \"aab\"\n>> MyClass.new(49).double\n=> 98\n>> MyClass.new([\u2018b\u2019, 6]).double\n=> [\"c\", 12]\n>> MyClass.new({\u2018x\u2019=>\u2018y\u2019}).double\nRuntimeError: don\u2019t know how to double Hash {\"x\"=>\"y\"}\n        from (irb):73:in `double'\n        from (irb):80\n        from :0<\/code><\/pre>\n\n\n\n
The above code looks Good, Right ?<\/p>\n\n\n\n
You\u2019re probably used \/ gone thought with this pattern. and, Its everywhere in Ruby on Rails.<\/p>\n\n\n\n
But, This style of code is Absolutely Wrong and that you should do a different thing.<\/p>\n\n\n\n
Why is the problem in above code?<\/strong><\/h3>\n\n\n\n
If I change how double<\/code> works on any of these classes, MyClass<\/code> must change, but that\u2019s not the real problem. What happens if MyClass<\/code> wants to double some new kind of object? I have to go into MyClass<\/code> and add a new branch to the case statement. How annoying is that?<\/p>\n\n\n\n
But that\u2019s the least of it. If I\u2019m writing code that follows this pattern, I likely have many classes that do stuff based on the classes of their collaborators. My entire application behaves this way. Every time I add a new collaborating object I have to go change code everywhere. Each subsequent change makes things worse. My application is a teetering house of cards and eventually it will come tumbling down.<\/p>\n\n\n\n
Also, what if some other wishes to use MyClass<\/code> with their new SuperDuperClass<\/code> object? They can\u2019t reuse MyClass<\/code> without changing it since MyClass<\/code> has a very limited notion of what kinds of objects can be doubled.<\/p>\n\n\n\n
MyClass<\/code> is both rigid and closed for extension.<\/p>\n\n\n\n
Code2<\/em>:<\/p>\n\n\n\n
class Numeric\n  def double\n    self * 2\n  end\nend\n\nclass String\n  def double\n    self.next \n  end\nend\n\nclass Array\n  def double\n    collect {|e| e.double}\n  end\nend\n\nclass Object\n  def double\n    raise \"don't know how to double #{self.class} #{self.inspect}\"\n  end\nend\n\nclass MyClass\n  attr_reader :input\n  \n  def initialize(input)\n    @input = input\n  end\n\n  def double\n    input.double\n  end\nend<\/code><\/pre>\n\n\n\n
What basically it should be as below (Something like this) :<\/p>\n\n\n\n
Using this new code, Output1 will be the same as before, but now we can also use this way as output2:<\/p>\n\n\n\n
Output2:<\/em><\/p>\n\n\n\n
>> 'aaa'.double\n=> \"aab\"\n>> 49.double\n=> 98\n>> ['b', 6].double\n=> [\"c\", 12]<\/code><\/pre>\n\n\n\n
<\/p>\n\n\n\n
In this above code2, <\/p>\n\n\n\n
The Objects are what they are and because of that, they actually behave the way they do.<\/strong><\/h3>\n\n\n\n
Above statement is very simple but incredibly important<\/strong>. <\/p>\n\n\n\n
They tell each other what<\/strong>, not how<\/strong>.<\/p>\n\n\n\n
What<\/strong> is the event\/notification\/request and it is the responsibility of the sender.(sender should know).<\/p>\n\n\n\n
How<\/strong> is the behaviour\/implementation and it should be completely hidden in the receiver (sender not required to know).<\/p>\n\n\n\n
Therefore<\/strong>:<\/p>\n\n\n\n