module ActiveRecord # = Active Record RecordInvalid # # Raised by save! and create! when the record is invalid. Use the # +record+ method to retrieve the record which did not validate. # # begin # complex_operation_that_internally_calls_save! # rescue ActiveRecord::RecordInvalid => invalid # puts invalid.record.errors # end class RecordInvalid < ActiveRecordError attr_reader :record def initialize(record = nil) if record @record = record errors = @record.errors.full_messages.join(", ") message = I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", errors: errors, default: :"errors.messages.record_invalid") else message = "Record invalid" end super(message) end end # = Active Record Validations # # Active Record includes the majority of its validations from ActiveModel::Validations # all of which accept the :on argument to define the context where the # validations are active. Active Record will always supply either the context of # :create or :update dependent on whether the model is a # new_record?. module Validations extend ActiveSupport::Concern include ActiveModel::Validations # The validation process on save can be skipped by passing validate: false. # The regular Base#save method is replaced with this when the validations # module is mixed in, which it is by default. def save(options={}) perform_validations(options) ? super : false end # Attempts to save the record just like Base#save but will raise a +RecordInvalid+ # exception instead of returning +false+ if the record is not valid. def save!(options={}) perform_validations(options) ? super : raise_validation_error end # Runs all the validations within the specified context. Returns +true+ if # no errors are found, +false+ otherwise. # # Aliased as validate. # # If the argument is +false+ (default is +nil+), the context is set to :create if # new_record? is +true+, and to :update if it is not. # # Validations with no :on option will run no matter the context. Validations with # some :on option will only run in the specified context. def valid?(context = nil) context ||= default_validation_context output = super(context) errors.empty? && output end alias_method :validate, :valid? protected def default_validation_context new_record? ? :create : :update end def raise_validation_error raise(RecordInvalid.new(self)) end def perform_validations(options={}) # :nodoc: options[:validate] == false || valid?(options[:context]) end end end require "active_record/validations/associated" require "active_record/validations/uniqueness" require "active_record/validations/presence" require "active_record/validations/absence" require "active_record/validations/length"