Rails: DRY style ajax validation

Formulation of the problem

1. when validating attributes use one logic: both for the back and for the front
2. quickly "hang up" checks on different forms and flexibly configure them (both logic and visual)

Instruments

Let's get to the point

• email - email address
• frequency - the frequency with which the newsletter will go to this address

• availability emailrequired
• email must be unique
• email must be email (with a dog and other things)
• frequencyoptional, but if any, it should be in the range of 1 to 7

class Email < ActiveRecord::Base
  before_save { self.email = email.downcase }
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  validates :email, presence: true,
            uniqueness: { case_sensitive: false },
            format: { with: VALID_EMAIL_REGEX }
  validates_inclusion_of :frequency, in: 1..7, allow_blank: true
end

class EmailsController < ApplicationController
  def new
    @email = Email.new
  end
  def create
    @email = Email.new(email_params)
    if @email.save
      flash[:success] = 'Email добавлен!'
      redirect_to emails_url
    else
      render :new
    end
  end
  private
    def email_params
      params.require(:email).permit(:email, :frequency)
    end
end

%h1 Новая почта
= form_for @email do |f|
  = render partial: 'shared/error_messages', locals: { object: f.object }
  %p= f.text_field :email, placeholder: 'Почта'
  %p= f.text_field :frequency, placeholder: 'Периодичность рассылки'
  %p= f.submit 'Добавить!'

I’ll repeat the link to the documentation for the plugin so that it no longer returns. There is a small problem with the structured content, but there is all the information.

jQuery ->
  validate_url = '/emails/validate'
  $('#new_email, [id^=edit_email_]').validate(
    debug: true
    rules:
      'email[email]':
        required: true
        remote:
          url: validate_url
          type: 'post'
      'email[frequency]':
        remote:
          url: validate_url
          type: 'post'
  )

• validate_url = '/emails/validate'
  the address to which we will send the ajax request to check the field values
• $('#new_email, [id^=edit_email_]').validate
  we hang the validator both on the form of a new email and on the form of editing existing addresses
• debug: true
  the method disables the form submission so that you can have fun with the settings
• rules:
  the verification rules for fields are written in the method, the plugin has a lot of them out of the box (see docks), but so far we are only interested in 2
• 'email[email]':
  name – attribute of the form field (simple names are indicated without quotes, with special characters - we take in quotes)

remote

remote:
  url: validate_url
  type: 'post'

• the answer truemeans that everything is ok with the field
• answers false, undefinedor null, as well as any other, string'аare regarded by the method as a signal of failed validation

required

required: true

Continue

• you need to create a method in the controller that will handle the request
• register a route to this method

  def validate
    # пока пустой
  end

resources :emails
post 'emails/validate', to: 'emails#validate', as: :emails_validation

Started POST "/emails/validate" for 127.0.0.1 at 2014-02-17 22:10:31 +0000
Processing by EmailsController#validate as JSON
  Parameters: {"email"=>{"frequency"=>"что-нибудь"}}

• from arriving at the controller json, we will create a new object in memoryEmail
• and pull its validation through ActiveModel
• an object of the class ActiveModel::Errors(accessible via the method errors) will be drawn in memory , in which there will be a hash @messageseither with errors (if the attributes did not pass validation) or empty (if everything is fine with the object)
• we will analyze this hash and, if it is empty, we will respond to the browser true, and if it has errors for the attribute being checked, we will respond with the text of these errors, which will be regarded by the receiving method of the plug-in as a failed validation. And, moreover, the plugin uses the string received as the text of the error message.

ru:
  activerecord:
    attributes:
      email:
        email: "Почта"
        frequency: "Периодичность"
    errors:
      models:
        email:
          attributes:
            email:
              blank: "обязательна"
              taken: "уже добавлена в список рассылки"
              invalid: "имеет странный формат"
            frequency:
              inclusion: "должна быть в диапазоне от 1 до 7 включительно"

We read about I18n in the Rails guides: http://guides.rubyonrails.org/i18n.html

def validate
  email = Email.new(email_params)
  email.valid?
  field = params[:email].first[0]
  @errors = email.errors[field]
  if @errors.empty?
    @errors = true
  else
    name = t("activerecord.attributes.email.#{field}")
    @errors.map! { |e| "#{name} #{e}
" }
  end
  respond_to do |format|
    format.json { render json: @errors }
  end
end

email = Email.new(email_params)
email.valid?

(rdb:938) email.errors
#=> #, @messages={:email=>["обязательна", "имеет странный формат"], :frequency=>["должна быть в диапазоне от 1 до 7 включительно"]}>

(rdb:938) email.errors['frequency']
#=> ["должна быть в диапазоне от 1 до 7 включительно"]

# так выглядит хэш
(rdb:938) params
#=> {"email"=>{"frequency"=>"что-нибудь"}, "controller"=>"emails", "action"=>"validate"}
# нам известно название модели, поэтому достаём атрибуты
(rdb:938) params[:email]
#=> {"frequency"=>"что-нибудь"}
# поскольку за запрос улетает всегда один атрибут, то забираем первый
(rdb:938) params[:email].first
#=> ["frequency", "что-нибудь"]
# на первом месте всегда будет ключ, то есть имя атрибута -> забираем
(rdb:938) params[:email].first[0]
#=> "frequency"

field = params[:email].first[0]
@errors = email.errors[field]

if @errors.empty?
  @errors = true
else
  name = t("activerecord.attributes.email.#{field}")
  @errors.map! { |e| "#{name} #{e}
" }
end

• if we give it away just like that @errors, we get a message “should be in the range from 1 to 7 inclusive” (and if there are several, they just “stick together” at the output)

• pull the model attribute name from the rail localization file:
  name = t("activerecord.attributes.email.#{field}")
• and in each element of the array with errors, add this name to the beginning with a space:
  @errors.map! { |e| "#{name} #{e}
" }
• you can also brstick at the end of each error, it depends on the layout, in short add to taste

respond_to do |format|
  format.json { render json: @errors }
end

Refactor

Routing

# было
post 'emails/validate', to: 'emails#validate', as: :emails_validation
# чтобы не переписывать маршрут для каждого контроллера
post ':controller/validate', action: 'validate', as: :validate_form

Validation method

def validator(object)
  object.valid?
  model = object.class.name.underscore.to_sym
  field = params[model].first[0]
  @errors = object.errors[field]
  if @errors.empty?
    @errors = true
  else
    name = t("activerecord.attributes.#{model}.#{field}")
    @errors.map! { |e| "#{name} #{e}
" }
  end
end

def validate
  email = Email.new(email_params)
  validator(email)
  respond_to do |format|
    format.json { render json: @errors }
  end
end