Ruby Rails Creating Variables in ERB Best Practices For Search - ruby-on-rails

Question

I have a project with a search feature. I have three classes, Product, Review and User. I have a self.search method in the product model doing a query on all three class tables.
When I put together the search view, It listed the product name, the review author and any text in a review that matches the search string.
Then I thought, lets pretty that up a bit.
So I'm cross referencing the ids to also list user avatars and time stamps and star ratings. But to do that, I'm making local variables searching in all the classes.
So I think there's now quite a code smell here. There is no controller to load up with #users = User.all. I'm sticking with _user = User.find_by types of local variable assignment. The search fingers are now in all class pies.
So my question is really, should my bloated search now rightly to be scaffolded into an actual class? Or is there another approach like a helper? Is it possible this is not that bad of an approach?
Ruby 2.6.5
Rails 5.2.4
Here is my view:
<div class="home-container">
<div class="welcome-sub-header">
<h1>Search Results</h1>
<div class='search-flex-container'>
<h2>Products that Match</h2>
<% if #results_products.empty?%>
<div class='search-noresult-card'>
<p>No products matched the search.</p>
</div>
<% end %>
<% #results_products.each do |results_product| %>
<div class='search-product-card'>
<div class='search-product-flex'>
<%= render partial: "shared/product_image", locals: { product: results_product } %>
<%= link_to results_product.name, product_path(results_product.id) %>
<p>Imported From <%= results_product.country %></p>
<div class="search-adjust-stars">
<%= render partial: "shared/review_stars", locals: { review: results_product.average_review } %>
</div>
</div>
</div>
<% end %>
<%= will_paginate #results_products %>
<h2>Product Reviews that Match</h2>
<% if #results_reviewers.empty?%>
<div class='search-noresult-card'>
<p>No reviewers matched the search.</p>
</div>
<% end %>
<% #results_reviewers.each do |results_reviewer| %>
<div class='search-review-card'>
<div class='search-review-flex'>
<% _reviewed_product = Product.find_by(id: results_reviewer.product_id) %>
<% _user = User.find_by(id: results_reviewer.user_id) %>
<div class="search-review-box1">
<%= render partial: "shared/avatar", locals: { user: _user } %>
<%= link_to (results_reviewer.author + " review of " + _reviewed_product.name), review_path(id: results_reviewer, product_id: results_reviewer.product_id) %><br>
</div>
<div class="search-review-box2">
<%= render partial: "shared/review_stars", locals: { review: results_reviewer.rating } %>
</div>
<div class="search-review-box3">
<p>On <%= results_reviewer.created_at.strftime('%m-%d-%Y') %></p>
</div>
<div class="search-review-box5">
<%= render partial: "shared/product_image", locals: { product: _reviewed_product } %>
</div>
</div>
</div>
<% end %>
<%= will_paginate #results_reviewers %>
<h2>Review Text that Matches</h2>
<% if #results_reviews.empty?%>
<div class='search-noresult-card'>
<p>No review text matched the search.</p>
</div>
<% end %>
<% #results_reviews.each do |results_review| %>
<% _user = User.find_by(id: results_review.user_id) %>
<div class='search-review-card'>
<%= render partial: "shared/avatar", locals: { user: _user } %>
<% _reviewed_product = Product.find_by(id: results_review.product_id) %>
<%= link_to (results_review.author + " review of " + _reviewed_product.name), review_path(id: results_review, product_id: results_review.product_id) %>
<p>Reviewed on <%= results_review.created_at.strftime('%m-%d-%Y') %></p>
<div class="search-review-text">
<%= results_review.content_body %>
</div>
</div>
<% end %>
<%= will_paginate #results_reviews %>
</div>
</div>
<div>Font made from oNline Web Fontsis licensed by CC BY 3.0</div>
</div>
This is the Product model with the self.search method.
class Product < ApplicationRecord
has_many :reviews, dependent: :destroy
validates :name, presence: true
validates_length_of :name, maximum: 30
validates :price, presence: true
validates_length_of :price, maximum: 8
validates :country, presence: true
validates_length_of :country, maximum: 50
has_one_attached :product_photo
before_save(:titleize_product)
scope :most_reviewed, -> {(
select("products.id, products.name, products.average_review,products.price, products.country, count(reviews.id) as reviews_count")
.joins(:reviews)
.group("products.id")
.order("reviews_count DESC")
.limit(6)
)}
scope :newest_product, -> { order(created_at: :desc).limit(6) }
scope :highest_reviewed, -> {(
select("products.id, products.name, products.price, products.country, products.average_review as average_review")
.joins(:reviews)
.group("products.id")
.order("average_review DESC")
.limit(6)
)}
def self.search(search)
where("lower(reviews.author) LIKE :search OR lower(products.name) LIKE :search OR lower(reviews.content_body) LIKE :search", search: "%#{search.downcase}%").uniq
end
def next
Product.where("id > ?", id).order("id ASC").first || Product.first
end
def previous
Product.where("id < ?", id).order("id DESC").first || Product.last
end
private
def titleize_product
self.name = self.name.titleize
self.country = self.country.titleize
end
end

Answer 1

I think you should separate search method into searchable module, and allow searchable-models declare what attributes involve in search query.
module Searchable
extend ActiveSupport::Concern
included do
#search_clauses ||= Hash.new
end
module ClassMethods
def search(key_search, scope: 'default')
search_clause ||= search_string_for(scope)
relation = joins(*search_clause[:joins].map(&:to_sym)) unless search_clause[:joins].blank?
(relation || self).where(search_clause[:where], key: "%#{key_search.downcase}%")
end
def search_clause(clause_str, scope: 'default')
#search_clauses[scope] = parse(clause_str)
# we can add dynamic function like seach_`scope_name`
end
def search_attributes(attributes, scope: 'default')
search_clause(attributes.map { |attribute| "%#{attribute}%"}.join(" OR "), scope: scope)
end
private
def search_string_for(scope)
#search_clauses&.dig(scope)
end
def parse(clause)
join_tables = Set.new
where_clause = clause.dup
parse_tables(clause) do |table|
join_tables << table unless table == self.class_name.tableize || table.blank?
where_clause.sub!("#{table}.", "#{table.tableize}.")
end
parse_logics!(where_clause)
parse_matches!(where_clause)
# other cases ...
{
joins: join_tables,
where: where_clause
}
end
def parse_logics!(clause)
clause.gsub!(/\|/, "OR")
clause.gsub!(/\&/, "AND")
# other ...
end
def parse_matches!(clause)
clause.scan(/(?<=%)[^\s\|\&\z\Z]*(?=%)/).each do |attribute|
clause.sub!(/%[^\s\|\&\z\Z]*%/, "lower(#{attribute}) LIKE :key")
end
end
def parse_tables(clause, &block)
clause.scan(/(?<=[%\s])[^%\s\|\&\z]*(?=\.)/).each(&block)
end
end
end
Example in my practice project:
class Task < ApplicationRecord
include Searchable
belongs_to :requirement
has_many :skills
# declare search clause, we can set the whole where-clause here
# those syntax %,|,& ... just for fun (simple way)
search_clause "%content% | %requirement.description%"
# with scope
search_clause "(%content% | %requirement.description%) & status = 0", scope: :open
# declare attributes
search_attributes %w[content skills.name], scope: :skill
end
# Demo
Task.search("setup") # default scope
Task.search("setup", scope: :open)
Task.search("ruby", scope: :skill)
Note: I recommend you use search-gems such as ransack, pg_search (in case of full-text-search).