rails_admin 0.6.0 → 0.6.1

data/app/controllers/rails_admin/application_controller.rb

@@ -20,57 +20,57 @@ module RailsAdmin
 
     def get_model
       @model_name = to_model_name(params[:model_name])
-      raise RailsAdmin::ModelNotFound unless (@abstract_model = RailsAdmin::AbstractModel.new(@model_name))
-      raise RailsAdmin::ModelNotFound if (@model_config = @abstract_model.config).excluded?
+      fail(RailsAdmin::ModelNotFound) unless (@abstract_model = RailsAdmin::AbstractModel.new(@model_name))
+      fail(RailsAdmin::ModelNotFound) if (@model_config = @abstract_model.config).excluded?
       @properties = @abstract_model.properties
     end
 
     def get_object
-      raise RailsAdmin::ObjectNotFound unless (@object = @abstract_model.get(params[:id]))
+      fail(RailsAdmin::ObjectNotFound) unless (@object = @abstract_model.get(params[:id]))
     end
 
     def to_model_name(param)
-      model_name = param.split("~").map(&:camelize).join("::")
+      param.split('~').collect(&:camelize).join('::')
     end
 
-    private
+  private
 
     def _get_plugin_name
       @plugin_name_array ||= [RailsAdmin.config.main_app_name.is_a?(Proc) ? instance_eval(&RailsAdmin.config.main_app_name) : RailsAdmin.config.main_app_name].flatten
     end
 
     def _authenticate!
-      instance_eval &RailsAdmin::Config.authenticate_with
+      instance_eval(&RailsAdmin::Config.authenticate_with)
     end
 
     def _authorize!
-      instance_eval &RailsAdmin::Config.authorize_with
+      instance_eval(&RailsAdmin::Config.authorize_with)
     end
 
     def _audit!
-      instance_eval &RailsAdmin::Config.audit_with
+      instance_eval(&RailsAdmin::Config.audit_with)
     end
 
     def _current_user
-      instance_eval &RailsAdmin::Config.current_user_method
+      instance_eval(&RailsAdmin::Config.current_user_method)
     end
 
     alias_method :user_for_paper_trail, :_current_user
 
     rescue_from RailsAdmin::ObjectNotFound do
-      flash[:error] = I18n.t('admin.flash.object_not_found', :model => @model_name, :id => params[:id])
+      flash[:error] = I18n.t('admin.flash.object_not_found', model: @model_name, id: params[:id])
       params[:action] = 'index'
       index
     end
 
     rescue_from RailsAdmin::ModelNotFound do
-      flash[:error] = I18n.t('admin.flash.model_not_found', :model => @model_name)
+      flash[:error] = I18n.t('admin.flash.model_not_found', model: @model_name)
       params[:action] = 'dashboard'
       dashboard
     end
 
     def not_found
-      render :file => Rails.root.join('public', '404.html'), :layout => false, :status => :not_found
+      render file: Rails.root.join('public', '404.html'), layout: false, status: :not_found
     end
 
     def rails_admin_controller?

data/app/controllers/rails_admin/main_controller.rb

@@ -1,15 +1,13 @@
 module RailsAdmin
-
   class MainController < RailsAdmin::ApplicationController
-
     include ActionView::Helpers::TextHelper
     include RailsAdmin::MainHelper
     include RailsAdmin::ApplicationHelper
 
     layout :get_layout
 
-    before_filter :get_model, :except => RailsAdmin::Config::Actions.all(:root).map(&:action_name)
-    before_filter :get_object, :only => RailsAdmin::Config::Actions.all(:member).map(&:action_name)
+    before_filter :get_model, except: RailsAdmin::Config::Actions.all(:root).collect(&:action_name)
+    before_filter :get_object, only: RailsAdmin::Config::Actions.all(:member).collect(&:action_name)
     before_filter :check_for_cancel
 
     RailsAdmin::Config::Actions.all.each do |action|
@@ -26,7 +24,7 @@ module RailsAdmin
     end
 
     def bulk_action
-      self.send(params[:bulk_action]) if params[:bulk_action].in?(RailsAdmin::Config::Actions.all(:controller => self, :abstract_model => @abstract_model).select(&:bulkable?).map(&:route_fragment))
+      send(params[:bulk_action]) if params[:bulk_action].in?(RailsAdmin::Config::Actions.all(controller: self, abstract_model: @abstract_model).select(&:bulkable?).collect(&:route_fragment))
     end
 
     def list_entries(model_config = @model_config, auth_scope_key = :index, additional_scope = get_association_scope_from_params, pagination = !(params[:associated_collection] || params[:all] || params[:bulk_ids]))
@@ -39,7 +37,7 @@ module RailsAdmin
       get_collection(model_config, scope, pagination)
     end
 
-    private
+  private
 
     def get_layout
       "rails_admin/#{request.headers['X-PJAX'] ? 'pjax' : 'application'}"
@@ -51,12 +49,12 @@ module RailsAdmin
 
     def get_sort_hash(model_config)
       abstract_model = model_config.abstract_model
-      params[:sort] = params[:sort_reverse] = nil unless model_config.list.fields.map {|f| f.name.to_s}.include? params[:sort]
+      params[:sort] = params[:sort_reverse] = nil unless model_config.list.fields.collect { |f| f.name.to_s }.include? params[:sort]
 
       params[:sort] ||= model_config.list.sort_by.to_s
       params[:sort_reverse] ||= 'false'
 
-      field = model_config.list.fields.find{ |f| f.name.to_s == params[:sort] }
+      field = model_config.list.fields.detect { |f| f.name.to_s == params[:sort] }
 
       column = if field.nil? || field.sortable == true # use params[:sort] on the base table
         "#{abstract_model.table_name}.#{params[:sort]}"
@@ -73,33 +71,33 @@ module RailsAdmin
       end
 
       reversed_sort = (field ? field.sort_reverse? : model_config.list.sort_reverse?)
-      {:sort => column, :sort_reverse => (params[:sort_reverse] == reversed_sort.to_s)}
+      {sort: column, sort_reverse: (params[:sort_reverse] == reversed_sort.to_s)}
     end
 
     def redirect_to_on_success
-      notice = t("admin.flash.successful", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+      notice = t('admin.flash.successful', name: @model_config.label, action: t("admin.actions.#{@action.key}.done"))
       if params[:_add_another]
-        redirect_to new_path(:return_to => params[:return_to]), :flash => { :success => notice }
+        redirect_to new_path(return_to: params[:return_to]), flash: {success: notice}
       elsif params[:_add_edit]
-        redirect_to edit_path(:id => @object.id, :return_to => params[:return_to]), :flash => { :success => notice }
+        redirect_to edit_path(id: @object.id, return_to: params[:return_to]), flash: {success: notice}
       else
-        redirect_to back_or_index, :flash => { :success => notice }
+        redirect_to back_or_index, flash: {success: notice}
       end
     end
 
     def satisfy_strong_params!
-      if @abstract_model.model.ancestors.map(&:to_s).include?('ActiveModel::ForbiddenAttributesProtection')
+      if @abstract_model.model.ancestors.collect(&:to_s).include?('ActiveModel::ForbiddenAttributesProtection')
         params[@abstract_model.param_key].try :permit!
       end
     end
 
     def sanitize_params_for!(action, model_config = @model_config, _params = params[@abstract_model.param_key])
       return unless _params.present?
-      fields = model_config.send(action).with(:controller => self, :view => self.view_context, :object => @object).visible_fields
-      allowed_methods = fields.map{|f|
+      fields = model_config.send(action).with(controller: self, view: view_context, object: @object).visible_fields
+      allowed_methods = fields.collect do|f|
         f.allowed_methods
-      }.flatten.uniq.map(&:to_s) << "id" << "_destroy"
-      fields.each {|f| f.parse_input(_params) }
+      end.flatten.uniq.collect(&:to_s) << 'id' << '_destroy'
+      fields.each { |f| f.parse_input(_params) }
       _params.slice!(*allowed_methods)
       fields.select(&:nested_form).each do |association|
         children_params = association.multiple? ? _params[association.method_name].try(:values) : [_params[association.method_name]].compact
@@ -109,35 +107,32 @@ module RailsAdmin
       end
     end
 
-    def handle_save_error whereto = :new
-      action = params[:action]
-
-      flash.now[:error] = t("admin.flash.error", :name => @model_config.label, :action => t("admin.actions.#{@action.key}.done"))
+    def handle_save_error(whereto = :new)
+      flash.now[:error] = t('admin.flash.error', name: @model_config.label, action: t("admin.actions.#{@action.key}.done"))
       flash.now[:error] += ". #{@object.errors[:base].to_sentence}" unless @object.errors[:base].blank?
 
       respond_to do |format|
-        format.html { render whereto, :status => :not_acceptable }
-        format.js   { render whereto, :layout => false, :status => :not_acceptable  }
+        format.html { render whereto, status: :not_acceptable }
+        format.js   { render whereto, layout: false, status: :not_acceptable  }
       end
     end
 
     def check_for_cancel
       if params[:_continue] || (params[:bulk_action] && !params[:bulk_ids])
-        redirect_to(back_or_index, :flash => { :info => t("admin.flash.noaction") })
+        redirect_to(back_or_index, flash: {info: t('admin.flash.noaction')})
       end
     end
 
     def get_collection(model_config, scope, pagination)
-      associations = model_config.list.fields.select {|f| f.type == :belongs_to_association && !f.polymorphic? }.map {|f| f.association[:name] }
+      associations = model_config.list.fields.select { |f| f.type == :belongs_to_association && !f.polymorphic? }.collect { |f| f.association[:name] }
       options = {}
-      options = options.merge(:page => (params[Kaminari.config.param_name] || 1).to_i, :per => (params[:per] || model_config.list.items_per_page)) if pagination
-      options = options.merge(:include => associations) unless associations.blank?
+      options = options.merge(page: (params[Kaminari.config.param_name] || 1).to_i, per: (params[:per] || model_config.list.items_per_page)) if pagination
+      options = options.merge(include: associations) unless associations.blank?
       options = options.merge(get_sort_hash(model_config))
-      options = options.merge(:query => params[:query]) if params[:query].present?
-      options = options.merge(:filters => params[:f]) if params[:f].present?
-      options = options.merge(:bulk_ids => params[:bulk_ids]) if params[:bulk_ids]
-
-      objects = model_config.abstract_model.all(options, scope)
+      options = options.merge(query: params[:query]) if params[:query].present?
+      options = options.merge(filters: params[:f]) if params[:f].present?
+      options = options.merge(bulk_ids: params[:bulk_ids]) if params[:bulk_ids]
+      model_config.abstract_model.all(options, scope)
     end
 
     def get_association_scope_from_params
@@ -145,8 +140,8 @@ module RailsAdmin
       source_abstract_model = RailsAdmin::AbstractModel.new(to_model_name(params[:source_abstract_model]))
       source_model_config = source_abstract_model.config
       source_object = source_abstract_model.get(params[:source_object_id])
-      action = params[:current_action].in?(['create', 'update']) ? params[:current_action] : 'edit'
-      @association = source_model_config.send(action).fields.find{|f| f.name == params[:associated_collection].to_sym }.with(:controller => self, :object => source_object)
+      action = params[:current_action].in?(%w(create update)) ? params[:current_action] : 'edit'
+      @association = source_model_config.send(action).fields.detect { |f| f.name == params[:associated_collection].to_sym }.with(controller: self, object: source_object)
       @association.associated_collection_scope
     end
   end

data/app/helpers/rails_admin/application_helper.rb

@@ -2,7 +2,6 @@ require 'rails_admin/i18n_support'
 
 module RailsAdmin
   module ApplicationHelper
-
     include RailsAdmin::I18nSupport
 
     def authorized?(action, abstract_model = nil, object = nil)
@@ -17,18 +16,18 @@ module RailsAdmin
     end
 
     def action(key, abstract_model = nil, object = nil)
-      RailsAdmin::Config::Actions.find(key, { :controller => self.controller, :abstract_model => abstract_model, :object => object })
+      RailsAdmin::Config::Actions.find(key, controller: controller, abstract_model: abstract_model, object: object)
     end
 
     def actions(scope = :all, abstract_model = nil, object = nil)
-      RailsAdmin::Config::Actions.all(scope, { :controller => self.controller, :abstract_model => abstract_model, :object => object })
+      RailsAdmin::Config::Actions.all(scope, controller: controller, abstract_model: abstract_model, object: object)
     end
 
     def edit_user_link
       return nil unless authorized?(:edit, _current_user.class, _current_user) && _current_user.respond_to?(:email)
       return nil unless abstract_model = RailsAdmin.config(_current_user.class).abstract_model
-      return nil unless edit_action = RailsAdmin::Config::Actions.find(:edit, {:controller => self.controller, :abstract_model => abstract_model, :object => _current_user })
-      link_to _current_user.email, url_for(:action => edit_action.action_name, :model_name => abstract_model.to_param, :id => _current_user.id, :controller => 'rails_admin/main')
+      return nil unless edit_action = RailsAdmin::Config::Actions.find(:edit, controller: controller, abstract_model: abstract_model, object: _current_user)
+      link_to _current_user.email, url_for(action: edit_action.action_name, model_name: abstract_model.to_param, id: _current_user.id, controller: 'rails_admin/main')
     end
 
     def logout_path
@@ -41,22 +40,22 @@ module RailsAdmin
     def wording_for(label, action = @action, abstract_model = @abstract_model, object = @object)
       model_config = abstract_model.try(:config)
       object = abstract_model && object.is_a?(abstract_model.model) ? object : nil
-      action = RailsAdmin::Config::Actions.find(action.to_sym) if (action.is_a?(Symbol) || action.is_a?(String))
+      action = RailsAdmin::Config::Actions.find(action.to_sym) if action.is_a?(Symbol) || action.is_a?(String)
 
       I18n.t("admin.actions.#{action.i18n_key}.#{label}",
-        :model_label => model_config && model_config.label,
-        :model_label_plural => model_config && model_config.label_plural,
-        :object_label => model_config && object.try(model_config.object_label_method)
+             model_label: model_config && model_config.label,
+             model_label_plural: model_config && model_config.label_plural,
+             object_label: model_config && object.try(model_config.object_label_method)
       )
     end
 
     def main_navigation
-      nodes_stack = RailsAdmin::Config.visible_models(:controller => self.controller)
-      node_model_names = nodes_stack.map{ |c| c.abstract_model.model_name }
+      nodes_stack = RailsAdmin::Config.visible_models(controller: controller)
+      node_model_names = nodes_stack.collect { |c| c.abstract_model.model_name }
 
-      nodes_stack.group_by(&:navigation_label).map do |navigation_label, nodes|
+      nodes_stack.group_by(&:navigation_label).collect do |navigation_label, nodes|
 
-        nodes = nodes.select{ |n| n.parent.nil? || !n.parent.to_s.in?(node_model_names) }
+        nodes = nodes.select { |n| n.parent.nil? || !n.parent.to_s.in?(node_model_names) }
         li_stack = navigation nodes_stack, nodes
 
         label = navigation_label || t('admin.misc.navigation')
@@ -65,8 +64,8 @@ module RailsAdmin
     end
 
     def static_navigation
-      li_stack = RailsAdmin::Config.navigation_static_links.map do |title, url|
-        content_tag(:li, link_to(title.to_s, url, :target => '_blank'))
+      li_stack = RailsAdmin::Config.navigation_static_links.collect do |title, url|
+        content_tag(:li, link_to(title.to_s, url, target: '_blank'))
       end.join
 
       label = RailsAdmin::Config.navigation_static_label || t('admin.misc.navigation_static_label')
@@ -74,52 +73,52 @@ module RailsAdmin
       li_stack
     end
 
-    def navigation nodes_stack, nodes, level=0
-      nodes.map do |node|
+    def navigation(nodes_stack, nodes, level = 0)
+      nodes.collect do |node|
         model_param = node.abstract_model.to_param
-        url         = url_for(:action => :index, :controller => 'rails_admin/main', :model_name => model_param)
+        url         = url_for(action: :index, controller: 'rails_admin/main', model_name: model_param)
         level_class = " nav-level-#{level}" if level > 0
         nav_icon = node.navigation_icon ? %{<i class="#{node.navigation_icon}"></i>}.html_safe : ''
 
-        li = content_tag :li, "data-model"=>model_param do
-          link_to nav_icon + node.label_plural, url, :class => "pjax#{level_class}"
+        li = content_tag :li, 'data-model' => model_param do
+          link_to nav_icon + node.label_plural, url, class: "pjax#{level_class}"
         end
-        li + navigation(nodes_stack, nodes_stack.select{ |n| n.parent.to_s == node.abstract_model.model_name}, level+1)
+        li + navigation(nodes_stack, nodes_stack.select { |n| n.parent.to_s == node.abstract_model.model_name }, level + 1)
       end.join.html_safe
     end
 
-    def breadcrumb action = @action, acc = []
+    def breadcrumb(action = @action, acc = [])
       begin
         (parent_actions ||= []) << action
-      end while action.breadcrumb_parent && (action = action(*action.breadcrumb_parent))
+      end while action.breadcrumb_parent && (action = action(*action.breadcrumb_parent)) # rubocop:disable Loop
 
-      content_tag(:ul, :class => "breadcrumb") do
-        parent_actions.map do |a|
+      content_tag(:ul, class: 'breadcrumb') do
+        parent_actions.collect do |a|
           am = a.send(:eval, 'bindings[:abstract_model]')
           o = a.send(:eval, 'bindings[:object]')
-          content_tag(:li, :class => current_action?(a, am, o) && "active") do
+          content_tag(:li, class: current_action?(a, am, o) && 'active') do
             crumb = if a.http_methods.include?(:get)
-              link_to url_for(:action => a.action_name, :controller => 'rails_admin/main', :model_name => am.try(:to_param), :id => (o.try(:persisted?) && o.try(:id) || nil)), :class => 'pjax' do
+              link_to url_for(action: a.action_name, controller: 'rails_admin/main', model_name: am.try(:to_param), id: (o.try(:persisted?) && o.try(:id) || nil)), class: 'pjax' do
                 wording_for(:breadcrumb, a, am, o)
               end
             else
               content_tag(:span, wording_for(:breadcrumb, a, am, o))
             end
-            crumb+= content_tag(:span, '/', :class => 'divider') unless current_action?(a, am, o)
+            crumb += content_tag(:span, '/', class: 'divider') unless current_action?(a, am, o)
             crumb
           end
-        end.reverse.join().html_safe
+        end.reverse.join.html_safe
       end
     end
 
     # parent => :root, :collection, :member
     def menu_for(parent, abstract_model = nil, object = nil, only_icon = false) # perf matters here (no action view trickery)
-      actions = actions(parent, abstract_model, object).select{ |a| a.http_methods.include?(:get) }
-      actions.map do |action|
+      actions = actions(parent, abstract_model, object).select { |a| a.http_methods.include?(:get) }
+      actions.collect do |action|
         wording = wording_for(:menu, action)
         %{
           <li title="#{wording if only_icon}" rel="#{'tooltip' if only_icon}" class="icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}">
-            <a class="#{action.pjax? ? 'pjax' : ''}" href="#{url_for({ :action => action.action_name, :controller => 'rails_admin/main', :model_name => abstract_model.try(:to_param), :id => (object.try(:persisted?) && object.try(:id) || nil) })}">
+            <a class="#{action.pjax? ? 'pjax' : ''}" href="#{url_for(action: action.action_name, controller: 'rails_admin/main', model_name: abstract_model.try(:to_param), id: (object.try(:persisted?) && object.try(:id) || nil))}">
               <i class="#{action.link_icon}"></i>
               <span#{only_icon ? " style='display:none'" : ""}>#{wording}</span>
             </a>
@@ -128,21 +127,19 @@ module RailsAdmin
       end.join.html_safe
     end
 
-    def bulk_menu abstract_model = @abstract_model
+    def bulk_menu(abstract_model = @abstract_model)
       actions = actions(:bulkable, abstract_model)
       return '' if actions.empty?
-      content_tag :li, { :class => 'dropdown', :style => 'float:right' } do
-        content_tag(:a, { :class => 'dropdown-toggle', :'data-toggle' => "dropdown", :href => '#' }) { t('admin.misc.bulk_menu_title').html_safe + '<b class="caret"></b>'.html_safe } +
-        content_tag(:ul, :class => 'dropdown-menu', :style => 'left:auto; right:0;') do
-          actions.map do |action|
+      content_tag :li, class: 'dropdown', style: 'float:right' do
+        content_tag(:a, :class => 'dropdown-toggle', :'data-toggle' => 'dropdown', :href => '#') { t('admin.misc.bulk_menu_title').html_safe + '<b class="caret"></b>'.html_safe } +
+        content_tag(:ul, class: 'dropdown-menu', style: 'left:auto; right:0;') do
+          actions.collect do |action|
             content_tag :li do
-              link_to wording_for(:bulk_link, action), '#', :onclick => "jQuery('#bulk_action').val('#{action.action_name}'); jQuery('#bulk_form').submit(); return false;"
+              link_to wording_for(:bulk_link, action), '#', onclick: "jQuery('#bulk_action').val('#{action.action_name}'); jQuery('#bulk_form').submit(); return false;"
             end
           end.join.html_safe
         end
       end.html_safe
     end
-
   end
 end
-

data/app/helpers/rails_admin/form_builder.rb

@@ -4,27 +4,27 @@ module RailsAdmin
 
     def generate(options = {})
       without_field_error_proc_added_div do
-        options.reverse_merge!({
-          :action => @template.controller.params[:action],
-          :model_config => @template.instance_variable_get(:@model_config),
-          :nested_in => false
-        })
+        options.reverse_merge!(
+          action: @template.controller.params[:action],
+          model_config: @template.instance_variable_get(:@model_config),
+          nested_in: false
+        )
 
         object_infos +
-        visible_groups(options[:model_config], generator_action(options[:action], options[:nested_in])).map do |fieldset|
+        visible_groups(options[:model_config], generator_action(options[:action], options[:nested_in])).collect do |fieldset|
           fieldset_for fieldset, options[:nested_in]
         end.join.html_safe +
-        (options[:nested_in] ? '' : @template.render(:partial => 'rails_admin/main/submit_buttons'))
+        (options[:nested_in] ? '' : @template.render(partial: 'rails_admin/main/submit_buttons'))
       end
     end
 
     def fieldset_for(fieldset, nested_in)
-      if (fields = fieldset.with(:form => self, :object => @object, :view => @template, :controller => @template.controller).visible_fields).length > 0
+      if (fields = fieldset.with(form: self, object: @object, view: @template, controller: @template.controller).visible_fields).length > 0
         @template.content_tag :fieldset do
           contents = []
-          contents << @template.content_tag(:legend, %{<i class="icon-chevron-#{(fieldset.active? ? 'down' : 'right')}"></i> #{fieldset.label}}.html_safe, :style => "#{fieldset.name == :default ? 'display:none' : ''}")
+          contents << @template.content_tag(:legend, %{<i class="icon-chevron-#{(fieldset.active? ? 'down' : 'right')}"></i> #{fieldset.label}}.html_safe, style: "#{fieldset.name == :default ? 'display:none' : ''}")
           contents << @template.content_tag(:p, fieldset.help) if fieldset.help.present?
-          contents << fields.map{ |field| field_wrapper_for(field, nested_in) }.join
+          contents << fields.collect { |field| field_wrapper_for(field, nested_in) }.join
           contents.join.html_safe
         end
       end
@@ -35,8 +35,8 @@ module RailsAdmin
         # do not show nested field if the target is the origin
         unless field.inverse_of.presence && field.inverse_of == nested_in &&
           @template.instance_variable_get(:@model_config).abstract_model == field.associated_model_config.abstract_model
-          @template.content_tag(:div, :class => "control-group #{field.type_css_class} #{field.css_class} #{'error' if field.errors.present?}", :id => "#{dom_id(field)}_field") do
-            label(field.method_name, field.label, :class => 'control-label') +
+          @template.content_tag(:div, class: "control-group #{field.type_css_class} #{field.css_class} #{'error' if field.errors.present?}", id: "#{dom_id(field)}_field") do
+            label(field.method_name, field.label, class: 'control-label') +
             (field.nested_form ? field_for(field) : input_for(field))
           end
         end
@@ -46,7 +46,7 @@ module RailsAdmin
     end
 
     def input_for(field)
-      @template.content_tag(:div, :class => 'controls') do
+      @template.content_tag(:div, class: 'controls') do
         field_for(field) +
         errors_for(field) +
         help_for(field)
@@ -54,11 +54,11 @@ module RailsAdmin
     end
 
     def errors_for(field)
-      field.errors.present? ? @template.content_tag(:span, "#{field.label} #{field.errors.to_sentence}", :class => 'help-inline') : ''.html_safe
+      field.errors.present? ? @template.content_tag(:span, "#{field.label} #{field.errors.to_sentence}", class: 'help-inline') : ''.html_safe
     end
 
     def help_for(field)
-      field.help.present? ? @template.content_tag(:p, field.help, :class => 'help-block') : ''.html_safe
+      field.help.present? ? @template.content_tag(:p, field.help, class: 'help-block') : ''.html_safe
     end
 
     def field_for(field)
@@ -73,21 +73,21 @@ module RailsAdmin
       model_config = RailsAdmin.config(object)
       model_label = model_config.label
       object_label = if object.new_record?
-        I18n.t('admin.form.new_model', :name => model_label)
+        I18n.t('admin.form.new_model', name: model_label)
       else
         object.send(model_config.object_label_method).presence || "#{model_config.label} ##{object.id}"
       end
-      %{<span style="display:none" class="object-infos" data-model-label="#{model_label}" data-object-label="#{CGI::escapeHTML(object_label)}"></span>}.html_safe
+      %{<span style="display:none" class="object-infos" data-model-label="#{model_label}" data-object-label="#{CGI.escapeHTML(object_label)}"></span>}.html_safe
     end
 
-    def jquery_namespace field
+    def jquery_namespace(field)
       %{#{'#modal ' if @template.controller.params[:modal]}##{dom_id(field)}_field}
     end
 
     def dom_id(field)
       (@dom_id ||= {})[field.name] ||=
         [
-          @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, ""),
+          @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, '_').sub(/_$/, ''),
           options[:index],
           field.method_name
         ].reject(&:blank?).join('_')
@@ -97,7 +97,8 @@ module RailsAdmin
       (@dom_name ||= {})[field.name] ||= %{#{@object_name}#{options[:index] && "[#{options[:index]}]"}[#{field.method_name}]#{field.is_a?(Config::Fields::Association) && field.multiple? ? '[]' : ''}}
     end
 
-    protected
+  protected
+
     def generator_action(action, nested)
       if nested
         action = :nested
@@ -110,17 +111,17 @@ module RailsAdmin
 
     def visible_groups(model_config, action)
       model_config.send(action).with(
-        :form => self,
-        :object => @object,
-        :view => @template,
-        :controller => @template.controller
+        form: self,
+        object: @object,
+        view: @template,
+        controller: @template.controller
       ).visible_groups
     end
 
     def without_field_error_proc_added_div
       default_field_error_proc = ::ActionView::Base.field_error_proc
       begin
-        ::ActionView::Base.field_error_proc = Proc.new { |html_tag, instance| html_tag }
+        ::ActionView::Base.field_error_proc = proc { |html_tag, instance| html_tag }
         yield
       ensure
         ::ActionView::Base.field_error_proc = default_field_error_proc