obitum-rails_admin 0.0.3 → 0.0.4

data/Gemfile

@@ -29,6 +29,8 @@ group :development, :test do
     end
   end
 
+  gem 'bson_ext'
+  gem 'mongoid'
   gem 'cancan'
 end
 
@@ -40,6 +42,7 @@ group :debug do
 
   platform :mri_19 do
     gem 'ruby-debug19'
+    gem 'simplecov', :require => false
   end
 end
 

data/README.md

@@ -18,61 +18,6 @@ Hoeven][plukevdh], and [Rein Henrichs][reinh].
 [plukevdh]: https://github.com/plukevdh
 [reinh]: https://github.com/reinh
 
-## <a name="announcements"></a>Announcements
-
-* Actions
-
-Custom actions are finally there. Default should stay put. To customize them, please have a look at:
-
-
-[Wiki: actions](https://github.com/sferik/rails_admin/wiki/Actions)<br>
-[Documented source code: Base Action class](https://github.com/sferik/rails_admin/blob/master/lib/rails_admin/config/actions/base.rb)
-
-
-* Translations
-
-Translations have been totally revamped (for custom actions)
-
-Translation keys for actions now look like:
-
-```yaml
-
-en:
-  admin:
-    actions:
-      <action_name>:
-        title: "..."
-        menu: "..."
-        breadcrumb: "..."
-
-```
-
-Other keys may have changed too.
-
-Old outdated translations have been removed, you must now fetch them from the wiki.
-
-See [Wiki](https://github.com/sferik/rails_admin/wiki/Translations) for more informations.
-
-Thanks a lot to all the translators sharing their work, sorry for the added worked (it was really needed).
-
-* History
-
-If you wish to continue using the old history feature, please add this to your initializer:
-
-```ruby
-config.audit_with :history, User
-```
-
-Alternatively, [PaperTrail](https://github.com/airblade/paper_trail) is now officially compatible. Install it, add `has_paper_trail` to the models you wish to track, and add this instead to your initializer:
-
-```ruby
-config.audit_with :paper_trail, User
-```
-
-Change `User` with the class you use with Devise.
-
-By default, there won't be any history shown.
-
 ## <a name="features"></a>Features
 
 * Display database tables
@@ -88,6 +33,7 @@ By default, there won't be any history shown.
 * User action history (internally or via [PaperTrail](https://github.com/airblade/paper_trail))
 * Supported ORMs
   * ActiveRecord
+  * Mongoid [new]
 
 ## <a name="demo"></a>Demo
 
@@ -119,9 +65,10 @@ It will modify your `config/routes.rb`, adding:
 mount RailsAdmin::Engine => '/admin', :as => 'rails_admin' # Feel free to change '/admin' to any namespace you need.
 ```
 
-It will add an intializer that will help you getting started. (head for config/initializers/rails_admin.rb)
+It will also add an intializer that will help you getting started. (head for config/initializers/rails_admin.rb)
 
-Optionaly, you may want to set up [Cancan](https://github.com/ryanb/cancan), [PaperTrail](https://github.com/airblade/paper_trail), [CKeditor](https://github.com/galetahub/ckeditor)
+Optionally, you may wish to set up [Cancan](https://github.com/ryanb/cancan), 
+[PaperTrail](https://github.com/airblade/paper_trail), [CKeditor](https://github.com/galetahub/ckeditor)
 
 More on that in the [Wiki](https://github.com/sferik/rails_admin/wiki)
 
@@ -138,21 +85,23 @@ You should now be able to administer your site at
 All configuration documentation has moved to the wiki: https://github.com/sferik/rails_admin/wiki
 
 ## <a name="support"></a>Support
-Please see [list of know issues](https://github.com/sferik/rails_admin/wiki/Known-issues) first.
+Please see [list of known issues](https://github.com/sferik/rails_admin/wiki/Known-issues) first.
+
+If you have a question, please check this README, the wiki, and the list of known issues.
 
-If you have a question, you can ask the [official RailsAdmin mailing
+If you still have a question, you can ask the [official RailsAdmin mailing
 list](http://groups.google.com/group/rails_admin) or ping sferik on IRC in
 [#railsadmin on
 irc.freenode.net](http://webchat.freenode.net/?channels=railsadmin).
 
-Check this README and the wiki first.
-
 If you think you found a bug in RailsAdmin, you can [submit an
-issue](https://github.com/sferik/rails_admin#issues)
-No feature requests or questions please (the mailing list is active).
+issue](https://github.com/sferik/rails_admin#issues).
+No feature requests or questions please (the mailing list is 
+active and is the preferred venue for feature requests and questions).
 
 ## <a name="contributing"></a>Contributing
-In the spirit of [free software](http://www.fsf.org/licensing/essays/free-sw.html), **everyone** is encouraged to help improve this project.
+In the spirit of [free software](http://www.fsf.org/licensing/essays/free-sw.html), 
+**everyone** is encouraged to help improve this project.
 
 Here are some ways *you* can contribute:
 
@@ -170,7 +119,7 @@ Here are some ways *you* can contribute:
 
 ## <a name="issues"></a>Submitting an Issue
 We use the [GitHub issue tracker](https://github.com/sferik/rails_admin/issues) to track bugs and
-features. Before submitting a bug report or feature request, check to make sure it hasn't already
+features. Before submitting a bug report or feature request, please check to make sure it hasn't already
 been submitted. You can indicate support for an existing issue by voting it up. When submitting a
 bug report, please include a [Gist](https://gist.github.com/) that includes a stack trace and any
 details that may be necessary to reproduce the bug, including your gem version, Ruby version, and
@@ -179,17 +128,18 @@ operating system. Ideally, a bug report should include a pull request with faili
 ## <a name="pulls"></a>Submitting a Pull Request
 1. Fork the project.
 2. Create a topic branch.
-3. Implement your feature or bug fix.  *NOTE* - there's a small test app located in the spec/dummy_app directory that you can use to experiment with rails_admin.
+3. Implement your feature or bug fix.  *NOTE* - there's a small test app located in the 
+spec/dummy_app directory that you can use to experiment with rails_admin.
 4. Add documentation for your feature or bug fix.
 5. Run `bundle exec rake doc:yard`. If your changes are not 100% documented, go back to step 4.
 6. Add specs for your feature or bug fix.
 7. Run `bundle exec rake spec`. If your changes are not 100% covered, go back to step 6.
 8. Commit and push your changes.
-9. Submit a pull request. Please do not include changes to the gemspec, version, or history file. (If you want to create your own version for some reason, please do so in a separate commit.)
+9. Submit a pull request. Please do not include changes to the gemspec, version, or history file. 
+(If you want to create your own version for some reason, please do so in a separate commit.)
 
 ## <a name="versions"></a>Supported Ruby Versions
-This library aims to support and is [tested against][travis] the following Ruby
-implementations:
+This library aims to support and is [tested against][travis] the following Ruby implementations:
 
 * Ruby 1.8.7
 * Ruby 1.9.2

data/Rakefile

@@ -11,4 +11,9 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :test => :spec
 task :default => :spec
-
+namespace :spec do
+  task :coverage do
+    ENV['INVOKE_SIMPLECOV'] = 'true'
+    Rake::Task[:spec].invoke
+  end
+end

data/app/assets/javascripts/rails_admin/rails_admin.js.erb

@@ -2,19 +2,24 @@
   theme = ENV['RAILS_ADMIN_THEME'] || :default
   require_asset 'jquery'
   require_asset 'jquery_ujs'
-  require_asset 'jquery_nested_form'
-  require_asset 'rails_admin/ra.nested-form-hooks'
   require_asset 'jquery.remotipart'
-  require_asset 'rails_admin/jquery.pjax'
-  require_asset 'rails_admin/jquery-ui-1.8.16.custom.js'
-  require_asset 'bootstrap'
+  require_asset 'jquery.effects.core'
+  require_asset 'jquery.ui.sortable'
+  require_asset 'jquery.ui.autocomplete'
+  require_asset 'jquery.ui.datepicker'
   require_asset 'rails_admin/jquery.ui.timepicker'
   require_asset 'rails_admin/ra.datetimepicker'
   require_asset 'rails_admin/ra.filter-box'
   require_asset 'rails_admin/ra.filtering-multiselect'
   require_asset 'rails_admin/ra.filtering-select'
   require_asset 'rails_admin/ra.remote-form'
+  require_asset 'rails_admin/jquery.pjax'
+  require_asset 'jquery_nested_form'
+  require_asset 'rails_admin/ra.nested-form-hooks'
+  require_asset 'bootstrap'
   require_asset 'rails_admin/ui'
   require_asset "rails_admin/themes/#{theme}/ui"
   require_asset 'rails_admin/custom/ui'
 %>
+
+

data/app/controllers/rails_admin/main_controller.rb

@@ -30,8 +30,10 @@ module RailsAdmin
     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]))
-      scope = @authorization_adapter && @authorization_adapter.query(auth_scope_key, model_config.abstract_model)
-      scope = model_config.abstract_model.scoped.merge(scope)
+      scope = model_config.abstract_model.scoped
+      if auth_scope = @authorization_adapter && @authorization_adapter.query(auth_scope_key, model_config.abstract_model)
+        scope = scope.merge(auth_scope)
+      end
       scope = scope.instance_eval(&additional_scope) if additional_scope
 
       get_collection(model_config, scope, pagination)
@@ -53,23 +55,23 @@ module RailsAdmin
       field = model_config.list.fields.find{ |f| f.name.to_s == params[:sort] }
 
       column = if field.nil? || field.sortable == true # use params[:sort] on the base table
-        "#{abstract_model.model.table_name}.#{params[:sort]}"
+        "#{abstract_model.table_name}.#{params[:sort]}"
       elsif field.sortable == false # use default sort, asked field is not sortable
-        "#{abstract_model.model.table_name}.#{model_config.list.sort_by}"
+        "#{abstract_model.table_name}.#{model_config.list.sort_by}"
       elsif field.sortable.is_a?(String) && field.sortable.include?('.') # just provide sortable, don't do anything smart
         field.sortable
       elsif field.sortable.is_a?(Hash) # just join sortable hash, don't do anything smart
         "#{field.sortable.keys.first}.#{field.sortable.values.first}"
       elsif field.association? # use column on target table
-        "#{field.associated_model_config.abstract_model.model.table_name}.#{field.sortable}"
+        "#{field.associated_model_config.abstract_model.table_name}.#{field.sortable}"
       else # use described column in the field conf.
-        "#{abstract_model.model.table_name}.#{field.sortable}"
+        "#{abstract_model.table_name}.#{field.sortable}"
       end
 
       reversed_sort = (field ? field.sort_reverse? : model_config.list.sort_reverse?)
       {: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"))
       if params[:_add_another]

data/config/initializers/mongoid_extensions.rb

@@ -0,0 +1,4 @@
+if defined?(::Mongoid::Document)
+  require 'rails_admin/adapters/mongoid/extension'
+  Mongoid::Document.send(:include, RailsAdmin::Adapters::Mongoid::Extension)
+end

data/lib/rails_admin/abstract_model.rb

@@ -20,15 +20,38 @@ module RailsAdmin
       rescue LoadError, NameError
         nil
       end
+
+      @@polymorphic_parents = {}
+
+      def polymorphic_parents(adapter, 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[:as].to_sym] ||= []) << am.model
+            end
+          end
+        end
+        @@polymorphic_parents[adapter.to_sym][name.to_sym]
+      end
+
+      # For testing
+      def reset_polymorphic_parents
+        @@polymorphic_parents = {}
+      end
     end
 
     def initialize(m)
       @model_name = m.to_s
-      # ActiveRecord
       if m.ancestors.map(&:to_s).include?('ActiveRecord::Base') && !m.abstract_class?
+        # ActiveRecord
         @adapter = :active_record
         require 'rails_admin/adapters/active_record'
         extend Adapters::ActiveRecord
+      elsif m.ancestors.map(&:to_s).include?('Mongoid::Document')
+        # Mongoid
+        @adapter = :mongoid
+        require 'rails_admin/adapters/mongoid'
+        extend Adapters::Mongoid
       end
     end
 
@@ -52,5 +75,36 @@ module RailsAdmin
     def pretty_name
       model.model_name.human
     end
+
+    private
+
+    def get_filtering_duration(operator, value)
+      date_format = I18n.t("admin.misc.filter_date_format", :default => I18n.t("admin.misc.filter_date_format", :locale => :en)).gsub('dd', '%d').gsub('mm', '%m').gsub('yy', '%Y')
+      case operator
+      when 'between'
+        start_date = value[1].present? ? (beginning_of_date(Date.strptime(value[1], date_format)) rescue false) : false
+        end_date   = value[2].present? ? (Date.strptime(value[2], date_format).end_of_day rescue false) : false
+      when 'today'
+        start_date = beginning_of_date(Date.today)
+        end_date   = Date.today.end_of_day
+      when 'yesterday'
+        start_date = beginning_of_date(Date.yesterday)
+        end_date   = Date.yesterday.end_of_day
+      when 'this_week'
+        start_date = beginning_of_date(Date.today.beginning_of_week)
+        end_date   = Date.today.end_of_week.end_of_day
+      when 'last_week'
+        start_date = beginning_of_date(1.week.ago.to_date.beginning_of_week)
+        end_date   = 1.week.ago.to_date.end_of_week.end_of_day
+      else # default
+        start_date = (beginning_of_date(Date.strptime(Array.wrap(value).first, date_format)) rescue false)
+        end_date   = (Date.strptime(Array.wrap(value).first, date_format).end_of_day rescue false)
+      end
+      [start_date, end_date]
+    end
+
+    def beginning_of_date(date)
+      date.beginning_of_day
+    end
   end
 end

data/lib/rails_admin/adapters/active_record.rb

@@ -7,11 +7,6 @@ module RailsAdmin
       DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial]
       AR_ADAPTER = ::ActiveRecord::Base.configurations[Rails.env]['adapter']
       LIKE_OPERATOR = AR_ADAPTER == "postgresql" ? 'ILIKE' : 'LIKE'
-      BEGINNING_OF_DAY = if AR_ADAPTER == "postgresql"
-        lambda { |date| date.beginning_of_day }
-      else
-        lambda { |date| date.yesterday.end_of_day }
-      end
 
       def new(params = {})
         AbstractObject.new(model.new(params))
@@ -90,6 +85,14 @@ module RailsAdmin
         end
       end
 
+      def table_name
+        model.table_name
+      end
+
+      def serialized_attributes
+        model.serialized_attributes.keys
+      end
+
       private
 
       def query_conditions(query, fields = config.list.fields.select(&:queryable?))
@@ -168,30 +171,12 @@ module RailsAdmin
             "%#{value}"
           when 'is', '='
             "#{value}"
+          else
+            return
           end
           ["(#{column} #{LIKE_OPERATOR} ?)", value]
         when :datetime, :timestamp, :date
-          date_format = I18n.t("admin.misc.filter_date_format", :default => I18n.t("admin.misc.filter_date_format", :locale => :en)).gsub('dd', '%d').gsub('mm', '%m').gsub('yy', '%Y')
-          case operator 
-          when 'between'
-            start_date = value[1].present? ? (Date.strptime(value[1], date_format).instance_eval(&BEGINNING_OF_DAY) rescue false) : false
-            end_date   = value[2].present? ? (Date.strptime(value[2], date_format).end_of_day rescue false) : false
-          when 'today'
-            start_date = Date.today.instance_eval(&BEGINNING_OF_DAY)
-            end_date   = Date.today.end_of_day
-          when 'yesterday'
-            start_date = Date.yesterday.instance_eval(&BEGINNING_OF_DAY)
-            end_date   = Date.yesterday.end_of_day
-          when 'this_week'
-            start_date = Date.today.beginning_of_week.instance_eval(&BEGINNING_OF_DAY)
-            end_date   = Date.today.end_of_week.end_of_day
-          when 'last_week'
-            start_date = 1.week.ago.to_date.beginning_of_week.instance_eval(&BEGINNING_OF_DAY)
-            end_date   = 1.week.ago.to_date.end_of_week.end_of_day
-          else # default
-            start_date = (Date.strptime(Array.wrap(value).first, date_format).instance_eval(&BEGINNING_OF_DAY) rescue false)
-            end_date   = (Date.strptime(Array.wrap(value).first, date_format).end_of_day rescue false)
-          end
+          start_date, end_date = get_filtering_duration(operator, value)
           
           if start_date && end_date
             ["(#{column} BETWEEN ? AND ?)", start_date, end_date]
@@ -206,22 +191,19 @@ module RailsAdmin
         end
       end
 
-      @@polymorphic_parents = nil
-
-      def self.polymorphic_parents(name)
-        @@polymorphic_parents ||= {}.tap do |hash|
-          RailsAdmin::AbstractModel.all(:active_record).each do |am|
-            am.model.reflect_on_all_associations.select{|r| r.options[:as] }.each do |reflection|
-              (hash[reflection.options[:as].to_sym] ||= []) << am.model
-            end
-          end
+      if AR_ADAPTER == "postgresql"
+        def beginning_of_date(date)
+          date.beginning_of_day
+        end
+      else
+        def beginning_of_date(date)
+          date.yesterday.end_of_day
         end
-        @@polymorphic_parents[name.to_sym]
       end
 
       def association_model_lookup(association)
         if association.options[:polymorphic]
-          RailsAdmin::Adapters::ActiveRecord.polymorphic_parents(association.name) || []
+          RailsAdmin::AbstractModel.polymorphic_parents(:active_record, association.name) || []
         else
           association.klass
         end
@@ -242,7 +224,7 @@ module RailsAdmin
       end
 
       def association_polymorphic_lookup(association)
-        association.options[:polymorphic]
+        !!association.options[:polymorphic]
       end
 
       def association_primary_key_lookup(association)

data/lib/rails_admin/adapters/mongoid.rb

@@ -0,0 +1,333 @@
+require 'mongoid'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/adapters/mongoid/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject]
+
+      def new(params = {})
+        AbstractObject.new(model.new)
+      end
+
+      def get(id)
+        if object = model.where(:_id=>BSON::ObjectId(id)).first
+          AbstractObject.new object
+        else
+          nil
+        end
+      end
+
+      def scoped
+        model.scoped
+      end
+
+      def first(options = {},scope=nil)
+        all(options, scope).first
+      end
+
+      def all(options = {},scope=nil)
+        scope ||= self.scoped
+        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 = scope.page(options[:page]).per(options[:per]) if options[:page] && options[:per]
+        scope = if options[:sort] && options[:sort_reverse]
+          scope.desc(options[:sort])
+        elsif options[:sort]
+          scope.asc(options[:sort])
+        else
+          scope
+        end
+      end
+      
+      def count(options = {},scope=nil)
+        all(options.merge({:limit => false, :page => false}), scope).count
+      end
+
+      def destroy(objects)
+        Array.wrap(objects).each &:destroy
+      end
+
+      def primary_key
+        :_id
+      end
+
+      def associations
+        model.associations.values.map do |association|
+          {
+            :name => association.name.to_sym,
+            :pretty_name => association.name.to_s.tr('_', ' ').capitalize,
+            :type => association_type_lookup(association.macro),
+            :model_proc => Proc.new { association_model_proc_lookup(association) },
+            :primary_key_proc => Proc.new { association_primary_key_lookup(association) },
+            :foreign_key => association_foreign_key_lookup(association),
+            :foreign_type => association_foreign_type_lookup(association),
+            :as => association_as_lookup(association),
+            :polymorphic => association_polymorphic_lookup(association),
+            :inverse_of => association_inverse_of_lookup(association),
+            :read_only => nil,
+            :nested_form => nil
+          }
+        end
+      end
+
+      def properties
+        @properties if @properties
+        @properties = model.fields.map do |name,field|
+          ar_type =
+            if name == '_type'
+              { :type => :mongoid_type, :length => 1024 }
+            elsif field.type.to_s == 'String'
+              if (length = length_validation_lookup(name)) && length < 256
+                { :type => :string, :length => length }
+              elsif STRING_TYPE_COLUMN_NAMES.include?(name.to_sym)
+                { :type => :string, :length => 255 }
+              else
+                { :type => :text, :length => nil }
+              end
+            else
+              {
+                "Array"          => { :type => :serialized, :length => nil },
+                "BigDecimal"     => { :type => :string, :length => 1024 },
+                "Boolean"        => { :type => :boolean, :length => nil },
+                "BSON::ObjectId" => { :type => :bson_object_id, :length => nil },
+                "Date"           => { :type => :date, :length => nil },
+                "DateTime"       => { :type => :datetime, :length => nil },
+                "Float"          => { :type => :float, :length => nil },
+                "Hash"           => { :type => :serialized, :length => nil },
+                "Integer"        => { :type => :integer, :length => nil },
+                "Time"           => { :type => :datetime, :length => nil },
+                "Object"         => { :type => :bson_object_id, :length => nil },
+              }[field.type.to_s] or raise "Need to map field #{field.type.to_s} for field name #{name} in #{model.inspect}"
+            end
+
+          {
+            :name => field.name.to_sym,
+            :pretty_name => field.name.to_s.gsub('_', ' ').strip.capitalize,
+            :nullable? => true,
+            :serial? => false,
+          }.merge(ar_type)
+        end
+      end
+
+      def table_name
+        model.collection.name
+      end
+
+      def serialized_attributes
+        # Mongoid Array and Hash type columns are mapped to RA serialized type
+        # through type detection in self#properties.
+        []
+      end
+
+      private
+
+      def query_conditions(query, fields = config.list.fields.select(&:queryable?))
+        statements = []
+
+        fields.each do |field|
+          conditions_per_collection = {}
+          field.searchable_columns.flatten.each do |column_infos|
+            collection_name, column_name = column_infos[:column].split('.')
+            statement = build_statement(column_name, column_infos[:type], query, field.search_operator)
+            if statement
+              conditions_per_collection[collection_name] ||= []
+              conditions_per_collection[collection_name] << statement
+            end
+          end
+          statements.concat make_condition_for_current_collection(field, conditions_per_collection)
+        end
+
+        if statements.any?
+          { '$or' => statements }
+        else
+          {}
+        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?))
+        statements = []
+
+        filters.each_pair do |field_name, filters_dump|
+          filters_dump.each do |filter_index, filter_dump|
+            conditions_per_collection = {}
+            field = fields.find{|f| f.name.to_s == field_name}
+            next unless field
+            field.searchable_columns.each do |column_infos|
+              collection_name, column_name = column_infos[:column].split('.')
+              statement = build_statement(column_name, column_infos[:type], filter_dump[:v], (filter_dump[:o] || 'default'))
+              if statement
+                conditions_per_collection[collection_name] ||= []
+                conditions_per_collection[collection_name] << statement
+              end
+            end
+            if conditions_per_collection.any?
+              field_statements = make_condition_for_current_collection(field, conditions_per_collection)
+              if field_statements.length > 1
+                statements << { '$or' => field_statements }
+              else
+                statements << field_statements.first
+              end
+            end
+          end
+        end
+
+        if statements.any?
+          { '$and' => statements }
+        else
+          {}
+        end
+      end
+
+      def build_statement(column, type, value, operator)
+        # this operator/value has been discarded (but kept in the dom to override the one stored in the various links of the page)
+        return if operator == '_discard' || value == '_discard'
+
+        # filtering data with unary operator, not type dependent
+        if operator == '_blank' || value == '_blank'
+          return { column => {'$in' => [nil, '']} }
+        elsif operator == '_present' || value == '_present'
+          return { column => {'$nin' => [nil, '']} }
+        elsif operator == '_null' || value == '_null'
+          return { column => nil }
+        elsif operator == '_not_null' || value == '_not_null'
+          return { column => {'$ne' => nil} }
+        elsif operator == '_empty' || value == '_empty'
+          return { column => '' }
+        elsif operator == '_not_empty' || value == '_not_empty'
+          return { column => {'$ne' => ''} }
+        end
+        # now we go type specific
+        case type
+        when :boolean
+          return { column => false } if ['false', 'f', '0'].include?(value)
+          return { column => true } if ['true', 't', '1'].include?(value)
+        when :integer, :belongs_to_association
+          return if value.blank?
+          { column => value.to_i } if value.to_i.to_s == value
+        when :string, :text
+          return if value.blank?
+          value = case operator
+          when 'default', 'like'
+            Regexp.compile(Regexp.escape(value))
+          when 'starts_with'
+            Regexp.compile("^#{Regexp.escape(value)}")
+          when 'ends_with'
+            Regexp.compile("#{Regexp.escape(value)}$")
+          when 'is', '='
+            value.to_s
+          else
+            return
+          end
+          { column => value }
+        when :datetime, :timestamp, :date
+          start_date, end_date = get_filtering_duration(operator, value)
+
+          if start_date && end_date
+            { column => { '$gte' => start_date, '$lte' => end_date } }
+          elsif start_date
+            { column => { '$gte' => start_date } }
+          elsif end_date
+            { column => { '$lte' => end_date } }
+          end
+        when :enum
+          return if value.blank?
+          { column => { "$in" => Array.wrap(value) } }
+        end
+      end
+
+      def association_model_proc_lookup(association)
+        if association.polymorphic? && association.macro == :referenced_in
+          RailsAdmin::AbstractModel.polymorphic_parents(:mongoid, association.name) || []
+        else
+          association.klass
+        end
+      end
+
+      def association_foreign_type_lookup(association)
+        if association.polymorphic? && association.macro == :referenced_in
+          association.inverse_type.try(:to_sym) || :"#{association.name}_type"
+        end
+      end
+
+      def association_as_lookup(association)
+        association.as.try :to_sym
+      end
+
+      def association_polymorphic_lookup(association)
+        !!association.polymorphic? && association.macro == :referenced_in
+      end
+
+      def association_primary_key_lookup(association)
+        :_id # todo
+      end
+
+      def association_inverse_of_lookup(association)
+        association.inverse_of.try :to_sym
+      end
+
+      def association_foreign_key_lookup(association)
+        association.foreign_key.to_sym rescue nil
+      end
+      
+      def association_type_lookup(macro)
+        case macro.to_sym
+        when :referenced_in, :embedded_in
+          :belongs_to
+        when :references_one, :embeds_one
+          :has_one
+        when :references_many, :embeds_many
+          :has_many
+        when :references_and_referenced_in_many
+          :has_and_belongs_to_many
+        else
+          raise "Unknown association type: #{macro.inspect}"
+        end
+      end
+
+      def length_validation_lookup(name)
+        shortest = model.validators.select do |validator|
+          validator.attributes.include?(name.to_sym) &&
+            validator.class == ActiveModel::Validations::LengthValidator
+        end.min{|a, b| a.options[:maximum] <=> b.options[:maximum] }
+        if shortest
+          shortest.options[:maximum]
+        else
+          false
+        end
+      end
+
+      def make_condition_for_current_collection(target_field, conditions_per_collection)
+        result =[]
+        conditions_per_collection.each do |collection_name, conditions|
+          if collection_name == table_name
+            # conditions referring current model column are passed directly
+            result.concat conditions
+          else
+            # otherwise, collect ids of documents that satisfy search condition
+            result.concat perform_search_on_associated_collection(target_field.name, conditions)
+          end
+        end
+        result
+      end
+
+      def perform_search_on_associated_collection(field_name, conditions)
+        target_association = associations.find{|a| a[:name] == field_name }
+        return [] unless target_association
+        model = target_association[:model_proc].call
+        case target_association[:type]
+        when :belongs_to, :has_and_belongs_to_many
+          [{ target_association[:foreign_key].to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:primary_key_proc].call)} }}]
+        when :has_many
+          [{ target_association[:primary_key_proc].call.to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:foreign_key])} }}]
+        end
+      end
+    end
+  end
+end