Quickery

# app/models/employee.rb
class Employee < ApplicationRecord
  # say we have the following attributes:
  #   branch_id:bigint
  #   branch_company_name:string

  belongs_to :branch

  # TL;DR: the following line means:
  #   make sure that this record's `branch_company_name` attribute will always have the same value as
  #   branch.company.name and auto-updates the value if it (or any associated record in between) changes

  quickery branch: { company: { name: :branch_company_name } }

  # feel free to rename :branch_company_name as you wish; it's just like any other attribute anyway
end

# app/models/branch.rb
class Branch < ApplicationRecord
  # say we have the following attributes:
  #   company_id:bigint

  belongs_to :company
end

# app/models/company.rb
class Company < ApplicationRecord
  # say we have the following attributes:
  #   name:string
end

# rails console
company = Company.create!(name: 'Jollibee')
branch = Branch.create!(company: company)
employee = Employee.create!(branch: branch)

puts employee.branch_company_name
# => 'Jollibee'

# As you can see the `branch_company_name` attribute above has the same value as the associated record's attribute
# Now, let's try updating company, and you will see below that `branch_company_name` automatically gets updated as well

company.update!(name: 'Mang Inasal')

puts employee.branch_company_name
# => 'Jollibee'

# You may or may not need to reload the object, depending on if you expect that it's been changed:
employee.reload

puts employee.branch_company_name
# => 'Mang Inasal'

# Now, let's try updating the intermediary association, and you will see below that `branch_company_name` would be updated accordingly
other_company = Company.create!(name: 'McDonalds')
branch.update!(company: other_company)

employee.reload

puts employee.branch_company_name
# => 'McDonalds'

# rails console
Employee.find_each do |employee|
  employee.recreate_quickery_cache!
end

# app/models/employee.rb
class Employee < ApplicationRecord
  belongs_to :branch
  belongs_to :company, foreign_key: :branch_company_id, optional: true

  quickery { branch: { company: { id: :branch_company_id } } }
end

# rails console
company = Company.create!(name: 'Jollibee')
branch = Branch.create!(company: company)
employee = Employee.create!(branch: branch)

puts employee.branch_company_id
# => 1

puts employee.company
# => #<Company id: 1 name: 'Jollibee'>

puts Employee.where(company: company)
# => [#<Employee id: 1>]

# as you may notice, the query above is a lot simpler and faster instead of doing it normally like below (if not using Quickery)
# you may however still use `has_many :through` to achieve a simplified code: `company.employees`, but it's still a lot slower because of JOINS
puts Employee.joins(branch: :company).where(companies: { id: company.id })
# => [#<Employee id: 1>]

# app/models/employee.rb
class Employee < ApplicationRecord
  belongs_to :branch

  quickery { branch: { company: { name: :branch_company_name } } }

  after_find :autoload_unsynced_quickery_attributes!
end

# rails console
company = Company.create!(name: 'Jollibee')
branch = Branch.create!(company: company)
employee_created_before_quickery_integration = Employee.create!(branch: branch)

puts employee_created_before_quickery_integration.branch_company_name
# => NoMethodError: undefined method `branch_company_name'

# Let's say the employee record above was created long time ago before Quickery was integrated,
# and then right now, you added the new quickery-attribute `branch_company_name`.

# Employee record above and all "old" Employee records now then will have "stale" `branch_company_name`,
# because it will have a value of `nil`.
# But using `after_find :autoload_unsynced_quickery_attributes!` above, all records will
# then be guaranteed to have up-to-date quickery attributes even if new quickery-attributes
# will be defined in the future.

puts employee_created_before_quickery_integration.branch_company_name
# => 'Jollibee'

# if without `after_find :autoload_unsynced_quickery_attributes!`, because this Employee is an "old" record
# then the puts just above will instead show
# => nil

# app/models/employee.rb
class Employee < ApplicationRecord
  # multiple-attributes and/or multiple-associations; as many, and as deep as you wish
  quickery(
    branch: {
      name: :branch_name,
      address: :branch_address,
      company: {
        name: :branch_company_name
      }
    },
    user: {
      first_name: :user_first_name,
      last_name: :user_last_name
    }
  )
end

# app/models/employee.rb
class Employee < ApplicationRecord
  # `quickery` can be called multiple times
  quickery { branch: { name: :branch_name } }
  quickery { branch: { address: :branch_address } }
  quickery { branch: { company: { name: :branch_company_name } } }
  quickery { user: { first_name: :user_first_name } }
  quickery { user: { last_name: :user_last_name } }
end

class Employee < ApplicationRecord
  belongs_to :branch

  quickery branch: { company: { name: :branch_company_name } }

  # this method will be called before an Employee gets created or updated
  # new_values is a Hash of quickery-defined attribute changes; say: `{ :branch_company_name => 'Jollibee' }`
  # i.e. when some_employee.update(branch: some_branch)
  def self.quickery_before_create_or_update(employee, new_values)
    employee.assign_attributes(new_values) # default behaviour of this method
  end

  # this method will be called before any updates happen on any of the association (that a quickery-defined attribute in this model depends on)
  # i.e. when some_branch.update(company: some_company)
  # i.e. when some_company.update(name: 'New Company Name')
  def self.quickery_before_association_update(employees, record_to_be_updated, new_values)
    employees.update_all(new_values) # default behaviour of this method
  end

  # this method will be called before any of the association gets destroyed (that a quickery-defined attribute in this model depends on)
  # i.e. when some_branch.destroy
  # i.e. when some_company.destroy
  def self.quickery_before_association_destroy(employees, record_to_be_destroyed, new_values)
    employees.update_all(new_values) # default behaviour of this method
  end
end

class Employee < ApplicationRecord
  belongs_to :branch

  quickery branch: { company: { name: :branch_company_name } }

  def self.quickery_before_create_or_update(employee, new_values)
    employee.assign_attributes(new_values)
  end

  # because updates can be slow for a very big DB table, then you can move the update logic into a background job
  # you can even batch the updates into a job like below

  def self.quickery_before_association_update(employees, record_to_be_updated, new_values)
    employees.find_in_batches(batch_size: 2000) do |grouped_employees|
      BatchQuickeryUpdatesJob.perform_later(self.class.to_s, grouped_employees.pluck(:id), new_values)
    end
  end

  def self.quickery_before_association_destroy(employees, record_to_be_destroyed, new_values)
    employees.find_in_batches(batch_size: 2000) do |grouped_employees|
      BatchQuickeryUpdatesJob.perform_later(self.class.to_s, grouped_employees.pluck(:id), new_values)
    end
  end
end

# app/jobs/batch_quickery_updates_job.rb
class BatchQuickeryUpdatesJob < ApplicationJob
  # or probably you have a :low_priority queue?
  queue_as :default

  def perform(model_str, ids, new_values)
    model = model_str.safe_constantize
    model.where(id: ids).update_all(new_values)
  end
end

class Employee < ApplicationRecord
  belongs_to :branch

  quickery branch: { company: { name: :branch_company_name } }

  def self.quickery_before_create_or_update(employee, new_values)
    employee.assign_attributes(quickery_format_values(new_values))
  end

  def self.quickery_before_association_update(employees, record_to_be_updated, new_values)
    employees.update_all(quickery_format_values(new_values))
  end

  def self.quickery_before_association_destroy(employees, record_to_be_destroyed, new_values)
    employees.update_all(quickery_format_values(new_values))
  end

  private

  # example (you can rename this method):
  def self.quickery_format_values(values)
    :branch_company_name.tap do |attr|
      # remove trailing white spaces and force-single-space between words, and then capitalise all characters
      values[attr] = values[attr].squish.upcase if values.has_key? attr
    end

    :user_first_name.tap do |attr|
      # only save the first 30 characters of user_first_name string
      values[attr] = values[attr][0...30] if values.has_key? attr
    end

    values
  end
end

class Employee < ApplicationRecord
  belongs_to :branch

  quickery branch: { company: { name: :branch_company_name } }

  def self.quickery_before_create_or_update(employee, new_values)
    employee.assign_attributes(quickery_with_computed_values(employee, new_values))
  end

  # IMPORTANT: for big tables, `find_each` below can be slow (consider moving into a background job or if possible use the default behaviour which is `update_all`)

  def self.quickery_before_association_update(employees, record_to_be_updated, new_values)
    employee.find_each do |employee|
      employee.update!(quickery_with_computed_values(employee, new_values))
    end
  end

  def self.quickery_before_association_destroy(employees, record_to_be_destroyed, new_values)
    employee.find_each do |employee|
      employee.update!(quickery_with_computed_values(employee, new_values))
    end
  end

  private

  # example (you can rename this method):
  def self.quickery_with_computed_values(employee, values)
    if values.has_key?(:user_first_name) || values.has_key?(:user_last_name)
      employee.user_first_name = values[:user_first_name] if values.has_key?(:user_first_name)
      employee.user_last_name = values[:user_last_name] if values.has_key?(:user_last_name)
      # concatenate first name and last name
      values[:user_full_name] = "#{employee.user_first_name} #{employee.user_last_name}".strip
    end

    # you can add logic that specifically depends on the record like the following:
    if employee.is_current_employee?
      if values.has_key? :branch_company_id
        # concatenate a unique code for the employee: i.e. a value of "11-5-1239"
        values[:unique_codename] = "#{employee.branch.company.id}-#{employee.branch.id}-#{employee.id}"
      end
    end

    values
  end
end

# db/migrate/TIMESTAMP_add_quickery_branch_company_name_branch_company_id_to_employees.rb
class AddQuickeryBranchCompanyNameBranchCompanyIdToEmployees < ActiveRecord::Migration[5.2]
  def change
    change_table :employees do |t|
      t.string :branch_company_name
      t.bigint :branch_company_id
    end
    add_index :employees, :branch_company_id
  end
end

# db/migrate/TIMESTAMP_add_quickery_branch_company_name_branch_company_id_to_employees.rb
class AddQuickeryBranchCompanyNameBranchCompanyIdToEmployees < ActiveRecord::Migration[5.2]
  def change
    change_table :employees do |t|
      t.string :branch_company_name
      t.boolean :branch_company_name_is_synced, null: false, default: false
      t.bigint :branch_company_id
      t.boolean :branch_company_id_is_synced, null: false, default: false
    end
    add_index :employees, :branch_company_id
  end
end