New tally method (Ruby 2.7)

New tally method (Ruby 2.7).md

def search_result
  categories.each_with_object([]) do |category, keywords|
    keywords << category.keywords.split(', ').select{ |c| c.include?(query) } unless category.keywords.blank?
  end.flatten.tally.first(3).map(&:first)
end

[1, 2, 2, 3].tally
# => { 1 => 1, 2 => 2, 3 => 1 }

%w(foo foo bar foo baz foo).tally
=> {"foo"=>4, "bar"=>1, "baz"=>1}

%w(foo foo bar foo baz foo).map { |s| s[0] }.tally
=> {“f” => 4, “b” => 2}

There’s discussion happening at the moment on accepting this feature, which would make the above syntax:

%w(foo foo bar foo baz foo).tally_by { |s| s[0] }
=> {“f” => 4, “b” => 2}

alternative

list.group_by { |v| v.something }.transform_values(&:size)
list.group_by { |v| v.something }.map { |k, vs| [k, vs.size] }.to_h
list.group_by { |v| v.something }.to_h { |k, vs| [k, vs.size] }
list.each_with_object(Hash.new(0)) { |v, h| h[v.something] += 1 }

Counter caches
1)

class AddVotesCount < ActiveRecord::Migration
  def change
    add_column :topics, :votes_count, :integer, :default => 0

  end
end

Update Vote model

class Vote < ActiveRecord::Base
  belongs_to :topic, :counter_cache :true
end

Now in the topics controller I can increment the up/down methods with
Increment

@topic.votes_count += 1

4. index.html.erb:

from the view

<td><%= pluralize(topic.votes_count, "vote") %></td>
<td><%= button_to '+1', upvote_topic_path(topic), method: :post %></td>
 <td><%= button_to '-1', downvote_topic_path(topic), method: :post %></td>

def upvote
  @topic = Topic.find(params[:id])
  @topic.votes.increment_counter(:tally, params[:id])
  redirect_to(topics_path)
end

Decrement

@topic.votes_count -= 1

def downvote
  @topic = Topic.find(params[:id])
  @topic.votes.decrement_counter(:tally, params[:id])
  redirect_to(topics_path)
end

Routes

Rails.application.routes.draw do
  resources :topics do
    member do
      post 'upvote'
      post 'downvote'
    end
  end

  root 'topics#index'  
end

@poll.poll_options.sum(:votes)

Then to create the % for the PHP for example you could do

total_votes = @poll.poll_options.sum(:votes)
php_votes = @poll.poll_options.where(name: 'PHP').votes
(php_votes / total_votes).to_i * 100

# app/controllers/concerns/voting_controller.rb
def obtain_resources
  model = controller_name.singularize.camelize.constantize
  instance_name = controller_name.singularize
  # here you get @universe or @character
  instance_variable_set "@#{instance_name}", model.find(params[:id])
end

def obtain_resources
  redirect_back(fallback_location: root_path) unless params[:id]

  klass_name, id = params[:id].split('_') # -> ['post', '12']
  redirect_back(fallback_location: root_path) unless %w[product service post].include?(klass_name)

  klass_name.classify.constantize.find_by(id: id) # -> Post.find_by(id: id)
end

<% ident_object = dom_id(object) %>
<% if user_signed_in? && object.favorites.exists?(owner: user) %>
  <%= link_to favorites_path(id: ident_object), method: :delete,
              class: 'favorites-link',
              data: { action: 'click->favorites#clearFromList',
                      ident_object: ident_object
                    } do %>
    <i class="fas fa-heart opacity-75"></i>
  <% end %>
<% else %>
  <%= link_to favorites_path(id: ident_object), method: :post,
              class: 'favorites-link' do %>
  <i i class="far fa-heart"></i>
  <% end %>
<% end %>

Service.all.pluck(:owner_id).tally
Service.group(:owner_id).size
Service.pluck(:owner_id).tally.sort_by{_2}.to_h
Service.pluck(:owner_id).tally.sort_by{-_2}.to_h
Service.group(:owner_id).size.sort_by(&:last).to_h
Service.group(:owner_id).size.sort_by(&:last).reverse.to_h
Service.group(:owner_id).size.sort_by{ |_, v| -v}.to_h
Service.group(:owner_id).size.sort_by{ |_, v| v}.reverse.to_h
Service.group(:owner_id).size.sort_by{_2}.to_h
Service.group(:owner_id).size.sort_by{_2}.reverse.to_h
Service.group(:owner_id).size.sort_by{-_2}.to_h

PS Search with Sphinx

class SearchService
  SEARCH_TYPES = %w[all question answer comment user].freeze

  def self.call(params)
    new(params).search
  end

  def initialize(params)
    @search_query = params[:search_query]
    @search_by    = params[:search_by]
  end

  def search
    return [] if @search_query.blank? || !SEARCH_TYPES.include?(@search_by)

    if @search_by == 'all'
      ThinkingSphinx.search(@search_query)
    else
      Object.const_get(@search_by.capitalize).search(@search_query)
    end
  end
end