Join table for has_many through in Rails

In Rails there are two ways to do many-to-many relationships:

has_and_belongs_to_many

sets up a many to many relationship without an intervening model.

class Category < ActiveRecord::Base
  has_and_belongs_to_many :products
end

class Product < ActiveRecord::Base
  has_and_belongs_to_many :categories
end

This is a good choice if you know that you will not need to store any additional data about the relationship or add any additional functionality - which in practice is actually really rare. It uses less memory since it does not have to instantiate an extra model just to do product.category.

When using has_and_belongs_to_many the convention is that the join table is named after the two entities in plural.

Category + Product = products_categories

The order does not seem to matter.

has_many through:

as you already have guessed uses an intermediate model.

class CategoryProduct < ActiveRecord::Base
  belongs_to :product
  belongs_to :category
end

class Category < ActiveRecord::Base
  has_many :category_products
  has_many :products, through: :category_products
end

class Product < ActiveRecord::Base
  has_many :category_products
  has_many :categories, through: :category_products
end

The advantage here is that you can store and retrieve additional data in the join table which describes the relationship. For example if you wanted to store who added a product to a category - or when the relationship was created.

In order to for Rails to be able to correctly find the ProductCategory class the has_many though the naming convention is:

model 1(singular) + model 2(plural) 
Product + Category = category_products

This is due to the way that rails infers the model class based on the table name. Using categories_products would case rails to look for Category::CategoriesProduct as plural words are interpreted as modules. However this is really just a lazy naming convention and there is often a noun which better descibes the relation between A and B (such as Categorization).

Many to Many in forms and controllers.

As IvanSelivanov already mentioned SimpleForm has helper methods for creating selects, checkboxes etc.

• https://github.com/plataformatec/simple_form#associations

But instead of overriding the .to_s method in your model you may want to use the label_method option instead.

f.assocation :categories, as: :checkboxes, label_method: :name

Overriding .to_s can make debugging harder and in some cases give confusing test error messages.

To whitelist the params in your controller you would do:

class ProductsController < ApplicationController
  def create
    @product = Product.new(product_params)
    if @product.save
      redirect_to @product
    else
      render :new
    end
  end

  def product_params
     params.require(:product)
           .permit(:name, :categories_ids, ...)
  end
end

You also have to add CategoryProduct to each model:

class Product < ActiveRecord::Base
  has_many :category_products
  has_many :categories, through: :category_product

It is very simple using gem simple form. All you have to do is to add:

t.association :categories

in a form for product and add :category_ids => [] to a list of permitted parameters in your products controller

If you prefer checkboxes instead of multi-select list, you can do

    t.association :categories, as: check_boxes

And the last thing, to display categories in human-readable format, you need to define a to_s method in your category model, i. e.:

class Category < ActiveRecord::Base
  ...
  def to_s
    name
  end 
end