How does || work in?: @client = client.find(params[:client_id] || params[:id])

Question

New to rails. Following a tutorial on polymorphic associations, I bump into this to set @client in create and destroy.

@client = Client.find(params[:client_id] || params[:id])

I'm normally only used to that you can only find @client = Client.find(params[:id])

so how does this work with there being two params? How does the || work?

FavoriteClientsController.rb:

class FavoriteClientsController < ApplicationController

  def create
    @client = Client.find(params[:client_id] || params[:id])

    if Favorite.create(favorited: @client, user: current_user)
      redirect_to @client, notice: 'Leverandøren er tilføjet til favoritter'
    else
      redirect_to @client, alert: 'Noget gik galt...*sad panda*'
    end
  end

  def destroy
    @client = Client.find(params[:client_id] || params[:id])

    Favorite.where(favorited_id: @client.id, user_id: current_user.id).first.destroy
    redirect_to @client, notice: 'Leverandøren er nu fjernet fra favoritter'
  end

end

Full code for controller, models can be seen here

Using rails 5

Answer 1

Expression: params[:client_id] || params[:id] is the same as:

if params[:client_id]
  params[:client_id]
else
  params[:id]
end

Answer 2

Wow thats an incredibly bad way to do it.

A very extendable and clean pattern for doing controllers for polymorphic children is to use inheritance:

class FavoritesController < ApplicationController

  def create
    @favorite = @parent.favorites.new(user: current_user)
    if @favorite.save 
      redirect_to @parent, notice: 'Leverandøren er tilføjet til favoritter'
    else
      redirect_to @parent, alert: 'Noget gik galt...*sad panda*'
    end
  end

  def destroy
    @favorite = @parent.favorites.find_by(user: current_user)
    redirect_to @parent, notice: 'Leverandøren er nu fjernet fra favoritter'
  end

  private

  def set_parent
    parent_class.includes(:favorites).find(param_key)
  end

  def parent_class
    # this will look up Parent if the controller is Parents::FavoritesController
    self.class.name.deconstantize.singularize.constantify
  end

  def param_key
     "#{ parent_class.naming.param_key }_id"
  end
end

We then define child classes:

# app/controllers/clients/favorites_controller.rb
module Clients
  class FavoritesController < ::FavoritesController; end
end

# just an example
# app/controllers/posts/favorites_controller.rb
module Posts
  class FavoritesController < ::FavoritesController; end
end

You can then create the routes by using:

Rails.application.routes.draw do

  # this is just a routing helper that proxies resources
  def favoritable_resources(*names, **kwargs)
    [*names].flatten.each do |name|
      resources(name, kwargs) do
        scope(module: name) do
          resource :favorite, only: [:create, :destroy]
        end
        yield if block_given?
      end
    end
  end

  favoritable_resources :clients, :posts
end

The end result is a customizable pattern based on OOP instead of "clever" code.

Answer 3

The tutorial which teaches you to do

Client.find(params[:client_id] || params[:id])

is a super-duper bad tutorial :) I strongly recommend you to switch to another one.

Back to the topic: it is logical OR: if first expression is neither nil or false, return it, otherwise return second expression.

Answer 4

That thing is just trying to find client by client_id if there is one in the request params. If not it's trying to find client by id.

However such practic can make you much more pain than profit.