Active Support: extensions and notifications

# Active Support adds methods to Ruby's built-in classes. These are called core extensions: they let Rails code read
# like prose. This file shows the extensions Kaksha uses most often, paired with their plain-Ruby equivalents.
require "active_support/all"

puts "=== blank? and present? (Object) ==="
# blank? returns true for nil, false, empty strings, empty arrays, and whitespace-only strings.
# present? is the opposite: !blank?.
name = ""
puts "name.blank?           => #{name.blank?}"         # true
puts "name.nil? || name.empty? => #{name.nil? || name.empty?}" # same thing for strings

guardian_phone = "   "
puts "guardian_phone.blank? => #{guardian_phone.blank?}" # true (whitespace only)
puts "guardian_phone.strip.empty? => #{guardian_phone.strip.empty?}" # plain Ruby equivalent

batch_ids = [1, 2, 3]
puts "batch_ids.present?    => #{batch_ids.present?}"  # true
puts "!batch_ids.empty?     => #{!batch_ids.empty?}"   # plain Ruby

puts "\n=== presence (Object) ==="
# presence returns the receiver if present?, otherwise nil. Useful for defaults.
input = "  "
fallback = input.presence || "N/A"
puts "input.presence || 'N/A' => #{fallback.inspect}" # "N/A"
# Plain Ruby: the conditional is longer
plain = (input && !input.strip.empty?) ? input : "N/A"
puts "plain Ruby conditional  => #{plain.inspect}"

puts "\n=== try (Object) ==="
# try calls a method only if the receiver responds to it; returns nil otherwise.
student = nil
puts "student.try(:name)    => #{student.try(:name).inspect}" # nil (no NoMethodError)
puts "student&.name         => #{student&.name.inspect}"      # Ruby 2.3+ safe navigation (similar)

# try also accepts a block
arr = [1, 2, 3]
puts "arr.try { |a| a.sum } => #{arr.try { |a| a.sum }}" # 6

puts "\n=== in? (Object) ==="
# in? checks membership, reading left to right.
status = "paid"
puts "status.in?(%w[paid pending]) => #{status.in?(%w[paid pending])}" # true
puts "%w[paid pending].include?(status) => #{%w[paid pending].include?(status)}" # plain Ruby

puts "\n=== Duration (Numeric) ==="
# Active Support lets you write durations as methods on numbers.
puts "2.days               => #{2.days.inspect}"       # 2 days
puts "2 * 24 * 60 * 60     => #{2 * 24 * 60 * 60}"     # 172800 seconds

# Durations work with Time
Time.zone = "Asia/Kolkata"
now = Time.zone.local(2031, 5, 10, 9, 0, 0)
puts "now                  => #{now}"
puts "now + 2.days         => #{now + 2.days}"         # 2031-05-12 09:00:00
puts "3.hours.ago(now)     => #{3.hours.ago(now)}"     # 2031-05-10 06:00:00

puts "\n=== to_sentence (Array) ==="
subjects = %w[Physics Chemistry Biology]
puts "subjects.to_sentence => #{subjects.to_sentence}" # "Physics, Chemistry, and Biology"
# Plain Ruby: subjects[0..-2].join(", ") + ", and " + subjects[-1]

puts "\n=== squish (String) ==="
# squish collapses all whitespace (including newlines) into single spaces and strips edges.
messy = "  Class   10\n\nScience  "
puts "messy.squish         => #{messy.squish.inspect}" # "Class 10 Science"
puts "messy.split.join(' ') => #{messy.split.join(' ').inspect}" # close, but split uses default separator

puts "\n=== inquiry (String) ==="
# inquiry wraps a string so you can ask questions about it with predicate methods.
env = "production".inquiry
puts "env.production?      => #{env.production?}"      # true
puts "env.development?     => #{env.development?}"     # false
puts "env == 'production'  => #{env == 'production'}"  # plain Ruby

puts "\n=== deep_symbolize_keys (Hash) ==="
config = { "database" => { "host" => "localhost", "port" => 5432 } }
puts "config.deep_symbolize_keys => #{config.deep_symbolize_keys.inspect}"
# { database: { host: "localhost", port: 5432 } }

puts "\n=== with_indifferent_access (Hash) ==="
params = { name: "Priya" }.with_indifferent_access
puts "params[:name]        => #{params[:name].inspect}"   # "Priya"
puts "params['name']       => #{params['name'].inspect}"  # "Priya" (same value)

puts "\n=== inflections (String) ==="
puts "'batch'.pluralize    => #{'batch'.pluralize}"       # "batches"
puts "'batches'.singularize => #{'batches'.singularize}"  # "batch"
puts "'fee_payment'.camelize => #{'fee_payment'.camelize}" # "FeePayment"
puts "'FeePayment'.underscore => #{'FeePayment'.underscore}" # "fee_payment"
puts "'fee_payments'.classify => #{'fee_payments'.classify}" # "FeePayment"
puts "'FeePayment'.tableize => #{'FeePayment'.tableize}"   # "fee_payments"

=== blank? and present? (Object) ===
name.blank?           => true
name.nil? || name.empty? => true
guardian_phone.blank? => true
guardian_phone.strip.empty? => true
batch_ids.present?    => true
!batch_ids.empty?     => true

=== presence (Object) ===
input.presence || 'N/A' => "N/A"
plain Ruby conditional  => "N/A"

=== try (Object) ===
student.try(:name)    => nil
student&.name         => nil
arr.try { |a| a.sum } => 6

=== in? (Object) ===
status.in?(%w[paid pending]) => true
%w[paid pending].include?(status) => true

=== Duration (Numeric) ===
2.days               => 2 days
2 * 24 * 60 * 60     => 172800
now                  => 2031-05-10 09:00:00 +0530
now + 2.days         => 2031-05-12 09:00:00 +0530
3.hours.ago(now)     => 2031-05-10 06:00:00 +0530

=== to_sentence (Array) ===
subjects.to_sentence => Physics, Chemistry, and Biology

=== squish (String) ===
messy.squish         => "Class 10 Science"
messy.split.join(' ') => "Class 10 Science"

=== inquiry (String) ===
env.production?      => true
env.development?     => false
env == 'production'  => true

=== deep_symbolize_keys (Hash) ===
config.deep_symbolize_keys => {database: {host: "localhost", port: 5432}}

=== with_indifferent_access (Hash) ===
params[:name]        => "Priya"
params['name']       => "Priya"

=== inflections (String) ===
'batch'.pluralize    => batches
'batches'.singularize => batch
'fee_payment'.camelize => FeePayment
'FeePayment'.underscore => fee_payment
'fee_payments'.classify => FeePayment
'FeePayment'.tableize => fee_payments

# ActiveSupport::Notifications lets you instrument your own code and subscribe to events. This example instruments
# fee calculations in Kaksha: the code announces what it is doing, and a subscriber listens and logs.
require "active_support/all"

# A simple fee calculator. We will instrument calculate_total so that subscribers know when it runs.
class FeeCalculator
  def calculate_total(student_id:, items:)
    # instrument wraps a block and publishes an event. The payload hash travels with the event.
    # The block form captures timing; we add the result to the payload explicitly.
    payload = { student_id: student_id, items: items }
    ActiveSupport::Notifications.instrument("calculate_total.fees", payload) do
      subtotal = items.sum { |item| item[:amount] }
      # Simulate applying a discount for early payment
      discount = subtotal > 10_000 ? (subtotal * 0.05).round : 0
      total = subtotal - discount
      # Add the result to the payload so subscribers can see it
      payload[:result] = { subtotal: subtotal, discount: discount, total: total }
      payload[:result]
    end
  end
end

# Subscribe to events. The block receives an ActiveSupport::Notifications::Event with timing and payload.
puts "=== Subscribing to calculate_total.fees ==="
collected_events = []
subscription = ActiveSupport::Notifications.subscribe("calculate_total.fees") do |event|
  collected_events << {
    name: event.name,
    student_id: event.payload[:student_id],
    items_count: event.payload[:items].size,
    result: event.payload[:result]
  }
end

# Run some calculations
calc = FeeCalculator.new

puts "\n=== Running two calculations ==="
result1 = calc.calculate_total(
  student_id: 42,
  items: [{ name: "Tuition", amount: 8_000 }, { name: "Lab", amount: 1_500 }]
)
puts "Student 42: #{result1}"

result2 = calc.calculate_total(
  student_id: 17,
  items: [{ name: "Tuition", amount: 12_000 }, { name: "Books", amount: 2_000 }]
)
puts "Student 17: #{result2}"

# Show what the subscriber collected
puts "\n=== Events collected by the subscriber ==="
collected_events.each do |e|
  puts "  #{e[:name]}: student #{e[:student_id]}, #{e[:items_count]} items"
  puts "    result: #{e[:result]}"
end

# Unsubscribe when done (important in tests to avoid leaking subscribers)
ActiveSupport::Notifications.unsubscribe(subscription)
puts "\n=== Unsubscribed ==="

# A second subscriber can filter by regex
puts "\n=== Subscribing to all *.fees events with a regex ==="
regex_sub = ActiveSupport::Notifications.subscribe(/\.fees$/) do |event|
  puts "  [regex subscriber] saw: #{event.name} for student #{event.payload[:student_id]}"
end

# Instrument another event that the regex subscriber will catch
puts "\n=== Applying a late fee (instrumented) ==="
ActiveSupport::Notifications.instrument("late_fee_applied.fees", student_id: 42, amount: 500) do
  puts "  Late fee of 500 applied to student 42"
end

ActiveSupport::Notifications.unsubscribe(regex_sub)

=== Subscribing to calculate_total.fees ===

=== Running two calculations ===
Student 42: {subtotal: 9500, discount: 0, total: 9500}
Student 17: {subtotal: 14000, discount: 700, total: 13300}

=== Events collected by the subscriber ===
  calculate_total.fees: student 42, 2 items
    result: {subtotal: 9500, discount: 0, total: 9500}
  calculate_total.fees: student 17, 2 items
    result: {subtotal: 14000, discount: 700, total: 13300}

=== Unsubscribed ===

=== Subscribing to all *.fees events with a regex ===

=== Applying a late fee (instrumented) ===
  Late fee of 500 applied to student 42
  [regex subscriber] saw: late_fee_applied.fees for student 42