rails_admin 0.6.1 → 0.6.2

data/app/views/rails_admin/main/index.html.haml

@@ -8,10 +8,10 @@
   sort = params[:sort]
   params.delete(:sort) if params[:sort] == @model_config.list.sort_by.to_s
 
-  export_action = RailsAdmin::Config::Actions.find(:export, { :controller => self.controller, :abstract_model => @abstract_model })
+  export_action = RailsAdmin::Config::Actions.find(:export, { controller: self.controller, abstract_model: @abstract_model })
   export_action = nil unless export_action && authorized?(export_action.authorization_key, @abstract_model)
 
-  properties = @model_config.list.with(:controller => self.controller, :view => self, :object => @abstract_model.model.new).visible_fields
+  properties = @model_config.list.with(controller: self.controller, view: self, object: @abstract_model.model.new).visible_fields
   # columns paginate
   @filterable_fields = @model_config.list.fields.select(&:filterable?)
   sets = get_column_sets(properties)
@@ -39,7 +39,7 @@
     field = @filterable_fields.find{ |field| field.name == filter_name.to_sym }
     field_options = case field.type
     when :enum
-      options_for_select(field.with(:object => @abstract_model.model.new).enum, filter_hash['v'])
+      options_for_select(field.with(object: @abstract_model.model.new).enum, filter_hash['v'])
     else
       ''
     end
@@ -52,26 +52,26 @@
 = content_for :contextual_tabs do
   = bulk_menu
   - if @filterable_fields.present?
-    %li.dropdown{:style => 'float:right'}
-      %a.dropdown-toggle{:href => '#', :'data-toggle' => "dropdown"}
+    %li.dropdown{style: 'float:right'}
+      %a.dropdown-toggle{href: '#', :'data-toggle' => "dropdown"}
         = t('admin.misc.add_filter')
         %b.caret
-      %ul.dropdown-menu#filters{:style => 'left:auto; right:0;'}
+      %ul.dropdown-menu#filters{style: 'left:auto; right:0;'}
         - @filterable_fields.each do |field|
           - field_options = case field.type
           - when :enum
-            - options_for_select(field.with(:object => @abstract_model.model.new).enum)
+            - options_for_select(field.with(object: @abstract_model.model.new).enum)
           - else
             - ''
           %li
-            %a{:href => '#', :"data-field-label" => field.label, :"data-field-name" => field.name, :"data-field-options" => field_options.html_safe, :"data-field-type" => field.type, :"data-field-value" => ""}= field.label
+            %a{href: '#', :"data-field-label" => field.label, :"data-field-name" => field.name, :"data-field-options" => field_options.html_safe, :"data-field-type" => field.type, :"data-field-value" => ""}= field.label
 
 #list
   %script
     jQuery(function($) {
     $.filters.options.regional = {
     datePicker: {
-    dateFormat: #{raw I18n.t("admin.misc.filter_date_format", :default => I18n.t("admin.misc.filter_date_format", :locale => :en)).to_json},
+    dateFormat: #{raw I18n.t("admin.misc.filter_date_format", default: I18n.t("admin.misc.filter_date_format", locale: :en)).to_json},
     dayNames: #{raw RailsAdmin::Config::Fields::Types::Datetime.day_names.to_json},
     dayNamesShort: #{raw RailsAdmin::Config::Fields::Types::Datetime.abbr_day_names.to_json},
     dayNamesMin: #{raw RailsAdmin::Config::Fields::Types::Datetime.abbr_day_names.to_json},
@@ -88,60 +88,60 @@
     - properties.select{ |p| p.column_width.present? }.each do |property|
       = "#list th.#{property.css_class} { width: #{property.column_width}px; min-width: #{property.column_width}px; }"
       = "#list td.#{property.css_class} { max-width: #{property.column_width}px; }"
-  = form_tag(index_path(params.except(*%w[page f query])), :method => :get, :class => "pjax-form form-inline") do
+  = form_tag(index_path(params.except(*%w[page f query])), method: :get, class: "pjax-form form-inline") do
     .well
       %span#filters_box
-      %hr.filters_box{:style => "display:#{@ordered_filters.empty? ? 'none' : 'block'}"}
-      %input.input-small{:name => "query", :type => "search", :value => query, :placeholder => t("admin.misc.filter")}
-      %button.btn.btn-primary{:type => "submit", :'data-disable-with' => "<i class='icon-white icon-refresh'></i> ".html_safe + t("admin.misc.refresh")}
+      %hr.filters_box{style: "display:#{@ordered_filters.empty? ? 'none' : 'block'}"}
+      %input.input-small{name: "query", type: "search", value: query, placeholder: t("admin.misc.filter")}
+      %button.btn.btn-primary{type: "submit", :'data-disable-with' => "<i class='icon-white icon-refresh'></i> ".html_safe + t("admin.misc.refresh")}
         %i.icon-white.icon-refresh
         = t("admin.misc.refresh")
       - if export_action
-        %span{:style => 'float:right'}= link_to wording_for(:link, export_action), export_path(params.except('set').except('page')), :class => 'btn btn-info'
+        %span{style: 'float:right'}= link_to wording_for(:link, export_action), export_path(params.except('set').except('page')), class: 'btn btn-info'
 
   - unless @model_config.list.scopes.empty?
     %ul.nav.nav-tabs#scope_selector
       - @model_config.list.scopes.each_with_index do |scope, index|
         - scope = '_all' if scope.nil?
         %li{class: "#{'active' if scope.to_s == params[:scope] || (params[:scope].blank? && index == 0)}"}
-          %a{href: index_path(params.merge(:scope => scope, :page => nil))}= I18n.t("admin.scopes.#{@abstract_model.to_param}.#{scope}", :default => I18n.t("admin.scopes.#{scope}", :default => scope.to_s.titleize))
+          %a{href: index_path(params.merge(scope: scope, page: nil))}= I18n.t("admin.scopes.#{@abstract_model.to_param}.#{scope}", default: I18n.t("admin.scopes.#{scope}", default: scope.to_s.titleize))
 
-  = form_tag bulk_action_path(:model_name => @abstract_model.to_param), :method => :post, :id => "bulk_form", :class => "form" do
+  = form_tag bulk_action_path(model_name: @abstract_model.to_param), method: :post, id: "bulk_form", class: "form" do
     = hidden_field_tag :bulk_action
     %table.table.table-condensed.table-striped
       %thead
         %tr
           %th.shrink
-            %input.toggle{:type => "checkbox"}
+            %input.toggle{type: "checkbox"}
           - if other_left
             %th.other.left.shrink= "..."
           - properties.each do |property|
             - selected = (sort == property.name.to_s)
             - if property.sortable
-              - sort_location = index_path params.except('sort_reverse').except('page').merge(:sort => property.name).merge(selected && sort_reverse != "true" ? {:sort_reverse => "true"} : {})
+              - sort_location = index_path params.except('sort_reverse').except('page').merge(sort: property.name).merge(selected && sort_reverse != "true" ? {sort_reverse: "true"} : {})
               - sort_direction = (sort_reverse == 'true' ? "headerSortUp" : "headerSortDown" if selected)
-            %th{:class => "#{property.sortable && "header pjax" || nil} #{sort_direction if property.sortable && sort_direction} #{property.css_class} #{property.type_css_class}", :'data-href' => (property.sortable && sort_location), :rel => "tooltip", :title => "#{property.hint}"}= property.label
+            %th{class: "#{property.sortable && "header pjax" || nil} #{sort_direction if property.sortable && sort_direction} #{property.css_class} #{property.type_css_class}", :'data-href' => (property.sortable && sort_location), rel: "tooltip", title: "#{property.hint}"}= property.label
           - if other_right
             %th.other.right.shrink= "..."
           %th.last.shrink
       %tbody
         - @objects.each do |object|
-          %tr{:class => "#{@abstract_model.param_key}_row"}
+          %tr{class: "#{@abstract_model.param_key}_row"}
             %td
               = check_box_tag "bulk_ids[]", object.id, false
-            - if @other_left_link ||= other_left && index_path(params.except('set').merge(params[:set].to_i != 1 ? {:set => (params[:set].to_i - 1)} : {}))
-              %td.other.left= link_to "...", @other_left_link, :class => 'pjax'
+            - if @other_left_link ||= other_left && index_path(params.except('set').merge(params[:set].to_i != 1 ? {set: (params[:set].to_i - 1)} : {}))
+              %td.other.left= link_to "...", @other_left_link, class: 'pjax'
             - properties.map{ |property| property.bind(:object, object) }.each do |property|
               - value = property.pretty_value
-              %td{:class => "#{property.css_class} #{property.type_css_class}", :title => strip_tags(value.to_s)}= value
-            - if @other_right_link ||= other_right && index_path(params.merge(:set => (params[:set].to_i + 1)))
-              %td.other.right= link_to "...", @other_right_link, :class => 'pjax'
+              %td{class: "#{property.css_class} #{property.type_css_class}", title: strip_tags(value.to_s)}= value
+            - if @other_right_link ||= other_right && index_path(params.merge(set: (params[:set].to_i + 1)))
+              %td.other.right= link_to "...", @other_right_link, class: 'pjax'
             %td.last.links
               %ul.inline= menu_for :member, @abstract_model, object, true
     - if @objects.respond_to?(:total_count)
       - total_count = @objects.total_count.to_i
-      = paginate(@objects, :theme => 'twitter-bootstrap', :remote => true)
-      = link_to(t("admin.misc.show_all"), index_path(params.merge(:all => true)), :class => "show-all btn clearfix pjax") unless total_count > 100 || total_count <= @objects.to_a.size
+      = paginate(@objects, theme: 'twitter-bootstrap', remote: true)
+      = link_to(t("admin.misc.show_all"), index_path(params.merge(all: true)), class: "show-all btn clearfix pjax") unless total_count > 100 || total_count <= @objects.to_a.size
       .clearfix.total-count= "#{total_count} #{@model_config.pluralize(total_count).downcase}"
     - else
       .clearfix.total-count= "#{@objects.size} #{@model_config.pluralize(@objects.size).downcase}"

data/app/views/rails_admin/main/new.html.haml

@@ -1,2 +1,2 @@
-= rails_admin_form_for @object, :url => new_path(:model_name => @abstract_model.to_param), :as => @abstract_model.param_key, :html => { :multipart => true, :class => "form-horizontal denser", :data => { :title => @page_name } } do |form|
-  = form.generate :action => :create
+= rails_admin_form_for @object, url: new_path(model_name: @abstract_model.to_param), as: @abstract_model.param_key, html: { multipart: true, class: "form-horizontal denser", data: { title: @page_name } } do |form|
+  = form.generate action: :create

data/app/views/rails_admin/main/show.html.haml

@@ -1,5 +1,5 @@
-- @model_config.show.with(:object => @object, :view => self, :controller => self.controller).visible_groups.each do |fieldset|
-  - unless (fields = fieldset.with(:object => @object, :view => self, :controller => self.controller).visible_fields).empty?
+- @model_config.show.with(object: @object, view: self, controller: self.controller).visible_groups.each do |fieldset|
+  - unless (fields = fieldset.with(object: @object, view: self, controller: self.controller).visible_fields).empty?
     - if !(values = fields.map{ |f| f.value.presence }).compact.empty? || !RailsAdmin::config.compact_show_view
       .fieldset
         %h4
@@ -10,7 +10,7 @@
           - fields.each_with_index do |field, index|
             - unless values[index].nil? && RailsAdmin::config.compact_show_view
               %dt
-                %span.label.label-info{:class => "#{field.type_css_class} #{field.css_class}"}
+                %span.label.label-info{class: "#{field.type_css_class} #{field.css_class}"}
                   = field.label
               %dd.well
                 = field.pretty_value

data/config/initializers/active_record_extensions.rb

@@ -1,18 +1,20 @@
 if defined?(::ActiveRecord)
-  class ActiveRecord::Base
-    def self.rails_admin(&block)
-      RailsAdmin.config(self, &block)
-    end
+  module ActiveRecord
+    class Base
+      def self.rails_admin(&block)
+        RailsAdmin.config(self, &block)
+      end
 
-    def rails_admin_default_object_label_method
-      self.new_record? ? "new #{self.class.to_s}" : "#{self.class.to_s} ##{id}"
-    end
+      def rails_admin_default_object_label_method
+        self.new_record? ? "new #{self.class}" : "#{self.class} ##{id}"
+      end
 
-    def safe_send(value)
-      if self.has_attribute?(value)
-        read_attribute(value)
-      else
-        send(value)
+      def safe_send(value)
+        if self.has_attribute?(value)
+          read_attribute(value)
+        else
+          send(value)
+        end
       end
     end
   end

data/config/routes.rb

@@ -3,7 +3,7 @@ RailsAdmin::Engine.routes.draw do
     RailsAdmin::Config::Actions.all(:root).each { |action| match "/#{action.route_fragment}", to: action.action_name, as: action.action_name, via: action.http_methods }
     scope ':model_name' do
       RailsAdmin::Config::Actions.all(:collection).each { |action| match "/#{action.route_fragment}", to: action.action_name, as: action.action_name, via: action.http_methods }
-      post  '/bulk_action', to: :bulk_action, as: 'bulk_action'
+      post '/bulk_action', to: :bulk_action, as: 'bulk_action'
       scope ':id' do
         RailsAdmin::Config::Actions.all(:member).each { |action| match "/#{action.route_fragment}", to: action.action_name, as: action.action_name, via: action.http_methods }
       end

data/lib/generators/rails_admin/install_generator.rb

@@ -11,7 +11,7 @@ module RailsAdmin
 
     def install
       namespace = ask_for('Where do you want to mount rails_admin?', 'admin', _namespace)
-      route("mount RailsAdmin::Engine => '/#{namespace}', :as => 'rails_admin'")
+      route("mount RailsAdmin::Engine => '/#{namespace}', as: 'rails_admin'")
       template 'initializer.erb', 'config/initializers/rails_admin.rb'
     end
   end

data/lib/rails_admin/abstract_model.rb

@@ -27,8 +27,8 @@ module RailsAdmin
       def polymorphic_parents(adapter, model_name, name)
         @@polymorphic_parents[adapter.to_sym] ||= {}.tap do |hash|
           all(adapter).each do |am|
-            am.associations.select { |r| r[:as] }.each do |association|
-              (hash[[association[:model_proc].call.to_s.underscore, association[:as]].join('_').to_sym] ||= []) << am.model
+            am.associations.select { |r| r.as }.each do |association|
+              (hash[[association.klass.to_s.underscore, association.as].join('_').to_sym] ||= []) << am.model
             end
           end
         end
@@ -82,13 +82,13 @@ module RailsAdmin
 
     def each_associated_children(object)
       associations.each do |association|
-        case association[:type]
+        case association.type
         when :has_one
-          if child = object.send(association[:name])
+          if child = object.send(association.name)
             yield(association, child)
           end
         when :has_many
-          object.send(association[:name]).each do |child| # rubocop:disable ShadowingOuterLocalVariable
+          object.send(association.name).each do |child| # rubocop:disable ShadowingOuterLocalVariable
             yield(association, child)
           end
         end

data/lib/rails_admin/adapters/active_record.rb

@@ -49,7 +49,7 @@ module RailsAdmin
 
       def associations
         model.reflect_on_all_associations.collect do |association|
-          Association.new(association, model).to_options_hash
+          Association.new(association, model)
         end
       end
 
@@ -60,20 +60,16 @@ module RailsAdmin
             DISABLED_COLUMN_MATCHERS.any? { |matcher| matcher.match(c.type.to_s) }
         end
         columns.collect do |property|
-          {
-            :name => property.name.to_sym,
-            :pretty_name => property.name.to_s.tr('_', ' ').capitalize,
-            :length => property.limit,
-            :nullable? => property.null,
-            :serial? => property.primary,
-          }.merge(type_lookup(property))
+          Property.new(property, model)
         end
       end
 
       delegate :primary_key, :table_name, to: :model, prefix: false
 
       def encoding
-        Rails.configuration.database_configuration[Rails.env]['encoding']
+        encoding = ::ActiveRecord::Base.connection.try(:encoding)
+        encoding ||= ::ActiveRecord::Base.connection.try(:charset) # mysql2
+        encoding || 'UTF-8'
       end
 
       def embedded?
@@ -88,8 +84,6 @@ module RailsAdmin
         true
       end
 
-    private
-
       class WhereBuilder
         def initialize(scope)
           @statements = []
@@ -110,7 +104,9 @@ module RailsAdmin
         end
 
         def build
-          @scope.where(@statements.join(' OR '), *@values).references(*(@tables.uniq))
+          scope = @scope.where(@statements.join(' OR '), *@values)
+          scope = scope.references(*(@tables.uniq)) if @tables.any?
+          scope
         end
       end
 
@@ -141,11 +137,48 @@ module RailsAdmin
         StatementBuilder.new(column, type, value, operator).to_statement
       end
 
-      def type_lookup(property)
-        if model.serialized_attributes[property.name.to_s]
-          {type: :serialized}
-        else
-          {type: property.type}
+      class Property
+        attr_reader :property, :model
+
+        def initialize(property, model)
+          @property = property
+          @model = model
+        end
+
+        def name
+          property.name.to_sym
+        end
+
+        def pretty_name
+          property.name.to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          if model.serialized_attributes[property.name.to_s]
+            :serialized
+          else
+            property.type
+          end
+        end
+
+        def length
+          property.limit
+        end
+
+        def nullable?
+          property.null
+        end
+
+        def serial?
+          property.primary
+        end
+
+        def association?
+          false
+        end
+
+        def read_only?
+          false
         end
       end
 
@@ -157,68 +190,67 @@ module RailsAdmin
           @model = model
         end
 
-        def to_options_hash
-          {
-            name: name.to_sym,
-            pretty_name: display_name,
-            type: macro,
-            model_proc: proc { model_lookup },
-            primary_key_proc: proc { primary_key_lookup },
-            foreign_key: foreign_key.to_sym,
-            foreign_type: foreign_type_lookup,
-            as: as_lookup,
-            polymorphic: polymorphic_lookup,
-            inverse_of: inverse_of_lookup,
-            read_only: read_only_lookup,
-            nested_form: nested_attributes_options_lookup
-          }
+        def name
+          association.name.to_sym
         end
 
-      private
+        def pretty_name
+          name.to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          association.macro
+        end
 
-        def model_lookup
+        def klass
           if options[:polymorphic]
-            polymorphic_parents(:active_record, model_name.to_s, name) || []
+            polymorphic_parents(:active_record, model.name.to_s, name) || []
           else
-            klass
+            association.klass
           end
         end
 
-        def foreign_type_lookup
+        def primary_key
+          (options[:primary_key] || association.klass.primary_key).try(:to_sym) unless polymorphic?
+        end
+
+        def foreign_key
+          association.foreign_key.to_sym
+        end
+
+        def foreign_type
           options[:foreign_type].try(:to_sym) || :"#{name}_type" if options[:polymorphic]
         end
 
-        def nested_attributes_options_lookup
-          model.nested_attributes_options.try { |o| o[name.to_sym] }
+        def foreign_inverse_of
+          nil
         end
 
-        def as_lookup
+        def as
           options[:as].try :to_sym
         end
 
-        def polymorphic_lookup
-          !!options[:polymorphic]
+        def polymorphic?
+          options[:polymorphic] || false
         end
 
-        def primary_key_lookup
-          options[:primary_key] || klass.primary_key
+        def inverse_of
+          options[:inverse_of].try :to_sym
         end
 
-        def inverse_of_lookup
-          options[:inverse_of].try :to_sym
+        def read_only?
+          (klass.all.instance_eval(&scope).readonly_value if scope.is_a? Proc) || false
         end
 
-        def read_only_lookup
-          klass.all.instance_eval(&scope).readonly_value if scope.is_a? Proc
+        def nested_options
+          model.nested_attributes_options.try { |o| o[name.to_sym] }
         end
 
-        def display_name
-          name.to_s.tr('_', ' ').capitalize
+        def association?
+          true
         end
 
-        delegate :klass, :macro, :name, :options, :scope, :foreign_key,
-                 to: :association, prefix: false
-        delegate :name, to: :model, prefix: true
+        delegate :options, :scope, to: :association, prefix: false
         delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
       end
 
@@ -295,7 +327,7 @@ module RailsAdmin
         end
 
         def ar_adapter
-          Rails.configuration.database_configuration[Rails.env]['adapter']
+          ::ActiveRecord::Base.connection.adapter_name.downcase
         end
 
         def like_operator