Bang! vs No-Bang: Mastering Rails Active Record Methods

# Non-bang: fails silently
user = User.new(email: nil)
user.save          # => false (email validation failed, no exception)
# Bang: fails loudly
user.save!         # => raises ActiveRecord::RecordInvalid
                   # "Validation failed: Email can't be blank"

# Non-bang: returns true/false
def update_profile(user, params)
  if user.update(params)
    render json: { status: :ok }
  else
    render json: { errors: user.errors.full_messages }, status: :unprocessable_entity
  end
end
# Bang: raises on failure - use inside transactions or background jobs
def sync_user_data!(user, external_data)
  user.update!(
    name: external_data[:name],
    synced_at: Time.current
  )
end

# Non-bang: returns the object regardless - even if invalid!
user = User.create(email: "bad")
user.persisted?    # => false - object was NOT saved
user.errors.full_messages  # => ["Email is invalid"]
# Bang: raises ActiveRecord::RecordInvalid immediately
user = User.create!(email: "bad")
# => ActiveRecord::RecordInvalid: Validation failed: Email is invalid

# Non-bang: returns true/false
order.update(status: "shipped")  # => true or false
# Bang: raises ActiveRecord::RecordInvalid
order.update!(status: "shipped")  # raises if validations fail

# Non-bang: returns the frozen object (even if callbacks prevented destroy)
user.destroy  # => returns user object, check user.destroyed? to verify
# Bang: raises ActiveRecord::RecordNotDestroyed if a before_destroy callback halts it
user.destroy! # => raises if any callback returns false/throws :abort

# Non-bang: returns nil if not found
user = User.find_by(email: "alice@example.com")
return if user.nil?   # handle the nil case
# Bang: raises ActiveRecord::RecordNotFound
user = User.find_by!(email: "alice@example.com")
# No nil check needed - exception propagates (caught by rescue_from in controllers)

# Non-bang: silently returns invalid object if creation fails
tag = Tag.where(name: "rails").first_or_create(color: nil)  # may return unpersisted record
# Bang: raises if creation fails validations
tag = Tag.where(name: "rails").first_or_create!(color: "#CC0000")

# Non-bang
subscription = Subscription.create_or_find_by(user: current_user, plan: "pro")
# Bang - raises if found record doesn't exist and creation fails for non-uniqueness reasons
subscription = Subscription.create_or_find_by!(user: current_user, plan: "pro")

# Raises ActiveRecord::RecordNotFound if zero found
# Raises ActiveRecord::SoleRecordExceeded if more than one found
admin = User.find_sole_by(role: "super_admin")

# insert_all: ignores conflicts (duplicate unique keys are skipped)
Product.insert_all([
  { sku: "ABC", name: "Widget" },
  { sku: "ABC", name: "Duplicate" }   # silently skipped
])
# insert_all!: raises ActiveRecord::RecordNotUnique on conflicts
Product.insert_all!([
  { sku: "ABC", name: "Widget" },
  { sku: "ABC", name: "Duplicate" }   # => raises!
])
# upsert_all: updates on conflict (no bang needed for this use case)
Product.upsert_all(
  [{ sku: "ABC", name: "Updated Widget" }],
  unique_by: :sku
)

def create
  @post = Post.new(post_params)
  if @post.save
    redirect_to @post, notice: "Post created"
  else
    render :new, status: :unprocessable_entity  # show errors to user
  end
end

# Trying to "claim" a record in a concurrent system
if order.update(claimed_by: current_user.id, claimed_at: Time.current)
  process_order(order)
else
  redirect_to orders_path, alert: "Order already claimed"
end

promo = Promotion.find_by(code: params[:promo_code])
discount = promo&.discount_percentage || 0

ActiveRecord::Base.transaction do
  order.update!(status: "processing")
  inventory.update!(quantity: inventory.quantity - order.quantity)
  payment.update!(charged_at: Time.current)
  # If any of these fail, the whole transaction rolls back
end

class SyncUserJob < ApplicationJob
  def perform(user_id)
    user = User.find(user_id)                    # raises if not found
    user.update!(synced_at: Time.current)        # raises if validation fails
    # Sidekiq/Solid Queue catches the exception and retries
  end
end

# db/seeds.rb
User.create!(email: "admin@example.com", role: "admin", password: "SecurePass123!")

class ChargeCustomer
  def call(user, amount)
    payment = Payment.create!(user: user, amount: amount, status: "pending")
    result = StripeGateway.charge(user.stripe_id, amount)
    payment.update!(status: "completed", stripe_id: result.id)
    payment
  rescue ActiveRecord::RecordInvalid => e
    Rails.logger.error("Payment record invalid: #{e.message}")
    raise  # re-raise for the controller to handle
  end
end

# Controller boundary - non-bang
def update
  if @user.update(user_params)
    ...
  end
end
# Service layer - bang
class UserProfileService
  def sync!(user)
    user.update!(last_synced: Time.current)  # let it raise, job will retry
  end
end