Join the social network of Tech Nerds, increase skill rank, get work, manage projects...
 

  • Rails code patterns Decorator/Presenter (Refacotring)

    @ravindra.rawat
    Recommendations Offline Message

    • 0
    • 0
    • 0
    • 0
    • 1
    • 0
    • 0
    • 0
    • 581
    Comment on it

    In my previous article i explained when we should refactor code and how to refactor. Lets take our discussion further to decorator/presenter pattern. Decorator/Presenter pattern have been overly used in rails community. There is a thin line between decorator and presenter.  I started my efforts to understand the idea behind this. I read few blogs/articles which explained the details. I have gathered my findings here in an effort to help others. I am thankful to the techies who wrote such nice blogs and explained in details.

     

    While building ruby on rails application we put all of the business logic in our models. However, some of the logic may not be directly related to the models or may be required in our views or some controllers. These fat codes clutter the models and put extra burdens. Here comes the decorator pattern to rescue. We can use decorators to extract fat codes from models.

     

    The idea of decorators seem to come from excessive methods being used in our view helpers. Helpers are modules which keeps our views related methods. However helpers are not object oriented. We have to pass the object in the helper methods. Keeping logic in views was never a good idea. For example: calling active record queries in views

     

    A decorator is a class that adds functionality to a specific object by wrapping it, without affecting other instances of that class. Decorator takes object in its constructor. Using decorator we can encapsulate methods intended for use by the views. This way we can keep the models separate but still access the properties.

    Sometimes a presenter is a decorator. A presenter is a class that adds presentation functionality to another class object.


    We can define decorators using couple of ways, lets use rails SimpleDelegator class:

    1. class Decorator < SimpleDelegator
    2. end
    3.  
    4. class Product
    5.   def price
    6.     500
    7.   end
    8. end
    9.  
    10. product = Product.new
    11. car.price #=> 500
    12.  
    13. now lets decorate our product object using decorator class we created:
    14.  
    15. decorated_product = Decorator.new(product)
    16. decorated_product.price #=> 500

     

    NOTE: Have you noticed, we called "price" method on decorated object. The method was not defined in Decorator class though. So decorator delegates the undefined methods to the decorated object.

     

    We can define price method in our decorator:

    1. class Decorator < SimpleDelegator
    2.   def price
    3.     super + 100
    4.   end
    5. end
    6.  
    7.  
    8. now lets decorate our product object using decorator class we created:
    9.  
    10. decorated_product = Decorator.new(product)
    11. decorated_product.price #=> 600
    12. decorated_product.class
    13. #=> Decorator
    14.  
    15.  
    16. product.price #=> 500
    17. product.class
    18. #=> Product


    Note: What we noticed, decorators do not modify the objects, it adds functionality by wrapping the object inside.

     

    Let's take a good example to see in details. Suppose we order a product from some e-commerce website. The buyer have options to take insurance on a product by taking some insurance plan. The product price changes with the insurance plan.  
     

    1. class ProductDecorator < SimpleDelegator
    2.   def coverage
    3.     "0%"
    4.   end
    5. end
    6.  
    7. class WithPlatinumInsuranceDecorator < SimpleDelegator
    8.   def price
    9.     price = super
    10.     price+(price*0.2)
    11.   end
    12.  
    13.   def coverage
    14.     "40%"
    15.   end
    16. end
    17.  
    18. class WithGoldInsuranceDecorator < SimpleDelegator
    19.   def price
    20.     price = super
    21.     price+(price*0.4)
    22.   end
    23.  
    24.   def coverage
    25.     "60%"
    26.   end
    27. end
    28.  
    29. class WithDiamondInsuranceDecorator < SimpleDelegator
    30.   def price
    31.     price = super
    32.     price+(price*0.6)
    33.   end
    34.  
    35.   def coverage
    36.     "80%"
    37.   end
    38. end
    39.  
    40.  
    41. platinum_pro = WithPlatinumInsuranceDecorator.new(product)
    42. gold_pro = WithGoldInsuranceDecorator.new(product)
    43. diamond_pro = WithDiamondInsuranceDecorator.new(product)
    44.  
    45. platinum_pro.price
    46. #=> 600.0
    47.  
    48. gold_pro.price
    49. #=> 700.0
    50.  
    51. diamond_pro.price
    52. #=> 800.0
    53.  
    54. product.price
    55. #=> 500.0


    NOTE: In above example we could have used inheritance to create subclasses instead of using multiple decorators. However, there are some downside for using inheritance in this particular example. First, the requirement is much related to presenter/view then ActiveRecord classes. There will be a tight coupling between classes, also any changes in superclass internals will affect subclasses.


    Let's create a method to accept collection in decorator:

    1. class Decorator < SimpleDelegator
    2.   def self.wrap_collection(collection)
    3.     collection.map do |obj|
    4.         new obj
    5.     end
    6.   end
    7.  
    8.   def price
    9.     super + 100
    10.   end
    11. end
    12.  
    13.  
    14. products = 1.upto(5).map{|f| Product.new}
    15.  => [#<Product:0x007feed80d4d90>, #<Product:0x007feed80d4d68>, #<Product:0x007feed80d4d40>, #<Product:0x007feed80d4d18>, #<Product:0x007feed80d4cf0>]
    16. products.first.class
    17. #=> Product
    18.  
    19.  
    20. decorators = Decorator.wrap_collection(products)
    21.  => [#<Product:0x007feed80d4d90>, #<Product:0x007feed80d4d68>, #<Product:0x007feed80d4d40>, #<Product:0x007feed80d4d18>, #<Product:0x007feed80d4cf0>]
    22.  
    23. decorators.first.class
    24. #=> Decorator


    NOTE: We can use multiple decorators by wrapping each other. Decorator encapsulate the decorated object without affecting it and adds new methods.

     

    For further details please visit:  https://bibwild.wordpress.com/2012/12/19/the-simplest-rails-decorator-implementation-that-just-might-work/

    Coding style decorators refactor Design pattern RubyonRails
    Comment on it

 1 Comment(s)

Sign In
Forgot Password?
                           OR                           
Create an account !!
                           OR                           
Register

Sign up using

                           OR                           
Forgot Password
Reset Password
Fill out the form below and reset your password: