rails_admin 0.8.1 → 2.2.1

data/lib/rails_admin/adapters/active_record.rb

@@ -6,7 +6,7 @@ require 'rails_admin/adapters/active_record/property'
 module RailsAdmin
   module Adapters
     module ActiveRecord
-      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial, :hstore, :geometry]
+      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial, :hstore, :geometry].freeze
 
       def new(params = {})
         AbstractObject.new(model.new(params))
@@ -56,20 +56,37 @@ module RailsAdmin
       def properties
         columns = model.columns.reject do |c|
           c.type.blank? ||
-          DISABLED_COLUMN_TYPES.include?(c.type.to_sym) ||
-          c.try(:array)
+            DISABLED_COLUMN_TYPES.include?(c.type.to_sym) ||
+            c.try(:array)
         end
         columns.collect do |property|
           Property.new(property, model)
         end
       end
 
+      def base_class
+        model.base_class
+      end
+
       delegate :primary_key, :table_name, to: :model, prefix: false
 
       def encoding
-        encoding = ::ActiveRecord::Base.connection.try(:encoding)
-        encoding ||= ::ActiveRecord::Base.connection.try(:charset) # mysql2
-        encoding || 'UTF-8'
+        adapter =
+          if ::ActiveRecord::Base.respond_to?(:connection_db_config)
+            ::ActiveRecord::Base.connection_db_config.configuration_hash[:adapter]
+          else
+            ::ActiveRecord::Base.connection_config[:adapter]
+          end
+        case adapter
+        when 'postgresql'
+          ::ActiveRecord::Base.connection.select_one("SELECT ''::text AS str;").values.first.encoding
+        when 'mysql2'
+          ::ActiveRecord::Base.connection.raw_connection.encoding
+        when 'oracle_enhanced'
+          ::ActiveRecord::Base.connection.select_one("SELECT dummy FROM DUAL").values.first.encoding
+        else
+          ::ActiveRecord::Base.connection.select_one("SELECT '' AS str;").values.first.encoding
+        end
       end
 
       def embedded?
@@ -94,12 +111,7 @@ module RailsAdmin
 
         def add(field, value, operator)
           field.searchable_columns.flatten.each do |column_infos|
-            if value.is_a?(Array)
-              value = value.map { |v| field.parse_value(v) }
-            else
-              value = field.parse_value(value)
-            end
-            statement, value1, value2 = StatementBuilder.new(column_infos[:column], column_infos[:type], value, operator).to_statement
+            statement, value1, value2 = StatementBuilder.new(column_infos[:column], column_infos[:type], value, operator, @scope.connection.adapter_name).to_statement
             @statements << statement if statement.present?
             @values << value1 unless value1.nil?
             @values << value2 unless value2.nil?
@@ -110,18 +122,23 @@ module RailsAdmin
 
         def build
           scope = @scope.where(@statements.join(' OR '), *@values)
-          scope = scope.references(*(@tables.uniq)) if @tables.any?
+          scope = scope.references(*@tables.uniq) if @tables.any?
           scope
         end
       end
 
       def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
-        wb = WhereBuilder.new(scope)
-        fields.each do |field|
-          wb.add(field, field.parse_value(query), field.search_operator)
+        if config.list.search_by
+          scope.send(config.list.search_by, query)
+        else
+          wb = WhereBuilder.new(scope)
+          fields.each do |field|
+            value = parse_field_value(field, query)
+            wb.add(field, value, field.search_operator)
+          end
+          # OR all query statements
+          wb.build
         end
-        # OR all query statements
-        wb.build
       end
 
       # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
@@ -133,7 +150,7 @@ module RailsAdmin
             field = fields.detect { |f| f.name.to_s == field_name }
             value = parse_field_value(field, filter_dump[:v])
 
-            wb.add(field, value, (filter_dump[:o] || 'default'))
+            wb.add(field, value, (filter_dump[:o] || RailsAdmin::Config.default_search_operator))
             # AND current filter statements to other filter statements
             scope = wb.build
           end
@@ -142,13 +159,31 @@ module RailsAdmin
       end
 
       def build_statement(column, type, value, operator)
-        StatementBuilder.new(column, type, value, operator).to_statement
+        StatementBuilder.new(column, type, value, operator, model.connection.adapter_name).to_statement
       end
 
       class StatementBuilder < RailsAdmin::AbstractModel::StatementBuilder
+        def initialize(column, type, value, operator, adapter_name)
+          super column, type, value, operator
+          @adapter_name = adapter_name
+        end
+
       protected
 
         def unary_operators
+          case @type
+          when :boolean
+            boolean_unary_operators
+          when :integer, :decimal, :float
+            numeric_unary_operators
+          else
+            generic_unary_operators
+          end
+        end
+
+      private
+
+        def generic_unary_operators
           {
             '_blank' => ["(#{@column} IS NULL OR #{@column} = '')"],
             '_present' => ["(#{@column} IS NOT NULL AND #{@column} != '')"],
@@ -159,7 +194,15 @@ module RailsAdmin
           }
         end
 
-      private
+        def boolean_unary_operators
+          generic_unary_operators.merge(
+            '_blank' => ["(#{@column} IS NULL)"],
+            '_empty' => ["(#{@column} IS NULL)"],
+            '_present' => ["(#{@column} IS NOT NULL)"],
+            '_not_empty' => ["(#{@column} IS NOT NULL)"],
+          )
+        end
+        alias_method :numeric_unary_operators, :boolean_unary_operators
 
         def range_filter(min, max)
           if min && max
@@ -178,6 +221,7 @@ module RailsAdmin
           when :string, :text             then build_statement_for_string_or_text
           when :enum                      then build_statement_for_enum
           when :belongs_to_association    then build_statement_for_belongs_to_association
+          when :uuid                      then build_statement_for_uuid
           end
         end
 
@@ -197,22 +241,27 @@ module RailsAdmin
 
         def build_statement_for_string_or_text
           return if @value.blank?
+
+          return ["(#{@column} = ?)", @value] if ['is', '='].include?(@operator)
+
+          unless ['postgresql', 'postgis'].include? ar_adapter
+            @value = @value.mb_chars.downcase
+          end
+
           @value = begin
             case @operator
             when 'default', 'like'
-              "%#{@value.downcase}%"
+              "%#{@value}%"
             when 'starts_with'
-              "#{@value.downcase}%"
+              "#{@value}%"
             when 'ends_with'
-              "%#{@value.downcase}"
-            when 'is', '='
-              "#{@value.downcase}"
+              "%#{@value}"
             else
               return
             end
           end
 
-          if ar_adapter == 'postgresql'
+          if ['postgresql', 'postgis'].include? ar_adapter
             ["(#{@column} ILIKE ?)", @value]
           else
             ["(LOWER(#{@column}) LIKE ?)", @value]
@@ -224,8 +273,14 @@ module RailsAdmin
           ["(#{@column} IN (?))", Array.wrap(@value)]
         end
 
+        def build_statement_for_uuid
+          if @value.to_s =~ /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/
+            column_for_value(@value)
+          end
+        end
+
         def ar_adapter
-          ::ActiveRecord::Base.connection.adapter_name.downcase
+          @adapter_name.downcase
         end
       end
     end

data/lib/rails_admin/adapters/mongoid/abstract_object.rb

@@ -1,4 +1,5 @@
 require 'rails_admin/adapters/active_record/abstract_object'
+
 module RailsAdmin
   module Adapters
     module Mongoid
@@ -6,6 +7,7 @@ module RailsAdmin
         def initialize(object)
           super
           object.associations.each do |name, association|
+            association = Association.new(association, object.class)
             if [:has_many, :references_many].include? association.macro
               instance_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def #{name.to_s.singularize}_ids
@@ -27,9 +29,7 @@ RUBY
                 def #{name}_id=(item_id)
                   item = (#{association.klass}.find(item_id) rescue nil)
                   return unless item
-                  unless persisted?
-                    item.update_attribute('#{association.foreign_key}', id)
-                  end
+                  item.update_attribute('#{association.foreign_key}', id) unless persisted?
                   super item.id
                 end
 RUBY

data/lib/rails_admin/adapters/mongoid/association.rb

@@ -3,6 +3,7 @@ module RailsAdmin
     module Mongoid
       class Association
         attr_reader :association, :model
+
         def initialize(association, model)
           @association = association
           @model = model
@@ -27,7 +28,7 @@ module RailsAdmin
           when :has_and_belongs_to_many, :references_and_referenced_in_many
             :has_and_belongs_to_many
           else
-            fail("Unknown association type: #{macro.inspect}")
+            raise("Unknown association type: #{macro.inspect}")
           end
         end
 
@@ -40,11 +41,11 @@ module RailsAdmin
         end
 
         def primary_key
-          :_id
+          association.primary_key.to_sym rescue :_id
         end
 
         def foreign_key
-          return unless [:embeds_one, :embeds_many].exclude?(macro.to_sym)
+          return if embeds?
           association.foreign_key.to_sym rescue nil
         end
 
@@ -81,8 +82,8 @@ module RailsAdmin
 
         def nested_options
           nested = nested_attributes_options.try { |o| o[name] }
-          if !nested && [:embeds_one, :embeds_many].include?(macro.to_sym) && !association.cyclic
-            fail <<-MSG.gsub(/^\s+/, '')
+          if !nested && [:embeds_one, :embeds_many].include?(macro.to_sym) && !cyclic?
+            raise <<-MSG.gsub(/^\s+/, '')
             Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,
             because embedded model doesn't have top-level access.
             Please add `accepts_nested_attributes_for :#{association.name}' line to `#{model}' model.
@@ -95,13 +96,24 @@ module RailsAdmin
           true
         end
 
+        def macro
+          association.try(:macro) || association.class.name.split('::').last.underscore.to_sym
+        end
+
+        def embeds?
+          [:embeds_one, :embeds_many].include?(macro)
+        end
+
       private
 
         def inverse_of_field
           association.respond_to?(:inverse_of_field) && association.inverse_of_field
         end
 
-        delegate :macro, :options, to: :association, prefix: false
+        def cyclic?
+          association.respond_to?(:cyclic?) ? association.cyclic? : association.cyclic
+        end
+
         delegate :nested_attributes_options, to: :model, prefix: false
         delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
       end

data/lib/rails_admin/adapters/mongoid/bson.rb

@@ -0,0 +1,29 @@
+require 'mongoid'
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      class Bson
+        OBJECT_ID = begin
+          if defined?(Moped::BSON)
+            Moped::BSON::ObjectId
+          elsif defined?(BSON::ObjectId)
+            BSON::ObjectId
+          end
+        end
+
+        class << self
+          def parse_object_id(value)
+            OBJECT_ID.from_string(value)
+          rescue => e
+            raise e if %w(
+              Moped::Errors::InvalidObjectId
+              BSON::ObjectId::Invalid
+              BSON::InvalidObjectId
+            ).exclude?(e.class.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/mongoid/extension.rb

@@ -11,12 +11,14 @@ module RailsAdmin
             def rails_admin(&block)
               RailsAdmin.config(self, &block)
             end
-            alias_method_chain :accepts_nested_attributes_for, :rails_admin
+
+            alias_method :accepts_nested_attributes_for_without_rails_admin, :accepts_nested_attributes_for
+            alias_method :accepts_nested_attributes_for, :accepts_nested_attributes_for_with_rails_admin
           end
         end
 
         def rails_admin_default_object_label_method
-          self.new_record? ? "new #{self.class}" : "#{self.class} ##{id}"
+          new_record? ? "new #{self.class}" : "#{self.class} ##{id}"
         end
 
         def safe_send(value)

data/lib/rails_admin/adapters/mongoid/property.rb

@@ -2,7 +2,7 @@ module RailsAdmin
   module Adapters
     module Mongoid
       class Property
-        STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject]
+        STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject].freeze
         attr_reader :property, :model
 
         def initialize(property, model)
@@ -70,8 +70,8 @@ module RailsAdmin
       private
 
         def object_field_type
-          if [:belongs_to, :referenced_in, :embedded_in].
-             include?(model.relations.values.detect { |r| r.foreign_key.try(:to_sym) == name }.try(:macro).try(:to_sym))
+          association = Association.new model.relations.values.detect { |r| r.try(:foreign_key).try(:to_sym) == name }, model
+          if [:belongs_to, :referenced_in, :embedded_in].include?(association.macro)
             :bson_object_id
           else
             :string

data/lib/rails_admin/adapters/mongoid.rb

@@ -3,11 +3,16 @@ require 'rails_admin/config/sections/list'
 require 'rails_admin/adapters/mongoid/abstract_object'
 require 'rails_admin/adapters/mongoid/association'
 require 'rails_admin/adapters/mongoid/property'
+require 'rails_admin/adapters/mongoid/bson'
 
 module RailsAdmin
   module Adapters
     module Mongoid
-      DISABLED_COLUMN_TYPES = ['Range', 'Moped::BSON::Binary', 'BSON::Binary', 'Mongoid::Geospatial::Point']
+      DISABLED_COLUMN_TYPES = %w(Range Moped::BSON::Binary BSON::Binary Mongoid::Geospatial::Point).freeze
+
+      def parse_object_id(value)
+        Bson.parse_object_id(value)
+      end
 
       def new(params = {})
         AbstractObject.new(model.new(params))
@@ -17,10 +22,10 @@ module RailsAdmin
         AbstractObject.new(model.find(id))
       rescue => e
         raise e if %w(
-          BSON::InvalidObjectId
           Mongoid::Errors::DocumentNotFound
           Mongoid::Errors::InvalidFind
           Moped::Errors::InvalidObjectId
+          BSON::InvalidObjectId
         ).exclude?(e.class.to_s)
       end
 
@@ -37,13 +42,21 @@ module RailsAdmin
         scope = scope.includes(*options[:include]) if options[:include]
         scope = scope.limit(options[:limit]) if options[:limit]
         scope = scope.any_in(_id: options[:bulk_ids]) if options[:bulk_ids]
-        scope = scope.where(query_conditions(options[:query])) if options[:query]
-        scope = scope.where(filter_conditions(options[:filters])) if options[:filters]
+        scope = query_scope(scope, options[:query]) if options[:query]
+        scope = filter_scope(scope, options[:filters]) if options[:filters]
         if options[:page] && options[:per]
           scope = scope.send(Kaminari.config.page_method_name, options[:page]).per(options[:per])
         end
         scope = sort_by(options, scope) if options[:sort]
         scope
+      rescue NoMethodError => e
+        if e.message =~ /page/
+          e = e.exception <<-EOM.gsub(/^\s{12}/, '')
+            #{e.message}
+            If you don't have kaminari-mongoid installed, add `gem 'kaminari-mongoid'` to your Gemfile.
+          EOM
+        end
+        raise e
       end
 
       def count(options = {}, scope = nil)
@@ -69,16 +82,22 @@ module RailsAdmin
         fields.collect { |_name, field| Property.new(field, model) }
       end
 
+      def base_class
+        klass = model
+        klass = klass.superclass while klass.hereditary?
+        klass
+      end
+
       def table_name
         model.collection_name.to_s
       end
 
       def encoding
-        'UTF-8'
+        Encoding::UTF_8
       end
 
       def embedded?
-        model.relations.values.detect { |a| a.macro.to_sym == :embedded_in }
+        associations.detect { |a| a.macro == :embedded_in }
       end
 
       def cyclic?
@@ -99,7 +118,6 @@ module RailsAdmin
         conditions_per_collection = {}
         field.searchable_columns.each do |column_infos|
           collection_name, column_name = parse_collection_name(column_infos[:column])
-          value = parse_field_value(field, value)
           statement = build_statement(column_name, column_infos[:type], value, operator)
           next unless statement
           conditions_per_collection[collection_name] ||= []
@@ -108,25 +126,25 @@ module RailsAdmin
         conditions_per_collection
       end
 
-      def query_conditions(query, fields = config.list.fields.select(&:queryable?))
-        statements = []
+      def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
+        if config.list.search_by
+          scope.send(config.list.search_by, query)
+        else
+          statements = []
 
-        fields.each do |field|
-          value = parse_field_value(field, query)
-          conditions_per_collection = make_field_conditions(field, value, field.search_operator)
-          statements.concat make_condition_for_current_collection(field, conditions_per_collection)
-        end
+          fields.each do |field|
+            value = parse_field_value(field, query)
+            conditions_per_collection = make_field_conditions(field, value, field.search_operator)
+            statements.concat make_condition_for_current_collection(field, conditions_per_collection)
+          end
 
-        if statements.any?
-          {'$or' => statements}
-        else
-          {}
+          scope.where(statements.any? ? {'$or' => statements} : {})
         end
       end
 
       # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
       # "0055" is the filter index, no use here. o is the operator, v the value
-      def filter_conditions(filters, fields = config.list.fields.select(&:filterable?))
+      def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
         statements = []
 
         filters.each_pair do |field_name, filters_dump|
@@ -144,16 +162,12 @@ module RailsAdmin
           end
         end
 
-        if statements.any?
-          {'$and' => statements}
-        else
-          {}
-        end
+        scope.where(statements.any? ? {'$and' => statements} : {})
       end
 
       def parse_collection_name(column)
         collection_name, column_name = column.split('.')
-        if [:embeds_one, :embeds_many].include?(model.relations[collection_name].try(:macro).try(:to_sym))
+        if associations.detect { |a| a.name == collection_name.to_sym }.try(:embeds?)
           [table_name, column]
         else
           [collection_name, column_name]
@@ -193,7 +207,7 @@ module RailsAdmin
         when String
           field_name, collection_name = options[:sort].split('.').reverse
           if collection_name && collection_name != table_name
-            fail('sorting by associated model column is not supported in Non-Relational databases')
+            raise('sorting by associated model column is not supported in Non-Relational databases')
           end
         when Symbol
           field_name = options[:sort].to_s

data/lib/rails_admin/bootstrap-sass/compass_functions.rb

@@ -8,7 +8,7 @@ module Sass
           image_url(source, Sass::Script::Bool.new(true))
         else
           # Revert to the old compass-agnostic path determination
-          asset_sans_quotes = source.value.gsub('"', '')
+          asset_sans_quotes = source.value.delete('"')
           Sass::Script::String.new("/images/#{asset_sans_quotes}", :string)
         end
       end

data/lib/rails_admin/bootstrap-sass/sass_functions.rb

@@ -1,5 +1,3 @@
-require 'sass'
-
 module Sass
   module Script
     module Functions
@@ -12,7 +10,7 @@ module Sass
         alphastr = alpha.to_s(16).rjust(2, '0')
         Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
       end
-      declare :ie_hex_str, [:color]
+      declare :ie_hex_str, [:color] if respond_to?(:declare)
     end
   end
 end

data/lib/rails_admin/bootstrap-sass.rb

@@ -11,18 +11,20 @@ module RailsAdmin
         require 'rails_admin/bootstrap-sass/sass_functions'
       end
 
-      require 'sass-rails' if rails?
+      require 'sassc-rails' if rails?
 
       unless rails? || compass?
-        fail(Bootstrap::FrameworkNotFound.new('bootstrap-sass requires either Rails > 3.1 or Compass, neither of which are loaded'))
+        raise(Bootstrap::FrameworkNotFound.new('bootstrap-sass requires either Rails > 3.1 or Compass, neither of which are loaded'))
       end
 
-      stylesheets = File.expand_path(File.join('..', 'vendor', 'assets', 'stylesheets'))
-      ::Sass.load_paths << stylesheets
+      if defined?(::Sass) && ::Sass.respond_to?(:load_paths)
+        stylesheets = File.expand_path(File.join('..', 'vendor', 'assets', 'stylesheets'))
+        fonts = File.expand_path(File.join('..', 'vendor', 'assets', 'fonts'))
+        ::Sass.load_paths << stylesheets
+        ::Sass.load_paths << fonts
+      end
     end
 
-  private
-
     def self.asset_pipeline?
       defined?(::Sprockets)
     end

data/lib/rails_admin/config/actions/base.rb

@@ -18,6 +18,22 @@ module RailsAdmin
           []
         end
 
+        register_instance_option :show_in_navigation do
+          root?
+        end
+
+        register_instance_option :show_in_sidebar do
+          !show_in_navigation
+        end
+
+        register_instance_option :show_in_menu do
+          true
+        end
+
+        register_instance_option :sidebar_label do
+          nil
+        end
+
         # http://getbootstrap.com/2.3.2/base-css.html#icons
         register_instance_option :link_icon do
           'icon-question-sign'
@@ -83,7 +99,7 @@ module RailsAdmin
           key.to_sym
         end
 
-        # For Cancan and the like
+        # For CanCanCan and the like
         register_instance_option :authorization_key do
           key.to_sym
         end
@@ -115,12 +131,11 @@ module RailsAdmin
 
         # Breadcrumb parent
         register_instance_option :breadcrumb_parent do
-          case
-          when root?
+          if root?
             [:dashboard]
-          when collection?
+          elsif collection?
             [:index, bindings[:abstract_model]]
-          when member?
+          elsif member?
             [:show, bindings[:abstract_model], bindings[:object]]
           end
         end

data/lib/rails_admin/config/actions/bulk_delete.rb

@@ -42,14 +42,12 @@ module RailsAdmin
               end
 
               if destroyed.nil?
-                msg = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
-                render text: msg, status: :not_found
+                flash[:error] = t('admin.flash.error', name: pluralize(0, @model_config.label), action: t('admin.actions.delete.done'))
               else
                 flash[:success] = t('admin.flash.successful', name: pluralize(destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless destroyed.empty?
                 flash[:error] = t('admin.flash.error', name: pluralize(not_destroyed.count, @model_config.label), action: t('admin.actions.delete.done')) unless not_destroyed.empty?
-                redirect_to back_or_index
               end
-
+              redirect_to back_or_index
             end
           end
         end

data/lib/rails_admin/config/actions/dashboard.rb

@@ -12,13 +12,17 @@ module RailsAdmin
           nil
         end
 
+        register_instance_option :auditing_versions_limit do
+          100
+        end
+
         register_instance_option :controller do
           proc do
-            @history = @auditing_adapter && @auditing_adapter.latest || []
+            @history = @auditing_adapter && @auditing_adapter.latest(@action.auditing_versions_limit) || []
             if @action.statistics?
               @abstract_models = RailsAdmin::Config.visible_models(controller: self).collect(&:abstract_model)
 
-              @most_recent_changes = {}
+              @most_recent_created = {}
               @count = {}
               @max = 0
               @abstract_models.each do |t|
@@ -26,11 +30,11 @@ module RailsAdmin
                 current_count = t.count({}, scope)
                 @max = current_count > @max ? current_count : @max
                 @count[t.model.name] = current_count
-                next unless t.properties.detect { |c| c.name == :updated_at }
-                @most_recent_changes[t.model.name] = t.first(sort: "#{t.table_name}.updated_at").try(:updated_at)
+                next unless t.properties.detect { |c| c.name == :created_at }
+                @most_recent_created[t.model.name] = t.model.last.try(:created_at)
               end
             end
-            render @action.template_name, status: (flash[:error].present? ? :not_found : 200)
+            render @action.template_name, status: @status_code || :ok
           end
         end