# app/helpers/application_helper.rb

module ApplicationHelper
  def body_class
    "#{page_name} #{page_full_name} #{:mobile if mobile?}"
  end

  def page_name
    "c-#{controller_name}"
  end

  def page_full_name
    "p-#{controller_name}-#{action_name}"
  end

  def turbolinks_on?
    # Your turblinks off logic
    true
  end

  def mobile?
    return true if params[:mobile].present?
    return false if params[:desktop].present?
    return true if session[:mobile_param] && session[:mobile_param] == '1'

    request.user_agent =~ /Mobile|webOS|Android/
  end
end

# config/initializers/field_with_error.rb

ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
  "<div class='field_with_errors'>
    #{html_tag}
    <div class='error_message'>
      #{instance.error_message.first}
    </div>
  </div>".html_safe
end

class CreateUsers < ActiveRecord::Migration[5.0]
  def change
    create_table :users do |t|
      t.string :email
      t.string :crypted_password
      t.string :token

      t.timestamps
    end

    add_index :users, :email, unique: true
    add_index :users, :token, unique: true
  end
end

# app/models/user.rub

require 'bcrypt'
require 'ulid'

class User < ApplicationRecord
  include BCrypt
  before_create :generate_token

  validates :email, presence: true
  validates :crypted_password, presence: true

  def password
    @password ||= Password.new(crypted_password)
  end

  def password=(new_password)
    @password = Password.create(new_password)
    self.crypted_password = @password
  end

private

  def generate_token
    self.token = ULID.generate
  end
end

# app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
  # ...

  helper_method :token, :current_user, :signed_in?

  def current_user
    @current_user ||= User.find_by(token: token)
  end

  def signed_in?
    current_user.present?
  end

  def token
    params_token || session_token
  end

private

  def session_token
    session[:token]
  end

  def params_token
    params[:token]
  end

  def set_session_token(token)
    session[:token] = token
  end
end

# app/controllers/users_controller.rb

class UsersControllerController < ApplicationController
  skip_before_action :verify_authenticity_token, only: [:create]

  def new
  end

  def create
    @user = User.build(user_create_params)

    if @user.save?
      set_session_token(@user.token)
      redirect_to root_url(notice: 'Вы успешно зарегистировались')
    else
      render :new
    end
  end

private

  def user_create_params
    params.require(:user).permit(:email)
  end
end

# app/controllers/sessions_controller.rb

class SessionsControllerController < ApplicationController
  skip_before_action :verify_authenticity_token, only: [:create]

  def new
    @user = User.new
  end

  def create
    @user = find_user

    if @user.present?
      set_session_token(@user.token)
      redirect_to root_url notice: 'Вы успешно вошли на сайт'
    else
      render :new
    end
  end

  def destroy
    set_session_token(nil)
    redirect_to root_url
  end

private

  def create_sessions_params
    params.require(:user).permit(:email, :password)
  end

  def find_user
    user = User.find_by(email: create_sessions_params[:email])
    return nil if user.nil?
    return nil if user.password != create_sessions_params[:password]

    user
  end
end

# config/routes.rb

Rails.application.routes.draw do
  resources :users, only: [:new, :create]
  resource :sessions, only: [:new, :create, :destroy]

  scope '(:token)' do
    # ...
  end
end

# app/models/item.rb
class Item < ApplicationRecord
  has_many :photos, dependent: :destroy
  accepts_nested_attributes_for :photos, allow_destroy: true
end

# app/models/photo.rb
class Photo < ApplicationRecord
  include ImageUploader[:image]
  belongs_to :item

  def before_destroy
    uploader = ImageUploader.new(:store)
    uploader.delete(image)
  end
end

# app/controllers/items_controller.rb
class ItemsController < ApplicationController
  # ...

  def update
    if @item.update(item_params)
      redirect_to item_url(@item)
    else
      render :edit
    end
  end

  # ...
private

  def item_params
    params
      .require(:item)
      .permit(:title, :description, photos_attributes: [:id, :_destroy])
  end
end

# app/controllers/photos_controller.rb
class PhotosController < ApplicationController
  def create
    item = current_user.items.find(params[:item_id])
    photo = item.photos.create(photo_params)
    render partial: 'items/photo',
      locals: { photo: photo, index: item.photos.count }
  end

private

  def photo_params
    params.
      require(:photo).
      permit(:image)
  end
end

# config/routes.rb
Rails.application.routes.draw do
  # ...
  resources :items do
    resource :photo, only: [:create]
  end
end

# Gemfile
gem 'aws-sdk'
gem 'shrine'

# config/initializers/shrine.rb
require 'shrine'
if Rails.env.development?
  require 'dotenv'
  Dotenv.load!('./.env')
end

require 'shrine/storage/s3'
s3_options = {
  access_key_id:     ENV['S3_KEY'],
  secret_access_key: ENV['S3_SECRET'],
  region:            '<BUCKET>',
  bucket:            '<REGION>',
}
Shrine.storages = {
  cache: Shrine::Storage::S3.new(prefix: 'cache', **s3_options),
  store: Shrine::Storage::S3.new(prefix: 'store', **s3_options),
}

Shrine.plugin :activerecord
Shrine.plugin :cached_attachment_data

# app/models/team.rb
class Team < ApplicationRecord
  include ImageUploader[:image]
  # ...
end

# app/services/image_uploader.rb
class ImageUploader < Shrine
  # Plugins and uploading logic. Example:
  # plugin :direct_upload
end

# rails c
> file = File.open('/Users/slash/Downloads/cl_logo_1024.png')
> uploader = ImageUploader.new(:store)
> uploaded_file = uploader.upload(file)
#<ImageUploader::UploadedFile:0x007fe23fb26bb8 @data={"id"=>"6e4a72aeb2769c67868c7ea903adc6dd.png", "storage"=>"store", "metadata"=>{"filename"=>"cl_logo_1024.png", "size"=>20341, "mime_type"=>nil}}>
> uploaded_file.url
# "https://BUCKET.s3.REGION.amazonaws.com/store/6e4a72aeb2769c67868c7ea903adc6dd.png?X-Amz-Algorithm=...&X-Amz-Date=...&...ignature=..."

Rails.application.configure do
  config.action_controller.perform_caching = false
end

Rails.application.configure do
  config.cache_store = :null_store
end

# app/models/game.rb
class Game < ApplicationRecord
  enum kind: { training: 0, friendly_match: 1 }
end

# app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  def self.human_enum_name(name, value)
    I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{name.to_s.pluralize}.#{value}")
  end
end

# app/twins/team_detail_twin.rb
require 'disposable/twin/property/hash'

class TeamDetailTwin < Disposable::Twin
  feature Sync
  include Property::Hash

  collection :phones, field: :hash do
    property :number
    property :descripton
  end
end

# spec/twins/team_detail_spec.rb
describe TeamDetailTwin do
  let(:twin) { TeamDetailTwin.new(team_detail) }
  let(:team) { build_stubbed :team }

  describe '#phones' do
    subject { twin.phones }
    let(:team_detail) { build :team_detail, team: team, phones: phones }

    context 'blank' do
      let(:phones) { nil }
      it { is_expected.to be_empty }
    end

    context 'present' do
      let(:phones) do
        [
          { number: '123', descripton: 'foo' },
          { number: '321', descripton: 'bar' }
        ]
      end

      it { is_expected.to have(2).items }
      its('first.number') { is_expected.to eq '123' }
      its('first.descripton') { is_expected.to eq 'foo' }
    end
  end
end

# ...

group :development do
  # ...

  gem 'rubocop-rails', require: false
  gem 'guard'
  gem 'guard-bundler', require: false
  gem 'guard-pow', require: false
  gem 'guard-rspec', require: false
  gem 'guard-rubocop', require: false
  gem 'guard-spring', require: false

  gem 'better_errors'
  gem 'binding_of_caller'
  gem 'listen'
  gem 'spring'
end

group :test do
  gem 'rspec-collection_matchers'
  gem 'rspec-its'
  gem 'rspec-rails'
  gem 'rspec_junit_formatter'
  gem 'shoulda'
  gem 'shoulda-matchers'
  gem 'timecop'
  gem 'vcr'
  gem 'webmock', require: false
end

# ...

data = { settings: { schedule: { week: [{ id: 1, day: false }, { id: 2, day: true }] } } }
CGI.unescape data.to_query
# > settings[schedule][week][][day]=false&settings[schedule][week][][id]=1&settings[schedule][week][][day]=true&settings[schedule][week][][id]=2

# turn off
old_logger = ActiveRecord::Base.logger
ActiveRecord::Base.logger = nil

# your code...

# turn on
ActiveRecord::Base.logger = old_logger

# config/initializers/assets.rb
Rails.application.config.assets.paths << Rails.root.join('app', 'assets', 'fonts')

# Gemfile
gem 'roda'

# app/services/image_uploader.rb
class ImageUploader < Shrine
  plugin :direct_upload
end

# config/routes.rb
Rails.application.routes.draw do
  # ...
  mount ImageUploader::UploadEndpoint => '/images'
end

# Model index 
class SuppliesIndex < Chewy::Index
  settings analysis: {
    analyzer: {
      lowercase: {
        tokenizer: 'standard',
        filter: ['lowercase']
      }
    },
  }

  define_type Supply do
    field :supplier_id, type: 'integer', index: :not_analyzed
    field :category_id, type: 'integer', index: :not_analyzed
    field :name, type: 'text', analyzer: :lowercase
    field :supplier_sku, type: 'text', analyzer: :lowercase
    field :manufacturer_sku, type: 'text', analyzer: :lowercase

    field :manufacturer,
      type: 'text',
      analyzer: :lowercase,
      fields: {
        raw: {
          type: 'keyword',
          index: :not_analyzed,
        }
      }

    field :price,
      type: 'float',
      value: ->(v) { v.prices.first&.price.to_f }
  end
end

# Queries
class ElasticSupply
  SEARCHABLE_FIELDS = %w(
    manufacturer
    manufacturer_sku
    name
    supplier_sku
  )

  # Return Supply filter with numbers of supplies.
  #
  # @example
  #   ElasticSupply.filter()
  #   or
  #   ElasticSupply.filter(supplier_id: 1)
  #
  def self.filter(supplier_id: nil)
    matches = []
    matches << { term: { supplier_id: supplier_id } } unless supplier_id.blank?
    SuppliesIndex.query({ bool: { must: matches } })
      .aggs({
        category: { terms: { field: 'category_id' } },
        manufacturer: { terms: { field: 'manufacturer.raw' } },
      })
      .limit(0)
      .aggs
  end

  # Find Supply by search query with pagination.
  #
  # @example
  #   ElasticSupply.search(query: '*foo*', supplier_id: 1, page: 1, per_page: 1)
  #   or
  #   ElasticSupply.search(query: '*foo*')
  #
  # @param query [String] - 'foo', 'foo*', '*foo*'
  # @param supplier_id [Integer] additional filter by supplier_id (optional)
  # @param page [Integer]
  # @param per_page [Integer]
  #
  # @return [Array<Supply>]
  def self.search(query:, supplier_id: nil, category_ids: nil, manufacturers: nil, page: 1, per_page: 20)
    ElasticSupply
      .full_search_raw(
        query: query,
        supplier_id: supplier_id,
        category_ids: category_ids,
        manufacturers: manufacturers,
      )
      .paginate(page: page, per_page: per_page)
      .load(scope: ->{ includes(:prices, :office_supplies) })
      .to_a
  end

  # Find total count items in the index by query.
  #
  # @example
  #   ElasticSupply.total_count(query: '*foo*')
  #   or
  #   ElasticSupply.total_count(query: '**', supplier_id: 1, manufacturers: ['KEYSTONE DENTAL'])
  #
  # @param query [String] - 'foo', 'foo*', '*foo*'
  # @param supplier_id [Integer] additional filter by supplier_id (optional)
  #
  # @return [Integer]
  def self.total_count(query:, supplier_id: nil, category_ids: nil, manufacturers: nil)
    ElasticSupply
      .full_search_raw(
        query: query,
        supplier_id: supplier_id,
        category_ids: category_ids,
        manufacturers: manufacturers,
      )
      .total_count
  end

  # Search by query in all fields.
  #
  # @param query [String] - 'foo', 'foo*', '*foo*'
  # @param supplier_id [Integer] additional filter by supplier_id
  #
  # @return [SuppliesIndex::Query]
  def self.full_search_raw(query:, supplier_id:, category_ids:, manufacturers:)
    matches = [{ query_string: { query: query } }]
    matches << { term: { supplier_id: supplier_id } } unless supplier_id.blank?

    if category_ids.present?
      categories_query = category_ids.map { |v| { match: { category_id: v } } }
      matches << { bool: { should: categories_query } }
    end

    if manufacturers.present?
      manufacturers_query = manufacturers.map do |v|
        { match: { 'manufacturer.raw': v } }
      end
      matches << { bool: { should: manufacturers_query } }
    end

    SuppliesIndex.query({ bool: { must: matches } })
  end

  # Search by query as prefix in all fields.
  #
  # @param query [String] the '*' is unnecessary: 'foo' is equivalent to the 'foo*'
  # @param supplier_id [Integer] additional filter by supplier_id
  #
  # @return [SuppliesIndex::Query]
  def self.prefix_search_raw(query:, supplier_id:)
    matches = SEARCHABLE_FIELDS.map do |field|
      { 'match_phrase_prefix' => { field => query } }
    end
    search = SuppliesIndex.query({ bool: { should: matches } })
    return search if supplier_id.blank?

    search.query(term: { supplier_id: supplier_id })
  end
end

class Message < ApplicationRecord
  belongs_to :user
end

class Conversation < ApplicationRecord
  belongs_to :message
  belongs_to :recipient, class_name: User.name
end

class CreateConversations < ActiveRecord::Migration[5.0]
  def change
    create_table :conversations do |t|
      t.references :message, foreign_key: true
      t.references :recipient, references: :user
      # ...
    end

    add_foreign_key :conversations, :users, column: :recipient_id
  end
end

class AddRecipientToConversations < ActiveRecord::Migration[5.0]
  def change
    add_reference :conversations, :recipient, references: :user, index: true
  end
end

FactoryGirl.define do
  factory :conversation do
    ...
    trait :with_recipient do
      recipient { create(:user) }
    end
end

# lib/service.rb
module Service
  extend ActiveSupport::Concern

  included do
    def self.call(*args)
      new(*args).call
    end
  end
end

# Gemfile
gem 'virtus'

# lib/attributable_service.rb
module AttributableService
  extend ActiveSupport::Concern

  included do
    include Service
    include Virtus.model
  end
end

module Users
  class Create
    include AttributableService

    attribute :params, Hash
    attribute :password, String

    def call
      user.password = password
      user.save

      user
    end

  private

    def user
      @user ||= User.new(params)
    end
end

Users::Create.call(params: params, password: 'asdf')

# spec/spec_helper
RSpec.configure do |config|
  # ...
  config.filter_run_excluding tag: :not_for_ci if ENV['CI']
end

# spec/controllers/foos_controller_spec.rb
describe FoosController, tag: :not_for_ci do
  render_views

  describe '#index' do
    # ...
  end
end

Time.use_zone('Eastern Time (US & Canada)') { Time.zone.parse('2020-07-21 14:49') }.in_time_zone

# => Tue, 21 Jul 2020 21:49:00 MSK +03:00