Rails: DRY style ajax validation

Formulation of the problem

1. in the validation of attributes use the same logic: both for the back and for the front
2. quickly “hang up” checks for different forms and flexibly adjust them (both logic and visual)

Instruments

Getting to the point

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

• email required
• email must be unique
• email should be email (with a dog and other ryushechkami)
• frequency is optional, but if so, it should be in the range from 1 to 7

 class Email < ActiveRecord::Base before_save { self.email = email.downcase } VALID_EMAIL_REGEX = /\A[\w+\-.]+@[az\d\-.]+\.[az]+\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 will repeat the link to the documentation for the plugin in order not to return to it anymore. There is a small problem with the structured content, but all the information is there.

 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 an ajax request to check the field values
• $('#new_email, [id^=edit_email_]').validate
  we hang the validator on the form of a new email, and on the form for editing already existing addresses
• debug: true
  the method disables submitting the form so that you can be entertained with the settings
• rules:
  In the method, validation rules for fields are prescribed, 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 them in quotes)

remote

 remote: url: validate_url type: 'post' 

• the answer is true - it means that everything is ok with the field
• false , undefined or null responses, as well as any other string' are regarded by the method as a signal of failed validation

required

 required: true 

We continue

• need to create a method in the controller that will process the request
• register 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 a json flown to the controller, we will create a new Email object in memory
• and remove its validation via ActiveModel
• an object of class ActiveModel::Errors (available through the errors method) is ActiveModel::Errors in memory, in which there will be a hash @messages - either with errors (if the attributes are not validated), or empty (if everything is fine with the object)
• we will analyze this hash and, if it is empty, we will answer the browser with true , and if there are errors in the attribute being checked, we will reply with the text of these errors, which will be considered by the plugin’s receiving method as failed validation. And, moreover, the plugin uses the received string 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 " 

Read about I18n in 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}<br />" } end respond_to do |format| format.json { render json: @errors } end end 

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

 (rdb:938) email.errors #=> #<ActiveModel::Errors:0x007fbbe378dfb0 @base=#<Email id: nil, email: nil, frequency: "-", created_at: nil, updated_at: nil>, @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}<br />" } end 

• if we give it up as just @errors , then we get the message “must be in the range from 1 to 7 inclusively” (and if there are several, they just “stick together” when outputting)

• We take out the name of the model attribute from the rail localization file:
  name = t("activerecord.attributes.email.#{field}")
• and in each array element with errors we add this name to the beginning with a space:
  @errors.map! { |e| "#{name} #{e}
" }
• You can also stick br 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 

Refractory

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}<br />" } end end 

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