When I first saw Ruby 1.9 new method Object#tap I slightly overlooked it and felt that this method may not be useful. But recently in one of my project I realized that how it can improve the reability of the code and avoids un-necessary return statements.

1
2
3
4
5
6
7
8
9
10

class Student
  attr_accessor :name, :age, :std
  def initialize name, age, std
      @name, @age, @std = [name, age, std]
  end

  def to_s
      "#{@name} #{@age} #{@std}"
  end
end

If we want to print and return the student object after creating it, without tap the code will look like:

1
2
3
4
5
6
7

class StudentFactory
  def self.create_student(name, age, std)
      student = Student.new(name, age, std)
      p student.to_s
      student
  end
end

The same can be made more readable and prettier with the help of tap

1
2
3
4
5

class StudentFactory
  def self.create_student(name, age, std)
      Student.new(name, age, std).tap { |student| p student.to_s }
  end
end

Rails offers two different way to implement the many to many association, this post will guide you to choose the right association for your project need

1
2
3
4
5
6
7

class Post
  has_and_many_belongs_to_many :comments
end

class Comments
  has_and_many_belongs_to_many :posts
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Post
  has_many :commentables
  has_many :comments, :through => :commentables
end

class Comment
  has_many :commentables
  has_many :posts, :through => :commentables
end

class Commentable
  belongs_to :post
  belongs_to :comment
end

In both approach, the intermediate table is going to hold the relation and also will yield the same result but when to choose what, still puzzled?

Pointers to choose has_and_belongs_to_many. If you choose not to:

• Access the model which holds the relationship
• Have any validations for the association
• Read the associaton through the relationship

To make it more clear, lets try to restrict the number of comments for a post. This as well can be implemented in many ways but we (atleast I initally went with this approach) naturally tend to add logic in Post class

1
2
3
4
5
6
7
8
9
10

class Post
  has_many :commentables,
  has_many :comments, :through => :commentables, :before_add => :check_comment_limit

  private
  def check_comment_limit(comment)
      #If you want to stop comment getting added to post, you have to raise an error.
      raise 'Comment limit reached' if self.comments.count = 5
  end
end

Another approach to tackle this is to add validation logic to the Comment class

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Comment
  has_many :commentables,
  has_many :posts, through => :commentables

  validate :check_comment_limit

  private
  def check_comment_limit
      comment_count = self.posts.comment.count
      errors.add(:posts, 'Comment limit reached') if comment_count = 5
      #If you want to stop comment getting added to post, you have to raise an error.
      raise 'Comment limit reached' if comment_count = 5
  end
end

In both the approaches we have to raise an exception to prevent the comment from getting added to the post. I felt these approaches are not the conventional way of doing things, I went back and read the rails guide on association and rewrote the validation logic in the relation model which holds the association.

1
2
3
4
5
6
7
8
9
10
11
12

class Commentable
  belongs_to :post
  belongs_to :comment

  validate :check_comment_limit

  private
  def check_comment_limit
      comment_count = self.posts.comment.count
      errors.add(:post, 'Comment limit reached') if comment_count = 5
  end
end

We don’t have to raise the exception by ourself rails will handle it gracefully.

We all know that inject is very powerful when it comes to:

1

[1,2,3,4,5].inject(0) { |sum, n| sum += n }

Simillary we can use it create a hash from an array

1
2
3
4
5
6
7
8

#using inject
[[:tom,25],[:jerry,15]].inject({}) do |result, name_and_age|
  name, age = name_and_age
  result[name] = age
  result
end

=> {:tom=>25, :jerry=>15}

Now, closely look at line number 5 we are returning the result from the block and this is passed on the enumerator for processing the next object in the array.

We can avoid this extra return statement with the help of Enumerator.each_with_object

1
2
3
4
5
6
7

#using each_with_object
[[:tom,25],[:jerry,15]].each_with_object({}) do |name_and_age, result|
  name, age = name_and_age
  result[name] = age
end

=> {:tom=>25, :jerry=>15}

I am starting the blogging journey with a big thanks to Brandon Mathis for his wonderfull blogging framework Octopress based on Jekyll

What I liked more about this blogging framework is the KISS principle. I can stick to my favourite text editor vim, it won’t ask you unnecessary question on configuring the website. Everything will be up by few commands (Hmm… yes actually you might need some ruby based coding knowledge to start using this blogging framework). The framework is well documented as well

Well…. thats it for now, will write more on how did I configured and installed Octopress for my personal needs.