obitum-rails_admin 0.0.1

data/config/routes.rb

@@ -0,0 +1,12 @@
+RailsAdmin::Engine.routes.draw do
+  controller "main" 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"
+      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
+    end
+  end
+end

data/lib/generators/rails_admin/install_generator.rb

@@ -0,0 +1,84 @@
+require 'rails/generators'
+require File.expand_path('../utils', __FILE__)
+
+# http://guides.rubyonrails.org/generators.html
+# http://rdoc.info/github/wycats/thor/master/Thor/Actions.html
+# keep generator idempotent, thanks
+
+module RailsAdmin
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    include Rails::Generators::Migration
+    include Generators::Utils::InstanceMethods
+    extend Generators::Utils::ClassMethods
+
+    argument :_model_name, :type => :string, :required => false, :desc => "Devise user model name"
+    argument :_namespace, :type => :string, :required => false, :desc => "RailsAdmin url namespace"
+    desc "RailsAdmin installation generator"
+
+    def install
+      routes = File.open(Rails.root.join("config/routes.rb")).try :read
+      initializer = (File.open(Rails.root.join("config/initializers/rails_admin.rb")) rescue nil).try :read
+
+      display "Hello, RailsAdmin installer will help you sets things up!", :blue
+      display "I need to work with Devise, let's look at a few things first:"
+      display "Checking for a current installation of devise..."
+      unless defined?(Devise)
+        display "Adding devise gem to your Gemfile:"
+        append_file "Gemfile", "\n", :force => true
+        gem 'devise'
+      else
+        display "Found it!"
+      end
+      unless File.exists?(Rails.root.join("config/initializers/devise.rb"))
+        display "Looks like you don't have devise installed! We'll install it for you:"
+        generate "devise:install"
+      else
+        display "Looks like you've already installed it, good!"
+      end
+
+      unless routes.index("devise_for")
+        model_name = ask_for("What would you like the user model to be called?", "user", _model_name)
+        display "Now setting up devise with user model name '#{model_name}':"
+        generate "devise", model_name
+      else
+        display "And you already set it up, good! We just need to know about your user model name..."
+        guess = routes.match(/devise_for :(\w+)/)[1].try(:singularize)
+        display("We found '#{guess}' (should be one of 'user', 'admin', etc.)")
+        model_name = ask_for("Correct Devise model name if needed.", guess, _model_name)
+        unless guess == model_name
+          display "Now setting up devise with user model name '#{model_name}':"
+          generate "devise", model_name
+        else
+          display "Ok, Devise looks already set up with user model name '#{model_name}':"
+        end
+      end
+      display "Now you'll need an initializer..."
+      @model_name = model_name
+      unless initializer
+        template "initializer.erb", "config/initializers/rails_admin.rb"
+      else
+        display "You already have a config file. You're updating, heh? I'm generating a new 'rails_admin.rb.example' that you can review."
+        template "initializer.erb", "config/initializers/rails_admin.rb.example"
+        config_tag = initializer.match(/RailsAdmin\.config.+\|(.+)\|/)[1] rescue nil
+        if config_tag
+          if initializer.index(::Regexp.new("#{config_tag}\.current_user_method.?\{.+?\}"))
+            display "current_user_method found and updated with 'current_#{model_name}'", :green
+            gsub_file Rails.root.join("config/initializers/rails_admin.rb"), ::Regexp.new("#{config_tag}\.current_user_method.?\{.+?\}"), "#{config_tag}.current_user_method { current_#{model_name} }"
+          else
+            display "current_user_method not found. Added one with 'current_#{model_name}'!", :yellow
+            insert_into_file Rails.root.join("config/initializers/rails_admin.rb"), "\n\n  #{config_tag}.current_user_method { current_#{model_name} } #auto-generated", :after => /^RailsAdmin\.config.+$/
+          end
+        else
+          display "Couldn't parse your config file: current_user_method couldn't be updated", :red
+        end
+      end
+      display "Adding a migration..."
+      migration_template 'migration.rb', 'db/migrate/create_rails_admin_histories_table.rb' rescue display $!.message
+      namespace = ask_for("Where do you want to mount rails_admin?", "admin", _namespace)
+      gsub_file "config/routes.rb", /mount RailsAdmin::Engine => \'\/.+\', :as => \'rails_admin\'/, ''
+      route("mount RailsAdmin::Engine => '/#{namespace}', :as => 'rails_admin'")
+      display "Job's done: migrate, start your server and visit '/#{namespace}'!", :blue
+    end
+  end
+end

data/lib/generators/rails_admin/templates/drop.rb

@@ -0,0 +1,18 @@
+class DropRailsAdminHistoriesTable < ActiveRecord::Migration
+   def self.up
+    drop_table :rails_admin_histories
+  end
+
+  def self.down
+    create_table :rails_admin_histories do |t|
+      t.text :message # title, name, or object_id
+      t.string :username
+      t.integer :item
+      t.string :table
+      t.integer :month, :limit => 2
+      t.integer :year, :limit => 5
+      t.timestamps
+    end
+    add_index(:rails_admin_histories, [:item, :table, :month, :year], :name => 'index_rails_admin_histories' )
+  end
+end

data/lib/generators/rails_admin/templates/initializer.erb

@@ -0,0 +1,101 @@
+# RailsAdmin config file. Generated on <%= DateTime.now.to_s(:long) %>
+# See github.com/sferik/rails_admin for more informations
+
+RailsAdmin.config do |config|
+
+  # If your default_local is different from :en, uncomment the following 2 lines and set your default locale here:
+  # require 'i18n'
+  # I18n.default_locale = :de
+
+  config.current_user_method { current_<%= @model_name.underscore %> } # auto-generated
+  
+  # If you want to track changes on your models:
+  # config.audit_with :history, <%= @model_name.classify %>
+  
+  # Or with a PaperTrail: (you need to install it first)
+  # config.audit_with :paper_trail, <%= @model_name.classify %>
+  
+  # Set the admin name here (optional second array element will appear in a beautiful RailsAdmin red ©)
+  config.main_app_name = ['<%= Rails.application.engine_name.titleize.chomp(' Application') %>', 'Admin']
+  # or for a dynamic name:
+  # config.main_app_name = Proc.new { |controller| [Rails.application.engine_name.titleize, controller.params['action'].titleize] }
+
+
+  #  ==> Global show view settings
+  # Display empty fields in show views
+  # config.compact_show_view = false
+
+  #  ==> Global list view settings
+  # Number of default rows per-page:
+  # config.default_items_per_page = 20
+
+  #  ==> Included models
+  # Add all excluded models here:
+  # config.excluded_models = [<%= RailsAdmin::AbstractModel.all_models.map(&:name).join(', ') %>]
+
+  # Add models here if you want to go 'whitelist mode':
+  # config.included_models = [<%= RailsAdmin::AbstractModel.all_models.map(&:name).join(', ') %>]
+
+  # Application wide tried label methods for models' instances
+  # config.label_methods << :description # Default is [:name, :title]
+
+  #  ==> Global models configuration
+  # config.models do
+  #   # Configuration here will affect all included models in all scopes, handle with care!
+  #
+  #   list do
+  #     # Configuration here will affect all included models in list sections (same for show, export, edit, update, create)
+  #
+  #     fields_of_type :date do
+  #       # Configuration here will affect all date fields, in the list section, for all included models. See README for a comprehensive type list.
+  #     end
+  #   end
+  # end
+  #
+  #  ==> Model specific configuration
+  # Keep in mind that *all* configuration blocks are optional.
+  # RailsAdmin will try his best to provide the best defaults for each section, for each field.
+  # Try to override as few things as possible, in the most generic way. Try to avoid setting labels for models and attributes, use ActiveRecord I18n API instead.
+  # Less code is better code!
+  # config.model MyModel do
+  #   # Cross-section field configuration
+  #   object_label_method :name     # Name of the method called for pretty printing an *instance* of ModelName
+  #   label 'My model'              # Name of ModelName (smartly defaults to ActiveRecord's I18n API)
+  #   label_plural 'My models'      # Same, plural
+  #   weight -1                     # Navigation priority. Bigger is higher.
+  #   parent OtherModel             # Set parent model for navigation. MyModel will be nested below. OtherModel will be on first position of the dropdown
+  #   navigation_label              # Sets dropdown entry's name in navigation. Only for parents!
+  #   # Section specific configuration:
+  #   list do
+  #     filters [:id, :name]  # Array of field names which filters should be shown by default in the table header
+  #     items_per_page 100    # Override default_items_per_page
+  #     sort_by :id           # Sort column (default is primary key)
+  #     sort_reverse true     # Sort direction (default is true for primary key, last created first)
+  #     # Here goes the fields configuration for the list view
+  #   end
+  # end
+
+  # Your model's configuration, to help you get started:
+
+  # All fields marked as 'hidden' won't be shown anywhere in the rails_admin unless you mark them as visible. (visible(true))
+
+<% RailsAdmin::AbstractModel.all.map do |abstract_model| -%>
+  # config.model <%= abstract_model.model.model_name %> do
+  #   # Found associations:
+<%= RailsAdmin.config(abstract_model).export.fields.select{|f| f.association?}.map do |field|
+%{  #     configure #{field.name.inspect}, #{field.type.inspect}#{"         # Hidden" unless field.visible?} }
+end.join("\n") -%>
+  #   # Found columns:
+<%= RailsAdmin.config(abstract_model).export.fields.select{|f| !f.association?}.map do |field|
+%{  #     configure #{field.name.inspect}, #{field.type.inspect}#{"         # Hidden" unless field.visible?} }
+end.join("\n") -%>
+  #   # Sections:
+  #   list do; end
+  #   export do; end
+  #   show do; end
+  #   edit do; end
+  #   create do; end
+  #   update do; end
+  # end
+<%- end -%>
+end

data/lib/generators/rails_admin/templates/migration.rb

@@ -0,0 +1,18 @@
+class CreateRailsAdminHistoriesTable < ActiveRecord::Migration
+   def self.up
+     create_table :rails_admin_histories do |t|
+       t.text :message # title, name, or object_id
+       t.string :username
+       t.integer :item
+       t.string :table
+       t.integer :month, :limit => 2
+       t.integer :year, :limit => 5
+       t.timestamps
+    end
+    add_index(:rails_admin_histories, [:item, :table, :month, :year], :name => 'index_rails_admin_histories' )
+  end
+
+  def self.down
+    drop_table :rails_admin_histories
+  end
+end

data/lib/generators/rails_admin/uninstall_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+require File.expand_path('../utils', __FILE__)
+
+module RailsAdmin
+  class UninstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    include Generators::Utils::InstanceMethods
+    extend Generators::Utils::ClassMethods
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "RailsAdmin uninstall"
+
+    def uninstall
+      display "Why you leaving so soon? :("
+      migration_template 'drop.rb', 'db/migrate/drop_rails_admin_histories_table.rb'
+      remove_file 'config/initializers/rails_admin.rb'
+      remove_file 'config/initializers/rails_admin.rb.example'
+      gsub_file "config/routes.rb", /mount RailsAdmin::Engine => \'\/.+\', :as => \'rails_admin\'/, ''
+      display "Done! Devise has been left untouched."
+    end
+  end
+end

data/lib/generators/rails_admin/utils.rb

@@ -0,0 +1,30 @@
+module RailsAdmin
+  module Generators
+    module Utils
+      module InstanceMethods
+        def display(output, color = :green)
+          say("           -  #{output}", color)
+        end
+
+        def ask_for(wording, default_value = nil, override_if_present_value = nil)
+          override_if_present_value.present? ?
+            display("Using [#{override_if_present_value}] for question '#{wording}'") && override_if_present_value :
+            ask("           ?  #{wording} Press <enter> for [#{default_value}] >", :yellow).presence || default_value
+        end
+      end
+
+      module ClassMethods
+        def next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+            migration_number += 1
+            migration_number.to_s
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_admin.rb

@@ -0,0 +1,39 @@
+require 'rails_admin/engine'
+require 'rails_admin/abstract_model'
+require 'rails_admin/config'
+require 'rails_admin/extension'
+require 'rails_admin/extensions/cancan'
+require 'rails_admin/extensions/paper_trail'
+require 'rails_admin/extensions/history'
+require 'rails_admin/support/csv_converter'
+require 'rails_admin/support/core_extensions'
+
+module RailsAdmin
+  # Setup RailsAdmin
+  #
+  # Given the first argument is a model class, a model class name
+  # or an abstract model object proxies to model configuration method.
+  #
+  # If only a block is passed it is stored to initializer stack to be evaluated
+  # on first request in production mode and on each request in development. If
+  # initialization has already occured (in other words RailsAdmin.setup has
+  # been called) the block will be added to stack and evaluated at once.
+  #
+  # Otherwise returns RailsAdmin::Config class.
+  #
+  # @see RailsAdmin::Config
+  def self.config(entity = nil, &block)
+    if entity
+      RailsAdmin::Config.model(entity, &block)
+    elsif block_given? && ENV['SKIP_RAILS_ADMIN_INITIALIZER'] != "true"
+      block.call(RailsAdmin::Config)
+    else
+      RailsAdmin::Config
+    end
+  end
+
+  # Reset RailsAdmin configuration to defaults
+  def self.reset
+    RailsAdmin::Config.reset
+  end
+end

data/lib/rails_admin/abstract_model.rb

@@ -0,0 +1,73 @@
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/generic_support'
+
+module RailsAdmin
+  class AbstractModel
+    cattr_accessor :all_models, :all_abstract_models
+    @@all_models = nil
+    @@all_abstract_models = nil
+    # Returns all models for a given Rails app
+
+    # self.all_abstract_models
+    def self.all
+      @@all_abstract_models ||= all_models.map{ |model| new(model) }
+    end
+
+    def self.all_models
+      @@all_models ||= (
+        possible_models = RailsAdmin::Config.included_models.map(&:to_s).presence || ([Rails.application] + Rails::Application::Railties.engines).map do |app|
+          (app.paths['app/models'] + app.config.autoload_paths).map do |load_path|
+            Dir.glob(app.root.join(load_path)).map do |load_dir|
+              Dir.glob(load_dir + "/**/*.rb").map do |filename|
+                lchomp(filename, "#{app.root.join(load_dir)}/").chomp('.rb').camelize  # app/models/module/class.rb => module/class.rb => module/class => Module::Class
+              end
+            end
+          end
+        end.flatten
+        excluded_models = (RailsAdmin::Config.excluded_models.map(&:to_s) + ['RailsAdmin::History'])
+        (possible_models - excluded_models).uniq.sort{|x, y| x.to_s <=> y.to_s}.map{|model| lookup(model) }.compact
+      )
+    end
+
+    # Given a string +model_name+, finds the corresponding model class
+    def self.lookup(model_name)
+      model = model_name.constantize rescue nil
+      if model && model.is_a?(Class) && superclasses(model).include?(ActiveRecord::Base) && !model.abstract_class?
+        model
+      else
+        nil
+      end
+    rescue LoadError
+      Rails.logger.error "Error while loading '#{model_name}': #{$!}"
+      nil
+    end
+
+    def initialize(model)
+      model = self.class.lookup(model.to_s.camelize) unless model.is_a?(Class)
+      @model_name = model.name
+      self.extend(GenericSupport)
+      ### TODO more ORMs support
+      require 'rails_admin/adapters/active_record'
+      self.extend(RailsAdmin::Adapters::ActiveRecord)
+    end
+
+    def model
+      @model_name.constantize
+    end
+
+    private
+
+    def self.superclasses(klass)
+      superclasses = []
+      while klass
+        superclasses << klass.superclass if klass && klass.superclass
+        klass = klass.superclass
+      end
+      superclasses
+    end
+
+    def self.lchomp(base, arg) # yeah.. delete was probably safe, but never know.
+      base.to_s.reverse.chomp(arg.to_s.reverse).reverse
+    end
+  end
+end

data/lib/rails_admin/abstract_object.rb

@@ -0,0 +1,28 @@
+ module RailsAdmin
+  class AbstractObject
+    # undef almost all of this class's methods so it will pass almost
+    # everything through to its delegate using method_missing (below).
+    instance_methods.each { |m| undef_method m unless m.to_s =~ /(^__|^send$|^object_id$)/ }
+    #                                                  ^^^^^
+    # the unnecessary "to_s" above is a workaround for meta_where, see
+    # https://github.com/sferik/rails_admin/issues/374
+
+    attr_accessor :object
+
+    def initialize(object)
+      self.object = object
+    end
+
+    def set_attributes(attributes, role = nil)
+      object.assign_attributes(attributes, :as => role)
+    end
+
+    def method_missing(name, *args, &block)
+      self.object.send(name, *args, &block)
+    end
+
+    def save(options = { :validate => true })
+      object.save(options)
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -0,0 +1,347 @@
+require 'active_record'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary]
+      @@polymorphic_parents = nil
+
+      def self.polymorphic_parents(name)
+        @@polymorphic_parents ||= {}.tap do |hash|
+          RailsAdmin::AbstractModel.all_models.each do |klass|
+            klass.reflect_on_all_associations.select{|r| r.options[:as] }.each do |reflection|
+              (hash[reflection.options[:as].to_sym] ||= []) << klass
+            end
+          end
+        end
+        @@polymorphic_parents[name.to_sym]
+      end
+
+      def get(id)
+        if object = model.where(model.primary_key => id).first
+          RailsAdmin::AbstractObject.new object
+        else
+          nil
+        end
+      end
+
+      def count(options = {}, scope = nil)
+        all(options.merge({:limit => false, :page => false}), scope).count
+      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.where(model.primary_key => options[:bulk_ids]) if options[:bulk_ids]
+        scope = scope.where(options[:conditions]) if options[:conditions]
+        scope = scope.page(options[:page]).per(options[:per]) if options[:page] && options[:per]
+        scope = scope.reorder("#{options[:sort]} #{options[:sort_reverse] ? 'asc' : 'desc'}") if options[:sort]
+        scope
+      end
+
+      def scoped
+        model.scoped
+      end
+
+      def create(params = {})
+        model.create(params)
+      end
+
+      def new(params = {})
+        RailsAdmin::AbstractObject.new(model.new(params))
+      end
+
+      def destroy(objects)
+        [objects].flatten.map &:destroy
+      end
+
+      def destroy_all!
+        model.all.each do |object|
+          object.destroy
+        end
+      end
+
+      def has_and_belongs_to_many_associations
+        associations.select do |association|
+          association[:type] == :has_and_belongs_to_many
+        end
+      end
+
+      def has_many_associations
+        associations.select do |association|
+          association[:type] == :has_many
+        end
+      end
+
+      def has_one_associations
+        associations.select do |association|
+          association[:type] == :has_one
+        end
+      end
+
+      def belongs_to_associations
+        associations.select do |association|
+          association[:type] == :belongs_to
+        end
+      end
+
+      def associations
+        model.reflect_on_all_associations.map do |association|
+          {
+            :name => association.name.to_sym,
+            :pretty_name => association.name.to_s.tr('_', ' ').capitalize,
+            :type => association.macro,
+            :parent_model => association_parent_model_lookup(association),
+            :parent_key => association_parent_key_lookup(association),
+            :child_model => association_child_model_lookup(association),
+            :child_key => association_child_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 => association_read_only_lookup(association),
+            :nested_form => association_nested_attributes_options_lookup(association)
+          }
+        end
+      end
+
+      def polymorphic_associations
+        (has_many_associations + has_one_associations).select do |association|
+          association[:options][:as]
+        end
+      end
+
+      def properties
+        columns = model.columns.reject {|c| c.type.blank? || DISABLED_COLUMN_TYPES.include?(c.type.to_sym) }
+        columns.map do |property|
+          {
+            :name => property.name.to_sym,
+            :pretty_name => property.name.to_s.tr('_', ' ').capitalize,
+            :type => property.type,
+            :length => property.limit,
+            :nullable? => property.null,
+            :serial? => property.primary,
+          }
+        end
+      end
+
+      def model_store_exists?
+        model.table_exists?
+      end
+
+      def get_conditions_hash(model_config, query, filters)
+        @like_operator =  "ILIKE" if ::ActiveRecord::Base.configurations[Rails.env]['adapter'] == "postgresql"
+        @like_operator ||= "LIKE"
+
+        query_statements = []
+        filters_statements = []
+        values = []
+        conditions = [""]
+
+        if query.present?
+          queryable_fields = model_config.list.fields.select(&:queryable?)
+          queryable_fields.each do |field|
+            searchable_columns = field.searchable_columns.flatten
+            searchable_columns.each do |field_infos|
+              statement, value1, value2 = build_statement(field_infos[:column], field_infos[:type], query, field.search_operator)
+              if statement
+                query_statements << statement
+                values << value1 unless value1.nil?
+                values << value2 unless value2.nil?
+              end
+            end
+          end
+        end
+
+        unless query_statements.empty?
+          conditions[0] += " AND " unless conditions == [""]
+          conditions[0] += "(#{query_statements.join(" OR ")})"
+        end
+
+        if filters.present?
+          @filterable_fields = model_config.list.fields.select(&:filterable?).inject({}){ |memo, field| memo[field.name.to_sym] = field.searchable_columns; memo }
+          filters.each_pair do |field_name, filters_dump|
+            filters_dump.each do |filter_index, filter_dump|
+              field_statements = []
+              @filterable_fields[field_name.to_sym].each do |field_infos|
+                statement, value1, value2 = build_statement(field_infos[:column], field_infos[:type], filter_dump[:v], (filter_dump[:o] || 'default'))
+                if statement
+                  field_statements << statement
+                  values << value1 unless value1.nil?
+                  values << value2 unless value2.nil?
+                end
+              end
+              filters_statements << "(#{field_statements.join(' OR ')})" unless field_statements.empty?
+            end
+          end
+        end
+
+        unless filters_statements.empty?
+         conditions[0] += " AND " unless conditions == [""]
+         conditions[0] += "#{filters_statements.join(" AND ")}" # filters should all be true
+        end
+
+        conditions += values
+        conditions != [""] ? { :conditions => conditions } : {}
+      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} IS NULL OR #{column} = '')"]
+        elsif operator == '_present' || value == '_present'
+          return ["(#{column} IS NOT NULL AND #{column} != '')"]
+        elsif operator == '_null' || value == '_null'
+          return ["(#{column} IS NULL)"]
+        elsif operator == '_not_null' || value == '_not_null'
+          return ["(#{column} IS NOT NULL)"]
+        elsif operator == '_empty' || value == '_empty'
+          return ["(#{column} = '')"]
+        elsif operator == '_not_empty' || value == '_not_empty'
+          return ["(#{column} != '')"]
+        end
+
+        # now we go type specific
+        case type
+        when :boolean
+          return ["(#{column} IS NULL OR #{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'
+            "%#{value}%"
+          when 'starts_with'
+            "#{value}%"
+          when 'ends_with'
+            "%#{value}"
+          when 'is', '='
+            "#{value}"
+          end
+          ["(#{column} #{@like_operator} ?)", value]
+        when :datetime, :timestamp, :date
+          return unless operator != 'default'
+          values = case operator
+          when 'today'
+            [Date.today.beginning_of_day, Date.today.end_of_day]
+          when 'yesterday'
+            [Date.yesterday.beginning_of_day, Date.yesterday.end_of_day]
+          when 'this_week'
+            [Date.today.beginning_of_week.beginning_of_day, Date.today.end_of_week.end_of_day]
+          when 'last_week'
+            [1.week.ago.to_date.beginning_of_week.beginning_of_day, 1.week.ago.to_date.end_of_week.end_of_day]
+          when 'less_than'
+            return if value.blank?
+            [value.to_i.days.ago, DateTime.now]
+          when 'more_than'
+            return if value.blank?
+            [2000.years.ago, value.to_i.days.ago]
+          when 'mmddyyyy'
+            return if (value.blank? || value.match(/([0-9]{8})/).nil?)
+            [Date.strptime(value.match(/([0-9]{8})/)[1], '%m%d%Y').beginning_of_day, Date.strptime(value.match(/([0-9]{8})/)[1], '%m%d%Y').end_of_day]
+          end
+          ["(#{column} BETWEEN ? AND ?)", *values]
+        when :enum
+          return if value.blank?
+          ["(#{column} IN (?))", [value].flatten]
+        end
+      end
+
+      def association_options(association)
+        if association.options[:polymorphic]
+          {
+            :polymorphic => true,
+            :foreign_type => association.options[:foreign_type] || "#{association.name}_type"
+          }
+        elsif association.options[:as]
+          {
+            :as => association.options[:as]
+          }
+        else
+          {}
+        end
+      end
+
+      def association_parent_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          if association.options[:polymorphic]
+            RailsAdmin::Adapters::ActiveRecord.polymorphic_parents(association.name) || []
+          else
+            association.klass
+          end
+        when :has_one, :has_many, :has_and_belongs_to_many
+          association.active_record
+        else
+          raise "Unknown association type: #{association.macro.inspect}"
+        end
+      end
+
+      def association_foreign_type_lookup(association)
+        if association.options[:polymorphic]
+          association.options[:foreign_type].try(:to_sym) || :"#{association.name}_type"
+        end
+      end
+
+      def association_nested_attributes_options_lookup(association)
+        model.nested_attributes_options.try { |o| o[association.name.to_sym] }
+      end
+
+      def association_as_lookup(association)
+        association.options[:as].try :to_sym
+      end
+
+      def association_polymorphic_lookup(association)
+        association.options[:polymorphic]
+      end
+
+      def association_parent_key_lookup(association)
+        [:id]
+      end
+
+      def association_inverse_of_lookup(association)
+        association.options[:inverse_of].try :to_sym
+      end
+
+      def association_read_only_lookup(association)
+        association.options[:readonly]
+      end
+
+      def association_child_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          association.active_record
+        when :has_one, :has_many, :has_and_belongs_to_many
+          association.klass
+        else
+          raise "Unknown association type: #{association.macro.inspect}"
+        end
+      end
+
+      def association_child_key_lookup(association)
+        case association.macro
+        when :belongs_to
+          association.options[:foreign_key].try(:to_sym) || "#{association.name}_id".to_sym
+        when :has_one, :has_many, :has_and_belongs_to_many
+          association.foreign_key.to_sym
+        else
+          raise "Unknown association type: #{association.macro.inspect}"
+        end
+      end
+    end
+  end
+end